SYMBOL INDEX (739 symbols across 68 files)

FILE: alphafold/common/confidence.py
  function compute_plddt (line 22) | def compute_plddt(logits: np.ndarray) -> np.ndarray:
  function _calculate_bin_centers (line 39) | def _calculate_bin_centers(breaks: np.ndarray):
  function _calculate_expected_aligned_error (line 58) | def _calculate_expected_aligned_error(
  function compute_predicted_aligned_error (line 80) | def compute_predicted_aligned_error(
  function predicted_tm_score (line 111) | def predicted_tm_score(

FILE: alphafold/common/protein.py
  class Protein (line 32) | class Protein:
    method __post_init__ (line 59) | def __post_init__(self):
  function from_pdb_string (line 66) | def from_pdb_string(pdb_str: str, chain_id: Optional[str] = None) -> Pro...
  function _chain_end (line 140) | def _chain_end(atom_index, end_resname, chain_name, residue_index) -> str:
  function to_pdb (line 146) | def to_pdb(prot: Protein) -> str:
  function ideal_atom_mask (line 226) | def ideal_atom_mask(prot: Protein) -> np.ndarray:
  function from_prediction (line 242) | def from_prediction(

FILE: alphafold/common/protein_test.py
  class ProteinTest (line 29) | class ProteinTest(parameterized.TestCase):
    method _check_shapes (line 31) | def _check_shapes(self, prot, num_res):
    method test_from_pdb_str (line 48) | def test_from_pdb_str(self, pdb_file, chain_id, num_res, num_chains):
    method test_to_pdb (line 60) | def test_to_pdb(self):
    method test_ideal_atom_mask (line 85) | def test_ideal_atom_mask(self):
    method test_too_many_chains (line 100) | def test_too_many_chains(self):

FILE: alphafold/common/residue_constants.py
  function load_stereo_chemical_props (line 392) | def load_stereo_chemical_props() -> Tuple[Mapping[str, List[Bond]],
  function sequence_to_onehot (line 546) | def sequence_to_onehot(
  function _make_standard_atom_mask (line 695) | def _make_standard_atom_mask() -> np.ndarray:
  function chi_angle_atom (line 713) | def chi_angle_atom(atom_index: int) -> np.ndarray:
  function _make_rigid_transformation_4x4 (line 755) | def _make_rigid_transformation_4x4(ex, ey, translation):
  function _make_rigid_group_constants (line 784) | def _make_rigid_group_constants():
  function make_atom14_dists_bounds (line 855) | def make_atom14_dists_bounds(overlap_tolerance=1.5,

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 53) | def testResidueAtoms(self, atom_name, num_residue_atoms):
    method testStandardAtomMask (line 57) | def testStandardAtomMask(self):
    method testAtomTypes (line 100) | def testAtomTypes(self):
    method testRestypes (line 116) | def testRestypes(self):
    method testSequenceToOneHotHHBlits (line 124) | def testSequenceToOneHotHHBlits(self):
    method testSequenceToOneHotStandard (line 157) | def testSequenceToOneHotStandard(self):
    method testSequenceToOneHotUnknownMapping (line 162) | def testSequenceToOneHotUnknownMapping(self):
    method testSequenceToOneHotUnknownMappingError (line 181) | def testSequenceToOneHotUnknownMappingError(self, seq):

FILE: alphafold/data/feature_processing.py
  function _is_homomer_or_monomer (line 39) | def _is_homomer_or_monomer(chains: Iterable[pipeline.FeatureDict]) -> bool:
  function pair_and_merge (line 48) | def pair_and_merge(
  function crop_chains (line 82) | def crop_chains(
  function _crop_single_chain (line 112) | def _crop_single_chain(chain: pipeline.FeatureDict,
  function process_final (line 163) | def process_final(np_example: pipeline.FeatureDict) -> pipeline.FeatureD...
  function _correct_msa_restypes (line 172) | def _correct_msa_restypes(np_example):
  function _make_seq_mask (line 180) | def _make_seq_mask(np_example):
  function _make_msa_mask (line 185) | def _make_msa_mask(np_example):
  function _filter_features (line 196) | def _filter_features(np_example: pipeline.FeatureDict) -> pipeline.Featu...
  function process_unmerged_features (line 201) | 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 96) | class ParsingResult:
  class ParseError (line 108) | class ParseError(Exception):
  function mmcif_loop_to_list (line 112) | def mmcif_loop_to_list(prefix: str,
  function mmcif_loop_to_dict (line 142) | def mmcif_loop_to_dict(prefix: str,
  function parse (line 165) | def parse(*,
  function _get_first_model (line 282) | def _get_first_model(structure: PdbStructure) -> PdbStructure:
  function get_release_date (line 289) | def get_release_date(parsed_info: MmCIFDict) -> str:
  function _get_header (line 295) | def _get_header(parsed_info: MmCIFDict) -> PdbHeader:
  function _get_atom_site_list (line 324) | def _get_atom_site_list(parsed_info: MmCIFDict) -> Sequence[AtomSite]:
  function _get_protein_chains (line 338) | def _get_protein_chains(
  function _is_set (line 384) | def _is_set(data: str) -> bool:

FILE: alphafold/data/msa_identifiers.py
  class Identifiers (line 50) | class Identifiers:
  function _parse_sequence_identifier (line 54) | 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
  function create_paired_features (line 54) | def create_paired_features(
  function pad_features (line 88) | def pad_features(feature: np.ndarray, feature_name: str) -> np.ndarray:
  function _make_msa_df (line 115) | def _make_msa_df(chain_features: pipeline.FeatureDict) -> pd.DataFrame:
  function _create_species_dict (line 134) | def _create_species_dict(msa_df: pd.DataFrame) -> Dict[bytes, pd.DataFra...
  function _match_rows_by_sequence_similarity (line 142) | def _match_rows_by_sequence_similarity(this_species_msa_dfs: List[pd.Dat...
  function pair_sequences (line 178) | def pair_sequences(examples: List[pipeline.FeatureDict]
  function reorder_paired_rows (line 231) | def reorder_paired_rows(all_paired_msa_rows_dict: Dict[int, np.ndarray]
  function block_diag (line 257) | def block_diag(*arrs: np.ndarray, pad_value: float = 0.0) -> np.ndarray:
  function _correct_post_merged_feats (line 266) | def _correct_post_merged_feats(
  function _pad_templates (line 313) | def _pad_templates(chains: Sequence[pipeline.FeatureDict],
  function _merge_features_from_multiple_chains (line 335) | def _merge_features_from_multiple_chains(
  function _merge_homomers_dense_msa (line 369) | def _merge_homomers_dense_msa(
  function _concatenate_paired_and_unpaired_features (line 396) | def _concatenate_paired_and_unpaired_features(
  function merge_chain_features (line 411) | def merge_chain_features(np_chains_list: List[pipeline.FeatureDict],
  function deduplicate_unpaired_sequences (line 441) | def deduplicate_unpaired_sequences(

FILE: alphafold/data/parsers.py
  class Msa (line 30) | class Msa:
    method __post_init__ (line 36) | def __post_init__(self):
    method __len__ (line 46) | def __len__(self):
    method truncate (line 49) | def truncate(self, max_seqs: int):
  class TemplateHit (line 56) | class TemplateHit:
  function parse_fasta (line 68) | def parse_fasta(fasta_string: str) -> Tuple[Sequence[str], Sequence[str]]:
  function parse_stockholm (line 97) | def parse_stockholm(stockholm_string: str) -> Msa:
  function parse_a3m (line 157) | def parse_a3m(a3m_string: str) -> Msa:
  function _convert_sto_seq_to_a3m (line 194) | def _convert_sto_seq_to_a3m(
  function convert_stockholm_to_a3m (line 203) | def convert_stockholm_to_a3m(stockholm_format: str,
  function _keep_line (line 257) | def _keep_line(line: str, seqnames: Set[str]) -> bool:
  function truncate_stockholm_msa (line 277) | def truncate_stockholm_msa(stockholm_msa_path: str, max_sequences: int) ...
  function remove_empty_columns_from_stockholm_msa (line 300) | def remove_empty_columns_from_stockholm_msa(stockholm_msa: str) -> str:
  function deduplicate_stockholm_msa (line 340) | def deduplicate_stockholm_msa(stockholm_msa: str) -> str:
  function _get_hhr_line_regex_groups (line 375) | def _get_hhr_line_regex_groups(
  function _update_hhr_residue_indices_list (line 383) | def _update_hhr_residue_indices_list(
  function _parse_hhr_hit (line 395) | def _parse_hhr_hit(detailed_lines: Sequence[str]) -> TemplateHit:
  function parse_hhr (line 491) | def parse_hhr(hhr_string: str) -> Sequence[TemplateHit]:
  function parse_e_values_from_tblout (line 509) | def parse_e_values_from_tblout(tblout: str) -> Dict[str, float]:
  function _get_indices (line 524) | def _get_indices(sequence: str, start: int) -> List[int]:
  class HitMetadata (line 543) | class HitMetadata:
  function _parse_hmmsearch_description (line 552) | def _parse_hmmsearch_description(description: str) -> HitMetadata:
  function parse_hmmsearch_a3m (line 572) | def parse_hmmsearch_a3m(query_sequence: str,

FILE: alphafold/data/pipeline.py
  function make_sequence_features (line 36) | def make_sequence_features(
  function make_msa_features (line 53) | def make_msa_features(msas: Sequence[parsers.Msa]) -> FeatureDict:
  function run_msa_tool (line 87) | def run_msa_tool(msa_runner, input_fasta_path: str, msa_out_path: str,
  class DataPipeline (line 111) | class DataPipeline:
    method __init__ (line 114) | def __init__(self,
    method process (line 150) | 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 65) | def temp_fasta_file(fasta_str: str):
  function convert_monomer_features (line 72) | def convert_monomer_features(
  function int_id_to_str_id (line 97) | def int_id_to_str_id(num: int) -> str:
  function add_assembly_features (line 119) | def add_assembly_features(
  function pad_msa (line 158) | def pad_msa(np_example, min_num_seq):
  class DataPipeline (line 170) | class DataPipeline:
    method __init__ (line 173) | def __init__(self,
    method _process_single_chain (line 197) | def _process_single_chain(
    method _all_seq_msa_features (line 224) | def _all_seq_msa_features(self, input_fasta_path, msa_output_dir):
    method process (line 240) | def process(self,

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 132) | def _parse_obsolete(obsolete_file_path: str) -> Mapping[str, Optional[st...
  function _parse_release_dates (line 155) | def _parse_release_dates(path: str) -> Mapping[str, datetime.datetime]:
  function _assess_hhsearch_hit (line 173) | def _assess_hhsearch_hit(
  function _find_template_in_pdb (line 233) | def _find_template_in_pdb(
  function _realign_pdb_template_to_query (line 297) | def _realign_pdb_template_to_query(
  function _check_residue_distances (line 409) | def _check_residue_distances(all_positions: np.ndarray,
  function _get_atom_positions (line 430) | def _get_atom_positions(
  function _extract_template_features (line 485) | def _extract_template_features(
  function _build_query_to_hit_index_mapping (line 615) | def _build_query_to_hit_index_mapping(
  class SingleHitResult (line 673) | class SingleHitResult:
  function _read_file (line 680) | def _read_file(path):
  function _process_single_hit (line 686) | def _process_single_hit(
  class TemplateSearchResult (line 794) | class TemplateSearchResult:
  class TemplateHitFeaturizer (line 800) | class TemplateHitFeaturizer(abc.ABC):
    method __init__ (line 803) | def __init__(
    method get_templates (line 863) | def get_templates(
  class HhsearchHitFeaturizer (line 870) | class HhsearchHitFeaturizer(TemplateHitFeaturizer):
    method get_templates (line 873) | def get_templates(
  class HmmsearchHitFeaturizer (line 932) | class HmmsearchHitFeaturizer(TemplateHitFeaturizer):
    method get_templates (line 935) | def get_templates(

FILE: alphafold/data/tools/hhblits.py
  class HHBlits (line 31) | class HHBlits:
    method __init__ (line 34) | def __init__(self,
    method query (line 97) | 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__(self,
    method output_format (line 60) | def output_format(self) -> str:
    method input_format (line 64) | def input_format(self) -> str:
    method query (line 67) | def query(self, a3m: str) -> str:
    method get_template_hits (line 102) | def get_template_hits(self,

FILE: alphafold/data/tools/hmmbuild.py
  class Hmmbuild (line 26) | class Hmmbuild(object):
    method __init__ (line 29) | def __init__(self,
    method build_profile_from_sto (line 46) | def build_profile_from_sto(self, sto: str, model_construction='fast') ...
    method build_profile_from_a3m (line 62) | def build_profile_from_a3m(self, a3m: str) -> str:
    method _build_profile (line 82) | def _build_profile(self, msa: str, model_construction: str = 'fast') -...

FILE: alphafold/data/tools/hmmsearch.py
  class Hmmsearch (line 28) | class Hmmsearch(object):
    method __init__ (line 31) | def __init__(self,
    method output_format (line 68) | def output_format(self) -> str:
    method input_format (line 72) | def input_format(self) -> str:
    method query (line 75) | def query(self, msa_sto: str) -> str:
    method query_with_hmm (line 81) | def query_with_hmm(self, hmm: str) -> str:
    method get_template_hits (line 121) | def get_template_hits(self,

FILE: alphafold/data/tools/jackhmmer.py
  class Jackhmmer (line 31) | class Jackhmmer:
    method __init__ (line 34) | def __init__(self,
    method _query_chunk (line 90) | def _query_chunk(self,
    method query (line 166) | def query(self,
    method query_multiple (line 172) | 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 46) | def squared_difference(x, y):
  function get_chi_atom_indices (line 50) | def get_chi_atom_indices():
  function atom14_to_atom37 (line 76) | def atom14_to_atom37(atom14_data: jnp.ndarray,  # (N, 14, ...)
  function atom37_to_atom14 (line 95) | def atom37_to_atom14(
  function atom37_to_frames (line 114) | def atom37_to_frames(
  function atom37_to_torsion_angles (line 271) | def atom37_to_torsion_angles(
  function torsion_angles_to_frames (line 445) | def torsion_angles_to_frames(
  function frames_and_literature_positions_to_atom14_pos (line 532) | def frames_and_literature_positions_to_atom14_pos(
  function extreme_ca_ca_distance_violations (line 575) | def extreme_ca_ca_distance_violations(
  function between_residue_bond_loss (line 609) | def between_residue_bond_loss(
  function between_residue_clash_loss (line 744) | def between_residue_clash_loss(
  function within_residue_violations (line 853) | def within_residue_violations(
  function find_optimal_renaming (line 929) | def find_optimal_renaming(
  function frame_aligned_point_error (line 1013) | def frame_aligned_point_error(
  function _make_renaming_matrices (line 1082) | def _make_renaming_matrices():
  function get_alt_atom14 (line 1112) | 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 56) | def _make_renaming_matrices():
  function _make_restype_atom37_mask (line 83) | def _make_restype_atom37_mask():
  function _make_restype_atom14_mask (line 96) | def _make_restype_atom14_mask():
  function _make_restype_atom37_to_atom14 (line 110) | def _make_restype_atom37_to_atom14():
  function _make_restype_atom14_to_atom37 (line 127) | def _make_restype_atom14_to_atom37():
  function _make_restype_atom14_is_ambiguous (line 143) | def _make_restype_atom14_is_ambiguous():
  function _make_restype_rigidgroup_base_atom37_idx (line 161) | def _make_restype_rigidgroup_base_atom37_idx():
  function get_atom37_mask (line 205) | def get_atom37_mask(aatype):
  function get_atom14_mask (line 209) | def get_atom14_mask(aatype):
  function get_atom14_is_ambiguous (line 213) | def get_atom14_is_ambiguous(aatype):
  function get_atom14_to_atom37_map (line 217) | def get_atom14_to_atom37_map(aatype):
  function get_atom37_to_atom14_map (line 221) | def get_atom37_to_atom14_map(aatype):
  function atom14_to_atom37 (line 225) | def atom14_to_atom37(atom14_data: jnp.ndarray,  # (N, 14, ...)
  function atom37_to_atom14 (line 241) | def atom37_to_atom14(aatype, all_atom_pos, all_atom_mask):
  function get_alt_atom14 (line 257) | def get_alt_atom14(aatype, positions: geometry.Vec3Array, mask):
  function atom37_to_frames (line 275) | def atom37_to_frames(
  function torsion_angles_to_frames (line 374) | def torsion_angles_to_frames(
  function frames_and_literature_positions_to_atom14_pos (line 441) | def frames_and_literature_positions_to_atom14_pos(
  function extreme_ca_ca_distance_violations (line 475) | def extreme_ca_ca_distance_violations(
  function between_residue_bond_loss (line 495) | def between_residue_bond_loss(
  function between_residue_clash_loss (line 596) | def between_residue_clash_loss(
  function within_residue_violations (line 679) | def within_residue_violations(
  function find_optimal_renaming (line 730) | def find_optimal_renaming(
  function frame_aligned_point_error (line 785) | def frame_aligned_point_error(
  function get_chi_atom_indices (line 856) | def get_chi_atom_indices():
  function compute_chi_angles (line 882) | def compute_chi_angles(positions: geometry.Vec3Array,
  function make_transform_from_reference (line 945) | def make_transform_from_reference(

FILE: alphafold/model/all_atom_test.py
  function get_identity_rigid (line 26) | def get_identity_rigid(shape):
  function get_global_rigid_transform (line 38) | def get_global_rigid_transform(rot_angle, translation, bcast_dims):
  class AllAtomTest (line 58) | class AllAtomTest(parameterized.TestCase, absltest.TestCase):
    method test_frame_aligned_point_error_perfect_on_global_transform (line 65) | def test_frame_aligned_point_error_perfect_on_global_transform(
    method test_frame_aligned_point_error_matches_expected (line 115) | def test_frame_aligned_point_error_matches_expected(

FILE: alphafold/model/common_modules.py
  function get_initializer_scale (line 29) | def get_initializer_scale(initializer_name, input_shape):
  class Linear (line 52) | class Linear(hk.Module):
    method __init__ (line 60) | def __init__(self,
    method __call__ (line 94) | def __call__(self, inputs):
  class LayerNorm (line 132) | class LayerNorm(hk.LayerNorm):
    method __init__ (line 140) | def __init__(self,
    method __call__ (line 163) | def __call__(self, x: jnp.ndarray) -> jnp.ndarray:

FILE: alphafold/model/config.py
  function model_config (line 26) | def model_config(name: str) -> ml_collections.ConfigDict:

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

FILE: alphafold/model/features.py
  function make_data_config (line 29) | def make_data_config(
  function tf_example_to_features (line 46) | def tf_example_to_features(tf_example: tf.train.Example,
  function np_example_to_features (line 78) | def np_example_to_features(np_example: FeatureDict,

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__(self,
    method __call__ (line 72) | def __call__(self, inputs_1d, inputs_2d, mask, affine):
  class FoldIteration (line 281) | class FoldIteration(hk.Module):
    method __init__ (line 292) | def __init__(self, config, global_config,
    method __call__ (line 298) | def __call__(self,
  function generate_affines (line 390) | def generate_affines(representations, batch, config, global_config,
  class StructureModule (line 464) | class StructureModule(hk.Module):
    method __init__ (line 470) | def __init__(self, config, global_config, compute_loss=True,
    method __call__ (line 477) | def __call__(self, representations, batch, is_training,
    method loss (line 520) | def loss(self, value, batch):
  function compute_renamed_ground_truth (line 561) | def compute_renamed_ground_truth(
  function backbone_loss (line 618) | def backbone_loss(ret, batch, value, config):
  function sidechain_loss (line 672) | def sidechain_loss(batch, value, config):
  function structural_violation_loss (line 717) | def structural_violation_loss(ret, batch, value, config):
  function find_structural_violations (line 734) | def find_structural_violations(
  function compute_violation_metrics (line 822) | def compute_violation_metrics(
  function supervised_chi_loss (line 854) | def supervised_chi_loss(ret, batch, value, config):
  function generate_new_affine (line 914) | def generate_new_affine(sequence_mask):
  function l2_normalize (line 924) | def l2_normalize(x, axis=-1, epsilon=1e-12):
  class MultiRigidSidechain (line 929) | class MultiRigidSidechain(hk.Module):
    method __init__ (line 932) | def __init__(self, config, global_config, name='rigid_sidechain'):
    method __call__ (line 937) | 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__(self,
    method __call__ (line 100) | def __call__(self, activations: jnp.ndarray) -> geometry.Rigid3Array:
  class PointProjection (line 140) | class PointProjection(hk.Module):
    method __init__ (line 143) | def __init__(self,
    method __call__ (line 168) | def __call__(
  class InvariantPointAttention (line 188) | class InvariantPointAttention(hk.Module):
    method __init__ (line 199) | def __init__(self,
    method __call__ (line 221) | def __call__(
  class FoldIteration (line 374) | class FoldIteration(hk.Module):
    method __init__ (line 383) | def __init__(self,
    method __call__ (line 391) | def __call__(
  function generate_monomer_rigids (line 478) | def generate_monomer_rigids(representations: Mapping[str, jnp.ndarray],
  class StructureModule (line 556) | class StructureModule(hk.Module):
    method __init__ (line 562) | def __init__(self,
    method __call__ (line 570) | def __call__(self,
    method loss (line 627) | def loss(self,
  function compute_atom14_gt (line 752) | def compute_atom14_gt(
  function backbone_loss (line 781) | def backbone_loss(gt_rigid: geometry.Rigid3Array,
  function compute_frames (line 802) | def compute_frames(
  function sidechain_loss (line 832) | def sidechain_loss(gt_frames: geometry.Rigid3Array,
  function structural_violation_loss (line 871) | def structural_violation_loss(mask: jnp.ndarray,
  function find_structural_violations (line 889) | def find_structural_violations(
  function compute_violation_metrics (line 982) | def compute_violation_metrics(
  function supervised_chi_loss (line 1012) | def supervised_chi_loss(
  function l2_normalize (line 1056) | def l2_normalize(x: jnp.ndarray,
  function get_renamed_chi_angles (line 1064) | def get_renamed_chi_angles(aatype: jnp.ndarray,
  class MultiRigidSidechain (line 1079) | class MultiRigidSidechain(hk.Module):
    method __init__ (line 1082) | def __init__(self,
    method __call__ (line 1090) | def __call__(self,

FILE: alphafold/model/geometry/rigid_matrix_vector.py
  class Rigid3Array (line 31) | class Rigid3Array:
    method __matmul__ (line 37) | def __matmul__(self, other: Rigid3Array) -> Rigid3Array:
    method inverse (line 42) | def inverse(self) -> Rigid3Array:
    method apply_to_point (line 48) | def apply_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
    method apply_inverse_to_point (line 52) | def apply_inverse_to_point(self, point: vector.Vec3Array) -> vector.Ve...
    method compose_rotation (line 57) | def compose_rotation(self, other_rotation):
    method identity (line 64) | def identity(cls, shape, dtype=jnp.float32) -> Rigid3Array:
    method scale_translation (line 70) | def scale_translation(self, factor: Float) -> Rigid3Array:
    method to_array (line 74) | def to_array(self):
    method from_array (line 80) | def from_array(cls, array):
    method from_array4x4 (line 86) | def from_array4x4(cls, array: jnp.ndarray) -> Rigid3Array:
    method __getstate__ (line 99) | def __getstate__(self):
    method __setstate__ (line 102) | def __setstate__(self, state):

FILE: alphafold/model/geometry/rotation_matrix.py
  class Rot3Array (line 32) | class Rot3Array:
    method inverse (line 47) | def inverse(self) -> Rot3Array:
    method apply_to_point (line 53) | def apply_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
    method apply_inverse_to_point (line 60) | def apply_inverse_to_point(self, point: vector.Vec3Array) -> vector.Ve...
    method __matmul__ (line 64) | def __matmul__(self, other: Rot3Array) -> Rot3Array:
    method identity (line 72) | def identity(cls, shape, dtype=jnp.float32) -> Rot3Array:
    method from_two_vectors (line 79) | def from_two_vectors(cls, e0: vector.Vec3Array,
    method from_array (line 102) | def from_array(cls, array: jnp.ndarray) -> Rot3Array:
    method to_array (line 108) | def to_array(self) -> jnp.ndarray:
    method from_quaternion (line 117) | def from_quaternion(cls,
    method random_uniform (line 143) | def random_uniform(cls, key, shape, dtype=jnp.float32) -> Rot3Array:
    method __getstate__ (line 149) | def __getstate__(self):
    method __setstate__ (line 153) | 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 77) | def replace(instance, **kwargs):
  function post_init (line 81) | def post_init(instance):
  function flatten (line 129) | def flatten(instance):
  function make_metadata_class (line 145) | def make_metadata_class(cls):
  function get_fields (line 156) | def get_fields(cls_or_instance, filterfn, return_values=False):
  function get_array_fields (line 167) | def get_array_fields(cls, return_values=False):
  function get_metadata_fields (line 174) | def get_metadata_fields(cls, return_values=False):
  class StructOfArray (line 181) | class StructOfArray:
    method __init__ (line 184) | def __init__(self, same_dtype=True):
    method __call__ (line 187) | def __call__(self, cls):

FILE: alphafold/model/geometry/test_utils.py
  function assert_rotation_matrix_equal (line 25) | def assert_rotation_matrix_equal(matrix1: rotation_matrix.Rot3Array,
  function assert_rotation_matrix_close (line 33) | def assert_rotation_matrix_close(mat1: rotation_matrix.Rot3Array,
  function assert_array_equal_to_rotation_matrix (line 38) | def assert_array_equal_to_rotation_matrix(array: jnp.ndarray,
  function assert_array_close_to_rotation_matrix (line 52) | def assert_array_close_to_rotation_matrix(array: jnp.ndarray,
  function assert_vectors_equal (line 57) | def assert_vectors_equal(vec1: vector.Vec3Array, vec2: vector.Vec3Array):
  function assert_vectors_close (line 63) | def assert_vectors_close(vec1: vector.Vec3Array, vec2: vector.Vec3Array):
  function assert_array_close_to_vector (line 69) | def assert_array_close_to_vector(array: jnp.ndarray, vec: vector.Vec3Arr...
  function assert_array_equal_to_vector (line 73) | def assert_array_equal_to_vector(array: jnp.ndarray, vec: vector.Vec3Arr...
  function assert_rigid_equal_to_rigid (line 77) | def assert_rigid_equal_to_rigid(rigid1: rigid_matrix_vector.Rigid3Array,
  function assert_rigid_close_to_rigid (line 82) | def assert_rigid_close_to_rigid(rigid1: rigid_matrix_vector.Rigid3Array,
  function assert_rot_trans_equal_to_rigid (line 87) | def assert_rot_trans_equal_to_rigid(rot: rotation_matrix.Rot3Array,
  function assert_rot_trans_close_to_rigid (line 94) | def assert_rot_trans_close_to_rigid(rot: rotation_matrix.Rot3Array,

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 32) | class Vec3Array:
    method __post_init__ (line 48) | def __post_init__(self):
    method __add__ (line 55) | def __add__(self, other: Vec3Array) -> Vec3Array:
    method __sub__ (line 58) | def __sub__(self, other: Vec3Array) -> Vec3Array:
    method __mul__ (line 61) | def __mul__(self, other: Float) -> Vec3Array:
    method __rmul__ (line 64) | def __rmul__(self, other: Float) -> Vec3Array:
    method __truediv__ (line 67) | def __truediv__(self, other: Float) -> Vec3Array:
    method __neg__ (line 70) | def __neg__(self) -> Vec3Array:
    method __pos__ (line 73) | def __pos__(self) -> Vec3Array:
    method cross (line 76) | def cross(self, other: Vec3Array) -> Vec3Array:
    method dot (line 83) | def dot(self, other: Vec3Array) -> Float:
    method norm (line 87) | def norm(self, epsilon: float = 1e-6) -> Float:
    method norm2 (line 95) | def norm2(self):
    method normalized (line 98) | def normalized(self, epsilon: float = 1e-6) -> Vec3Array:
    method zeros (line 103) | def zeros(cls, shape, dtype=jnp.float32):
    method to_array (line 109) | def to_array(self) -> jnp.ndarray:
    method from_array (line 113) | def from_array(cls, array):
    method __getstate__ (line 116) | def __getstate__(self):
    method __setstate__ (line 122) | def __setstate__(self, state):
  function square_euclidean_distance (line 129) | def square_euclidean_distance(vec1: Vec3Array,
  function dot (line 151) | def dot(vector1: Vec3Array, vector2: Vec3Array) -> Float:
  function cross (line 155) | def cross(vector1: Vec3Array, vector2: Vec3Array) -> Float:
  function norm (line 159) | def norm(vector: Vec3Array, epsilon: float = 1e-6) -> Float:
  function normalized (line 163) | def normalized(vector: Vec3Array, epsilon: float = 1e-6) -> Vec3Array:
  function euclidean_distance (line 167) | def euclidean_distance(vec1: Vec3Array,
  function dihedral_angle (line 187) | def dihedral_angle(a: Vec3Array, b: Vec3Array, c: Vec3Array,
  function random_gaussian_vector (line 215) | def random_gaussian_vector(shape, key, dtype=jnp.float32):

FILE: alphafold/model/layer_stack.py
  function _check_no_varargs (line 38) | def _check_no_varargs(f):
  function nullcontext (line 48) | def nullcontext():
  function maybe_with_rng (line 52) | def maybe_with_rng(key):
  function maybe_fold_in (line 59) | def maybe_fold_in(key, data):
  class _LayerStack (line 66) | class _LayerStack(hk.Module):
    method __init__ (line 69) | def __init__(self,
    method __call__ (line 78) | def __call__(self, x, *args_ys):
    method _call_wrapped (line 160) | def _call_wrapped(self,
  class _LayerStackNoState (line 167) | class _LayerStackNoState(_LayerStack):
    method __init__ (line 170) | def __init__(self,
    method _call_wrapped (line 180) | def _call_wrapped(self, args, y):
  class _LayerStackWithState (line 190) | class _LayerStackWithState(_LayerStack):
    method __init__ (line 193) | def __init__(self,
    method _call_wrapped (line 202) | def _call_wrapped(self, x, *args):
  function layer_stack (line 206) | def layer_stack(num_layers: int,

FILE: alphafold/model/layer_stack_test.py
  function _slice_layers_params (line 32) | def _slice_layers_params(layers_params):
  class LayerStackTest (line 44) | class LayerStackTest(parameterized.TestCase):
    method test_layer_stack (line 47) | def test_layer_stack(self, unroll):
    method test_layer_stack_multi_args (line 88) | def test_layer_stack_multi_args(self):
    method test_layer_stack_no_varargs (line 128) | def test_layer_stack_no_varargs(self):
    method test_layer_stack_grads (line 157) | def test_layer_stack_grads(self, unroll):
    method test_random (line 204) | def test_random(self):
    method test_threading (line 225) | def test_threading(self):
    method test_nested_stacks (line 250) | def test_nested_stacks(self):
    method test_with_state_multi_args (line 272) | def test_with_state_multi_args(self):
    method test_with_container_state (line 299) | def test_with_container_state(self):

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

FILE: alphafold/model/lddt_test.py
  class LddtTest (line 23) | class LddtTest(parameterized.TestCase, absltest.TestCase):
    method test_lddt (line 63) | def test_lddt(

FILE: alphafold/model/mapping.py
  function _maybe_slice (line 34) | def _maybe_slice(array, i, slice_size, axis):
  function _maybe_get_size (line 42) | def _maybe_get_size(array, axis):
  function _expand_axes (line 49) | def _expand_axes(axes, values, name='sharded_apply'):
  function sharded_map (line 57) | def sharded_map(
  function sharded_apply (line 87) | def sharded_apply(
  function inference_subbatch (line 198) | def inference_subbatch(

FILE: alphafold/model/model.py
  function get_confidence_metrics (line 31) | def get_confidence_metrics(
  class RunModel (line 64) | class RunModel:
    method __init__ (line 67) | def __init__(self,
    method init_params (line 92) | def init_params(self, feat: features.FeatureDict, random_seed: int = 0):
    method process_features (line 111) | def process_features(
    method eval_shape (line 141) | def eval_shape(self, feat: features.FeatureDict) -> jax.ShapeDtypeStruct:
    method predict (line 149) | def predict(self,

FILE: alphafold/model/modules.py
  function softmax_cross_entropy (line 35) | def softmax_cross_entropy(logits, labels):
  function sigmoid_cross_entropy (line 41) | def sigmoid_cross_entropy(logits, labels):
  function apply_dropout (line 50) | def apply_dropout(*, tensor, safe_key, rate, is_training, broadcast_dim=...
  function dropout_wrapper (line 63) | def dropout_wrapper(module,
  function create_extra_msa_feature (line 101) | def create_extra_msa_feature(batch):
  class AlphaFoldIteration (line 126) | class AlphaFoldIteration(hk.Module):
    method __init__ (line 137) | def __init__(self, config, global_config, name='alphafold_iteration'):
    method __call__ (line 142) | def __call__(self,
  class AlphaFold (line 273) | class AlphaFold(hk.Module):
    method __init__ (line 279) | def __init__(self, config, name='alphafold'):
    method __call__ (line 284) | def __call__(
  class TemplatePairStack (line 396) | class TemplatePairStack(hk.Module):
    method __init__ (line 402) | def __init__(self, config, global_config, name='template_pair_stack'):
    method __call__ (line 407) | def __call__(self, pair_act, pair_mask, is_training, safe_key=None):
  class Transition (line 479) | class Transition(hk.Module):
    method __init__ (line 486) | def __init__(self, config, global_config, name='transition_block'):
    method __call__ (line 491) | def __call__(self, act, mask, is_training=True):
  function glorot_uniform (line 535) | def glorot_uniform():
  class Attention (line 541) | class Attention(hk.Module):
    method __init__ (line 544) | def __init__(self, config, global_config, output_dim, name='attention'):
    method __call__ (line 551) | def __call__(self, q_data, m_data, bias, nonbatched_bias=None):
  class GlobalAttention (line 633) | class GlobalAttention(hk.Module):
    method __init__ (line 639) | def __init__(self, config, global_config, output_dim, name='attention'):
    method __call__ (line 646) | def __call__(self, q_data, m_data, q_mask):
  class MSARowAttentionWithPairBias (line 730) | class MSARowAttentionWithPairBias(hk.Module):
    method __init__ (line 736) | def __init__(self, config, global_config,
    method __call__ (line 742) | def __call__(self,
  class MSAColumnAttention (line 798) | class MSAColumnAttention(hk.Module):
    method __init__ (line 804) | def __init__(self, config, global_config, name='msa_column_attention'):
    method __call__ (line 809) | def __call__(self,
  class MSAColumnGlobalAttention (line 853) | class MSAColumnGlobalAttention(hk.Module):
    method __init__ (line 859) | def __init__(self, config, global_config, name='msa_column_global_atte...
    method __call__ (line 864) | def __call__(self,
  class TriangleAttention (line 911) | class TriangleAttention(hk.Module):
    method __init__ (line 918) | def __init__(self, config, global_config, name='triangle_attention'):
    method __call__ (line 923) | def __call__(self, pair_act, pair_mask, is_training=False):
  class MaskedMsaHead (line 974) | class MaskedMsaHead(hk.Module):
    method __init__ (line 983) | def __init__(self, config, global_config, name='masked_msa_head'):
    method __call__ (line 993) | def __call__(self, representations, batch, is_training):
    method loss (line 1015) | def loss(self, value, batch):
  class PredictedLDDTHead (line 1024) | class PredictedLDDTHead(hk.Module):
    method __init__ (line 1031) | def __init__(self, config, global_config, name='predicted_lddt_head'):
    method __call__ (line 1036) | def __call__(self, representations, batch, is_training):
    method loss (line 1082) | def loss(self, value, batch):
  class PredictedAlignedErrorHead (line 1128) | class PredictedAlignedErrorHead(hk.Module):
    method __init__ (line 1135) | def __init__(self, config, global_config,
    method __call__ (line 1141) | def __call__(self, representations, batch, is_training):
    method loss (line 1168) | def loss(self, value, batch):
  class ExperimentallyResolvedHead (line 1218) | class ExperimentallyResolvedHead(hk.Module):
    method __init__ (line 1225) | def __init__(self, config, global_config,
    method __call__ (line 1231) | def __call__(self, representations, batch, is_training):
    method loss (line 1252) | def loss(self, value, batch):
  function _layer_norm (line 1275) | def _layer_norm(axis=-1, name='layer_norm'):
  class TriangleMultiplication (line 1288) | class TriangleMultiplication(hk.Module):
    method __init__ (line 1295) | def __init__(self, config, global_config, name='triangle_multiplicatio...
    method __call__ (line 1300) | def __call__(self, left_act, left_mask, is_training=True):
    method _triangle_multiplication (line 1319) | def _triangle_multiplication(self, left_act, left_mask):
    method _fused_triangle_multiplication (line 1387) | def _fused_triangle_multiplication(self, left_act, left_mask):
  class DistogramHead (line 1431) | class DistogramHead(hk.Module):
    method __init__ (line 1437) | def __init__(self, config, global_config, name='distogram_head'):
    method __call__ (line 1442) | def __call__(self, representations, batch, is_training):
    method loss (line 1468) | def loss(self, value, batch):
  function _distogram_log_loss (line 1473) | def _distogram_log_loss(logits, bin_edges, batch, num_bins):
  class OuterProductMean (line 1505) | class OuterProductMean(hk.Module):
    method __init__ (line 1511) | def __init__(self,
    method __call__ (line 1521) | def __call__(self, act, mask, is_training=True):
  function dgram_from_positions (line 1594) | def dgram_from_positions(positions, num_bins, min_bin, max_bin):
  function pseudo_beta_fn (line 1626) | def pseudo_beta_fn(aatype, all_atom_positions, all_atom_masks):
  class EvoformerIteration (line 1646) | class EvoformerIteration(hk.Module):
    method __init__ (line 1652) | def __init__(self, config, global_config, is_extra_msa,
    method __call__ (line 1659) | def __call__(self, activations, masks, is_training=True, safe_key=None):
  class EmbeddingsAndEvoformer (line 1776) | class EmbeddingsAndEvoformer(hk.Module):
    method __init__ (line 1783) | def __init__(self, config, global_config, name='evoformer'):
    method __call__ (line 1788) | def __call__(self, batch, is_training, safe_key=None):
  class SingleTemplateEmbedding (line 2014) | class SingleTemplateEmbedding(hk.Module):
    method __init__ (line 2020) | def __init__(self, config, global_config, name='single_template_embedd...
    method __call__ (line 2025) | def __call__(self, query_embedding, batch, mask_2d, is_training):
  class TemplateEmbedding (line 2116) | class TemplateEmbedding(hk.Module):
    method __init__ (line 2123) | def __init__(self, config, global_config, name='template_embedding'):
    method __call__ (line 2128) | def __call__(self, query_embedding, template_batch, mask_2d, is_traini...

FILE: alphafold/model/modules_multimer.py
  function reduce_fn (line 42) | def reduce_fn(x, mode):
  function gumbel_noise (line 53) | 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 93) | def gumbel_argsort_sample_idx(key: jnp.ndarray,
  function make_masked_msa (line 120) | def make_masked_msa(batch, key, config, epsilon=1e-6):
  function nearest_neighbor_clusters (line 160) | def nearest_neighbor_clusters(batch, gap_agreement_weight=0.):
  function create_msa_feat (line 205) | def create_msa_feat(batch):
  function create_extra_msa_feature (line 226) | def create_extra_msa_feature(batch, num_extra_msa):
  function sample_msa (line 253) | def sample_msa(key, batch, max_seq):
  function make_msa_profile (line 286) | def make_msa_profile(batch):
  class AlphaFoldIteration (line 294) | class AlphaFoldIteration(hk.Module):
    method __init__ (line 302) | def __init__(self, config, global_config, name='alphafold_iteration'):
    method __call__ (line 307) | def __call__(self,
  class AlphaFold (line 411) | class AlphaFold(hk.Module):
    method __init__ (line 415) | def __init__(self, config, name='alphafold'):
    method __call__ (line 420) | def __call__(
  class EmbeddingsAndEvoformer (line 526) | class EmbeddingsAndEvoformer(hk.Module):
    method __init__ (line 532) | def __init__(self, config, global_config, name='evoformer'):
    method _relative_encoding (line 537) | def _relative_encoding(self, batch):
    method __call__ (line 610) | def __call__(self, batch, is_training, safe_key=None):
  class TemplateEmbedding (line 819) | class TemplateEmbedding(hk.Module):
    method __init__ (line 822) | def __init__(self, config, global_config, name='template_embedding'):
    method __call__ (line 827) | def __call__(self, query_embedding, template_batch, padding_mask_2d,
  class SingleTemplateEmbedding (line 899) | class SingleTemplateEmbedding(hk.Module):
    method __init__ (line 902) | def __init__(self, config, global_config, name='single_template_embedd...
    method __call__ (line 907) | def __call__(self, query_embedding, template_aatype,
  class TemplateEmbeddingIteration (line 1048) | class TemplateEmbeddingIteration(hk.Module):
    method __init__ (line 1051) | def __init__(self, config, global_config,
    method __call__ (line 1057) | def __call__(self, act, pair_mask, is_training=True,
  function template_embedding_1d (line 1119) | 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 22) | class PrngTest(absltest.TestCase):
    method test_key_reuse (line 24) | def test_key_reuse(self):

FILE: alphafold/model/quat_affine.py
  function rot_to_quat (line 83) | def rot_to_quat(rot, unstack_inputs=False):
  function rot_list_to_tensor (line 117) | def rot_list_to_tensor(rot_list):
  function vec_list_to_tensor (line 126) | def vec_list_to_tensor(vec_list):
  function quat_to_rot (line 131) | def quat_to_rot(normalized_quat):
  function quat_multiply_by_vec (line 144) | def quat_multiply_by_vec(quat, vec):
  function quat_multiply (line 153) | def quat_multiply(quat1, quat2):
  function apply_rot_to_vec (line 162) | def apply_rot_to_vec(rot, vec, unstack=False):
  function apply_inverse_rot_to_vec (line 173) | def apply_inverse_rot_to_vec(rot, vec):
  class QuatAffine (line 181) | class QuatAffine(object):
    method __init__ (line 184) | def __init__(self, quaternion, translation, rotation=None, normalize=T...
    method to_tensor (line 221) | def to_tensor(self):
    method apply_tensor_fn (line 227) | def apply_tensor_fn(self, tensor_fn):
    method apply_rotation_tensor_fn (line 235) | def apply_rotation_tensor_fn(self, tensor_fn):
    method scale_translation (line 243) | def scale_translation(self, position_scale):
    method from_tensor (line 253) | def from_tensor(cls, tensor, normalize=False):
    method pre_compose (line 259) | def pre_compose(self, update):
    method apply_to_point (line 287) | def apply_to_point(self, point, extra_dims=0):
    method invert_point (line 313) | def invert_point(self, transformed_point, extra_dims=0):
    method __repr__ (line 340) | def __repr__(self):
  function _multiply (line 344) | def _multiply(a, b):
  function make_canonical_transform (line 359) | def make_canonical_transform(
  function make_transform_from_reference (line 431) | def make_transform_from_reference(

FILE: alphafold/model/quat_affine_test.py
  class QuatAffineTest (line 33) | class QuatAffineTest(absltest.TestCase):
    method _assert_check (line 35) | def _assert_check(self, to_check, tol=1e-5):
    method test_conversion (line 43) | def test_conversion(self):
    method test_double_cover (line 68) | def test_double_cover(self):
    method test_homomorphism (line 84) | def test_homomorphism(self):
    method test_batching (line 116) | def test_batching(self):
    method assertAllClose (line 142) | def assertAllClose(self, a, b, rtol=1e-06, atol=1e-06):
    method assertAllEqual (line 145) | def assertAllEqual(self, a, b):

FILE: alphafold/model/r3.py
  function squared_difference (line 54) | def squared_difference(x, y):
  function invert_rigids (line 58) | def invert_rigids(r: Rigids) -> Rigids:
  function invert_rots (line 66) | def invert_rots(m: Rots) -> Rots:
  function rigids_from_3_points (line 73) | def rigids_from_3_points(
  function rigids_from_list (line 99) | def rigids_from_list(l: List[jnp.ndarray]) -> Rigids:
  function rigids_from_quataffine (line 105) | def rigids_from_quataffine(a: quat_affine.QuatAffine) -> Rigids:
  function rigids_from_tensor4x4 (line 111) | def rigids_from_tensor4x4(
  function rigids_from_tensor_flat9 (line 132) | def rigids_from_tensor_flat9(
  function rigids_from_tensor_flat12 (line 144) | def rigids_from_tensor_flat12(
  function rigids_mul_rigids (line 153) | def rigids_mul_rigids(a: Rigids, b: Rigids) -> Rigids:
  function rigids_mul_rots (line 160) | def rigids_mul_rots(r: Rigids, m: Rots) -> Rigids:
  function rigids_mul_vecs (line 165) | def rigids_mul_vecs(r: Rigids, v: Vecs) -> Vecs:
  function rigids_to_list (line 170) | def rigids_to_list(r: Rigids) -> List[jnp.ndarray]:
  function rigids_to_quataffine (line 175) | def rigids_to_quataffine(r: Rigids) -> quat_affine.QuatAffine:
  function rigids_to_tensor_flat9 (line 185) | def rigids_to_tensor_flat9(
  function rigids_to_tensor_flat12 (line 194) | def rigids_to_tensor_flat12(
  function rots_from_tensor3x3 (line 201) | def rots_from_tensor3x3(
  function rots_from_two_vecs (line 212) | def rots_from_two_vecs(e0_unnormalized: Vecs, e1_unnormalized: Vecs) -> ...
  function rots_mul_rots (line 240) | def rots_mul_rots(a: Rots, b: Rots) -> Rots:
  function rots_mul_vecs (line 248) | def rots_mul_vecs(m: Rots, v: Vecs) -> Vecs:
  function vecs_add (line 255) | def vecs_add(v1: Vecs, v2: Vecs) -> Vecs:
  function vecs_dot_vecs (line 260) | def vecs_dot_vecs(v1: Vecs, v2: Vecs) -> jnp.ndarray:
  function vecs_cross_vecs (line 265) | def vecs_cross_vecs(v1: Vecs, v2: Vecs) -> Vecs:
  function vecs_from_tensor (line 272) | def vecs_from_tensor(x: jnp.ndarray  # shape (..., 3)
  function vecs_robust_normalize (line 280) | def vecs_robust_normalize(v: Vecs, epsilon: float = 1e-8) -> Vecs:
  function vecs_robust_norm (line 293) | def vecs_robust_norm(v: Vecs, epsilon: float = 1e-8) -> jnp.ndarray:
  function vecs_sub (line 305) | def vecs_sub(v1: Vecs, v2: Vecs) -> Vecs:
  function vecs_squared_distance (line 310) | def vecs_squared_distance(v1: Vecs, v2: Vecs) -> jnp.ndarray:
  function vecs_to_tensor (line 317) | def vecs_to_tensor(v: Vecs  # shape (...)

FILE: alphafold/model/tf/data_transforms.py
  function cast_64bit_ints (line 35) | def cast_64bit_ints(protein):
  function make_seq_mask (line 49) | def make_seq_mask(protein):
  function make_template_mask (line 55) | def make_template_mask(protein):
  function curry1 (line 62) | def curry1(f):
  function add_distillation_flag (line 72) | def add_distillation_flag(protein, distillation):
  function make_all_atom_aatype (line 79) | def make_all_atom_aatype(protein):
  function fix_templates_aatype (line 84) | def fix_templates_aatype(protein):
  function correct_msa_restypes (line 97) | def correct_msa_restypes(protein):
  function squeeze_features (line 115) | def squeeze_features(protein):
  function make_random_crop_to_size_seed (line 134) | def make_random_crop_to_size_seed(protein):
  function randomly_replace_msa_with_unknown (line 141) | def randomly_replace_msa_with_unknown(protein, replace_proportion):
  function sample_msa (line 162) | def sample_msa(protein, max_seq, keep_extra):
  function crop_extra_msa (line 191) | def crop_extra_msa(protein, max_extra_msa):
  function delete_extra_msa (line 203) | def delete_extra_msa(protein):
  function block_delete_msa (line 211) | def block_delete_msa(protein, config):
  function nearest_neighbor_clusters (line 252) | def nearest_neighbor_clusters(protein, gap_agreement_weight=0.):
  function summarize_clusters (line 288) | def summarize_clusters(protein):
  function make_msa_mask (line 312) | def make_msa_mask(protein):
  function pseudo_beta_fn (line 321) | def pseudo_beta_fn(aatype, all_atom_positions, all_atom_masks):
  function make_pseudo_beta (line 341) | def make_pseudo_beta(protein, prefix=''):
  function add_constant_field (line 353) | def add_constant_field(protein, key, value):
  function shaped_categorical (line 358) | def shaped_categorical(probs, epsilon=1e-10):
  function make_hhblits_profile (line 368) | def make_hhblits_profile(protein):
  function make_masked_msa (line 380) | def make_masked_msa(protein, config, replace_fraction):
  function make_fixed_size (line 413) | def make_fixed_size(protein, shape_schema, msa_cluster_size, extra_msa_s...
  function make_msa_feat (line 446) | def make_msa_feat(protein):
  function select_feat (line 490) | def select_feat(protein, feature_list):
  function crop_templates (line 495) | def crop_templates(protein, max_templates):
  function random_crop_to_size (line 503) | def random_crop_to_size(protein, crop_size, max_templates, shape_schema,
  function make_atom14_masks (line 565) | def make_atom14_masks(protein):

FILE: alphafold/model/tf/input_pipeline.py
  function nonensembled_map_fns (line 33) | def nonensembled_map_fns(data_config):
  function ensembled_map_fns (line 64) | def ensembled_map_fns(data_config):
  function process_tensors_from_config (line 125) | def process_tensors_from_config(tensors, data_config):
  function compose (line 163) | def compose(x, fs):

FILE: alphafold/model/tf/protein_features.py
  class FeatureType (line 25) | class FeatureType(enum.Enum):
  function register_feature (line 71) | def register_feature(name: str,
  function shape (line 80) | def shape(feature_name: str,

FILE: alphafold/model/tf/protein_features_test.py
  function _random_bytes (line 24) | def _random_bytes():
  class FeaturesTest (line 28) | class FeaturesTest(parameterized.TestCase, tf.test.TestCase):
    method setUp (line 30) | def setUp(self):
    method testFeatureNames (line 34) | def testFeatureNames(self):
    method testReplacement (line 42) | def testReplacement(self):

FILE: alphafold/model/tf/proteins_dataset.py
  function parse_tfexample (line 24) | def parse_tfexample(
  function _first (line 52) | def _first(tensor: tf.Tensor) -> tf.Tensor:
  function parse_reshape_logic (line 57) | def parse_reshape_logic(
  function _make_features_metadata (line 112) | def _make_features_metadata(
  function create_tensor_dict (line 124) | def create_tensor_dict(
  function np_to_tensor_dict (line 145) | 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 22) | class ShapeTest(tf.test.TestCase):
    method setUp (line 24) | def setUp(self):
    method test_shape_list (line 28) | def test_shape_list(self):

FILE: alphafold/model/tf/utils.py
  function tf_combine_mask (line 19) | def tf_combine_mask(*masks):
  class SeedMaker (line 27) | class SeedMaker(object):
    method __init__ (line 30) | def __init__(self, initial_seed=0):
    method __call__ (line 33) | def __call__(self):
  function make_random_seed (line 41) | def make_random_seed():

FILE: alphafold/model/utils.py
  function bfloat16_creator (line 29) | def bfloat16_creator(next_creator, shape, dtype, init, context):
  function bfloat16_getter (line 36) | def bfloat16_getter(next_getter, value, context):
  function bfloat16_context (line 45) | def bfloat16_context():
  function final_init (line 50) | def final_init(config):
  function batched_gather (line 57) | def batched_gather(params, indices, axis=0, batch_dims=0):
  function mask_mean (line 65) | def mask_mean(mask, value, axis=None, drop_mask_channel=False, eps=1e-10):
  function flat_params_to_haiku (line 95) | def flat_params_to_haiku(params: Mapping[str, np.ndarray]) -> hk.Params:
  function padding_consistent_rng (line 107) | def padding_consistent_rng(f):

FILE: alphafold/notebooks/notebook_utils.py
  function clean_and_validate_single_sequence (line 25) | def clean_and_validate_single_sequence(
  function clean_and_validate_input_sequences (line 50) | def clean_and_validate_input_sequences(
  function merge_chunked_msa (line 72) | def merge_chunked_msa(
  function show_msa_info (line 101) | def show_msa_info(
  function empty_placeholder_template_features (line 128) | def empty_placeholder_template_features(
  function get_pae_json (line 146) | def get_pae_json(pae: np.ndarray, max_pae: float) -> str:

FILE: alphafold/notebooks/notebook_utils_test.py
  class NotebookUtilsTest (line 82) | class NotebookUtilsTest(parameterized.TestCase):
    method test_clean_and_validate_sequence_ok (line 87) | def test_clean_and_validate_sequence_ok(self, sequence, exp_clean):
    method test_clean_and_validate_sequence_bad (line 101) | def test_clean_and_validate_sequence_bad(self, sequence, exp_error):
    method test_validate_input_ok (line 111) | def test_validate_input_ok(self, input_sequences, exp_sequences):
    method test_validate_input_bad (line 121) | def test_validate_input_bad(self, input_sequences, exp_error):
    method test_merge_chunked_msa_no_hits (line 127) | def test_merge_chunked_msa_no_hits(self):
    method test_merge_chunked_msa (line 136) | def test_merge_chunked_msa(self):
    method test_show_msa_info (line 159) | def test_show_msa_info(self, mocked_stdout):
    method test_empty_placeholder_template_features (line 175) | def test_empty_placeholder_template_features(self, num_templates):
    method test_get_pae_json (line 187) | def test_get_pae_json(self):

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 74) | def _openmm_minimize(
  function _get_pdb_string (line 113) | def _get_pdb_string(topology: openmm_app.Topology, positions: unit.Quant...
  function _check_cleaned_atoms (line 120) | def _check_cleaned_atoms(pdb_cleaned_string: str, pdb_ref_string: str):
  function _check_residues_are_well_defined (line 139) | def _check_residues_are_well_defined(prot: protein.Protein):
  function _check_atom_mask_is_ideal (line 147) | def _check_atom_mask_is_ideal(prot):
  function clean_protein (line 154) | def clean_protein(
  function make_atom14_positions (line 188) | def make_atom14_positions(prot):
  function find_violations (line 320) | def find_violations(prot_np: protein.Protein):
  function get_violation_metrics (line 356) | def get_violation_metrics(prot: protein.Protein):
  function _run_one_iteration (line 368) | def _run_one_iteration(
  function run_pipeline (line 426) | 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 44) | def test_raises_invalid_protein_assertion(self):
    method test_iterative_relax (line 58) | def test_iterative_relax(self):
    method test_find_violations (line 69) | 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 63) | def clean_structure(pdb_structure, alterations_info):
  function _remove_heterogens (line 74) | def _remove_heterogens(fixer, alterations_info, keep_water):
  function _replace_met_se (line 95) | def _replace_met_se(pdb_structure, alterations_info):
  function _remove_chains_of_length_one (line 109) | def _remove_chains_of_length_one(pdb_structure, alterations_info):

FILE: alphafold/relax/cleanup_test.py
  function _pdb_to_structure (line 23) | def _pdb_to_structure(pdb_str):
  function _lines_to_structure (line 28) | def _lines_to_structure(pdb_lines):
  class CleanupTest (line 32) | class CleanupTest(absltest.TestCase):
    method test_missing_residues (line 34) | def test_missing_residues(self):
    method test_missing_atoms (line 60) | def test_missing_atoms(self):
    method test_remove_heterogens (line 83) | def test_remove_heterogens(self):
    method test_fix_nonstandard_residues (line 97) | def test_fix_nonstandard_residues(self):
    method test_replace_met_se (line 112) | def test_replace_met_se(self):
    method test_remove_chains_of_length_one (line 124) | 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__(self,
    method process (line 58) | def process(self, *,

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 40) | def test_process(self):
    method test_unresolved_violations (line 70) | 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 61) | def assert_equal_nonterminal_atom_types(

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

FILE: run_alphafold.py
  class ModelsToRelax (line 50) | class ModelsToRelax(enum.Enum):
  function _check_flag (line 158) | def _check_flag(flag_name: str,
  function _jnp_to_np (line 167) | def _jnp_to_np(output: Dict[str, Any]) -> Dict[str, Any]:
  function predict_structure (line 177) | def predict_structure(
  function main (line 341) | def main(argv):