SYMBOL INDEX (847 symbols across 76 files)

FILE: alphafold/common/confidence.py
  function _softmax (line 23) | def _softmax(x: np.ndarray, axis: Optional[int] = None):
  function compute_plddt (line 30) | def compute_plddt(logits: np.ndarray) -> np.ndarray:
  function _confidence_category (line 47) | def _confidence_category(score: float) -> str:
  function confidence_json (line 61) | def confidence_json(plddt: np.ndarray) -> str:
  function _calculate_bin_centers (line 84) | def _calculate_bin_centers(breaks: np.ndarray):
  function _calculate_expected_aligned_error (line 102) | def _calculate_expected_aligned_error(
  function compute_predicted_aligned_error (line 127) | def compute_predicted_aligned_error(
  function pae_json (line 158) | def pae_json(pae: np.ndarray, max_pae: float) -> str:
  function predicted_tm_score (line 184) | def predicted_tm_score(

FILE: alphafold/common/confidence_test.py
  class ConfidenceTest (line 23) | class ConfidenceTest(absltest.TestCase):
    method test_pae_json (line 25) | def test_pae_json(self):
    method test_confidence_json (line 34) | def test_confidence_json(self):

FILE: alphafold/common/mmcif_metadata.py
  function add_metadata_to_mmcif (line 72) | def add_metadata_to_mmcif(

FILE: alphafold/common/protein.py
  class Protein (line 65) | class Protein:
    method __post_init__ (line 92) | def __post_init__(self):
  function _from_bio_structure (line 100) | def _from_bio_structure(
  function from_pdb_string (line 182) | def from_pdb_string(pdb_str: str, chain_id: Optional[str] = None) -> Pro...
  function from_mmcif_string (line 202) | def from_mmcif_string(
  function _chain_end (line 224) | def _chain_end(atom_index, end_resname, chain_name, residue_index) -> str:
  function to_pdb (line 232) | def to_pdb(prot: Protein) -> str:
  function ideal_atom_mask (line 327) | def ideal_atom_mask(prot: Protein) -> np.ndarray:
  function from_prediction (line 343) | def from_prediction(
  function to_mmcif (line 384) | def to_mmcif(
  function _int_id_to_str_id (line 524) | def _int_id_to_str_id(num: int) -> str:
  function _get_entity_poly_seq (line 546) | def _get_entity_poly_seq(
  function _create_mmcif_string (line 594) | def _create_mmcif_string(mmcif_dict: Dict[str, Any]) -> str:

FILE: alphafold/common/protein_test.py
  class ProteinTest (line 28) | class ProteinTest(parameterized.TestCase):
    method _check_shapes (line 30) | def _check_shapes(self, prot, num_res):
    method test_from_pdb_str (line 63) | def test_from_pdb_str(self, pdb_file, chain_id, num_res, num_chains):
    method test_to_pdb (line 76) | def test_to_pdb(self):
    method test_to_mmcif (line 114) | def test_to_mmcif(self, pdb_file, model_type):
    method test_ideal_atom_mask (line 142) | def test_ideal_atom_mask(self):
    method test_too_many_chains (line 160) | def test_too_many_chains(self):

FILE: alphafold/common/residue_constants.py
  function load_stereo_chemical_props (line 413) | def load_stereo_chemical_props() -> Tuple[
  function sequence_to_onehot (line 587) | def sequence_to_onehot(
  function atom_id_to_type (line 659) | def atom_id_to_type(atom_id: str) -> str:
  function _make_standard_atom_mask (line 768) | def _make_standard_atom_mask() -> np.ndarray:
  function chi_angle_atom (line 786) | def chi_angle_atom(atom_index: int) -> np.ndarray:
  function _make_rigid_transformation_4x4 (line 831) | def _make_rigid_transformation_4x4(ex, ey, translation):
  function _make_rigid_group_constants (line 860) | def _make_rigid_group_constants():
  function make_atom14_dists_bounds (line 939) | def make_atom14_dists_bounds(

FILE: alphafold/common/residue_constants_test.py
  class ResidueConstantsTest (line 23) | class ResidueConstantsTest(parameterized.TestCase):
    method testChiAnglesAtoms (line 33) | def testChiAnglesAtoms(self, residue_name, chi_num):
    method testChiGroupsForAtom (line 39) | def testChiGroupsForAtom(self):
    method testResidueAtoms (line 70) | def testResidueAtoms(self, atom_name, num_residue_atoms):
    method testStandardAtomMask (line 74) | def testStandardAtomMask(self):
    method testAtomTypes (line 127) | def testAtomTypes(self):
    method testRestypes (line 143) | def testRestypes(self):
    method testSequenceToOneHotHHBlits (line 153) | def testSequenceToOneHotHHBlits(self):
    method testSequenceToOneHotStandard (line 188) | def testSequenceToOneHotStandard(self):
    method testSequenceToOneHotUnknownMapping (line 194) | def testSequenceToOneHotUnknownMapping(self):
    method testSequenceToOneHotUnknownMappingError (line 217) | def testSequenceToOneHotUnknownMappingError(self, seq):

FILE: alphafold/data/feature_processing.py
  function _is_homomer_or_monomer (line 60) | def _is_homomer_or_monomer(chains: Iterable[pipeline.FeatureDict]) -> bool:
  function pair_and_merge (line 74) | def pair_and_merge(
  function crop_chains (line 110) | def crop_chains(
  function _crop_single_chain (line 142) | def _crop_single_chain(
  function process_final (line 198) | def process_final(np_example: pipeline.FeatureDict) -> pipeline.FeatureD...
  function _correct_msa_restypes (line 207) | def _correct_msa_restypes(np_example):
  function _make_seq_mask (line 215) | def _make_seq_mask(np_example):
  function _make_msa_mask (line 220) | def _make_msa_mask(np_example):
  function _filter_features (line 231) | def _filter_features(np_example: pipeline.FeatureDict) -> pipeline.Featu...
  function process_unmerged_features (line 236) | def process_unmerged_features(

FILE: alphafold/data/mmcif_parsing.py
  class Monomer (line 35) | class Monomer:
  class AtomSite (line 43) | class AtomSite:
  class ResiduePosition (line 56) | class ResiduePosition:
  class ResidueAtPosition (line 63) | class ResidueAtPosition:
  class MmcifObject (line 71) | class MmcifObject:
  class ParsingResult (line 97) | class ParsingResult:
  class ParseError (line 110) | class ParseError(Exception):
  function mmcif_loop_to_list (line 114) | def mmcif_loop_to_list(
  function mmcif_loop_to_dict (line 146) | def mmcif_loop_to_dict(
  function parse (line 170) | def parse(
  function _get_first_model (line 293) | def _get_first_model(structure: PdbStructure) -> PdbStructure:
  function get_release_date (line 301) | def get_release_date(parsed_info: MmCIFDict) -> str:
  function _get_header (line 307) | def _get_header(parsed_info: MmCIFDict) -> PdbHeader:
  function _get_atom_site_list (line 342) | def _get_atom_site_list(parsed_info: MmCIFDict) -> Sequence[AtomSite]:
  function _get_protein_chains (line 359) | def _get_protein_chains(
  function _is_set (line 411) | def _is_set(data: str) -> bool:

FILE: alphafold/data/msa_identifiers.py
  class Identifiers (line 51) | class Identifiers:
  function _parse_sequence_identifier (line 55) | def _parse_sequence_identifier(msa_sequence_identifier: str) -> Identifi...
  function _extract_sequence_identifier (line 75) | def _extract_sequence_identifier(description: str) -> Optional[str]:
  function get_identifiers (line 84) | def get_identifiers(description: str) -> Identifiers:

FILE: alphafold/data/msa_pairing.py
  class MSAStatistics (line 71) | class MSAStatistics:
    method from_chain_features (line 88) | def from_chain_features(
    method __len__ (line 124) | def __len__(self) -> int:
    method get_top_msa_rows (line 127) | def get_top_msa_rows(self, num_rows: int) -> np.ndarray:
    method to_species_dict (line 132) | def to_species_dict(self) -> Mapping[bytes, 'MSAStatistics']:
  function create_paired_features (line 153) | def create_paired_features(
  function pad_features (line 188) | def pad_features(feature: np.ndarray, feature_name: str) -> np.ndarray:
  function _match_rows_by_sequence_similarity (line 220) | def _match_rows_by_sequence_similarity(
  function pair_sequences (line 256) | def pair_sequences(
  function reorder_paired_rows (line 322) | def reorder_paired_rows(
  function block_diag (line 349) | def block_diag(*arrs: np.ndarray, pad_value: float = 0.0) -> np.ndarray:
  function _correct_post_merged_feats (line 358) | def _correct_post_merged_feats(
  function _pad_templates (line 411) | def _pad_templates(
  function _merge_features_from_multiple_chains (line 434) | def _merge_features_from_multiple_chains(
  function _merge_homomers_dense_msa (line 469) | def _merge_homomers_dense_msa(
  function _concatenate_paired_and_unpaired_features (line 498) | def _concatenate_paired_and_unpaired_features(
  function merge_chain_features (line 513) | def merge_chain_features(
  function deduplicate_unpaired_sequences (line 546) | def deduplicate_unpaired_sequences(

FILE: alphafold/data/parsers.py
  class Msa (line 30) | class Msa:
    method __post_init__ (line 37) | def __post_init__(self):
    method __len__ (line 50) | def __len__(self):
    method truncate (line 53) | def truncate(self, max_seqs: int):
  class TemplateHit (line 62) | class TemplateHit:
  function parse_fasta (line 75) | def parse_fasta(fasta_string: str) -> Tuple[Sequence[str], Sequence[str]]:
  function parse_stockholm (line 104) | def parse_stockholm(stockholm_string: str) -> Msa:
  function parse_a3m (line 166) | def parse_a3m(a3m_string: str) -> Msa:
  function _convert_sto_seq_to_a3m (line 205) | def _convert_sto_seq_to_a3m(
  function convert_stockholm_to_a3m (line 215) | def convert_stockholm_to_a3m(
  function _keep_line (line 274) | def _keep_line(line: str, seqnames: Set[str]) -> bool:
  function truncate_stockholm_msa (line 294) | def truncate_stockholm_msa(stockholm_msa_path: str, max_sequences: int) ...
  function remove_empty_columns_from_stockholm_msa (line 317) | def remove_empty_columns_from_stockholm_msa(stockholm_msa: str) -> str:
  function deduplicate_stockholm_msa (line 357) | def deduplicate_stockholm_msa(stockholm_msa: str) -> str:
  function _get_hhr_line_regex_groups (line 392) | def _get_hhr_line_regex_groups(
  function _update_hhr_residue_indices_list (line 401) | def _update_hhr_residue_indices_list(
  function _parse_hhr_hit (line 414) | def _parse_hhr_hit(detailed_lines: Sequence[str]) -> TemplateHit:
  function parse_hhr (line 518) | def parse_hhr(hhr_string: str) -> Sequence[TemplateHit]:
  function parse_e_values_from_tblout (line 536) | def parse_e_values_from_tblout(tblout: str) -> Dict[str, float]:
  function _get_indices (line 551) | def _get_indices(sequence: str, start: int) -> List[int]:
  class HitMetadata (line 570) | class HitMetadata:
  function _parse_hmmsearch_description (line 579) | def _parse_hmmsearch_description(description: str) -> HitMetadata:
  function parse_hmmsearch_a3m (line 601) | def parse_hmmsearch_a3m(

FILE: alphafold/data/pipeline.py
  function make_sequence_features (line 37) | def make_sequence_features(
  function make_msa_features (line 57) | def make_msa_features(msas: Sequence[parsers.Msa]) -> FeatureDict:
  function run_msa_tool (line 94) | def run_msa_tool(
  class DataPipeline (line 123) | class DataPipeline:
    method __init__ (line 126) | def __init__(
    method process (line 174) | def process(self, input_fasta_path: str, msa_output_dir: str) -> Featu...

FILE: alphafold/data/pipeline_multimer.py
  class _FastaChain (line 40) | class _FastaChain:
  function _make_chain_id_map (line 45) | def _make_chain_id_map(
  function temp_fasta_file (line 72) | def temp_fasta_file(fasta_str: str):
  function convert_monomer_features (line 79) | def convert_monomer_features(
  function int_id_to_str_id (line 108) | def int_id_to_str_id(num: int) -> str:
  function add_assembly_features (line 130) | def add_assembly_features(
  function pad_msa (line 170) | def pad_msa(np_example, min_num_seq):
  class DataPipeline (line 184) | class DataPipeline:
    method __init__ (line 187) | def __init__(
    method _process_single_chain (line 218) | def _process_single_chain(
    method _all_seq_msa_features (line 248) | def _all_seq_msa_features(self, input_fasta_path, msa_output_dir):
    method process (line 269) | def process(

FILE: alphafold/data/templates.py
  class Error (line 35) | class Error(Exception):
  class NoChainsError (line 39) | class NoChainsError(Error):
  class SequenceNotInTemplateError (line 43) | class SequenceNotInTemplateError(Error):
  class NoAtomDataInTemplateError (line 47) | class NoAtomDataInTemplateError(Error):
  class TemplateAtomMaskAllZerosError (line 51) | class TemplateAtomMaskAllZerosError(Error):
  class QueryToTemplateAlignError (line 55) | class QueryToTemplateAlignError(Error):
  class CaDistanceError (line 59) | class CaDistanceError(Error):
  class MultipleChainsError (line 63) | class MultipleChainsError(Error):
  class PrefilterError (line 68) | class PrefilterError(Exception):
  class DateError (line 72) | class DateError(PrefilterError):
  class AlignRatioError (line 76) | class AlignRatioError(PrefilterError):
  class DuplicateError (line 80) | class DuplicateError(PrefilterError):
  class LengthError (line 84) | class LengthError(PrefilterError):
  function _get_pdb_id_and_chain (line 98) | def _get_pdb_id_and_chain(hit: parsers.TemplateHit) -> Tuple[str, str]:
  function _is_after_cutoff (line 108) | def _is_after_cutoff(
  function _parse_obsolete (line 133) | def _parse_obsolete(obsolete_file_path: str) -> Mapping[str, Optional[st...
  function _parse_release_dates (line 156) | def _parse_release_dates(path: str) -> Mapping[str, datetime.datetime]:
  function _assess_hhsearch_hit (line 175) | def _assess_hhsearch_hit(
  function _find_template_in_pdb (line 244) | def _find_template_in_pdb(
  function _realign_pdb_template_to_query (line 316) | def _realign_pdb_template_to_query(
  function _check_residue_distances (line 453) | def _check_residue_distances(
  function _get_atom_positions (line 477) | def _get_atom_positions(
  function _extract_template_features (line 544) | def _extract_template_features(
  function _build_query_to_hit_index_mapping (line 692) | def _build_query_to_hit_index_mapping(
  class SingleHitResult (line 750) | class SingleHitResult:
  function _read_file (line 757) | def _read_file(path):
  function _process_single_hit (line 763) | def _process_single_hit(
  class TemplateSearchResult (line 908) | class TemplateSearchResult:
  class TemplateHitFeaturizer (line 914) | class TemplateHitFeaturizer(abc.ABC):
    method __init__ (line 917) | def __init__(
    method get_templates (line 979) | def get_templates(
  class HhsearchHitFeaturizer (line 985) | class HhsearchHitFeaturizer(TemplateHitFeaturizer):
    method get_templates (line 988) | def get_templates(
  class HmmsearchHitFeaturizer (line 1053) | class HmmsearchHitFeaturizer(TemplateHitFeaturizer):
    method get_templates (line 1056) | def get_templates(

FILE: alphafold/data/tools/hhblits.py
  class HHBlits (line 32) | class HHBlits:
    method __init__ (line 35) | def __init__(
    method query (line 100) | def query(self, input_fasta_path: str) -> List[Mapping[str, Any]]:

FILE: alphafold/data/tools/hhsearch.py
  class HHSearch (line 29) | class HHSearch:
    method __init__ (line 32) | def __init__(
    method output_format (line 65) | def output_format(self) -> str:
    method input_format (line 69) | def input_format(self) -> str:
    method query (line 72) | def query(self, a3m: str) -> str:
    method get_template_hits (line 111) | def get_template_hits(

FILE: alphafold/data/tools/hmmbuild.py
  class Hmmbuild (line 27) | class Hmmbuild(object):
    method __init__ (line 30) | def __init__(self, *, binary_path: str, singlemx: bool = False):
    method build_profile_from_sto (line 44) | def build_profile_from_sto(self, sto: str, model_construction='fast') ...
    method build_profile_from_a3m (line 60) | def build_profile_from_a3m(self, a3m: str) -> str:
    method _build_profile (line 80) | def _build_profile(self, msa: str, model_construction: str = 'fast') -...

FILE: alphafold/data/tools/hmmsearch.py
  class Hmmsearch (line 29) | class Hmmsearch(object):
    method __init__ (line 32) | def __init__(
    method output_format (line 76) | def output_format(self) -> str:
    method input_format (line 80) | def input_format(self) -> str:
    method query (line 83) | def query(self, msa_sto: str) -> str:
    method query_with_hmm (line 90) | def query_with_hmm(self, hmm: str) -> str:
    method get_template_hits (line 135) | def get_template_hits(

FILE: alphafold/data/tools/jackhmmer.py
  class Jackhmmer (line 31) | class Jackhmmer:
    method __init__ (line 34) | def __init__(
    method _query_chunk (line 92) | def _query_chunk(
    method query (line 171) | def query(
    method query_multiple (line 177) | def query_multiple(

FILE: alphafold/data/tools/kalign.py
  function _to_a3m (line 26) | def _to_a3m(sequences: Sequence[str]) -> str:
  class Kalign (line 36) | class Kalign:
    method __init__ (line 39) | def __init__(self, *, binary_path: str):
    method align (line 50) | def align(self, sequences: Sequence[str]) -> str:

FILE: alphafold/data/tools/utils.py
  function tmpdir_manager (line 25) | def tmpdir_manager(base_dir: Optional[str] = None):
  function timing (line 35) | def timing(msg: str):

FILE: alphafold/model/all_atom.py
  function squared_difference (line 44) | def squared_difference(x, y):
  function get_chi_atom_indices (line 48) | def get_chi_atom_indices():
  function atom14_to_atom37 (line 75) | def atom14_to_atom37(
  function atom37_to_atom14 (line 95) | def atom37_to_atom14(
  function atom37_to_frames (line 115) | def atom37_to_frames(
  function atom37_to_torsion_angles (line 288) | def atom37_to_torsion_angles(
  function torsion_angles_to_frames (line 495) | def torsion_angles_to_frames(
  function frames_and_literature_positions_to_atom14_pos (line 599) | def frames_and_literature_positions_to_atom14_pos(
  function extreme_ca_ca_distance_violations (line 647) | def extreme_ca_ca_distance_violations(
  function between_residue_bond_loss (line 685) | def between_residue_bond_loss(
  function _loss_and_violation_mask (line 830) | def _loss_and_violation_mask(
  function between_residue_clash_loss (line 847) | def between_residue_clash_loss(
  function within_residue_violations (line 974) | def within_residue_violations(
  function find_optimal_renaming (line 1058) | def find_optimal_renaming(
  function frame_aligned_point_error (line 1159) | def frame_aligned_point_error(
  function _make_renaming_matrices (line 1231) | def _make_renaming_matrices():
  function get_alt_atom14 (line 1264) | def get_alt_atom14(aatype, positions, mask):

FILE: alphafold/model/all_atom_multimer.py
  function squared_difference (line 26) | def squared_difference(x, y):
  function _make_chi_atom_indices (line 30) | def _make_chi_atom_indices():
  function _make_renaming_matrices (line 57) | def _make_renaming_matrices():
  function _make_restype_atom37_mask (line 86) | def _make_restype_atom37_mask():
  function _make_restype_atom14_mask (line 99) | def _make_restype_atom14_mask():
  function _make_restype_atom37_to_atom14 (line 114) | def _make_restype_atom37_to_atom14():
  function _make_restype_atom14_to_atom37 (line 132) | def _make_restype_atom14_to_atom37():
  function _make_restype_atom14_is_ambiguous (line 149) | def _make_restype_atom14_is_ambiguous():
  function _make_restype_rigidgroup_base_atom37_idx (line 170) | def _make_restype_rigidgroup_base_atom37_idx():
  function get_atom37_mask (line 215) | def get_atom37_mask(aatype):
  function get_atom14_mask (line 219) | def get_atom14_mask(aatype):
  function get_atom14_is_ambiguous (line 223) | def get_atom14_is_ambiguous(aatype):
  function get_atom14_to_atom37_map (line 227) | def get_atom14_to_atom37_map(aatype):
  function get_atom37_to_atom14_map (line 231) | def get_atom37_to_atom14_map(aatype):
  function atom14_to_atom37 (line 235) | def atom14_to_atom37(
  function atom37_to_atom14 (line 252) | def atom37_to_atom14(aatype, all_atom_pos, all_atom_mask):
  function get_alt_atom14 (line 271) | def get_alt_atom14(aatype, positions: geometry.Vec3Array, mask):
  function atom37_to_frames (line 291) | def atom37_to_frames(
  function torsion_angles_to_frames (line 398) | def torsion_angles_to_frames(
  function frames_and_literature_positions_to_atom14_pos (line 478) | def frames_and_literature_positions_to_atom14_pos(
  function extreme_ca_ca_distance_violations (line 517) | def extreme_ca_ca_distance_violations(
  function between_residue_bond_loss (line 539) | def between_residue_bond_loss(
  function between_residue_clash_loss (line 664) | def between_residue_clash_loss(
  function within_residue_violations (line 758) | def within_residue_violations(
  function find_optimal_renaming (line 814) | def find_optimal_renaming(
  function frame_aligned_point_error (line 873) | def frame_aligned_point_error(
  function get_chi_atom_indices (line 949) | def get_chi_atom_indices():
  function compute_chi_angles (line 976) | def compute_chi_angles(
  function make_transform_from_reference (line 1046) | def make_transform_from_reference(

FILE: alphafold/model/all_atom_test.py
  function _relu (line 33) | def _relu(x):
  function _get_positions_for_ca_c_n_violation_mask (line 38) | def _get_positions_for_ca_c_n_violation_mask():
  function _get_mask_for_ca_c_n_violation_mask (line 44) | def _get_mask_for_ca_c_n_violation_mask():
  function get_identity_rigid (line 50) | def get_identity_rigid(shape):
  function get_global_rigid_transform (line 60) | def get_global_rigid_transform(rot_angle, translation, bcast_dims):
  class AllAtomTest (line 88) | class AllAtomTest(parameterized.TestCase):
    method test_frame_aligned_point_error_perfect_on_global_transform (line 96) | def test_frame_aligned_point_error_perfect_on_global_transform(
    method test_frame_aligned_point_error_matches_expected (line 166) | def test_frame_aligned_point_error_matches_expected(
    method test_between_residue_bond_loss (line 266) | def test_between_residue_bond_loss(

FILE: alphafold/model/base_config.py
  function _strip_optional (line 30) | def _strip_optional(t: type[Any]) -> type[Any]:
  class _Autocreate (line 42) | class _Autocreate:
    method __init__ (line 44) | def __init__(self, **defaults: Any):
  function autocreate (line 48) | def autocreate(**defaults: Any) -> Any:
  function _clone_field (line 53) | def _clone_field(
  class ConfigMeta (line 70) | class ConfigMeta(type):
    method __new__ (line 73) | def __new__(mcs, name, bases, classdict):
  class BaseConfig (line 132) | class BaseConfig(metaclass=ConfigMeta):
    method _coercable_fields (line 148) | def _coercable_fields(self) -> Mapping[str, tuple[type['BaseConfig'], ...
    method as_dict (line 151) | def as_dict(self, include_none: bool = True) -> Mapping[str, Any]:
    method __setattr__ (line 168) | def __setattr__(self, name: str, value: Any) -> None:
    method _toggle_freeze (line 178) | def _toggle_freeze(self, frozen: bool) -> None:
    method freeze (line 186) | def freeze(self) -> None:
    method unfreeze (line 191) | def unfreeze(self: _ConfigT) -> Iterator[_ConfigT]:

FILE: alphafold/model/base_config_test.py
  class InnerConfig (line 23) | class InnerConfig(base_config.BaseConfig):
  class OuterConfig (line 28) | class OuterConfig(base_config.BaseConfig):
  class ModelConfigTest (line 38) | class ModelConfigTest(absltest.TestCase):
    method _equal_at_path (line 40) | def _equal_at_path(self, path, a, b):
    method test_post_init_is_chained (line 43) | def test_post_init_is_chained(self):
    method test_config_is_dataclass (line 53) | def test_config_is_dataclass(self):
    method test_nested_values_not_provided (line 56) | def test_nested_values_not_provided(self):
    method test_config_dict_escape_hatch (line 62) | def test_config_dict_escape_hatch(self):
    method test_config_from_dict (line 71) | def test_config_from_dict(self):
    method test_create_config (line 92) | def test_create_config(self):
    method test_freeze (line 113) | def test_freeze(self):
    method test_unfreeze (line 134) | def test_unfreeze(self):

FILE: alphafold/model/common_modules.py
  function get_initializer_scale (line 31) | def get_initializer_scale(initializer_name, input_shape):
  class Linear (line 54) | class Linear(hk.Module):
    method __init__ (line 62) | def __init__(
    method __call__ (line 98) | def __call__(self, inputs):
  class LayerNorm (line 138) | class LayerNorm(hk.LayerNorm):
    method __init__ (line 146) | def __init__(
    method __call__ (line 172) | def __call__(self, x: jnp.ndarray) -> jnp.ndarray:

FILE: alphafold/model/config.py
  class MaskedMsa (line 689) | class MaskedMsa(base_config.BaseConfig):
  class CommonData (line 696) | class CommonData(base_config.BaseConfig):
  class EvalData (line 708) | class EvalData(base_config.BaseConfig):
  class Data (line 719) | class Data(base_config.BaseConfig):
  class MsaRowAttentionWithPairBias (line 724) | class MsaRowAttentionWithPairBias(base_config.BaseConfig):
  class MsaColumnAttention (line 732) | class MsaColumnAttention(base_config.BaseConfig):
  class MsaTransition (line 740) | class MsaTransition(base_config.BaseConfig):
  class OuterProductMean (line 747) | class OuterProductMean(base_config.BaseConfig):
  class TriangleAttention (line 756) | class TriangleAttention(base_config.BaseConfig):
  class TriangleMultiplication (line 764) | class TriangleMultiplication(base_config.BaseConfig):
  class PairTransition (line 773) | class PairTransition(base_config.BaseConfig):
  class Evoformer (line 780) | class Evoformer(base_config.BaseConfig):
  class TemplateAttention (line 792) | class TemplateAttention(base_config.BaseConfig):
  class DgramFeatures (line 799) | class DgramFeatures(base_config.BaseConfig):
  class TemplatePairStackAttention (line 805) | class TemplatePairStackAttention(base_config.BaseConfig):
  class TemplatePairStackTriangleMultiplication (line 815) | class TemplatePairStackTriangleMultiplication(base_config.BaseConfig):
  class TemplatePairStackTransition (line 824) | class TemplatePairStackTransition(base_config.BaseConfig):
  class TemplatePairStack (line 831) | class TemplatePairStack(base_config.BaseConfig):
  class Template (line 840) | class Template(base_config.BaseConfig):
  class PrevPos (line 852) | class PrevPos(base_config.BaseConfig):
  class EmbeddingsAndEvoformer (line 858) | class EmbeddingsAndEvoformer(base_config.BaseConfig):
  class GlobalConfig (line 881) | class GlobalConfig(base_config.BaseConfig):
  class DistogramHead (line 892) | class DistogramHead(base_config.BaseConfig):
  class PredictedAlignedErrorHead (line 899) | class PredictedAlignedErrorHead(base_config.BaseConfig):
  class ExperimentallyResolvedHead (line 909) | class ExperimentallyResolvedHead(base_config.BaseConfig):
  class Fape (line 916) | class Fape(base_config.BaseConfig):
  class Sidechain (line 922) | class Sidechain(base_config.BaseConfig):
  class StructureModuleHead (line 931) | class StructureModuleHead(base_config.BaseConfig):
  class PredictedLDDTHead (line 957) | class PredictedLDDTHead(base_config.BaseConfig):
  class MaskedMSAHead (line 966) | class MaskedMSAHead(base_config.BaseConfig):
  class Heads (line 971) | class Heads(base_config.BaseConfig):
  class Model (line 980) | class Model(base_config.BaseConfig):
  class AlphaFoldConfig (line 990) | class AlphaFoldConfig(base_config.BaseConfig):
  function model_config (line 995) | def model_config(name: str) -> ml_collections.ConfigDict:
  function get_model_config (line 1009) | def get_model_config(name: str, frozen: bool = True) -> AlphaFoldConfig:
  function _apply_model_1_diff (line 1025) | def _apply_model_1_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_2_diff (line 1034) | def _apply_model_2_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_3_diff (line 1042) | def _apply_model_3_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_4_diff (line 1047) | def _apply_model_4_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_5_diff (line 1052) | def _apply_model_5_diff(cfg: AlphaFoldConfig) -> None:  # pylint: disabl...
  function _apply_model_1_ptm_diff (line 1056) | def _apply_model_1_ptm_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_2_ptm_diff (line 1066) | def _apply_model_2_ptm_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_3_ptm_diff (line 1075) | def _apply_model_3_ptm_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_4_ptm_diff (line 1081) | def _apply_model_4_ptm_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_5_ptm_diff (line 1087) | def _apply_model_5_ptm_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_1_multimer_v3_diff (line 1091) | def _apply_model_1_multimer_v3_diff(cfg: AlphaFoldConfig) -> None:  # py...
  function _apply_model_2_multimer_v3_diff (line 1095) | def _apply_model_2_multimer_v3_diff(cfg: AlphaFoldConfig) -> None:  # py...
  function _apply_model_3_multimer_v3_diff (line 1099) | def _apply_model_3_multimer_v3_diff(cfg: AlphaFoldConfig) -> None:  # py...
  function _apply_model_4_multimer_v3_diff (line 1103) | def _apply_model_4_multimer_v3_diff(cfg: AlphaFoldConfig) -> None:
  function _apply_model_5_multimer_v3_diff (line 1107) | def _apply_model_5_multimer_v3_diff(cfg: AlphaFoldConfig) -> None:
  function _common_updates (line 1111) | def _common_updates(cfg: AlphaFoldConfig) -> None:

FILE: alphafold/model/config_test.py
  class ConfigTest (line 22) | class ConfigTest(parameterized.TestCase):
    method test_config_dict_and_dataclass_agree (line 25) | def test_config_dict_and_dataclass_agree(self, model_name):

FILE: alphafold/model/data.py
  function get_model_haiku_params (line 25) | def get_model_haiku_params(model_name: str, data_dir: str) -> hk.Params:

FILE: alphafold/model/features.py
  function make_data_config (line 28) | def make_data_config(
  function np_example_to_features (line 45) | def np_example_to_features(

FILE: alphafold/model/folding.py
  function squared_difference (line 33) | def squared_difference(x, y):
  class InvariantPointAttention (line 37) | class InvariantPointAttention(hk.Module):
    method __init__ (line 50) | def __init__(
    method __call__ (line 74) | def __call__(self, inputs_1d, inputs_2d, mask, affine):
  class FoldIteration (line 290) | class FoldIteration(hk.Module):
    method __init__ (line 301) | def __init__(self, config, global_config, name='fold_iteration'):
    method __call__ (line 306) | def __call__(
  function generate_affines (line 397) | def generate_affines(
  class StructureModule (line 465) | class StructureModule(hk.Module):
    method __init__ (line 471) | def __init__(
    method __call__ (line 479) | def __call__(self, representations, batch, is_training, safe_key=None):
    method loss (line 527) | def loss(self, value, batch):
  function compute_renamed_ground_truth (line 573) | def compute_renamed_ground_truth(
  function backbone_loss (line 634) | def backbone_loss(ret, batch, value, config):
  function sidechain_loss (line 701) | def sidechain_loss(batch, value, config):
  function structural_violation_loss (line 746) | def structural_violation_loss(ret, batch, value, config):
  function find_structural_violations (line 765) | def find_structural_violations(
  function compute_violation_metrics (line 868) | def compute_violation_metrics(
  function supervised_chi_loss (line 907) | def supervised_chi_loss(ret, batch, value, config):
  function generate_new_affine (line 973) | def generate_new_affine(sequence_mask):
  function l2_normalize (line 983) | def l2_normalize(x, axis=-1, epsilon=1e-12):
  class MultiRigidSidechain (line 989) | class MultiRigidSidechain(hk.Module):
    method __init__ (line 992) | def __init__(self, config, global_config, name='rigid_sidechain'):
    method __call__ (line 997) | def __call__(self, affine, representations_list, aatype):

FILE: alphafold/model/folding_multimer.py
  function squared_difference (line 40) | def squared_difference(x: jnp.ndarray, y: jnp.ndarray) -> jnp.ndarray:
  function make_backbone_affine (line 45) | def make_backbone_affine(
  class QuatRigid (line 65) | class QuatRigid(hk.Module):
    method __init__ (line 68) | def __init__(
    method __call__ (line 102) | def __call__(self, activations: jnp.ndarray) -> geometry.Rigid3Array:
  class PointProjection (line 144) | class PointProjection(hk.Module):
    method __init__ (line 147) | def __init__(
    method __call__ (line 174) | def __call__(
  class InvariantPointAttention (line 194) | class InvariantPointAttention(hk.Module):
    method __init__ (line 205) | def __init__(
    method __call__ (line 229) | def __call__(
  class FoldIteration (line 384) | class FoldIteration(hk.Module):
    method __init__ (line 393) | def __init__(
    method __call__ (line 403) | def __call__(
  function generate_monomer_rigids (line 483) | def generate_monomer_rigids(
  class StructureModule (line 552) | class StructureModule(hk.Module):
    method __init__ (line 558) | def __init__(
    method __call__ (line 568) | def __call__(
    method loss (line 631) | def loss(
  function compute_atom14_gt (line 767) | def compute_atom14_gt(
  function backbone_loss (line 798) | def backbone_loss(
  function compute_frames (line 827) | def compute_frames(
  function sidechain_loss (line 860) | def sidechain_loss(
  function structural_violation_loss (line 900) | def structural_violation_loss(
  function find_structural_violations (line 922) | def find_structural_violations(
  function compute_violation_metrics (line 1030) | def compute_violation_metrics(
  function supervised_chi_loss (line 1067) | def supervised_chi_loss(
  function l2_normalize (line 1119) | def l2_normalize(
  function get_renamed_chi_angles (line 1127) | def get_renamed_chi_angles(
  class MultiRigidSidechain (line 1143) | class MultiRigidSidechain(hk.Module):
    method __init__ (line 1146) | def __init__(
    method __call__ (line 1156) | def __call__(

FILE: alphafold/model/geometry/rigid_matrix_vector.py
  class Rigid3Array (line 32) | class Rigid3Array:
    method __matmul__ (line 38) | def __matmul__(self, other: Rigid3Array) -> Rigid3Array:
    method inverse (line 43) | def inverse(self) -> Rigid3Array:
    method apply_to_point (line 49) | def apply_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
    method apply_inverse_to_point (line 53) | def apply_inverse_to_point(self, point: vector.Vec3Array) -> vector.Ve...
    method compose_rotation (line 58) | def compose_rotation(self, other_rotation):
    method identity (line 66) | def identity(cls, shape, dtype=jnp.float32) -> Rigid3Array:
    method scale_translation (line 73) | def scale_translation(self, factor: Float) -> Rigid3Array:
    method to_array (line 77) | def to_array(self):
    method from_array (line 83) | def from_array(cls, array):
    method from_array4x4 (line 89) | def from_array4x4(cls, array: jnp.ndarray) -> Rigid3Array:
    method __getstate__ (line 103) | def __getstate__(self):
    method __setstate__ (line 106) | def __setstate__(self, state):

FILE: alphafold/model/geometry/rotation_matrix.py
  class Rot3Array (line 33) | class Rot3Array:
    method inverse (line 48) | def inverse(self) -> Rot3Array:
    method apply_to_point (line 56) | def apply_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
    method apply_inverse_to_point (line 64) | def apply_inverse_to_point(self, point: vector.Vec3Array) -> vector.Ve...
    method __matmul__ (line 68) | def __matmul__(self, other: Rot3Array) -> Rot3Array:
    method identity (line 76) | def identity(cls, shape, dtype=jnp.float32) -> Rot3Array:
    method from_two_vectors (line 83) | def from_two_vectors(
    method from_array (line 108) | def from_array(cls, array: jnp.ndarray) -> Rot3Array:
    method to_array (line 114) | def to_array(self) -> jnp.ndarray:
    method from_quaternion (line 126) | def from_quaternion(
    method random_uniform (line 154) | def random_uniform(cls, key, shape, dtype=jnp.float32) -> Rot3Array:
    method __getstate__ (line 160) | def __getstate__(self):
    method __setstate__ (line 163) | def __setstate__(self, state):

FILE: alphafold/model/geometry/struct_of_array.py
  function get_item (line 21) | def get_item(instance, key):
  function get_shape (line 33) | def get_shape(instance):
  function get_len (line 44) | def get_len(instance):
  function get_dtype (line 54) | def get_dtype(instance):
  function replace (line 79) | def replace(instance, **kwargs):
  function post_init (line 83) | def post_init(instance):
  function flatten (line 135) | def flatten(instance):
  function make_metadata_class (line 151) | def make_metadata_class(cls):
  function get_fields (line 164) | def get_fields(cls_or_instance, filterfn, return_values=False):
  function get_array_fields (line 175) | def get_array_fields(cls, return_values=False):
  function get_metadata_fields (line 183) | def get_metadata_fields(cls, return_values=False):
  class StructOfArray (line 191) | class StructOfArray:
    method __init__ (line 194) | def __init__(self, same_dtype=True):
    method __call__ (line 197) | def __call__(self, cls):

FILE: alphafold/model/geometry/test_utils.py
  function assert_rotation_matrix_equal (line 25) | def assert_rotation_matrix_equal(
  function assert_rotation_matrix_close (line 35) | def assert_rotation_matrix_close(
  function assert_array_equal_to_rotation_matrix (line 41) | def assert_array_equal_to_rotation_matrix(
  function assert_array_close_to_rotation_matrix (line 56) | def assert_array_close_to_rotation_matrix(
  function assert_vectors_equal (line 62) | def assert_vectors_equal(vec1: vector.Vec3Array, vec2: vector.Vec3Array):
  function assert_vectors_close (line 68) | def assert_vectors_close(vec1: vector.Vec3Array, vec2: vector.Vec3Array):
  function assert_array_close_to_vector (line 74) | def assert_array_close_to_vector(array: jnp.ndarray, vec: vector.Vec3Arr...
  function assert_array_equal_to_vector (line 78) | def assert_array_equal_to_vector(array: jnp.ndarray, vec: vector.Vec3Arr...
  function assert_rigid_equal_to_rigid (line 82) | def assert_rigid_equal_to_rigid(
  function assert_rigid_close_to_rigid (line 89) | def assert_rigid_close_to_rigid(
  function assert_rot_trans_equal_to_rigid (line 96) | def assert_rot_trans_equal_to_rigid(
  function assert_rot_trans_close_to_rigid (line 105) | def assert_rot_trans_close_to_rigid(

FILE: alphafold/model/geometry/utils.py
  function unstack (line 21) | def unstack(value: jnp.ndarray, axis: int = -1) -> List[jnp.ndarray]:

FILE: alphafold/model/geometry/vector.py
  class Vec3Array (line 33) | class Vec3Array:
    method __post_init__ (line 49) | def __post_init__(self):
    method __add__ (line 56) | def __add__(self, other: Vec3Array) -> Vec3Array:
    method __sub__ (line 59) | def __sub__(self, other: Vec3Array) -> Vec3Array:
    method __mul__ (line 62) | def __mul__(self, other: Float) -> Vec3Array:
    method __rmul__ (line 65) | def __rmul__(self, other: Float) -> Vec3Array:
    method __truediv__ (line 68) | def __truediv__(self, other: Float) -> Vec3Array:
    method __neg__ (line 71) | def __neg__(self) -> Vec3Array:
    method __pos__ (line 74) | def __pos__(self) -> Vec3Array:
    method cross (line 77) | def cross(self, other: Vec3Array) -> Vec3Array:
    method dot (line 84) | def dot(self, other: Vec3Array) -> Float:
    method norm (line 88) | def norm(self, epsilon: float = 1e-6) -> Float:
    method norm2 (line 96) | def norm2(self):
    method normalized (line 99) | def normalized(self, epsilon: float = 1e-6) -> Vec3Array:
    method zeros (line 104) | def zeros(cls, shape, dtype=jnp.float32):
    method to_array (line 112) | def to_array(self) -> jnp.ndarray:
    method from_array (line 116) | def from_array(cls, array):
    method __getstate__ (line 119) | def __getstate__(self):
    method __setstate__ (line 125) | def __setstate__(self, state):
  function square_euclidean_distance (line 132) | def square_euclidean_distance(
  function dot (line 154) | def dot(vector1: Vec3Array, vector2: Vec3Array) -> Float:
  function cross (line 158) | def cross(vector1: Vec3Array, vector2: Vec3Array) -> Float:
  function norm (line 162) | def norm(vector: Vec3Array, epsilon: float = 1e-6) -> Float:
  function normalized (line 166) | def normalized(vector: Vec3Array, epsilon: float = 1e-6) -> Vec3Array:
  function euclidean_distance (line 170) | def euclidean_distance(
  function dihedral_angle (line 190) | def dihedral_angle(
  function random_gaussian_vector (line 219) | def random_gaussian_vector(shape, key, dtype=jnp.float32):

FILE: alphafold/model/layer_stack.py
  function _check_no_varargs (line 39) | def _check_no_varargs(f):
  function nullcontext (line 52) | def nullcontext():
  function maybe_with_rng (line 56) | def maybe_with_rng(key):
  function maybe_fold_in (line 63) | def maybe_fold_in(key, data):
  class _LayerStack (line 70) | class _LayerStack(hk.Module):
    method __init__ (line 73) | def __init__(self, count: int, unroll: int, name: Optional[str] = None):
    method __call__ (line 79) | def __call__(self, x, *args_ys):
    method _call_wrapped (line 169) | def _call_wrapped(
  class _LayerStackNoState (line 177) | class _LayerStackNoState(_LayerStack):
    method __init__ (line 180) | def __init__(
    method _call_wrapped (line 188) | def _call_wrapped(self, args, y):
  class _LayerStackWithState (line 198) | class _LayerStackWithState(_LayerStack):
    method __init__ (line 201) | def __init__(
    method _call_wrapped (line 208) | def _call_wrapped(self, x, *args):
  function layer_stack (line 212) | def layer_stack(

FILE: alphafold/model/layer_stack_test.py
  function _slice_layers_params (line 30) | def _slice_layers_params(layers_params):
  class LayerStackTest (line 42) | class LayerStackTest(parameterized.TestCase):
    method test_layer_stack (line 45) | def test_layer_stack(self, unroll):
    method test_layer_stack_multi_args (line 86) | def test_layer_stack_multi_args(self):
    method test_layer_stack_no_varargs (line 126) | def test_layer_stack_no_varargs(self):
    method test_layer_stack_grads (line 156) | def test_layer_stack_grads(self, unroll):
    method test_random (line 207) | def test_random(self):
    method test_threading (line 227) | def test_threading(self):
    method test_nested_stacks (line 252) | def test_nested_stacks(self):
    method test_with_state_multi_args (line 274) | def test_with_state_multi_args(self):
    method test_with_container_state (line 303) | def test_with_container_state(self):

FILE: alphafold/model/lddt.py
  function lddt (line 19) | def lddt(

FILE: alphafold/model/lddt_test.py
  class LddtTest (line 21) | class LddtTest(parameterized.TestCase, absltest.TestCase):
    method test_lddt (line 79) | def test_lddt(self, predicted_pos, true_pos, exp_lddt):

FILE: alphafold/model/mapping.py
  function _set_docstring (line 36) | def _set_docstring(docstr: str) -> Callable[[T], T]:
  function _maybe_slice (line 46) | def _maybe_slice(array, i, slice_size, axis):
  function _maybe_get_size (line 55) | def _maybe_get_size(array, axis):
  function _expand_axes (line 62) | def _expand_axes(axes, values, name='sharded_apply'):
  function sharded_map (line 70) | def sharded_map(
  function sharded_apply (line 101) | def sharded_apply(
  function inference_subbatch (line 224) | def inference_subbatch(

FILE: alphafold/model/model.py
  function get_confidence_metrics (line 31) | def get_confidence_metrics(
  class RunModel (line 72) | class RunModel:
    method __init__ (line 75) | def __init__(
    method init_params (line 104) | def init_params(self, feat: features.FeatureDict, random_seed: int = 0):
    method process_features (line 122) | def process_features(
    method eval_shape (line 143) | def eval_shape(self, feat: features.FeatureDict) -> jax.ShapeDtypeStruct:
    method predict (line 153) | def predict(

FILE: alphafold/model/modules.py
  function softmax_cross_entropy (line 38) | def softmax_cross_entropy(logits, labels):
  function sigmoid_cross_entropy (line 44) | def sigmoid_cross_entropy(logits, labels):
  function apply_dropout (line 53) | def apply_dropout(*, tensor, safe_key, rate, is_training, broadcast_dim=...
  function dropout_wrapper (line 66) | def dropout_wrapper(
  function create_extra_msa_feature (line 108) | def create_extra_msa_feature(batch):
  class AlphaFoldIteration (line 134) | class AlphaFoldIteration(hk.Module):
    method __init__ (line 145) | def __init__(self, config, global_config, name='alphafold_iteration'):
    method __call__ (line 150) | def __call__(
  class AlphaFold (line 289) | class AlphaFold(hk.Module):
    method __init__ (line 295) | def __init__(self, config, name='alphafold'):
    method __call__ (line 300) | def __call__(
  class TemplatePairStack (line 414) | class TemplatePairStack(hk.Module):
    method __init__ (line 420) | def __init__(self, config, global_config, name='template_pair_stack'):
    method __call__ (line 425) | def __call__(self, pair_act, pair_mask, is_training, safe_key=None):
  class Transition (line 515) | class Transition(hk.Module):
    method __init__ (line 522) | def __init__(self, config, global_config, name='transition_block'):
    method __call__ (line 527) | def __call__(self, act, mask, is_training=True):
  function glorot_uniform (line 573) | def glorot_uniform():
  class Attention (line 579) | class Attention(hk.Module):
    method __init__ (line 582) | def __init__(self, config, global_config, output_dim, name='attention'):
    method __call__ (line 589) | def __call__(self, q_data, m_data, mask, nonbatched_bias=None):
  class GlobalAttention (line 686) | class GlobalAttention(hk.Module):
    method __init__ (line 692) | def __init__(self, config, global_config, output_dim, name='attention'):
    method __call__ (line 699) | def __call__(self, q_data, m_data, q_mask):
  class MSARowAttentionWithPairBias (line 795) | class MSARowAttentionWithPairBias(hk.Module):
    method __init__ (line 801) | def __init__(
    method __call__ (line 808) | def __call__(self, msa_act, msa_mask, pair_act, is_training=False):
  class MSAColumnAttention (line 858) | class MSAColumnAttention(hk.Module):
    method __init__ (line 864) | def __init__(self, config, global_config, name='msa_column_attention'):
    method __call__ (line 869) | def __call__(self, msa_act, msa_mask, is_training=False):
  class MSAColumnGlobalAttention (line 910) | class MSAColumnGlobalAttention(hk.Module):
    method __init__ (line 916) | def __init__(self, config, global_config, name='msa_column_global_atte...
    method __call__ (line 921) | def __call__(self, msa_act, msa_mask, is_training=False):
  class TriangleAttention (line 963) | class TriangleAttention(hk.Module):
    method __init__ (line 970) | def __init__(self, config, global_config, name='triangle_attention'):
    method __call__ (line 975) | def __call__(self, pair_act, pair_mask, is_training=False):
  class MaskedMsaHead (line 1027) | class MaskedMsaHead(hk.Module):
    method __init__ (line 1036) | def __init__(self, config, global_config, name='masked_msa_head'):
    method __call__ (line 1046) | def __call__(self, representations, batch, is_training):
    method loss (line 1068) | def loss(self, value, batch):
  class PredictedLDDTHead (line 1079) | class PredictedLDDTHead(hk.Module):
    method __init__ (line 1086) | def __init__(self, config, global_config, name='predicted_lddt_head'):
    method __call__ (line 1091) | def __call__(self, representations, batch, is_training):
    method loss (line 1133) | def loss(self, value, batch):
  class PredictedAlignedErrorHead (line 1181) | class PredictedAlignedErrorHead(hk.Module):
    method __init__ (line 1188) | def __init__(
    method __call__ (line 1195) | def __call__(self, representations, batch, is_training):
    method loss (line 1224) | def loss(self, value, batch):
  class ExperimentallyResolvedHead (line 1284) | class ExperimentallyResolvedHead(hk.Module):
    method __init__ (line 1291) | def __init__(
    method __call__ (line 1298) | def __call__(self, representations, batch, is_training):
    method loss (line 1320) | def loss(self, value, batch):
  function _layer_norm (line 1344) | def _layer_norm(axis=-1, name='layer_norm'):
  class TriangleMultiplication (line 1358) | class TriangleMultiplication(hk.Module):
    method __init__ (line 1365) | def __init__(self, config, global_config, name='triangle_multiplicatio...
    method __call__ (line 1370) | def __call__(self, left_act, left_mask, is_training=True):
    method _triangle_multiplication (line 1389) | def _triangle_multiplication(self, left_act, left_mask):
    method _fused_triangle_multiplication (line 1471) | def _fused_triangle_multiplication(self, left_act, left_mask):
  class DistogramHead (line 1519) | class DistogramHead(hk.Module):
    method __init__ (line 1525) | def __init__(self, config, global_config, name='distogram_head'):
    method __call__ (line 1530) | def __call__(self, representations, batch, is_training):
    method loss (line 1559) | def loss(self, value, batch):
  function _distogram_log_loss (line 1565) | def _distogram_log_loss(logits, bin_edges, batch, num_bins):
  class OuterProductMean (line 1600) | class OuterProductMean(hk.Module):
    method __init__ (line 1606) | def __init__(
    method __call__ (line 1614) | def __call__(self, act, mask, is_training=True):
  function dgram_from_positions (line 1692) | def dgram_from_positions(positions, num_bins, min_bin, max_bin):
  function pseudo_beta_fn (line 1729) | def pseudo_beta_fn(aatype, all_atom_positions, all_atom_masks):
  class EvoformerIteration (line 1751) | class EvoformerIteration(hk.Module):
    method __init__ (line 1757) | def __init__(
    method __call__ (line 1765) | def __call__(self, activations, masks, is_training=True, safe_key=None):
  class EmbeddingsAndEvoformer (line 1904) | class EmbeddingsAndEvoformer(hk.Module):
    method __init__ (line 1911) | def __init__(self, config, global_config, name='evoformer'):
    method __call__ (line 1916) | def __call__(self, batch, is_training, safe_key=None):
  class SingleTemplateEmbedding (line 2150) | class SingleTemplateEmbedding(hk.Module):
    method __init__ (line 2156) | def __init__(self, config, global_config, name='single_template_embedd...
    method __call__ (line 2161) | def __call__(self, query_embedding, batch, mask_2d, is_training):
  class TemplateEmbedding (line 2258) | class TemplateEmbedding(hk.Module):
    method __init__ (line 2265) | def __init__(self, config, global_config, name='template_embedding'):
    method __call__ (line 2270) | def __call__(self, query_embedding, template_batch, mask_2d, is_traini...

FILE: alphafold/model/modules_multimer.py
  function reduce_fn (line 41) | def reduce_fn(x, mode):
  function gumbel_noise (line 52) | def gumbel_noise(key: jnp.ndarray, shape: Sequence[int]) -> jnp.ndarray:
  function gumbel_max_sample (line 73) | def gumbel_max_sample(key: jnp.ndarray, logits: jnp.ndarray) -> jnp.ndar...
  function gumbel_argsort_sample_idx (line 92) | def gumbel_argsort_sample_idx(
  function make_masked_msa (line 121) | def make_masked_msa(batch, key, config, epsilon=1e-6):
  function nearest_neighbor_clusters (line 164) | def nearest_neighbor_clusters(batch, gap_agreement_weight=0.0):
  function create_msa_feat (line 212) | def create_msa_feat(batch):
  function create_extra_msa_feature (line 236) | def create_extra_msa_feature(batch, num_extra_msa):
  function sample_msa (line 266) | def sample_msa(key, batch, max_seq):
  function make_msa_profile (line 301) | def make_msa_profile(batch):
  class AlphaFoldIteration (line 310) | class AlphaFoldIteration(hk.Module):
    method __init__ (line 318) | def __init__(self, config, global_config, name='alphafold_iteration'):
    method __call__ (line 323) | def __call__(
  class AlphaFold (line 427) | class AlphaFold(hk.Module):
    method __init__ (line 430) | def __init__(self, config, name='alphafold'):
    method __call__ (line 435) | def __call__(
  class EmbeddingsAndEvoformer (line 539) | class EmbeddingsAndEvoformer(hk.Module):
    method __init__ (line 545) | def __init__(self, config, global_config, name='evoformer'):
    method _relative_encoding (line 550) | def _relative_encoding(self, batch):
    method __call__ (line 629) | def __call__(self, batch, is_training, safe_key=None):
  class TemplateEmbedding (line 846) | class TemplateEmbedding(hk.Module):
    method __init__ (line 849) | def __init__(self, config, global_config, name='template_embedding'):
    method __call__ (line 854) | def __call__(
  class SingleTemplateEmbedding (line 941) | class SingleTemplateEmbedding(hk.Module):
    method __init__ (line 944) | def __init__(self, config, global_config, name='single_template_embedd...
    method __call__ (line 949) | def __call__(
  class TemplateEmbeddingIteration (line 1110) | class TemplateEmbeddingIteration(hk.Module):
    method __init__ (line 1113) | def __init__(
    method __call__ (line 1120) | def __call__(self, act, pair_mask, is_training=True, safe_key=None):
  function template_embedding_1d (line 1196) | def template_embedding_1d(batch, num_channel, global_config):

FILE: alphafold/model/prng.py
  function safe_dropout (line 21) | def safe_dropout(*, tensor, safe_key, rate, is_deterministic, is_training):
  class SafeKey (line 28) | class SafeKey:
    method __init__ (line 31) | def __init__(self, key):
    method _assert_not_used (line 35) | def _assert_not_used(self):
    method get (line 39) | def get(self):
    method split (line 44) | def split(self, num_keys=2):
    method duplicate (line 50) | def duplicate(self, num_keys=2):
  function _safe_key_flatten (line 56) | def _safe_key_flatten(safe_key):
  function _safe_key_unflatten (line 61) | def _safe_key_unflatten(aux_data, children):

FILE: alphafold/model/prng_test.py
  class PrngTest (line 20) | class PrngTest(absltest.TestCase):
    method test_key_reuse (line 22) | def test_key_reuse(self):

FILE: alphafold/model/quat_affine.py
  function rot_to_quat (line 93) | def rot_to_quat(rot, unstack_inputs=False):
  function rot_list_to_tensor (line 128) | def rot_list_to_tensor(rot_list):
  function vec_list_to_tensor (line 140) | def vec_list_to_tensor(vec_list):
  function quat_to_rot (line 145) | def quat_to_rot(normalized_quat):
  function quat_multiply_by_vec (line 161) | def quat_multiply_by_vec(quat, vec):
  function quat_multiply (line 169) | def quat_multiply(quat1, quat2):
  function apply_rot_to_vec (line 177) | def apply_rot_to_vec(rot, vec, unstack=False):
  function apply_inverse_rot_to_vec (line 190) | def apply_inverse_rot_to_vec(rot, vec):
  class QuatAffine (line 200) | class QuatAffine(object):
    method __init__ (line 203) | def __init__(
    method to_tensor (line 249) | def to_tensor(self):
    method apply_tensor_fn (line 256) | def apply_tensor_fn(self, tensor_fn):
    method apply_rotation_tensor_fn (line 265) | def apply_rotation_tensor_fn(self, tensor_fn):
    method scale_translation (line 274) | def scale_translation(self, position_scale):
    method from_tensor (line 285) | def from_tensor(cls, tensor, normalize=False):
    method pre_compose (line 291) | def pre_compose(self, update):
    method apply_to_point (line 322) | def apply_to_point(self, point, extra_dims=0):
    method invert_point (line 349) | def invert_point(self, transformed_point, extra_dims=0):
    method __repr__ (line 377) | def __repr__(self):
  function _multiply (line 381) | def _multiply(a, b):
  function make_canonical_transform (line 401) | def make_canonical_transform(
  function make_transform_from_reference (line 484) | def make_transform_from_reference(

FILE: alphafold/model/quat_affine_test.py
  class QuatAffineTest (line 31) | class QuatAffineTest(absltest.TestCase):
    method _assert_check (line 33) | def _assert_check(self, to_check, tol=1e-5):
    method test_conversion (line 41) | def test_conversion(self):
    method test_double_cover (line 67) | def test_double_cover(self):
    method test_homomorphism (line 81) | def test_homomorphism(self):
    method test_batching (line 114) | def test_batching(self):
    method assertAllClose (line 138) | def assertAllClose(self, a, b, rtol=1e-06, atol=1e-06):
    method assertAllEqual (line 141) | def assertAllEqual(self, a, b):

FILE: alphafold/model/r3.py
  function squared_difference (line 56) | def squared_difference(x, y):
  function invert_rigids (line 60) | def invert_rigids(r: Rigids) -> Rigids:
  function invert_rots (line 68) | def invert_rots(m: Rots) -> Rots:
  function rigids_from_3_points (line 73) | def rigids_from_3_points(
  function rigids_from_list (line 101) | def rigids_from_list(l: List[jnp.ndarray]) -> Rigids:
  function rigids_from_quataffine (line 107) | def rigids_from_quataffine(a: quat_affine.QuatAffine) -> Rigids:
  function rigids_from_tensor4x4 (line 112) | def rigids_from_tensor4x4(
  function rigids_from_tensor_flat9 (line 143) | def rigids_from_tensor_flat9(
  function rigids_from_tensor_flat12 (line 154) | def rigids_from_tensor_flat12(
  function rigids_mul_rigids (line 163) | def rigids_mul_rigids(a: Rigids, b: Rigids) -> Rigids:
  function rigids_mul_rots (line 171) | def rigids_mul_rots(r: Rigids, m: Rots) -> Rigids:
  function rigids_mul_vecs (line 176) | def rigids_mul_vecs(r: Rigids, v: Vecs) -> Vecs:
  function rigids_to_list (line 181) | def rigids_to_list(r: Rigids) -> List[jnp.ndarray]:
  function rigids_to_quataffine (line 186) | def rigids_to_quataffine(r: Rigids) -> quat_affine.QuatAffine:
  function rigids_to_tensor_flat9 (line 199) | def rigids_to_tensor_flat9(
  function rigids_to_tensor_flat12 (line 210) | def rigids_to_tensor_flat12(
  function rots_from_tensor3x3 (line 217) | def rots_from_tensor3x3(
  function rots_from_two_vecs (line 236) | def rots_from_two_vecs(e0_unnormalized: Vecs, e1_unnormalized: Vecs) -> ...
  function rots_mul_rots (line 267) | def rots_mul_rots(a: Rots, b: Rots) -> Rots:
  function rots_mul_vecs (line 275) | def rots_mul_vecs(m: Rots, v: Vecs) -> Vecs:
  function vecs_add (line 284) | def vecs_add(v1: Vecs, v2: Vecs) -> Vecs:
  function vecs_dot_vecs (line 289) | def vecs_dot_vecs(v1: Vecs, v2: Vecs) -> jnp.ndarray:
  function vecs_cross_vecs (line 294) | def vecs_cross_vecs(v1: Vecs, v2: Vecs) -> Vecs:
  function vecs_from_tensor (line 303) | def vecs_from_tensor(x: jnp.ndarray) -> Vecs:  # shape (..., 3)  # shape...
  function vecs_robust_normalize (line 310) | def vecs_robust_normalize(v: Vecs, epsilon: float = 1e-8) -> Vecs:
  function vecs_robust_norm (line 324) | def vecs_robust_norm(v: Vecs, epsilon: float = 1e-8) -> jnp.ndarray:
  function vecs_sub (line 337) | def vecs_sub(v1: Vecs, v2: Vecs) -> Vecs:
  function vecs_squared_distance (line 342) | def vecs_squared_distance(v1: Vecs, v2: Vecs) -> jnp.ndarray:
  function vecs_to_tensor (line 351) | def vecs_to_tensor(v: Vecs) -> jnp.ndarray:  # shape (...)  # shape(..., 3)

FILE: alphafold/model/tf/data_transforms.py
  function cast_64bit_ints (line 35) | def cast_64bit_ints(protein):
  function make_seq_mask (line 53) | def make_seq_mask(protein):
  function make_template_mask (line 60) | def make_template_mask(protein):
  function curry1 (line 68) | def curry1(f):
  function add_distillation_flag (line 78) | def add_distillation_flag(protein, distillation):
  function make_all_atom_aatype (line 85) | def make_all_atom_aatype(protein):
  function fix_templates_aatype (line 90) | def fix_templates_aatype(protein):
  function correct_msa_restypes (line 105) | def correct_msa_restypes(protein):
  function squeeze_features (line 126) | def squeeze_features(protein):
  function make_random_crop_to_size_seed (line 155) | def make_random_crop_to_size_seed(protein):
  function randomly_replace_msa_with_unknown (line 162) | def randomly_replace_msa_with_unknown(protein, replace_proportion):
  function sample_msa (line 186) | def sample_msa(protein, max_seq, keep_extra):
  function crop_extra_msa (line 215) | def crop_extra_msa(protein, max_extra_msa):
  function delete_extra_msa (line 227) | def delete_extra_msa(protein):
  function block_delete_msa (line 235) | def block_delete_msa(protein, config):
  function nearest_neighbor_clusters (line 278) | def nearest_neighbor_clusters(protein, gap_agreement_weight=0.0):
  function summarize_clusters (line 317) | def summarize_clusters(protein):
  function make_msa_mask (line 343) | def make_msa_mask(protein):
  function pseudo_beta_fn (line 354) | def pseudo_beta_fn(aatype, all_atom_positions, all_atom_masks):
  function make_pseudo_beta (line 376) | def make_pseudo_beta(protein, prefix=''):
  function add_constant_field (line 390) | def add_constant_field(protein, key, value):
  function shaped_categorical (line 395) | def shaped_categorical(probs, epsilon=1e-10):
  function make_hhblits_profile (line 404) | def make_hhblits_profile(protein):
  function make_masked_msa (line 417) | def make_masked_msa(protein, config, replace_fraction):
  function make_fixed_size (line 452) | def make_fixed_size(
  function make_msa_feat (line 491) | def make_msa_feat(protein):
  function select_feat (line 538) | def select_feat(protein, feature_list):
  function crop_templates (line 543) | def crop_templates(protein, max_templates):
  function random_crop_to_size (line 551) | def random_crop_to_size(
  function make_atom14_masks (line 628) | def make_atom14_masks(protein):

FILE: alphafold/model/tf/input_pipeline.py
  function nonensembled_map_fns (line 34) | def nonensembled_map_fns(data_config):
  function ensembled_map_fns (line 65) | def ensembled_map_fns(data_config):
  function process_tensors_from_config (line 131) | def process_tensors_from_config(tensors, data_config):
  function compose (line 165) | def compose(x, fs):

FILE: alphafold/model/tf/protein_features.py
  class FeatureType (line 25) | class FeatureType(enum.Enum):
  function register_feature (line 75) | def register_feature(
  function shape (line 84) | def shape(

FILE: alphafold/model/tf/protein_features_test.py
  class FeaturesTest (line 19) | class FeaturesTest(absltest.TestCase):
    method testFeatureNames (line 21) | def testFeatureNames(self):
    method testReplacement (line 30) | def testReplacement(self):

FILE: alphafold/model/tf/proteins_dataset.py
  function _first (line 24) | def _first(tensor: tf.Tensor) -> tf.Tensor:
  function parse_reshape_logic (line 29) | def parse_reshape_logic(
  function _make_features_metadata (line 95) | def _make_features_metadata(
  function np_to_tensor_dict (line 109) | def np_to_tensor_dict(

FILE: alphafold/model/tf/shape_helpers.py
  function shape_list (line 19) | def shape_list(x):

FILE: alphafold/model/tf/shape_helpers_test.py
  class ShapeTest (line 20) | class ShapeTest(tf.test.TestCase):
    method setUp (line 22) | def setUp(self):
    method test_shape_list (line 26) | def test_shape_list(self):

FILE: alphafold/model/tf/utils.py
  class SeedMaker (line 19) | class SeedMaker(object):
    method __init__ (line 22) | def __init__(self, initial_seed=0):
    method __call__ (line 25) | def __call__(self):
  function make_random_seed (line 34) | def make_random_seed():

FILE: alphafold/model/utils.py
  function stable_softmax (line 30) | def stable_softmax(logits: jax.Array) -> jax.Array:
  function bfloat16_creator (line 44) | def bfloat16_creator(next_creator, shape, dtype, init, context):
  function bfloat16_getter (line 51) | def bfloat16_getter(next_getter, value, context):
  function bfloat16_context (line 60) | def bfloat16_context():
  function final_init (line 65) | def final_init(config):
  function batched_gather (line 72) | def batched_gather(params, indices, axis=0, batch_dims=0):
  function mask_mean (line 80) | def mask_mean(mask, value, axis=None, drop_mask_channel=False, eps=1e-10):
  function flat_params_to_haiku (line 112) | def flat_params_to_haiku(params: Mapping[str, np.ndarray]) -> hk.Params:
  function padding_consistent_rng (line 124) | def padding_consistent_rng(f):
  function ks_normal_test (line 181) | def ks_normal_test(

FILE: alphafold/notebooks/notebook_utils.py
  function clean_and_validate_single_sequence (line 24) | def clean_and_validate_single_sequence(
  function clean_and_validate_input_sequences (line 54) | def clean_and_validate_input_sequences(
  function merge_chunked_msa (line 80) | def merge_chunked_msa(
  function show_msa_info (line 112) | def show_msa_info(
  function empty_placeholder_template_features (line 144) | def empty_placeholder_template_features(
  function check_cell_execution_order (line 170) | def check_cell_execution_order(

FILE: alphafold/notebooks/notebook_utils_test.py
  class NotebookUtilsTest (line 104) | class NotebookUtilsTest(parameterized.TestCase):
    method test_clean_and_validate_sequence_ok (line 113) | def test_clean_and_validate_sequence_ok(self, sequence, exp_clean):
    method test_clean_and_validate_sequence_bad (line 129) | def test_clean_and_validate_sequence_bad(self, sequence, exp_error):
    method test_validate_input_ok (line 141) | def test_validate_input_ok(self, input_sequences, exp_sequences):
    method test_validate_input_bad (line 154) | def test_validate_input_bad(self, input_sequences, exp_error):
    method test_merge_chunked_msa_no_hits (line 162) | def test_merge_chunked_msa_no_hits(self):
    method test_merge_chunked_msa (line 171) | def test_merge_chunked_msa(self):
    method test_show_msa_info (line 196) | def test_show_msa_info(self, mocked_stdout):
    method test_empty_placeholder_template_features (line 218) | def test_empty_placeholder_template_features(self, num_templates):
    method test_check_cell_execution_order_correct (line 236) | def test_check_cell_execution_order_correct(self):
    method test_check_cell_execution_order_missing (line 243) | def test_check_cell_execution_order_missing(

FILE: alphafold/relax/amber_minimize.py
  function will_restrain (line 40) | def will_restrain(atom: openmm_app.Atom, rset: str) -> bool:
  function _add_restraints (line 49) | def _add_restraints(
  function _openmm_minimize (line 79) | def _openmm_minimize(
  function _get_pdb_string (line 116) | def _get_pdb_string(topology: openmm_app.Topology, positions: unit.Quant...
  function _check_cleaned_atoms (line 123) | def _check_cleaned_atoms(pdb_cleaned_string: str, pdb_ref_string: str):
  function _check_residues_are_well_defined (line 145) | def _check_residues_are_well_defined(prot: protein.Protein):
  function _check_atom_mask_is_ideal (line 155) | def _check_atom_mask_is_ideal(prot):
  function clean_protein (line 162) | def clean_protein(prot: protein.Protein, checks: bool = True):
  function make_atom14_positions (line 194) | def make_atom14_positions(prot):
  function find_violations (line 333) | def find_violations(prot_np: protein.Protein):
  function get_violation_metrics (line 370) | def get_violation_metrics(prot: protein.Protein):
  function _run_one_iteration (line 383) | def _run_one_iteration(
  function run_pipeline (line 446) | def run_pipeline(

FILE: alphafold/relax/amber_minimize_test.py
  function _load_test_protein (line 27) | def _load_test_protein(data_path):
  class AmberMinimizeTest (line 33) | class AmberMinimizeTest(absltest.TestCase):
    method test_multiple_disulfides_target (line 35) | def test_multiple_disulfides_target(self):
    method test_raises_invalid_protein_assertion (line 49) | def test_raises_invalid_protein_assertion(self):
    method test_iterative_relax (line 67) | def test_iterative_relax(self):
    method test_find_violations (line 79) | def test_find_violations(self):

FILE: alphafold/relax/cleanup.py
  function fix_pdb (line 27) | def fix_pdb(pdbfile, alterations_info):
  function clean_structure (line 64) | def clean_structure(pdb_structure, alterations_info):
  function _remove_heterogens (line 75) | def _remove_heterogens(fixer, alterations_info, keep_water):
  function _replace_met_se (line 97) | def _replace_met_se(pdb_structure, alterations_info):
  function _remove_chains_of_length_one (line 111) | def _remove_chains_of_length_one(pdb_structure, alterations_info):

FILE: alphafold/relax/cleanup_test.py
  function _pdb_to_structure (line 22) | def _pdb_to_structure(pdb_str):
  function _lines_to_structure (line 27) | def _lines_to_structure(pdb_lines):
  class CleanupTest (line 31) | class CleanupTest(absltest.TestCase):
    method test_missing_residues (line 33) | def test_missing_residues(self):
    method test_missing_atoms (line 57) | def test_missing_atoms(self):
    method test_remove_heterogens (line 86) | def test_remove_heterogens(self):
    method test_fix_nonstandard_residues (line 105) | def test_fix_nonstandard_residues(self):
    method test_replace_met_se (line 125) | def test_replace_met_se(self):
    method test_remove_chains_of_length_one (line 142) | def test_remove_chains_of_length_one(self):

FILE: alphafold/relax/relax.py
  class AmberRelaxation (line 23) | class AmberRelaxation(object):
    method __init__ (line 26) | def __init__(
    method process (line 60) | def process(

FILE: alphafold/relax/relax_test.py
  class RunAmberRelaxTest (line 25) | class RunAmberRelaxTest(absltest.TestCase):
    method setUp (line 27) | def setUp(self):
    method test_process (line 42) | def test_process(self):
    method test_unresolved_violations (line 78) | def test_unresolved_violations(self):

FILE: alphafold/relax/utils.py
  function overwrite_b_factors (line 22) | def overwrite_b_factors(pdb_str: str, bfactors: np.ndarray) -> str:
  function assert_equal_nonterminal_atom_types (line 64) | def assert_equal_nonterminal_atom_types(

FILE: alphafold/relax/utils_test.py
  class UtilsTest (line 25) | class UtilsTest(absltest.TestCase):
    method test_overwrite_b_factors (line 27) | def test_overwrite_b_factors(self):

FILE: conftest.py
  function initialize_absl_flags (line 27) | def initialize_absl_flags(request):

FILE: docker/run_docker.py
  function _create_mount (line 133) | def _create_mount(mount_name: str, path: str) -> Tuple[types.Mount, str]:
  function main (line 159) | def main(argv):

FILE: run_alphafold.py
  class ModelsToRelax (line 51) | class ModelsToRelax(enum.Enum):
  function _check_flag (line 269) | def _check_flag(flag_name: str, other_flag_name: str, should_be_set: bool):
  function _jnp_to_np (line 278) | def _jnp_to_np(output: Dict[str, Any]) -> Dict[str, Any]:
  function _save_confidence_json_file (line 288) | def _save_confidence_json_file(
  function _save_mmcif_file (line 301) | def _save_mmcif_file(
  function _save_pae_json_file (line 326) | def _save_pae_json_file(
  function predict_structure (line 345) | def predict_structure(
  function main (line 558) | def main(argv):

FILE: run_alphafold_test.py
  class RunAlphafoldTest (line 29) | class RunAlphafoldTest(parameterized.TestCase):
    method test_end_to_end (line 35) | def test_end_to_end(self, models_to_relax):