Bio.PDB.internal_coords 模块

支持蛋白质结构内部坐标的类。

内部坐标包括沿蛋白质主链的 Psi、Omega 和 Phi 二面角，沿侧链的 Chi 角，以及定义蛋白质链的所有 3 个原子角和键长。这些例程可以从原子 XYZ 坐标计算内部坐标，并从内部坐标计算原子 XYZ 坐标。

次要好处包括能够在 3D 结构中对齐和比较残基环境，支持 2D 原子距离图，将距离图加上手性信息转换为结构，生成用于 3D 打印的结构的 OpenSCAD 描述，以及将结构读写为内部坐标数据文件。

用法

from Bio.PDB.PDBParser import PDBParser
from Bio.PDB.Chain import Chain
from Bio.PDB.internal_coords import *
from Bio.PDB.PICIO import write_PIC, read_PIC, read_PIC_seq
from Bio.PDB.ic_rebuild import write_PDB, IC_duplicate, structure_rebuild_test
from Bio.PDB.SCADIO import write_SCAD
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.PDB.PDBIO import PDBIO
import numpy as np

# load a structure as normal, get first chain
parser = PDBParser()
myProtein = parser.get_structure("7rsa", "pdb7rsa.ent")
myChain = myProtein[0]["A"]

# compute bond lengths, angles, dihedral angles
myChain.atom_to_internal_coordinates(verbose=True)

# check myChain makes sense (can get angles and rebuild same structure)
resultDict = structure_rebuild_test(myChain)
assert resultDict['pass'] == True

# get residue 1 chi2 angle
r1 = next(myChain.get_residues())
r1chi2 = r1.internal_coord.get_angle("chi2")

# rotate residue 1 chi2 angle by 120 degrees (loops w/in +/-180)
r1.internal_coord.set_angle("chi2", r1chi2 + 120.0)
# or
r1.internal_coord.bond_rotate("chi2", 120.0)
# update myChain XYZ coordinates with chi2 changed
myChain.internal_to_atom_coordinates()
# write new conformation with PDBIO
write_PDB(myProtein, "myChain.pdb")
# or just the ATOM records without headers:
io = PDBIO()
io.set_structure(myProtein)
io.save("myChain2.pdb")

# write chain as 'protein internal coordinates' (.pic) file
write_PIC(myProtein, "myChain.pic")
# read .pic file
myProtein2 = read_PIC("myChain.pic")

# create default structure for random sequence by reading as .pic file
myProtein3 = read_PIC_seq(
    SeqRecord(
        Seq("GAVLIMFPSTCNQYWDEHKR"),
        id="1RND",
        description="my random sequence",
    )
)
myProtein3.internal_to_atom_coordinates()
write_PDB(myProtein3, "myRandom.pdb")

# access the all-dihedrals array for the chain, e.g. residue 1 chi2 angle:
r1chi2_obj = r1.internal_coord.pick_angle("chi2")
# or same thing: r1chi2_obj = r1.internal_coord.pick_angle("CA:CB:CG:CD")
r1chi2_key = r1chi2_obj.atomkeys
# r1chi2_key is tuple of AtomKeys (1_K_CA, 1_K_CB, 1_K_CG, 1_K_CD)
r1chi2_index = myChain.internal_coord.dihedraNdx[r1chi2_key]
# or same thing: r1chi2_index = r1chi2_obj.ndx
r1chi2_value = myChain.internal_coord.dihedraAngle[r1chi2_index]
# also true: r1chi2_obj == myChain.internal_coord.dihedra[r1chi2_index]

# access the array of all atoms for the chain, e.g. residue 1 C-beta
r1_cBeta_index = myChain.internal_coord.atomArrayIndex[AtomKey("1_K_CB")]
r1_cBeta_coords = myChain.internal_coord.atomArray[r1_cBeta_index]
# r1_cBeta_coords = [ x, y, z, 1.0 ]

# the Biopython Atom coord array is now a view into atomArray, so
assert r1_cBeta_coords[1] == r1["CB"].coord[1]
r1_cBeta_coords[1] += 1.0  # change the Y coord 1 angstrom
assert r1_cBeta_coords[1] == r1["CB"].coord[1]
# they are always the same (they share the same memory)
r1_cBeta_coords[1] -= 1.0  # restore

# create a selector to filter just the C-alpha atoms from the all atom array
atmNameNdx = AtomKey.fields.atm
atomArrayIndex = myChain.internal_coord.atomArrayIndex
CaSelect = [
    atomArrayIndex.get(k) for k in atomArrayIndex.keys() if k.akl[atmNameNdx] == "CA"
]
# now the ordered array of C-alpha atom coordinates is:
CA_coords = myChain.internal_coord.atomArray[CaSelect]
# note this uses Numpy fancy indexing, so CA_coords is a new copy

# create a C-alpha distance plot
caDistances = myChain.internal_coord.distance_plot(CaSelect)
# display with e.g. MatPlotLib:
# import matplotlib.pyplot as plt
# plt.imshow(caDistances, cmap="hot", interpolation="nearest")
# plt.show()

# build structure from distance plot:
## create the all-atom distance plot
distances = myChain.internal_coord.distance_plot()
## get the sign of the dihedral angles
chirality = myChain.internal_coord.dihedral_signs()
## get new, empty data structure : copy data structure from myChain
myChain2 = IC_duplicate(myChain)[0]["A"]
cic2 = myChain2.internal_coord
## clear the new atomArray and di/hedra value arrays, just for proof
cic2.atomArray = np.zeros((cic2.AAsiz, 4), dtype=np.float64)
cic2.dihedraAngle[:] = 0.0
cic2.hedraAngle[:] = 0.0
cic2.hedraL12[:] = 0.0
cic2.hedraL23[:] = 0.0
## copy just the first N-Ca-C coords so structures will superimpose:
cic2.copy_initNCaCs(myChain.internal_coord)
## copy distances to chain arrays:
cic2.distplot_to_dh_arrays(distances, chirality)
## compute angles and dihedral angles from distances:
cic2.distance_to_internal_coordinates()
## generate XYZ coordinates from internal coordinates:
myChain2.internal_to_atom_coordinates()
## confirm result atomArray matches original structure:
assert np.allclose(cic2.atomArray, myChain.internal_coord.atomArray)

# superimpose all phe-phe pairs - quick hack just to demonstrate concept
# for analyzing pairwise residue interactions.  Generates PDB ATOM records
# placing each PHE at origin and showing all other PHEs in environment
## shorthand for key variables:
cic = myChain.internal_coord
resNameNdx = AtomKey.fields.resname
aaNdx = cic.atomArrayIndex
## select just PHE atoms:
pheAtomSelect = [aaNdx.get(k) for k in aaNdx.keys() if k.akl[resNameNdx] == "F"]
aaF = cic.atomArray[ pheAtomSelect ]  # numpy fancy indexing makes COPY not view

for ric in cic.ordered_aa_ic_list:  # internal_coords version of get_residues()
    if ric.rbase[2] == "F":  # if PHE, get transform matrices for chi1 dihedral
        chi1 = ric.pick_angle("N:CA:CB:CG")  # chi1 space has C-alpha at origin
        cst = np.transpose(chi1.cst)  # transform TO chi1 space
        # rcst = np.transpose(chi1.rcst)  # transform FROM chi1 space
        cic.atomArray[pheAtomSelect] = aaF.dot(cst)  # transform just the PHEs
        for res in myChain.get_residues():  # print PHEs in new coordinate space
            if res.resname in ["PHE"]:
                print(res.internal_coord.pdb_residue_string())
        cic.atomArray[pheAtomSelect] = aaF  # restore coordinate space from copy

# write OpenSCAD program of spheres and cylinders to 3d print myChain backbone
## set atom load filter to accept backbone only:
IC_Residue.accept_atoms = IC_Residue.accept_backbone
## delete existing data to force re-read of all atoms:
myChain.internal_coord = None
write_SCAD(myChain, "myChain.scad", scale=10.0)

有关更多讨论，请参见 Biopython 教程和食谱的内部坐标模块部分。

术语和关键数据结构： 内部坐标在跨越残基或遵循侧链上接受的命名法的原子序列上定义。为了管理这些序列并支持 Biopython 的无序机制，AtomKey 规范被实现以在一个对象中捕获残基、原子和变异标识。一个 Hedron 对象被指定为三个连续的 AtomKeys，包括两个键长和它们之间的键角。一个 Dihedron 由四个连续的 AtomKeys 组成，将两个 Hedra 连接起来，它们之间有一个二面角。

算法概述： 内部坐标模块将 ic_data 文件中连接的原子作为 hedra 和 dihedra 的规范，与这里的例程相结合，以在局部坐标系和例如 PDB 或 mmCif 数据文件中提供的世界坐标之间转换这些原子集的 XYZ 坐标。局部坐标系将 hedra 的中心原子置于原点 (0,0,0)，一条腿位于 +Z 轴，另一条腿位于 XZ 平面（见 Hedron）。在局部坐标空间中测量和创建或操作 hedra 和 dihedra 很简单，并且计算出的变换矩阵能够从提供的（PDB）初始 N-Ca-C 原子坐标开始，将这些子单元组装成蛋白质链。

Psi 和 Phi 角在蛋白质链中相邻残基的原子上定义，例如，请参见 pick_angle() 和 ic_data，了解残基和主链二面角之间的相关映射。

通过 IC_Chain.dCoordSpace 和 Dihedron 属性 .cst 和 .rcst 可以访问往返于上述 dihedron 局部坐标空间的变换，并且可以通过以下代码行在对齐和比较残基及其环境时应用：

chi1 = ric0.pick_angle("chi1") # chi1 space defined with CA at origin
cst = np.transpose(chi1.cst) # transform TO chi1 local space
newAtomCoords = oldAtomCoords.dot(cst)

核心算法是在 1993-4 年期间独立开发的，用于 ‘’开发和应用蛋白质中氨基酸环境的三维描述,’’ Miller、Douthart 和 Dunker，分子生物信息学进展，IOS 出版社，1994 年，ISBN 90 5199 172 x，第 9-30 页。

一个蛋白质内部坐标 (.pic) 文件格式被定义为捕获足够的细节，以从链起始坐标（第一个残基 N、Ca、C XYZ 坐标）和剩余的内部坐标重新生成 PDB 文件。这些文件在内部用于验证给定结构是否可以从其内部坐标重新生成。有关读写 .pic 文件的信息，请参见 PICIO；有关确定特定 PDB 或 mmCif 数据文件是否包含足够信息以在笛卡尔坐标和内部坐标之间相互转换的信息，请参见 structure_rebuild_test()。

内部坐标也可以导出为 OpenSCAD 数据数组，用于生成 3D 打印的蛋白质模型。OpenSCAD 软件作为生成此类模型的起点和概念验证提供。有关更多信息，请参见 SCADIO 和这个 Thingiverse 项目，其中包含更高级的示例。

有关将结构数据转换为/从 2D 距离图转换的信息，请参见 distance_plot() 和 distance_to_internal_coordinates()。

以下类包含用于处理内部坐标的核心功能，并且相互关联且耦合，因此将它们放在此模块中。

IC_Chain：在 .internal_coord 属性上扩展 Biopython Chain。: 管理连接的残基序列和链断裂；为所有原子坐标和键几何持有 numpy 数组。对于“并行”处理，IC_Chain 方法使用单个 numpy 命令对这些数组进行操作。
IC_Residue：在 .internal_coord 属性上扩展 Biopython Residue。: 访问内部坐标的每个残基视图，以及用于串行（逐残基）组装的方法。
Dihedron：四个连接的原子形成一个二面角。: 二面角、局部坐标空间中的同质原子坐标、对相关 Hedra 和 IC_Residue 的引用。获取残基二面角、键角和键长的 getter 方法。
Hedron：三个连接的原子形成一个平面。: 包含局部坐标空间中的同质原子坐标，以及它们之间的键长和角。
Edron：Hedron 和 Dihedron 类的基类。: AtomKeys 元组，包括子元素、字符串 ID、主链成员资格布尔值和其他适用于 Hedra 和 Dihedra 的例程。实现丰富的比较。
AtomKey：用于引用原子序列的键（字典和字符串）。: 捕获残基和无序/占用信息，为 .pic 文件提供无空格键，并实现丰富的比较。

自定义异常类：HedronMatchError 和 MissingAtomError

class Bio.PDB.internal_coords.IC_Chain(parent, verbose: bool = False)

Bases: object

用于扩展 Biopython Chain 的类，添加内部坐标数据。

属性：

chain：对象引用: 扩展的 Biopython Bio.PDB.Chain.Chain 对象
MaxPeptideBond：float: 类属性，用于检测链断裂。对于具有某些非常长键的完全连续链（例如，对于 3D 打印（OpenSCAD 输出）具有缺失残基的结构）覆盖。 MaxPeptideBond
ParallelAssembleResidues：bool: Class 属性影响 internal_to_atom_coords。短链（50 个残基或更少）在没有创建 numpy 数组的开销的情况下更快地组装，并且算法更容易理解和跟踪一次处理一个残基。清除（设置为 False）此标志将切换到串行算法
ordered_aa_ic_list: 列表: IC_Residue 对象的内部坐标算法可以处理（例如，没有水分子）
initNCaC: N、Ca、C AtomKey 元组（NCaCKeys）列表。: NCaCKeys 开始链段（第一个残基或链断裂后）。这 3 个原子定义了连续链段的坐标空间，如 PDB 或 mmCIF 文件最初指定的。
AAsiz = int: 原子数组大小，此链中的原子数
atomArray: numpy 数组: 链中每个原子的同质原子坐标（[x,, y, z, 1.0]）
atomArrayIndex: 字典: 将 AtomKeys 映射到 atomArray 索引
hedra: 字典: 此链中形成 Hedra 的残基；按 AtomKeys 的 3 元组索引。
hedraLen: int: hedra 字典的长度
hedraNdx: 字典: 将 hedra AtomKeys 映射到 hedra 数据数组中的数字索引，例如下面的 hedraL12
a2ha_map: [hedraLen x 3]: hedraNdx 顺序中的原子索引
dihedra: 字典: 此链中形成 Dihedra 的残基；按 AtomKeys 的 4 元组索引。
dihedraLen: int: dihedra 字典的长度
dihedraNdx: 字典: 将 dihedra AtomKeys 映射到 dihedra 数据数组，例如 dihedraAngle
a2da_map[dihedraLen x 4]: dihedraNdx 顺序中的 AtomNdx’s
d2a_map[dihedraLen x [4]]: 每个二面体的 AtomNdx’s（重塑的 a2da_map）
用于链二/面体向量处理的 Numpy 数组
hedraL12: numpy 数组: hedron 第 1 和第 2 个原子之间的键长
hedraAngle: numpy 数组: 每个 hedra 的键角，以度为单位
hedraL23: numpy 数组: hedron 第 2 和第 3 个原子之间的键长
id3_dh_index: 字典: 将 hedra 键映射到以 hedra 开始的二面体列表，assemble 和 bond_rotate 使用它来查找具有 h1 键的二面体
id32_dh_index: 字典: 类似于 id3_dh_index，从 h2 键查找二面体
hAtoms: numpy 数组: hedron 的同质原子坐标 (3x4)，中心原子位于原点
hAtomsR: numpy 数组: 反向方向的 hAtoms
hAtoms_needs_update: bool 的 numpy 数组: 指示 hAtoms 是否表示 hedraL12/A/L23
dihedraAngle: numpy 数组: 每个二面体的二面角（度）
dAtoms: numpy 数组: 二面体的同质原子坐标 (4x4)，第二个原子位于原点
dAtoms_needs_update: bool 的 numpy 数组: 指示 dAtoms 是否表示 dihedraAngle
dCoordSpace: numpy 数组: 标准化第一个 hedra 位置的正向和反向变换矩阵。参见 dCoordSpace.
dcsValid: bool: 指示 dCoordSpace 是否是最新的
另请参阅由 :meth:`build_edraArrays` 生成的属性，用于索引
di/hedra 数据元素。

方法

internal_to_atom_coordinates	处理 ic 数据以获得残基/原子坐标；调用 assemble_residues()
assemble_residues	从内部坐标（并行）生成 IC_Chain 原子坐标
assemble_residues_ser	从内部坐标（串行）生成 IC_Residue 原子坐标
atom_to_internal_coordinates	计算原子数据的二面角、角度、键长（内部坐标）
write_SCAD	写入包含链的内部坐标数据的 OpenSCAD 矩阵；这是一个支持例程，参见 `SCADIO.write_SCAD()` 以生成蛋白质链的 OpenSCAD 描述。
distance_plot	生成具有可选过滤器的原子间距离的二维图
distance_to_internal_coordinates	从距离图和二面角符号数组计算内部坐标。
make_extended	任意地将所有 psi 和 phi 主链角度设置为 123 度和 -104 度。

MaxPeptideBond = 1.4: 大于此值的 C-N 距离将是链断裂

ParallelAssembleResidues = True: 启用并行 internal_to_atom 算法，对于短链来说速度较慢

AAsiz = 0: 此链中的原子数（atomArray 的大小）

atomArray: array = None: AAsiz x [4] 的 float np.float64 同质原子坐标，链中的所有原子。

dCoordSpace = None: [2][dihedraLen][4][4] : 每个二面体的 2 个 4x4 坐标空间变换数组。第一个 [0] 转换为标准空间，第一个原子位于 XZ 平面上，第二个原子位于原点，第三个原子位于 +Z 轴上，第四个原子根据二面角放置。第二个 [1] 变换从标准空间返回到世界坐标（PDB 文件输入或当前坐标）。也可以在 Dihedron 中访问为 .cst（正向变换）和 .rcst（反向变换）。

dcsValid = None: 如果 dCoordSpace 为最新，则为 True。如果需要，请使用 update_dCoordSpace().

__init__(parent, verbose: bool = False) → None

初始化 IC_Chain 对象，无论是否具有残基/原子数据。

参数:: parent (Bio.PDB.Chain) – Biopython Chain 对象此对象扩展

__deepcopy__(memo) → IC_Chain: 为 IC_Chain 实现 deepcopy。

clear_ic(): 清除此链的残基内部坐标设置。

build_atomArray() → None

从 biopython 原子构建 IC_Chain numpy 坐标数组。

另请参阅 init_edra() 以更完整地初始化 IC_Chain。

输入

self.akset集合: 此链中的 AtomKey s

生成

self.AAsizint: 链中的原子数 (len(akset))
self.aktupleAAsiz x AtomKeys: 排序的 akset AtomKeys
self.atomArrayIndex[AAsiz] 的 int: aktuple 中每个 AtomKey 的数字索引
self.atomArrayValidAAsiz x bool: 如果为 True，则 atomArray 坐标与内部坐标当前一致
self.atomArrayAAsiz x np.float64[4]: 同质原子坐标；执行后，Biopython Atom 坐标将成为此数组的视图
rak_cache字典: 每个残基的 AtomKeys 查找缓存

build_edraArrays() → None

构建链级 hedra 和 dihedra 数组。

由 init_edra() 和 _hedraDict2chain() 使用。应该是私有方法，但为了文档而公开。

输入

self.dihedraLenint: 需要的二面体数量
self.hedraLenint: 需要的 hedra 数量
self.AAsizint: atomArray 的长度
self.hedraNdx字典: 将 hedra 键映射到 range(hedraLen)
self.dihedraNdx字典: 将 dihedron 键映射到 range(dihedraLen)
self.hedra字典: 将 Hedra 键映射到链的 Hedra
self.atomArrayAAsiz x np.float64[4]: 链的同质原子坐标
self.atomArrayIndex字典: 将 AtomKeys 映射到 atomArray
self.atomArrayValidAAsiz x bool: 指示坐标是否是最新的

生成

self.dCoordSpace[2][dihedraLen][4][4]: 转换到/从二面体坐标空间
self.dcsValiddihedraLen x bool: 指示 dCoordSpace 是否为当前坐标
self.hAtomshedraLen x 3 x np.float64[4]: hCoordSpace 中的原子坐标
self.hAtomsRhedraLen x 3 x np.float64[4]: 反向顺序的 hAtoms（用空间换时间）
self.hAtoms_needs_updatehedraLen x bool: 指示 hAtoms，当前的 hAtoms
self.a2h_mapAAsiz x [int …]: 将 atomArrayIndex 映射到包含该原子的 hedraNdx
self.a2ha_map[hedraLen x 3]: hedraNdx 顺序的 AtomNdx
self.h2aahedraLen x [int …]: 将 hedraNdx 映射到 hedron 中的 atomNdx（稍后重塑）
Hedron.ndxint: 存储在 Hedron 对象中的 self.hedraNdx 值
self.dRevdihedraLen x bool: 如果为真，则 dihedron 反转
self.dH1ndx, dH2ndx[dihedraLen]: 第一个和第二个 hedra 的 hedraNdx
self.h1d_maphedraLen x []: hedraNdx -> [使用 hedron 的 dihedra]
Dihedron.h1key, h2key[AtomKey …]: dihedron 的 hedron 键，根据需要反转
Dihedron.hedron1, hedron2Hedron: dihedron 内部对 hedra 的引用
Dihedron.ndxint: Dihedron 对象内的 self.dihedraNdx 信息
Dihedron.cst, rcstnp.float64p4][4]: Dihedron 内部的 dCoordSpace 引用
self.a2da_map[dihedraLen x 4]: dihedraNdx 顺序中的 AtomNdx’s
self.d2a_map[dihedraLen x [4]]: 每个二面体的 AtomNdx’s（重塑的 a2da_map）
self.dFwdbool: 如果为真，则 dihedron 未反转
self.a2d_mapAAsiz x [[dihedraNdx: [dihedron 中原子的 atom ndx 0-3]]，将原子索引映射到 dihedra 及其内部原子
self.dAtoms_needs_updatedihedraLen x bool: 如果为假，则 h1、h2 中的原子为当前原子

assemble_residues(verbose: bool = False) → None

从内部坐标生成原子坐标（矢量化）。

这是 assemble_residues_ser() 的“Numpy 并行”版本。

从 init_atom_coords() 形成的 dihedra 开始，将每个 dihedra 从 dihedron 本地坐标空间转换为蛋白质链坐标空间。重复迭代直到所有依赖项得到满足。

不更新 dCoordSpace，因为 assemble_residues_ser() 会更新。如果需要，请调用 update_dCoordSpace()。一次操作完成所有原子坐标后，这样做会更快。

参数:: verbose (bool) – 默认 False。报告计算更改 dihedra 的迭代次数

生成

self.dSet: AAsiz x dihedraLen x 4: 将 dihedra 中的原子映射到 atomArray
self.dSetValid[dihedraLen][4] of bool: 有效原子到 dihedra 的映射，用于检测 3 或 4 个有效原子

输出坐标写入 atomArray。Biopython Bio.PDB.Atom 坐标是此数据的视图。

assemble_residues_ser(verbose: bool = False, start: int | None = None, fin: int | None = None) → None

从内部坐标生成 IC_Residue 原子坐标（串行）。

有关“numpy 并行”版本的详细信息，请参见 assemble_residues()。

如果设置，则过滤开始和结束之间的位置，找到每个残基的适当开始坐标并传递给 assemble()

参数:

verbose (bool) – 默认 False。描述运行时问题
start,fin (int) – 默认 None。要生成坐标的子区域的开始和结束的序列位置。

init_edra(verbose: bool = False) → None

创建链和残基 di/hedra 结构、数组、atomArray。

输入

self.ordered_aa_ic_list : list of IC_Residue

生成

edra 对象，self.di/hedra（执行 _create_edra()）
atomArray 和支持（执行 build_atomArray()）
self.hedraLen : 结构中 hedra 的数量
hedraL12 : 长度和角度的 numpy 数组（空）
hedraAngle ..
hedraL23 ..
self.hedraNdx : 将 hedrakey 映射到 hedraL12 等等的字典
self.dihedraLen : 结构中 dihedra 的数量
dihedraAngle ..
dihedraAngleRads : 角度的 np 数组（空）
self.dihedraNdx : 将 dihedrakey 映射到 dihedraAngle 的字典

init_atom_coords() → None

从角度和距离设置链级 di/hedra 初始坐标。

初始化 hedra 和 dihedra 在本地坐标空间中的原子坐标，稍后将通过 dCoordSpace 矩阵进行适当的转换以进行组装。

update_dCoordSpace(workSelector: ndarray | None = None) → None

计算/更新链 dihedra 的坐标空间转换。

需要更新所有原子，因此会调用 assemble_residues()（如果所有原子已组装，则会立即返回）。

参数:: workSelector ([bool]) – 可选掩码，用于选择要更新的 dihedra

propagate_changes() → None: 跟踪 di/hedra 以使依赖原子失效。

internal_to_atom_coordinates(verbose: bool = False, start: int | None = None, fin: int | None = None) → None

将 IC 数据处理为 Residue/Atom 坐标。

参数:

verbose (bool) – 默认 False。描述运行时问题
start,fin (int) – 可选的序列位置，用于要处理的子区域的开始和结束。

注意

设置开始或结束会激活串行 assemble_residues_ser() 而不是（Numpy 并行）assemble_residues()。开始 C-alpha 将位于原点。

另请参见

ParallelAssembleResidues

atom_to_internal_coordinates(verbose: bool = False) → None

计算 Atom 数据的二面角、角度和键长。

生成原子数组（通过 init_edra），用于 hedra 和 dihedra 的值数组，以及用于 dihedra 的坐标空间变换。

如果指定，则生成 Gly C-beta，请参阅 IC_Residue.gly_Cbeta

参数:: verbose (bool) – 默认值 False。描述运行时问题

distance_plot(filter: ndarray | None = None) → ndarray

从 atomArray 生成 2D 距离图。

默认情况下，计算所有原子的距离。要生成经典的 C-alpha 距离图，请传递一个布尔掩码数组，例如

atmNameNdx = internal_coords.AtomKey.fields.atm
CaSelect = [
    atomArrayIndex.get(k)
    for k in atomArrayIndex.keys()
    if k.akl[atmNameNdx] == "CA"
]
plot = cic.distance_plot(CaSelect)

或者，这将选择所有主链原子

backboneSelect = [
    atomArrayIndex.get(k)
    for k in atomArrayIndex.keys()
    if k.is_backbone()
]

参数:: filter ([bool]) – 限制用于计算的原子

另请参见

distance_to_internal_coordinates()，它需要默认的全部原子距离图。

dihedral_signs() → ndarray

获取链 dihedraAngle 数组中每个元素的符号数组 (+1/-1)。

需要用于 distance_to_internal_coordinates()

distplot_to_dh_arrays(distplot: ndarray, dihedra_signs: ndarray) → None

从 distplot 加载 di/hedra 距离数组。

从输入 distplot 填充 IC_Chain 数组 hedraL12、L23、L13 和 dihedraL14 距离值数组，从输入 dihedra_signs 数组填充 dihedra_signs。Distplot 和 di/hedra 距离数组必须根据 IC_Chain 中的 AtomKey 映射进行索引。hedraNdx 和 .dihedraNdx（在 IC_Chain.init_edra() 中创建）

在运行此操作之前，调用 atom_to_internal_coordinates()（或至少 init_edra()）以生成 a2ha_map 和 d2a_map。

从 distance_to_internal_coordinates() 中显式删除，因此用户可以通过其他方法填充这些链 di/hedra 数组。

distance_to_internal_coordinates(resetAtoms: bool | None = True) → None

从距离和手性数据计算链 di/hedra。

hedra L12、L23、L13 和 dihedra L14 上的距离属性由 distplot_to_dh_arrays() 或其他加载器配置。

dihedraAngles 结果在最后一步乘以 dihedra_signs，以恢复在距离图中丢失的手性信息（结构的镜像图像具有相同的距离，但二面角符号相反）。

请注意，链断裂会导致重建结构中的错误，使用 copy_initNCaCs() 以避免这种情况

基于 Blue，Hedronometer 对四面体二面角与其边长的关系的解答，在 math.stackexchange.com 上。另请参阅：“四面体体积的类海伦公式结果”。

该分析中的其他值作为注释包含在此处，以确保完整性

oa = 如果 reverse 则为 hedron1 L12，否则为 hedron1 L23
ob = 如果 reverse 则为 hedron1 L23，否则为 hedron1 L12
ac = 如果 reverse 则为 hedron2 L12，否则为 hedron2 L23
ab = hedron1 L13 = OA、OB（hedron1 L12、L23）上的余弦定理
oc = hedron2 L13 = OA、AC（hedron2 L12、L23）上的余弦定理
bc = dihedron L14

目标是 OA，即沿边 oa 的二面角。

参数:: resetAtoms (bool) – 默认值 True。标记 di/hedra 和 atomArray 中的所有原子，以便由 internal_to_atom_coordinates() 更新。或者将此值设置为 False 并直接操作 atomArrayValid、dAtoms_needs_update 和 hAtoms_needs_update 以减少计算量。

copy_initNCaCs(other: IC_Chain) → None

从其他 IC_Chain 复制 initNCaC 原子的原子坐标。

复制坐标并为初始 NCaC 以及任何链断裂后的原子设置 atomArrayValid 标志为 True。

如果目标有链断裂，则需要用于 distance_to_internal_coordinates()（否则每个片段将从原点开始）。

如果从另一个链复制内部坐标，也很有用。

注意 IC_Residue.set_angle() 和 IC_Residue.set_length() 会使相关的原子失效，因此在调用此函数之前先应用它们。

make_extended(): 将所有 psi 和 phi 角设置为扩展构象（123，-104）。

__annotations__ = {'atomArray': <built-in function array>, 'atomArrayIndex': "dict['AtomKey', int]", 'bpAtomArray': "list['Atom']", 'ordered_aa_ic_list': 'list[IC_Residue]'}

class Bio.PDB.internal_coords.IC_Residue(parent: Residue)

Bases: object

类，用于扩展 Biopython Residue 以包含内部坐标数据。

参数:

parent: 此类扩展的 biopython Residue 对象

属性：

no_altloc: bool 默认值为 False

类变量，如果为 True，则禁用 ALTLOC 原子的处理，仅使用选定的原子。

accept_atoms: 元组

类变量 accept_atoms，在生成内部坐标时要使用的 PDB 原子名称列表。默认情况下，

accept_atoms = accept_mainchain + accept_hydrogens

在内部坐标和生成的 PDB 文件中排除氢原子，覆盖为

IC_Residue.accept_atoms = IC_Residue.accept_mainchain

仅获取主链原子加上酰胺质子，使用

IC_Residue.accept_atoms = IC_Residue.accept_mainchain + ('H',)

将 D 原子转换为 H，设置 AtomKey.d2h = True 并使用

IC_Residue.accept_atoms = (
    accept_mainchain + accept_hydrogens + accept_deuteriums
)

请注意 accept_mainchain = accept_backbone + accept_sidechain。因此，要生成与序列无关的构象数据（例如，在二面角空间中进行结构比对），请使用

IC_Residue.accept_atoms = accept_backbone

或设置 gly_Cbeta = True 并使用

IC_Residue.accept_atoms = accept_backbone + ('CB',)

更改 accept_atoms 会导致 ic_rebuild 中的默认 structure_rebuild_test 失败，如果某些原子被过滤掉（显然）。使用 quick=True 选项仅测试过滤掉原子的坐标以避免这种情况。

目前没有选项可以输出带有 D 而不是 H 的内部坐标。

accept_resnames: 元组

类变量 accept_resnames，用于生成内部坐标的 HETATM 接受的 3 字母残基名称列表。 HETATM 侧链将被忽略，但正常主链原子（N、CA、C、O、CB）将被包含。目前仅为 CYG、YCM 和 UNK；请自行承担风险覆盖。要生成侧链，请在 ic_data 中添加相应的条目到 ic_data_sidechains 并支持 IC_Chain.atom_to_internal_coordinates()。

gly_Cbeta: 布尔值，默认值为 False

类变量 gly_Cbeta，覆盖为 True 以在 IC_Chain.atom_to_internal_coordinates() 中为甘氨酸 CB 原子生成内部坐标。

IC_Residue.gly_Cbeta = True

pic_accuracy: 字符串，默认值为 “17.13f”

类变量 pic_accuracy 设置 .pic 文件中数值（角度、长度）的精度。默认值设置为高以支持重建测试中的 mmCIF 文件精度。如果您发现重建测试失败并出现“ERROR -COORDINATES-”且 verbose=True 仅显示微小的差异，请尝试提高此值（或者如果仅使用 PDB 格式文件，则降低到 9.5）。

IC_Residue.pic_accuracy = "9.5f"

residue: Biopython 残基对象引用

扩展的 Residue 对象

hedra: 字典，由 3 个 AtomKeys 的元组索引

形成此残基的 Hedra

dihedra: 字典，由 4 个 AtomKeys 的元组索引

形成（重叠）此残基的 Dihedra

rprev, rnext: IC_Residue 对象列表

链中相邻（键合，不缺失，可能无序）残基的引用

atom_coords: AtomKey 索引的 numpy [4] 数组字典

已删除 使用 AtomKeys 和 atomArrayIndex 在需要时构建

ak_set: Dihedra 中 AtomKeys 的集合

此残基重叠的所有 Dihedra 中的 AtomKeys（见 __contains__（））

alt_ids: 字符列表

来自 PDB 文件的 AltLoc ID

bfactors: 字典

来自 PDB 文件的 AtomKey 索引的 B 因子

NCaCKey: 元组列表

N、Ca、C 主链原子 AtomKeys 的元组列表；通常只有 1 个，但如果主链 altlocs 则更多。

is20AA: 布尔值

如果残基是 20 种标准氨基酸中的一种，则为 True，基于残基 resname

isAccept: 布尔值

如果为 is20AA 或在下面的 accept_resnames 中，则为 True

rbase: 元组

残基位置、插入代码或无、resname（如果为标准氨基酸，则为 1 个字母）

cic: IC_Chain，默认值为 None

父链 IC_Chain 对象

scale: 可选浮点数

用于 OpenSCAD 输出以生成 gly_Cbeta 键长

方法

assemble(atomCoordsIn, resetLocation, verbose)	根据内部坐标计算此残基的原子坐标
get_angle()	返回传递的键的角度
get_length()	返回指定对的键长
pick_angle()	查找传递的键的 Hedron 或 Dihedron
pick_length()	查找传递的 AtomKey 对的 hedra
set_angle()	设置传递的键的角度（不更新位置）
set_length()	在所有相关的 hedra 中设置指定对的键长
bond_rotate(delta)	通过 delta 调整相关的二面角角度，例如，旋转 psi（N-Ca-C-N）将通过相同的量调整相邻的 N-Ca-C-O 以避免冲突
bond_set(angle)	使用 bond_rotate 将指定的二面角设置为角度并相应地调整相关的二面角
rak(atom info)	此残基的缓存 AtomKeys

accept_resnames = ('CYG', 'YCM', 'UNK'): 在此处添加具有正常主链的非标准残基的 3 字母残基名称。 CYG 包含用于测试用例 4LGY（1305 个残基连续链）。可以安全地添加更多用于 N-CA-C-O 主链的名称，任何更复杂的复杂性都需要在 accept_atoms、ic_data_sidechains 中添加内容，并在 ic_data 中添加支持，并在 IC_Chain.atom_to_internal_coordinates() 中添加支持。

no_altloc: bool = False: 设置为 True 以过滤输入的 altloc 原子，仅使用 Biopython 默认原子

gly_Cbeta: bool = False

在所有 Gly 残基上创建 beta 碳。

将此设置为 True 将在 atom_to_internal_coordinates() 中为 Gly C-beta 碳生成内部坐标。

从 2019 年 9 月的 Dunbrack cullpdb_pc20_res2.2_R1.0 中获得的平均数据，限制为具有酰胺质子的结构。请参见

PISCES：蛋白质序列剔除服务器

‘G. Wang 和 R. L. Dunbrack, Jr. PISCES：蛋白质序列剔除服务器。生物信息学，19:1589-1591，2003。’

Ala 从 NCACO 查询中获得的 OCCACB 的平均旋转

select avg(g.rslt) as avg_rslt, stddev(g.rslt) as sd_rslt, count(*)
from
(select f.d1d, f.d2d,
(case when f.rslt > 0 then f.rslt-360.0 else f.rslt end) as rslt
from (select d1.angle as d1d, d2.angle as d2d,
(d2.angle - d1.angle) as rslt from dihedron d1,
dihedron d2 where d1.re_class='AOACACAACB' and
d2.re_class='ANACAACAO' and d1.pdb=d2.pdb and d1.chn=d2.chn
and d1.res=d2.res) as f) as g

结果

| avg_rslt          | sd_rslt          | count   |
| -122.682194862932 | 5.04403040513919 | 14098   |

pic_accuracy: str = '17.13f'

accept_backbone = ('N', 'CA', 'C', 'O', 'OXT')

accept_sidechain = ('CB', 'CG', 'CG1', 'OG1', 'OG', 'SG', 'CG2', 'CD', 'CD1', 'SD', 'OD1', 'ND1', 'CD2', 'ND2', 'CE', 'CE1', 'NE', 'OE1', 'NE1', 'CE2', 'OE2', 'NE2', 'CE3', 'CZ', 'NZ', 'CZ2', 'CZ3', 'OD2', 'OH', 'CH2', 'NH1', 'NH2')

accept_mainchain = ('N', 'CA', 'C', 'O', 'OXT', 'CB', 'CG', 'CG1', 'OG1', 'OG', 'SG', 'CG2', 'CD', 'CD1', 'SD', 'OD1', 'ND1', 'CD2', 'ND2', 'CE', 'CE1', 'NE', 'OE1', 'NE1', 'CE2', 'OE2', 'NE2', 'CE3', 'CZ', 'NZ', 'CZ2', 'CZ3', 'OD2', 'OH', 'CH2', 'NH1', 'NH2')

accept_hydrogens = ('H', 'H1', 'H2', 'H3', 'HA', 'HA2', 'HA3', 'HB', 'HB1', 'HB2', 'HB3', 'HG2', 'HG3', 'HD2', 'HD3', 'HE2', 'HE3', 'HZ1', 'HZ2', 'HZ3', 'HG11', 'HG12', 'HG13', 'HG21', 'HG22', 'HG23', 'HZ', 'HD1', 'HE1', 'HD11', 'HD12', 'HD13', 'HG', 'HG1', 'HD21', 'HD22', 'HD23', 'NH1', 'NH2', 'HE', 'HH11', 'HH12', 'HH21', 'HH22', 'HE21', 'HE22', 'HE2', 'HH', 'HH2')

accept_deuteriums = ('D', 'D1', 'D2', 'D3', 'DA', 'DA2', 'DA3', 'DB', 'DB1', 'DB2', 'DB3', 'DG2', 'DG3', 'DD2', 'DD3', 'DE2', 'DE3', 'DZ1', 'DZ2', 'DZ3', 'DG11', 'DG12', 'DG13', 'DG21', 'DG22', 'DG23', 'DZ', 'DD1', 'DE1', 'DD11', 'DD12', 'DD13', 'DG', 'DG1', 'DD21', 'DD22', 'DD23', 'ND1', 'ND2', 'DE', 'DH11', 'DH12', 'DH21', 'DH22', 'DE21', 'DE22', 'DE2', 'DH', 'DH2')

accept_atoms = ('N', 'CA', 'C', 'O', 'OXT', 'CB', 'CG', 'CG1', 'OG1', 'OG', 'SG', 'CG2', 'CD', 'CD1', 'SD', 'OD1', 'ND1', 'CD2', 'ND2', 'CE', 'CE1', 'NE', 'OE1', 'NE1', 'CE2', 'OE2', 'NE2', 'CE3', 'CZ', 'NZ', 'CZ2', 'CZ3', 'OD2', 'OH', 'CH2', 'NH1', 'NH2', 'H', 'H1', 'H2', 'H3', 'HA', 'HA2', 'HA3', 'HB', 'HB1', 'HB2', 'HB3', 'HG2', 'HG3', 'HD2', 'HD3', 'HE2', 'HE3', 'HZ1', 'HZ2', 'HZ3', 'HG11', 'HG12', 'HG13', 'HG21', 'HG22', 'HG23', 'HZ', 'HD1', 'HE1', 'HD11', 'HD12', 'HD13', 'HG', 'HG1', 'HD21', 'HD22', 'HD23', 'NH1', 'NH2', 'HE', 'HH11', 'HH12', 'HH21', 'HH22', 'HE21', 'HE22', 'HE2', 'HH', 'HH2'): 修改 accept_atoms 以限制处理的原子。有关用法，请参见 IC_Residue。

__init__(parent: Residue) → None

使用父 Biopython 残基初始化 IC_Residue。

参数:: parent (Residue) – Biopython 残基对象。此对象扩展的 Biopython 残基

__deepcopy__(memo): IC_Residue 的深度复制实现。

__contains__(ak: AtomKey) → bool: 如果原子键在此残基中，则返回 True。

rak(atm: str | Atom) → AtomKey: 缓存对此残基的 AtomKey 的调用。

__repr__() → str: 打印字符串是父残基 ID。

pretty_str() → str: 残基 ID 的漂亮字符串。

set_flexible() → None

对于 OpenSCAD，将 N-CA 和 CA-C 键标记为柔性连接。

参见 SCADIO.write_SCAD()

set_hbond() → None

对于 OpenSCAD，将 H-N 和 C-O 键标记为氢键（磁铁）。

参见 SCADIO.write_SCAD()

clear_transforms()

在 assemble() 之前使二面角坐标空间属性失效。

坐标空间属性是 Dihedron.cst 和 .rcst，以及 IC_Chain.dCoordSpace

assemble(resetLocation: bool = False, verbose: bool = False) → dict[AtomKey, array] | dict[tuple[AtomKey, AtomKey, AtomKey], array] | None

从内部坐标计算此残基的原子坐标。

这是 assemble_residues_ser() 串行版本的 IC_Residue 部分，有关 numpy 向量化方法的示例，请参见 assemble_residues()，该方法在 IC_Chain 级别上运行。

从 N-CA-C 和 N-CA-CB 二面体开始连接准备好的二面体，计算主链和侧链原子的蛋白质空间坐标

在每个二面体上设置正向和反向变换，以从蛋白质坐标转换为前三个原子的二面体空间坐标（参见 IC_Chain.dCoordSpace)

在来到这里之前，调用 init_atom_coords() 以更新任何已修改的二/面体，这只会将二面体组装到蛋白质坐标空间中。

算法

形成双端队列，从 c-ca-n、o-c-ca、n-ca-cb、n-ca-c 开始。

如果 resetLocation=True，则使用生成二面体的初始坐标作为 n-ca-c 初始位置（结果在二面体坐标空间中）。

当队列不为空时

获取 3 个原子三面体的键。

对于每个从三面体键开始的二面体（二面体的第一个三面体）

如果已经拥有所有 4 个原子的坐标
将第二个三面体键添加到队列的末尾

否则，如果拥有前 3 个原子的坐标
计算正向和反向变换，将前 3 个原子带入/带出二面体的初始坐标空间。

使用反向变换从二面体的初始坐标获取当前坐标中第四个原子位置。

将第二个三面体键添加到队列的末尾

否则
排序失败，将三面体键放到队列的末尾，并希望下次我们拥有前 3 个原子位置（不应该发生）。

循环终止（队列耗尽），因为没有开始任何二面体的三面体键在没有动作的情况下被删除。

参数:

resetLocation (bool) – 默认值为 False。- 选项是忽略起始位置并进行定向，以便初始 N-Ca-C 三面体位于原点。

返回值:

AtomKey 到蛋白质空间中残基相对于先前残基的同质原子坐标的字典

此外，还会直接更新 IC_Chain.atomArray，如同 assemble_residues() 所做的那样。

split_akl(lst: tuple[AtomKey, ...] | list[AtomKey], missingOK: bool = False) → list[tuple[AtomKey, ...]]

获取此残基的 AtomKeys（ak_set），用于通用的 AtomKeys 列表。

更改或扩展通用的 AtomKeys 列表（例如，“N, C, C”），以使其特定于此残基的 altlocs 等，例如，“(N-Ca_A_0.3-C, N-Ca_B_0.7-C)”

给定一个用于 Hedron 或 Dihedron 的 AtomKeys 列表，

返回

匹配的原子键列表，这些原子键在该残基中具有 id3_dh（如果占用率 != 1.00，则 ak 可能会发生变化）

或: 为所有原子 altlocs 扩展的匹配原子键的多个列表
或: 如果任何 atom_coord(ak) 丢失，并且没有 missingOK，则为空列表

参数:

lst (list) – AtomKeys 的 list[3] 或 [4]。要匹配到此残基的特定 AtomKeys 的非 altloc AtomKeys
missingOK (bool) – 默认值为 False，如上所述。

atom_sernum = None

atom_chain = None

pdb_residue_string() → str

将此残基的 PDB ATOM 记录生成为字符串。

用于 PDBIO.py 中未公开的功能的便捷方法。如果 IC_Residue.atom_sernum 不为 None，则递增该值。

参数:

IC_Residue.atom_sernum – 类变量，默认为 None。如果该值不为 None，则覆盖并递增原子序列号。
IC_Residue.atom_chain – 类变量。如果该值不为 None，则覆盖原子链 ID。

待办事项

移至 PDBIO

pic_flags = (1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 496, 525, 1021, 1024, 2048, 4096, 7168, 8192, 16384): 由 PICIO.write_PIC() 用于控制要设置为默认值的数值类别。

picFlagsDefault = 31744: 默认情况下为所有 dihedra + 初始 tau 原子 + bFactors。

picFlagsDict = {'all': 7168, 'bFactors': 16384, 'chi': 496, 'chi1': 16, 'chi2': 32, 'chi3': 64, 'chi4': 128, 'chi5': 256, 'classic': 1021, 'classic_b': 525, 'hedra': 1024, 'initAtoms': 8192, 'omg': 2, 'phi': 4, 'pomg': 512, 'primary': 2048, 'psi': 1, 'secondary': 4096, 'tau': 8}: pic_flags 值的字典，根据需要使用。

pick_angle(angle_key: tuple[AtomKey, AtomKey, AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey] | str) → Hedron | Dihedron | None

获取 angle_key 的 Hedron 或 Dihedron。

参数:

angle_key –

3 或 4 个 AtomKeys 的元组
用冒号隔开的原子名称字符串（“CA”）
用冒号隔开的 [-1, 0, 1]<原子名称> 字符串。-1 为前一个残基，0 为当前残基，1 为下一个残基
psi、phi、omg、omega、chi1、chi2、chi3、chi4、chi5
tau（N-CA-C 角度）请参阅 Richardson1981
AtomKeys 的元组仅用于访问备用无序原子。

请注意，残基的 phi 和 omega 二面角以及包含它们的 hedra（包括 N:Ca:C tau hedra）存储在 n-1 di/hedra 集中；此重叠在此处处理，但如果直接访问，可能会出现问题。

以下打印命令等效（除了侧链中用于 chi2 的非碳原子）。

ric = r.internal_coord
print(
    r,
    ric.get_angle("psi"),
    ric.get_angle("phi"),
    ric.get_angle("omg"),
    ric.get_angle("tau"),
    ric.get_angle("chi2"),
)
print(
    r,
    ric.get_angle("N:CA:C:1N"),
    ric.get_angle("-1C:N:CA:C"),
    ric.get_angle("-1CA:-1C:N:CA"),
    ric.get_angle("N:CA:C"),
    ric.get_angle("CA:CB:CG:CD"),
)

有关枚举的侧链角度中的原子和跨越肽键的骨架角度的详细信息，请参阅 ic_data.py。使用“s”表示当前残基（“self”），“n”表示下一个残基，跨越（重叠）角度为

(sN, sCA, sC, nN)   # psi
(sCA, sC, nN, nCA)  # omega i+1
(sC, nN, nCA, nC)   # phi i+1
(sCA, sC, nN)
(sC, nN, nCA)
(nN, nCA, nC)       # tau i+1

返回值:: 匹配的 Hedron、Dihedron 或 None。

get_angle(angle_key: tuple[AtomKey, AtomKey, AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey] | str) → float | None

获取指定键的 dihedron 或 hedron 角度。

有关键规范，请参阅 pick_angle()。

set_angle(angle_key: tuple[AtomKey, AtomKey, AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey] | str, v: float, overlap=True)

为指定键设置二面角或多面角。

如果角度是 Dihedron 且 overlap 为 True（默认），则也会根据需要更改重叠的二面角。重叠是 ic_data 和 _create_edra() 中蛋白质链定义的结果（例如 psi 重叠 N-CA-C-O）。

默认的 overlap=True 可能适合： set_angle(“chi1”, val)

当处理链或残基中的所有二面角（例如从另一个结构复制）时，默认值可能不适合，因为重叠的二面角可能也在集合中。

注意：设置例如 PRO chi2 允许，不会产生错误或警告！

有关 angle_key 规范，请参阅 pick_angle()。有关更改二面角度的说明，请参阅 bond_rotate()

参数:

angle_key – 角度标识符。
v (float) – 新角度，以度为单位（结果调整到 +/-180）。
overlap (bool) – 默认值 True。根据需要修改重叠的二面角。

bond_rotate(angle_key: tuple[AtomKey, AtomKey, AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey] | str, delta: float)

将一组重叠的二面角旋转 delta 度。

通过给定的 delta 更改二面角，即 new_angle = current_angle + delta。值会进行调整，因此 new_angle 将在 +/-180 范围内。

更改重叠的二面角，与 set_angle() 相同。

有关键规范，请参阅 pick_angle()。

bond_set(angle_key: tuple[AtomKey, AtomKey, AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey] | str, val: float)

将二面角设置为 val，并通过相同数量更新重叠的二面角。

与 set_angle() 重复，保留以确保兼容性。与 set_angle() 不同，此方法仅适用于二面角，并且没有选项可以不更新重叠的二面角。

有关键规范，请参阅 pick_angle()。

pick_length(ak_spec: str | tuple[AtomKey, AtomKey]) → tuple[list[Hedron] | None, tuple[AtomKey, AtomKey] | None]

获取包含指定原子对的多面体列表。

参数:

ak_spec –

两个 AtomKey 的元组
字符串：两个原子名称，用 ‘:’ 分隔，例如 ‘N:CA’，可选的相对位置规范符，例如 ‘-1C:N’ 表示前面的肽键。位置规范符是 -1、0、1。

以下等效

ric = r.internal_coord
print(
    r,
    ric.get_length("0C:1N"),
)
print(
    r,
    None
    if not ric.rnext
    else ric.get_length((ric.rak("C"), ric.rnext[0].rak("N"))),
)

如果在当前残基上找不到原子，则会在 rprev[0] 上查找，以处理例如 Gly N:CA 的情况。有关更细致的控制，请直接访问 IC_Chain.hedra。

返回值:: 包含指定原子对的多面体列表，作为 AtomKey 的元组。

get_length(ak_spec: str | tuple[AtomKey, AtomKey]) → float | None

获取指定原子对的键长。

有关 ak_spec 和详细信息，请参阅 pick_length()。

set_length(ak_spec: str | tuple[AtomKey, AtomKey], val: float) → None

为指定原子对设置键长。

有关 ak_spec，请参阅 pick_length()。

applyMtx(mtx: array) → None: 将矩阵应用于此 IC_Residue 的 atom_coords。

__annotations__ = {'_AllBonds': <class 'bool'>, 'ak_set': 'set[AtomKey]', 'akc': 'dict[Union[str, Atom], AtomKey]', 'alt_ids': 'Union[list[str], None]', 'bfactors': 'dict[str, float]', 'cic': 'IC_Chain', 'dihedra': 'dict[DKT, Dihedron]', 'gly_Cbeta': <class 'bool'>, 'hedra': 'dict[HKT, Hedron]', 'no_altloc': <class 'bool'>, 'pic_accuracy': <class 'str'>, 'rnext': 'list[IC_Residue]', 'rprev': 'list[IC_Residue]'}

class Bio.PDB.internal_coords.Edron(*args: list[AtomKey] | tuple[AtomKey, AtomKey, AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey], **kwargs: str)

Bases: object

Hedron 和 Dihedron 类的基类。

支持基于 AtomKey 列表的丰富比较。

属性：

atomkeys: 元组: 定义此 di/hedron 的 3 个（hedron）或 4 个（dihedron）AtomKey。
id: str: 此 di/hedron 的 AtomKey 的 ‘:’-连接字符串。
needs_update: bool: 表示 di/hedron 本地 atom_coords 不反映 hedron 本地坐标空间中当前的 di/hedron 角和长度值。
e_class: str: 构成 di/hedron 的原子序列（无位置或残基），用于统计。
re_class: str: 构成 di/hedron 的残基和原子序列，用于统计。
cre_class: str: 构成 di/hedron 的共价半径类序列，用于统计。
edron_re: 编译后的正则表达式（类属性）: 一个匹配 Hedron 和 Dihedron 对象的字符串 ID 的编译后的正则表达式。
cic: IC_Chain 引用: 包含此 hedron 的链内部坐标对象。
ndx: int: di/hedra 的 IC_Chain 级别 numpy 数据数组中的索引。在 IC_Chain.init_edra() 中设置。
rc: int: 此 edron 中涉及的残基数量。

方法

gen_key([AtomKey, …] 或 AtomKey, …) (静态方法)	生成 AtomKey ID 的 ‘:’-连接字符串。
is_backbone()	如果所有 atomkeys 原子都是 N、Ca、C 或 O，则返回 True。

edron_re = re.compile('^(?P<pdbid>\\w+)?\\s(?P<chn>[\\w|\\s])?\\s(?P<a1>[\\w\\-\\.]+):(?P<a2>[\\w\\-\\.]+):(?P<a3>[\\w\\-\\.]+)(:(?P<a4>[\\w\\-\\.]+))?\\s+(((?P<len12>\\S+)\\s+(?P<angle>\\S+)\\s+(?P<len23>\\S+)\\s*$)|((?P<): 一个匹配 Hedron 和 Dihedron 对象的字符串 ID 的编译后的正则表达式。

static gen_key(lst: list[AtomKey]) → str

从输入中生成 ‘:’-连接的 AtomKey 字符串。

从 (2_A_C, 3_P_N, 3_P_CA) 生成 ‘2_A_C:3_P_N:3_P_CA’ :param list lst: AtomKey 对象列表

static gen_tuple(akstr: str) → tuple

为 ‘:’-连接的 AtomKey 字符串生成 AtomKey 元组。

从 ‘2_A_C:3_P_N:3_P_CA’ 生成 (2_A_C, 3_P_N, 3_P_CA) :param str akstr: 由 ‘:’-分隔的 AtomKey 字符串组成的字符串

__init__(*args: list[AtomKey] | tuple[AtomKey, AtomKey, AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey], **kwargs: str) → None

用 AtomKey 序列初始化 Edron。

可接受的输入

[ AtomKey, … ] : AtomKey 列表 AtomKey, … : AtomKey 作为参数的序列 {‘a1’: str, ‘a2’: str, … } : AtomKey 作为 ‘a1’, ‘a2’ … 的字典

__deepcopy__(memo): Edron 的深层复制实现。

__contains__(ak: AtomKey) → bool: 如果 atomkey 在此 edron 中，则返回 True。

is_backbone() → bool: 对于仅包含 N、C、CA、O、H 原子的 contains，报告 True。

__repr__() → str: AtomKey 的元组是默认的 repr 字符串。

__hash__() → int: 哈希值在初始化时从 atomkeys 元组计算得出。

__eq__(other: object) → bool: 测试相等性。

__ne__(other: object) → bool: 测试不相等性。

__gt__(other: object) → bool: 测试大于。

__ge__(other: object) → bool: 测试大于或等于。

__lt__(other: object) → bool: 测试小于。

__le__(other: object) → bool: 测试小于或等于。

class Bio.PDB.internal_coords.Hedron(*args: list[AtomKey] | tuple[AtomKey, AtomKey, AtomKey], **kwargs: str)

基类：Edron

表示三个连接原子形成平面的类。

包含局部坐标空间中的原子坐标：中心原子位于原点，一个末端原子位于 XZ 平面上，另一个位于 +Z 轴上。存储在两种方向上，第三个（向前）或第一个（反向）原子位于 +Z 轴上。有关向前和反向方向的使用，请参阅 Dihedron。

属性：

len12: float: 第一个和第二个原子之间的距离
len23: float: 第二个和第三个原子之间的距离
angle: float: hedron 中三个原子形成的角度（度数）
xrh_class: string: 仅适用于跨越 2 个残基的 hedron，将对仅贡献一个原子的残基使用“X”

方法

get_length()	获取指定原子对的键长
set_length()	设置指定原子对的键长
angle()，len12()，len23()	相关属性的 setter（角度以度为单位）

__init__(*args: list[AtomKey] | tuple[AtomKey, AtomKey, AtomKey], **kwargs: str) → None

使用 AtomKeys 序列和 kwargs 初始化 Hedron。

可接受的输入: 与 Edron 相同，加上可选的“len12”、“angle”、“len23”关键字值。

__repr__() → str: 打印 Hedron 对象的字符串。

property angle: float: 获取此 hedron 角度。

property len12: 获取 Hedron 的第一个长度。

property len23: float: 获取 Hedron 的第二个长度。

get_length(ak_tpl: tuple[AtomKey, AtomKey]) → float | None

获取指定原子对的键长。

参数:: ak_tpl (tuple) – AtomKeys 的元组。此 Hedron 中的原子对

set_length(ak_tpl: tuple[AtomKey, AtomKey], newLength: float)

设置指定原子对的键长；设置 needs_update。

参数:: .ak_tpl (tuple) – AtomKeys 的元组。此 Hedron 中的原子对

class Bio.PDB.internal_coords.Dihedron(*args: list[AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey], **kwargs: str)

基类：Edron

表示四个连接原子形成二面角的类。

属性：

angle: float: 以度为单位测量或指定二面角；最好使用 IC_Residue.bond_set() 设置
hedron1，hedron2：Hedron 对象引用: 形成二面角的两个 hedron
h1key，h2key：AtomKeys 的元组: hedron1 和 hedron2 的哈希键
id3，id32：AtomKeys 的元组: 组成 dihedron 的前 3 个和后 3 个原子；hxkey 顺序可能不同
ric：IC_Residue 对象引用: IC_Residue 包含此二面角的对象
reverse: bool: 指示二面角中原子的顺序是否与 hedron 中原子的顺序相反
primary: bool: 如果这是 psi、phi、omega 或侧链 chi 角，则为 True
pclass: string（主要角度类别）: 根据命名法（psi、omega、phi）使用 X 表示相邻残基的 re_class
cst，rcst：numpy [4][4] 数组: 从 (cst) 和到 (rcst) 二面角坐标空间的转换，定义为原子 2（Hedron 1 中心原子）位于原点。关于 IC_Chain.dCoordSpace 的视图。

方法

angle()	二面角（以度为单位）的 getter/setter；最好使用 `IC_Residue.bond_set()`
bits()	返回 `IC_Residue.pic_flags` 二面角 psi、omega 等的位掩码

__init__(*args: list[AtomKey] | tuple[AtomKey, AtomKey, AtomKey, AtomKey], **kwargs: str) → None

使用 AtomKeys 序列和可选的二面角初始化 Dihedron。

可接受的输入: 与 Edron 相同，加上可选的“dihedral”关键字角度值。

__repr__() → str: 打印二面角对象的字符串。

property angle: float: 获取二面角。

static angle_dif(a1: float | ndarray, a2: float | ndarray)

获取两个 +/- 180 角之间的角度差。

https://stackoverflow.com/a/36001014/2783487

static angle_avg(alst: list, in_rads: bool = False, out_rads: bool = False)

获取 +/-180 角列表的平均值。

参数:

alst (List) – 要平均的角度列表
in_rads (bool) – 输入值以弧度表示
out_rads (bool) – 以弧度表示结果

static angle_pop_sd(alst: list, avg: float)

获取 +/-180 角列表的总体标准差。

应该是样本标准差，但避免 len(alst)=1 -> 除以 0

difference(other: Dihedron) → float: 获取此角度与其他 +/- 180 角之间的角度差。

bits() → int: 获取 IC_Residue.pic_flags 用于自身是 psi、omg、phi、pomg、chiX 的位掩码。

class Bio.PDB.internal_coords.AtomKey(*args: IC_Residue | Atom | list | dict | str, **kwargs: str)

Bases: object

用于引用原子坐标的字典键类。

AtomKeys 将残基和无序信息一起捕获，并为 .pic 文件提供一个无空格字符串键。

支持丰富的比较和多种初始化方式。

AtomKeys 包含: 残基位置（respos）、插入代码（icode）、1 或 3 个字符残基名称（resname）、原子名称（atm）、altloc（altloc）和占位率（occ）

使用 AtomKey.fields 通过名称获取感兴趣组件的索引

使用 AtomKeys 从 IC_Chain atomArray 和 atomArrayIndex 获取 C-alpha 原子

atmNameNdx = internal_coords.AtomKey.fields.atm
CaSelection = [
    atomArrayIndex.get(k)
    for k in atomArrayIndex.keys()
    if k.akl[atmNameNdx] == "CA"
]
AtomArrayCa = atomArray[CaSelection]

获取链中的所有苯丙氨酸原子

resNameNdx = internal_coords.AtomKey.fields.resname
PheSelection = [
    atomArrayIndex.get(k)
    for k in atomArrayIndex.keys()
    if k.akl[resNameNdx] == "F"
]
AtomArrayPhe = atomArray[PheSelection]

如果为 20 个标准残基之一，则 “resname” 将是 1 个字母的大写氨基酸代码，否则为提供的 3 个字母代码。作为输入提供或从 IC_Residue 的 .rbase 属性读取。

属性：

akl: tuple: AtomKey 的所有六个字段
fieldNames: tuple (类属性): 键索引位置到名称的映射
fields: namedtuple (类属性): 字段名称到索引位置的映射。
id: str: “_” 连接的 AtomKey 字段，不包括 “None” 字段
atom_re: 编译后的正则表达式（类属性）: 匹配键的字符串形式的编译后的正则表达式
d2h: bool (类属性) 默认为 False: 如果为 True，则在输入时将 D 原子转换为 H；还必须修改 IC_Residue.accept_atoms
missing: bool 默认为 False: 从字符串初始化的 AtomKey 可能丢失，设置此标志以记录问题。由 IC_Residue.rak() 设置
ric: IC_Residue 默认为 None: 如果使用 IC_Residue 初始化，则它引用 IC_residue

方法

altloc_match(other)	如果此 AtomKey 匹配其他 AtomKey（不包括 altloc 和 occupancy 字段），则返回 True
is_backbone()	如果原子是 N、CA、C、O 或 H，则返回 True
atm()	返回原子名称，例如 N、CA、CB 等。
cr_class()	返回共价半径类，例如 Csb

atom_re = re.compile('^(?P<respos>-?\\d+)(?P<icode>[A-Za-z])?_(?P<resname>[a-zA-Z]+)_(?P<atm>[A-Za-z0-9]+)(?:_(?P<altloc>\\w))?(?:_(?P<occ>-?\\d\\.\\d+?))?$'): 预编译的正则表达式，用于匹配 AtomKey 字符串。

fieldNames = ('respos', 'icode', 'resname', 'atm', 'altloc', 'occ')

fields = (0, 1, 2, 3, 4, 5): 使用此命名元组访问 AtomKey 字段。参见 AtomKey

d2h = False: 设置为 True 以在输入时将 D 氘转换为 H 氢。

__init__(*args: IC_Residue | Atom | list | dict | str, **kwargs: str) → None

使用残基和原子数据初始化 AtomKey。

可接受输入的示例

(<IC_Residue>, 'CA', ...)    : IC_Residue with atom info
(<IC_Residue>, <Atom>)       : IC_Residue with Biopython Atom
([52, None, 'G', 'CA', ...])  : list of ordered data fields
(52, None, 'G', 'CA', ...)    : multiple ordered arguments
({respos: 52, icode: None, atm: 'CA', ...}) : dict with fieldNames
(respos: 52, icode: None, atm: 'CA', ...) : kwargs with fieldNames
52_G_CA, 52B_G_CA, 52_G_CA_0.33, 52_G_CA_B_0.33  : id strings

__deepcopy__(memo): AtomKey 的深层复制实现。

__repr__() → str: 来自 id 的 Repr 字符串。

__hash__() → int: 在初始化时从 akl 元组计算的哈希值。

altloc_match(other: AtomKey) → bool: 测试 AtomKey 是否匹配其他 AtomKey，忽略占位率和 altloc。

is_backbone() → bool: 如果为 N、C、CA、O 或 H，则返回 True。

atm() → str: 返回原子名称：N、CA、CB、O 等。

cr_class() → str | None: 返回原子的共价半径类别或 None。

__ne__(other: object) → bool: 测试不相等性。

__eq__(other: object) → bool: 测试相等性。

__gt__(other: object) → bool: 测试大于。

__ge__(other: object) → bool: 测试大于或等于。

__lt__(other: object) → bool: 测试小于。

__le__(other: object) → bool: 测试小于或等于。

Bio.PDB.internal_coords.set_accuracy_95(num: float) → float

将浮点数精度降低到 9.5 (xxxx.xxxxx)。

由 IC_Residue 类写入 PIC 和 SCAD 文件时使用。

参数:: num (float) – 输入数字
返回值:: 具有指定精度的浮点数

exception Bio.PDB.internal_coords.HedronMatchError

Bases: Exception

无法为给定键在残基中找到 hedron。

exception Bio.PDB.internal_coords.MissingAtomError

Bases: Exception

hedron 或 dihedron 缺少原子坐标。