def atoms_to_residues(atoms, atomsPerRes, seqid, resnames=None):
"""
Builds a list of residues from a list of atoms, where each residue
i the list has 'atomsPerRes' atoms per residue. All residues are
set to 'A', if no residue names are given.
"""
# Check the arguments
if (len(atoms) % atomsPerRes) != 0:
raise ValueError, "Mismatch between list length and atoms per residues."
if resnames==None:
resnames = [" A" for _ in xrange(len(atoms)/atomsPerRes)]
residues = []
res = None
for (i,atom) in enumerate(atoms):
# Residue number
resnumber = i // atomsPerRes
# Create a new residue
if (i % atomsPerRes) == 0:
if res!=None:
residues.append(res)
res = Residue((" ", resnumber, " "), resnames[resnumber], seqid)
res.add(atom)
# Add an atom
else:
res.add(atom)
if res!=None:
residues.append(res)
return residues
def init_residue(self, resname, field, resseq, icode):
"""Initiate a new Residue object.
Arguments:
o resname - string, e.g. "ASN"
o field - hetero flag, "W" for waters, "H" for
hetero residues, otherwise blanc.
o resseq - int, sequence identifier
o icode - string, insertion code
"""
if field != " ":
if field == "H":
# The hetero field consists of
# H_ + the residue name (e.g. H_FUC)
field = "H_" + resname
res_id = (field, resseq, icode)
if resseq > self.max_resseq:
self.max_resseq = resseq
if field == " ":
fudged_resseq = False
while (self.chain.has_id(res_id) or resseq == 0):
# There already is a residue with the id (field, resseq, icode)
# resseq == 0 catches already wrapped residue numbers which
# do not trigger the has_id() test.
#
# Be sloppy and just increment...
# (This code will not leave gaps in resids... I think)
#
# XXX: shouldn't we also do this for hetero atoms and water??
self.max_resseq += 1
resseq = self.max_resseq
res_id = (field, resseq, icode) # use max_resseq!
fudged_resseq = True
if fudged_resseq and self.verbose:
sys.stderr.write("Residues are wrapping (Residue " +
"('%s', %i, '%s') at line %i)." %
(field, resseq, icode, self.line_counter) +
".... assigning new resid %d.\n" %
self.max_resseq)
residue = Residue(res_id, resname, self.segid)
self.chain.add(residue)
self.residue = residue
def build_structure(self, sequence, start_index, moltype):
"""
builds new structure composed of atom_name atoms only
for nucleic acids these are C4', for proteins CA
"""
new_chain = list(self.fragment_lattice.get_chains())[0]
for resi in sequence:
#print "resi", resi, start_index
resi_id = (" ", start_index, " ")
#resi_name = resi
###############33
if moltype == "protein":
resi_name = AMINOACIDS[resi.upper()]
else:
resi_name = NUCLEOTIDES[resi.upper()]
###############33
new_resi = Residue(resi_id, resi_name, " ")
new_chain.add(new_resi)
start_index += 1
def _cmp_res(r0: Residue, r1: Residue, verbose: bool, cmpdict: Dict) -> None:
r0id, r0fid, r1fid = r0.id, r0.full_id, r1.full_id
chn = r0.parent.id
if chn not in cmpdict["chains"]:
cmpdict["chains"].append(chn)
cmpdict["rCount"] += 1
if r0fid == r1fid:
cmpdict["rMatchCount"] += 1
elif verbose:
print(r0fid, "!=", r1fid)
if " " == r0id[0] and not (" " == r0.resname[0] or 2 == len(r0.resname)):
# skip water, DNA (' ' == [0] for pdb, 2 == len() for mmcif)
cmpdict["residues"] += 1
longer = r0 if len(r0.child_dict) >= len(r1.child_dict) else r1
for ak in longer.child_dict:
a0 = r0.child_dict.get(ak, None)
if a0 is None:
aknd = re.sub("D", "H", ak, count=1)
a0 = r0.child_dict.get(aknd, None)
a1 = r1.child_dict.get(ak, None)
if a1 is None:
aknd = re.sub("D", "H", ak, count=1)
a1 = r1.child_dict.get(aknd, None)
if (a0 is None or a1 is None
or 0 == a0.is_disordered() == a1.is_disordered()):
_cmp_atm(r0, r1, a0, a1, verbose, cmpdict)
elif 2 == a0.is_disordered() == a1.is_disordered():
cmpdict["disAtmCount"] += 1
for da0k in a0.child_dict:
_cmp_atm(
r0,
r1,
a0.child_dict.get(da0k, None),
a1.child_dict.get(da0k, None),
verbose,
cmpdict,
)
else:
if verbose:
print("disorder disagreement:", r0.get_full_id(), ak)
cmpdict["aCount"] += 1
def get_CA_or(res: Residue) -> Atom:
"""Returns the alpha carbon for the resiude if there is one, else the first atom in the list"""
atoms: List[Atom] = list(res.get_atoms())
alphacarbons = list(
filter(lambda atom: True if atom.get_name() == 'CA' else False, atoms))
return atoms[0] if len(alphacarbons) == 0 else alphacarbons[0]
def makeResidueTuple(res:Residue)->Tuple[ str, int, NDArray[3] ]:
ac : Atom = get_alpha_carbon(res)
coords : NDArray[3] = ac.get_coord()
resi : int = res.get_id()
resn : str = res.get_resname()
return tuple(( resn, resi, coords ))
def build_martini_representation(self, old_struct, new_st):
"""
Reduces complexity of protein residue to the MARTINI coarse grained model:
CA, O, Bead(s) in specific atom location.
Reference:
Monticelli et al. The MARTINI coarse-grained force field: extension to proteins.
J. Chem. Theory Comput. (2008) vol. 4 (5) pp. 819-834
"""
conversion_table = {
"L": ["CG"],
"V": ["CB"],
"E": ["CB"],
"d": ["CG"],
"T": ["CB"],
"Q": ["CB"],
"S": ["CB"],
"A": [],
"G": [],
"K": ["CG", "CE"],
"I": ["CD1"],
"R": ["CG", "NE"],
"N": ["CG"],
"P": ["CG"],
"F": ["CG", "CE1", "CE2"],
"Y": ["CG", "CE1", "CE2"],
"H": ["CB", "ND1", "NE2"],
"M": ["CG"],
"W": ["CB", "CD1", "CD2", "CE2"],
"C": ["SG"],
"LEU": ["CG"],
"VAL": ["CB"],
"GLU": ["CB"],
"ASP": ["CG"],
"THR": ["CB"],
"GLN": ["CB"],
"SER": ["CB"],
"ALA": [],
"GLY": [],
"LYS": ["CG", "CE"],
"ILE": ["CD1"],
"ARG": ["CG", "NE"],
"ASN": ["CG"],
"PRO": ["CG"],
"PHE": ["CG", "CE1", "CE2"],
"TYR": ["CG", "CE1", "CE2"],
"HIS": ["CB", "ND1", "NE2"],
"MET": ["CG"],
"TRP": ["CB", "CD1", "CD2", "CE2"],
"CYS": ["SG"],
}
for resi in old_struct.struct.get_residues():
new_chain = list(new_st.get_chains())[0]
#print "@@@", resi.resname, resi.id
hetname = resi.id[0].split("_")
if hetname[0] == "H": continue
for atom in resi:
resname = resi.resname.strip()
if atom.name in conversion_table[resname] or atom.name == "CA":
resi = atom.get_parent()
if new_chain.has_id(resi.id): pass
else:
new_resi = Residue(resi.id, resi.resname, " ")
new_chain.add(new_resi)
new_resi.add(atom)
del self.fa_struct
class TestCsvParser(unittest.TestCase):
"""Test that we can parse CSV files correctly."""
CSV_STRING = textwrap.dedent("""\
NONSENSE_FIELD Phi Psi Chi0 Chi1 Chi2 Chi3 PDB_FILE CHAIN RES_INDEX AA ICODE
foo -20 30 10 0 0 0 a.pdb A 10 SER X
bar -15.0 0 180.0 0 0 0 b.pdb B 12 VAL
baz -180 50 300 -200 102 300 c.pdb A 33A ARG
""")
CORRECT_TORSION = [(-20, 30), (-15.0, 0), (-180, 50)]
CORRECT_CHI = [(10,), (180.0,), (300, -200, 102, 300)]
CORRECT_RESIDUES = [
Residue((' ', 10, 'X'), 'SER', 1),
Residue((' ', 12, ' '), 'VAL', 1),
Residue((' ', 33, 'A'), 'ARG', 1),
]
CORRECT_CHAINS = ['A', 'B', 'A']
CORRECT_SOURCES = ['a.pdb', 'b.pdb', 'c.pdb']
def assertTupleAlmostequal(self, a, b, places, msg):
for val1, val2 in zip(a, b):
self.assertAlmostEqual(val1, val2, places, msg)
def assertResiduesEqual(self, a, b, msg=""):
self.assertEqual(
a.get_full_id(),
b.get_full_id(),
"{}: Full ID".format(msg))
self.assertEqual(
a.get_resname(),
b.get_resname(),
"{} Residue name".format(msg))
def test_parser(self):
"""Parse a dummy CSV file."""
mapping = {
"phi": "Phi",
"psi": "Psi",
"chi": ("Chi0", "Chi1", "Chi2", "Chi3"),
"source": "PDB_FILE",
"chain": "CHAIN",
"residue": {"id": (None, "RES_INDEX", "ICODE"), "resname": "AA"}
}
parser = CsvParser(mapping, {}, delimiter=' ')
with tempfile.NamedTemporaryFile("w") as csv_file:
csv_file.write(self.CSV_STRING)
csv_file.flush()
results = parser.run({"residue_csv": csv_file.name})
for i, residue in enumerate(results["residues"]):
self.assertTupleAlmostequal(
residue["torsion"],
self.CORRECT_TORSION[i],
1,
"Residue {} torsion".format(i))
self.assertTupleAlmostequal(
residue["sidechain"].angles,
self.CORRECT_CHI[i],
1,
"Residue {} chi".format(i))
self.assertEqual(
residue["source"],
self.CORRECT_SOURCES[i],
"Residue {} source".format(i))
self.assertResiduesEqual(
residue["residue"],
self.CORRECT_RESIDUES[i],
"Residue {}".format(i))
self.assertEqual(
residue["chain"],
self.CORRECT_CHAINS[i],
"Residue {} chain".format(i))
def makeTyr(segID: int, N, CA, C, O, geo: TyrGeo) -> Residue:
"""Creates a Tyrosine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_CD1_length = geo.CG_CD1_length
CB_CG_CD1_angle = geo.CB_CG_CD1_angle
CA_CB_CG_CD1_diangle = geo.CA_CB_CG_CD1_diangle
CG_CD2_length = geo.CG_CD2_length
CB_CG_CD2_angle = geo.CB_CG_CD2_angle
CA_CB_CG_CD2_diangle = geo.CA_CB_CG_CD2_diangle
CD1_CE1_length = geo.CD1_CE1_length
CG_CD1_CE1_angle = geo.CG_CD1_CE1_angle
CB_CG_CD1_CE1_diangle = geo.CB_CG_CD1_CE1_diangle
CD2_CE2_length = geo.CD2_CE2_length
CG_CD2_CE2_angle = geo.CG_CD2_CE2_angle
CB_CG_CD2_CE2_diangle = geo.CB_CG_CD2_CE2_diangle
CE1_CZ_length = geo.CE1_CZ_length
CD1_CE1_CZ_angle = geo.CD1_CE1_CZ_angle
CG_CD1_CE1_CZ_diangle = geo.CG_CD1_CE1_CZ_diangle
CZ_OH_length = geo.CZ_OH_length
CE1_CZ_OH_angle = geo.CE1_CZ_OH_angle
CD1_CE1_CZ_OH_diangle = geo.CD1_CE1_CZ_OH_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
carbon_d1 = calculateCoordinates(CA, CB, CG, CG_CD1_length,
CB_CG_CD1_angle, CA_CB_CG_CD1_diangle)
CD1 = Atom("CD1", carbon_d1, 0.0, 1.0, " ", " CD1", 0, "C")
carbon_d2 = calculateCoordinates(CA, CB, CG, CG_CD2_length,
CB_CG_CD2_angle, CA_CB_CG_CD2_diangle)
CD2 = Atom("CD2", carbon_d2, 0.0, 1.0, " ", " CD2", 0, "C")
carbon_e1 = calculateCoordinates(CB, CG, CD1, CD1_CE1_length,
CG_CD1_CE1_angle, CB_CG_CD1_CE1_diangle)
CE1 = Atom("CE1", carbon_e1, 0.0, 1.0, " ", " CE1", 0, "C")
carbon_e2 = calculateCoordinates(CB, CG, CD2, CD2_CE2_length,
CG_CD2_CE2_angle, CB_CG_CD2_CE2_diangle)
CE2 = Atom("CE2", carbon_e2, 0.0, 1.0, " ", " CE2", 0, "C")
carbon_z = calculateCoordinates(CG, CD1, CE1, CE1_CZ_length,
CD1_CE1_CZ_angle, CG_CD1_CE1_CZ_diangle)
CZ = Atom("CZ", carbon_z, 0.0, 1.0, " ", " CZ", 0, "C")
oxygen_h = calculateCoordinates(CD1, CE1, CZ, CZ_OH_length,
CE1_CZ_OH_angle, CD1_CE1_CZ_OH_diangle)
OH = Atom("OH", oxygen_h, 0.0, 1.0, " ", " OH", 0, "O")
##Create Residue Data S
res = Residue((" ", segID, " "), "TYR", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(CD1)
res.add(CE1)
res.add(CD2)
res.add(CE2)
res.add(CZ)
res.add(OH)
return res
def makePro(segID: int, N, CA, C, O, geo: ProGeo) -> Residue:
"""Creates a Proline residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_CD_length = geo.CG_CD_length
CB_CG_CD_angle = geo.CB_CG_CD_angle
CA_CB_CG_CD_diangle = geo.CA_CB_CG_CD_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
carbon_d = calculateCoordinates(CA, CB, CG, CG_CD_length, CB_CG_CD_angle,
CA_CB_CG_CD_diangle)
CD = Atom("CD", carbon_d, 0.0, 1.0, " ", " CD", 0, "C")
res = Residue((" ", segID, " "), "PRO", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(CD)
return res
def makeIle(segID: int, N, CA, C, O, geo: IleGeo) -> Residue:
"""Creates an Isoleucine residue"""
##R-group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG1_length = geo.CB_CG1_length
CA_CB_CG1_angle = geo.CA_CB_CG1_angle
N_CA_CB_CG1_diangle = geo.N_CA_CB_CG1_diangle
CB_CG2_length = geo.CB_CG2_length
CA_CB_CG2_angle = geo.CA_CB_CG2_angle
N_CA_CB_CG2_diangle = geo.N_CA_CB_CG2_diangle
CG1_CD1_length = geo.CG1_CD1_length
CB_CG1_CD1_angle = geo.CB_CG1_CD1_angle
CA_CB_CG1_CD1_diangle = geo.CA_CB_CG1_CD1_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g1 = calculateCoordinates(N, CA, CB, CB_CG1_length, CA_CB_CG1_angle,
N_CA_CB_CG1_diangle)
CG1 = Atom("CG1", carbon_g1, 0.0, 1.0, " ", " CG1", 0, "C")
carbon_g2 = calculateCoordinates(N, CA, CB, CB_CG2_length, CA_CB_CG2_angle,
N_CA_CB_CG2_diangle)
CG2 = Atom("CG2", carbon_g2, 0.0, 1.0, " ", " CG2", 0, "C")
carbon_d1 = calculateCoordinates(CA, CB, CG1, CG1_CD1_length,
CB_CG1_CD1_angle, CA_CB_CG1_CD1_diangle)
CD1 = Atom("CD1", carbon_d1, 0.0, 1.0, " ", " CD1", 0, "C")
res = Residue((" ", segID, " "), "ILE", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG1)
res.add(CG2)
res.add(CD1)
return res
def add_ACE_cap_at_res(res, next_res=None):
if 'N' in res:
#ADD ACE residue
print(residue_id(res), "Adding extra ACE residue")
print(" Adding new atom C")
new_res = Residue((' ', res.id[1] - 1, ' '), 'ACE', 0)
add_new_atom_to_residue(
new_res, 'C',
build_coords_from_ats_internal(res['N'], res['CA'], res['C'],
[PEPDIS, SP2ANGLE, 180.]))
print(" Adding new atom CH3")
add_new_atom_to_residue(
new_res, 'CH3',
build_coords_trans_CA(new_res['C'], res['N'], res['CA']))
print(" Adding new atom O")
add_new_atom_to_residue(
new_res, 'O',
build_coords_SP2(OINTERNALS[0], new_res['C'], new_res['CH3'],
res['N']))
# Checking position to insert new res
pos = res.get_parent().get_list().index(res)
res.get_parent().insert(pos, new_res)
elif 'CA' in res:
#Modify residue to ACE
for atm in res.get_atoms():
print(residue_id(res), "Replacing by ACE residue")
if atm.id not in ('C', 'O', 'CA'):
print(residue_id(res))
remove_atom_from_res(res, atm.id)
print(" Removing atom {}".format(atm.id))
if atm.id == 'CA':
rename_atom(res, 'CA', 'CH3')
res.resname = 'ACE'
else:
# Mutate to ACE
print(residue_id(res), "No CA, Replacing by ACE residue")
#clean
if next_res is None:
print("Error")
return True
# Clean residue side chain
for atm in res.get_atoms():
if atm.id not in ('C', 'O', 'CA'):
remove_atom_from_res(res, atm.id)
print(" Removing unexpected atom {}".format(atm.id))
print(" Adding new atom CA")
add_new_atom_to_residue(
res, 'CH3',
build_coords_trans_CA(res['C'], next_res['N'], next_res['CA']))
if 'O' not in res:
print(" Adding new atom O")
add_new_atom_to_residue(
res, 'O',
build_coords_SP2(OINTERNALS[0], res['C'], res['CH3'],
next_res['N']))
res.resname = 'ACE'
return False
# nie jestem pewien dlaczego to nie działa. Pojawia się błąd:
# AttributeError: 'module' object has no attribute 'array'
from Bio import PDB
from Bio.PDB import PDBParser, NeighborSearch, Superimposer, PDBIO
from Bio.PDB.Atom import Atom
from Bio.PDB.Residue import Residue
from Bio.PDB.Chain import Chain
from Bio.PDB.Model import Model
from Bio.PDB.Structure import Structure
my_structure = Structure('Cytosine')
my_model = Model(0)
my_chain = Chain('A')
my_residue = Residue((' ', 1, ' '), 'C', ' ')
atoms = [{
'name': 'N1',
'coord': PDB.Atom.array([64.612, 45.818, 10.877], 'f'),
'bfactor': 42.59,
'occupancy': 1.0,
'altloc': ' ',
'fullname': 'N1',
'serial_number': 1
}, {
'name': 'C2',
'coord': PDB.Atom.array([65.472, 46.868, 10.634], 'f'),
'bfactor': 44.48,
'occupancy': 1.0,
'altloc': ' ',
'fullname': 'C2',
'serial_number': 2
def res_full_id(res: Residue):
"""Return full residue identifier for thoroughly comparing residues."""
return (res.get_resname(), *res.get_id())
nargs='+',
help=('One or more atoms or residues in the format of '
'{model}/{chain}/{resnum}/{inscode}/[{atomname}]'))
args = parser.parse_args()
# MODIFIED PDB WITH FAKE "LIGAND" RESIDUE TO DEFINE POCKET
mod_pdb = args.pdb + '_mod'
# PREFIX FOR DPOCKET OUTPUT
dpocket_prefix = os.path.split(args.pdb)[-1].replace('.', '_')
structure = PDBParser().get_structure('_', args.pdb)
# FAKE RESIDUE FOR DPOCKET POCKET DEFINITION
fake = Residue(('H_STP', 9999, ' '), 'STP', 1)
atom_counter = 0
for entity in args.entities:
entity = entity.strip('/').split('/')
atoms = []
# RESIDUE
if len(entity) == 4:
model, chain, resnum, inscode = entity
residue = structure[int(model)][chain][(' ', int(resnum),
inscode if inscode else ' ')]
atoms = list(residue.get_list())
def run(self, data, config=None, pipeline=None):
"""
Parse a CSV file and add the ``residues`` key to `data`.
See :py:func:`phyre_engine.component.rotamer.extract.AngleExtractor.run`
for the format of the ``residues`` list that will be added by this
method.
"""
residue_csv = self.get_vals(data)
residues = []
with open(residue_csv, "r", newline="") as csv_fh:
reader = csv.DictReader(csv_fh, **self.csv_params)
for values in reader:
# Parse out residue ID
res_id = [' ', None, ' ']
for i, id_elem in enumerate(self.mapping["residue"]["id"]):
if id_elem is not None and values[id_elem] is not None:
res_id[i] = values[id_elem]
try:
res_id[1] = int(res_id[1])
except ValueError as err:
# Try and split numeric and non-numeric parts of the ID into
# residue number and insertion code.
numeric_match = re.search(r"(\d+)", res_id[1])
non_numeric_match = re.search(r"(\D+)", res_id[1])
# Bail if the matches fail (i.e. there are junk characters)
if numeric_match is None or non_numeric_match is None:
raise err
res_id[1] = int(numeric_match.group(0))
res_id[2] = non_numeric_match.group(0)
res_id = tuple(res_id)
# Get residue name
res_name = values[self.mapping["residue"]["resname"]]
# Build Bio.PDB.Residue object
residue = Residue(res_id, res_name, 1)
# Get phi, psi, chi angles
num_chi = NUM_CHI_ANGLES[res_name]
phi = float(values[self.mapping["phi"]])
psi = float(values[self.mapping["psi"]])
chi = [
float(values[name])
for name in self.mapping["chi"][0:num_chi]
]
# Force final chi angle into correct range
if (res_name in self.final_chi_range
and chi[-1] not in self.final_chi_range[res_name]):
chi[-1] = (chi[-1] + 180) % 360
residue = {
"torsion": (phi, psi),
"sidechain": Sidechain(res_name, tuple(chi)),
"residue": residue
}
# Parse remaining mapped columns
already_parsed = ("phi", "psi", "chi", "residue")
for to_key, from_key in self.mapping.items():
if to_key not in already_parsed:
residue[to_key] = values[from_key]
residues.append(residue)
data["residues"] = residues
return data
def makeHis(segID: int, N, CA, C, O, geo: HisGeo) -> Residue:
"""Creates a Histidine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_ND1_length = geo.CG_ND1_length
CB_CG_ND1_angle = geo.CB_CG_ND1_angle
CA_CB_CG_ND1_diangle = geo.CA_CB_CG_ND1_diangle
CG_CD2_length = geo.CG_CD2_length
CB_CG_CD2_angle = geo.CB_CG_CD2_angle
CA_CB_CG_CD2_diangle = geo.CA_CB_CG_CD2_diangle
ND1_CE1_length = geo.ND1_CE1_length
CG_ND1_CE1_angle = geo.CG_ND1_CE1_angle
CB_CG_ND1_CE1_diangle = geo.CB_CG_ND1_CE1_diangle
CD2_NE2_length = geo.CD2_NE2_length
CG_CD2_NE2_angle = geo.CG_CD2_NE2_angle
CB_CG_CD2_NE2_diangle = geo.CB_CG_CD2_NE2_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
nitrogen_d1 = calculateCoordinates(CA, CB, CG, CG_ND1_length,
CB_CG_ND1_angle, CA_CB_CG_ND1_diangle)
ND1 = Atom("ND1", nitrogen_d1, 0.0, 1.0, " ", " ND1", 0, "N")
carbon_d2 = calculateCoordinates(CA, CB, CG, CG_CD2_length,
CB_CG_CD2_angle, CA_CB_CG_CD2_diangle)
CD2 = Atom("CD2", carbon_d2, 0.0, 1.0, " ", " CD2", 0, "C")
carbon_e1 = calculateCoordinates(CB, CG, ND1, ND1_CE1_length,
CG_ND1_CE1_angle, CB_CG_ND1_CE1_diangle)
CE1 = Atom("CE1", carbon_e1, 0.0, 1.0, " ", " CE1", 0, "C")
nitrogen_e2 = calculateCoordinates(CB, CG, CD2, CD2_NE2_length,
CG_CD2_NE2_angle, CB_CG_CD2_NE2_diangle)
NE2 = Atom("NE2", nitrogen_e2, 0.0, 1.0, " ", " NE2", 0, "N")
res = Residue((" ", segID, " "), "HIS", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(ND1)
res.add(CD2)
res.add(CE1)
res.add(NE2)
return res
def makeLeu(segID: int, N, CA, C, O, geo: LeuGeo) -> Residue:
"""Creates a Leucine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_CD1_length = geo.CG_CD1_length
CB_CG_CD1_angle = geo.CB_CG_CD1_angle
CA_CB_CG_CD1_diangle = geo.CA_CB_CG_CD1_diangle
CG_CD2_length = geo.CG_CD2_length
CB_CG_CD2_angle = geo.CB_CG_CD2_angle
CA_CB_CG_CD2_diangle = geo.CA_CB_CG_CD2_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g1 = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g1, 0.0, 1.0, " ", " CG", 0, "C")
carbon_d1 = calculateCoordinates(CA, CB, CG, CG_CD1_length,
CB_CG_CD1_angle, CA_CB_CG_CD1_diangle)
CD1 = Atom("CD1", carbon_d1, 0.0, 1.0, " ", " CD1", 0, "C")
carbon_d2 = calculateCoordinates(CA, CB, CG, CG_CD2_length,
CB_CG_CD2_angle, CA_CB_CG_CD2_diangle)
CD2 = Atom("CD2", carbon_d2, 0.0, 1.0, " ", " CD2", 0, "C")
res = Residue((" ", segID, " "), "LEU", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(CD1)
res.add(CD2)
return res
def makePhe(segID: int, N, CA, C, O, geo: PheGeo) -> Residue:
"""Creates a Phenylalanine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_CD1_length = geo.CG_CD1_length
CB_CG_CD1_angle = geo.CB_CG_CD1_angle
CA_CB_CG_CD1_diangle = geo.CA_CB_CG_CD1_diangle
CG_CD2_length = geo.CG_CD2_length
CB_CG_CD2_angle = geo.CB_CG_CD2_angle
CA_CB_CG_CD2_diangle = geo.CA_CB_CG_CD2_diangle
CD1_CE1_length = geo.CD1_CE1_length
CG_CD1_CE1_angle = geo.CG_CD1_CE1_angle
CB_CG_CD1_CE1_diangle = geo.CB_CG_CD1_CE1_diangle
CD2_CE2_length = geo.CD2_CE2_length
CG_CD2_CE2_angle = geo.CG_CD2_CE2_angle
CB_CG_CD2_CE2_diangle = geo.CB_CG_CD2_CE2_diangle
CE1_CZ_length = geo.CE1_CZ_length
CD1_CE1_CZ_angle = geo.CD1_CE1_CZ_angle
CG_CD1_CE1_CZ_diangle = geo.CG_CD1_CE1_CZ_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
carbon_d1 = calculateCoordinates(CA, CB, CG, CG_CD1_length,
CB_CG_CD1_angle, CA_CB_CG_CD1_diangle)
CD1 = Atom("CD1", carbon_d1, 0.0, 1.0, " ", " CD1", 0, "C")
carbon_d2 = calculateCoordinates(CA, CB, CG, CG_CD2_length,
CB_CG_CD2_angle, CA_CB_CG_CD2_diangle)
CD2 = Atom("CD2", carbon_d2, 0.0, 1.0, " ", " CD2", 0, "C")
carbon_e1 = calculateCoordinates(CB, CG, CD1, CD1_CE1_length,
CG_CD1_CE1_angle, CB_CG_CD1_CE1_diangle)
CE1 = Atom("CE1", carbon_e1, 0.0, 1.0, " ", " CE1", 0, "C")
carbon_e2 = calculateCoordinates(CB, CG, CD2, CD2_CE2_length,
CG_CD2_CE2_angle, CB_CG_CD2_CE2_diangle)
CE2 = Atom("CE2", carbon_e2, 0.0, 1.0, " ", " CE2", 0, "C")
carbon_z = calculateCoordinates(CG, CD1, CE1, CE1_CZ_length,
CD1_CE1_CZ_angle, CG_CD1_CE1_CZ_diangle)
CZ = Atom("CZ", carbon_z, 0.0, 1.0, " ", " CZ", 0, "C")
res = Residue((" ", segID, " "), "PHE", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(CD1)
res.add(CE1)
res.add(CD2)
res.add(CE2)
res.add(CZ)
return res
def makeThr(segID: int, N, CA, C, O, geo: ThrGeo) -> Residue:
"""Creates a Threonine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_OG1_length = geo.CB_OG1_length
CA_CB_OG1_angle = geo.CA_CB_OG1_angle
N_CA_CB_OG1_diangle = geo.N_CA_CB_OG1_diangle
CB_CG2_length = geo.CB_CG2_length
CA_CB_CG2_angle = geo.CA_CB_CG2_angle
N_CA_CB_CG2_diangle = geo.N_CA_CB_CG2_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
oxygen_g1 = calculateCoordinates(N, CA, CB, CB_OG1_length, CA_CB_OG1_angle,
N_CA_CB_OG1_diangle)
OG1 = Atom("OG1", oxygen_g1, 0.0, 1.0, " ", " OG1", 0, "O")
carbon_g2 = calculateCoordinates(N, CA, CB, CB_CG2_length, CA_CB_CG2_angle,
N_CA_CB_CG2_diangle)
CG2 = Atom("CG2", carbon_g2, 0.0, 1.0, " ", " CG2", 0, "C")
res = Residue((" ", segID, " "), "THR", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(OG1)
res.add(CG2)
return res
def makeTrp(segID: int, N, CA, C, O, geo: TrpGeo) -> Residue:
"""Creates a Tryptophan residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_CD1_length = geo.CG_CD1_length
CB_CG_CD1_angle = geo.CB_CG_CD1_angle
CA_CB_CG_CD1_diangle = geo.CA_CB_CG_CD1_diangle
CG_CD2_length = geo.CG_CD2_length
CB_CG_CD2_angle = geo.CB_CG_CD2_angle
CA_CB_CG_CD2_diangle = geo.CA_CB_CG_CD2_diangle
CD1_NE1_length = geo.CD1_NE1_length
CG_CD1_NE1_angle = geo.CG_CD1_NE1_angle
CB_CG_CD1_NE1_diangle = geo.CB_CG_CD1_NE1_diangle
CD2_CE2_length = geo.CD2_CE2_length
CG_CD2_CE2_angle = geo.CG_CD2_CE2_angle
CB_CG_CD2_CE2_diangle = geo.CB_CG_CD2_CE2_diangle
CD2_CE3_length = geo.CD2_CE3_length
CG_CD2_CE3_angle = geo.CG_CD2_CE3_angle
CB_CG_CD2_CE3_diangle = geo.CB_CG_CD2_CE3_diangle
CE2_CZ2_length = geo.CE2_CZ2_length
CD2_CE2_CZ2_angle = geo.CD2_CE2_CZ2_angle
CG_CD2_CE2_CZ2_diangle = geo.CG_CD2_CE2_CZ2_diangle
CE3_CZ3_length = geo.CE3_CZ3_length
CD2_CE3_CZ3_angle = geo.CD2_CE3_CZ3_angle
CG_CD2_CE3_CZ3_diangle = geo.CG_CD2_CE3_CZ3_diangle
CZ2_CH2_length = geo.CZ2_CH2_length
CE2_CZ2_CH2_angle = geo.CE2_CZ2_CH2_angle
CD2_CE2_CZ2_CH2_diangle = geo.CD2_CE2_CZ2_CH2_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
carbon_d1 = calculateCoordinates(CA, CB, CG, CG_CD1_length,
CB_CG_CD1_angle, CA_CB_CG_CD1_diangle)
CD1 = Atom("CD1", carbon_d1, 0.0, 1.0, " ", " CD1", 0, "C")
carbon_d2 = calculateCoordinates(CA, CB, CG, CG_CD2_length,
CB_CG_CD2_angle, CA_CB_CG_CD2_diangle)
CD2 = Atom("CD2", carbon_d2, 0.0, 1.0, " ", " CD2", 0, "C")
nitrogen_e1 = calculateCoordinates(CB, CG, CD1, CD1_NE1_length,
CG_CD1_NE1_angle, CB_CG_CD1_NE1_diangle)
NE1 = Atom("NE1", nitrogen_e1, 0.0, 1.0, " ", " NE1", 0, "N")
carbon_e2 = calculateCoordinates(CB, CG, CD2, CD2_CE2_length,
CG_CD2_CE2_angle, CB_CG_CD2_CE2_diangle)
CE2 = Atom("CE2", carbon_e2, 0.0, 1.0, " ", " CE2", 0, "C")
carbon_e3 = calculateCoordinates(CB, CG, CD2, CD2_CE3_length,
CG_CD2_CE3_angle, CB_CG_CD2_CE3_diangle)
CE3 = Atom("CE3", carbon_e3, 0.0, 1.0, " ", " CE3", 0, "C")
carbon_z2 = calculateCoordinates(CG, CD2, CE2, CE2_CZ2_length,
CD2_CE2_CZ2_angle, CG_CD2_CE2_CZ2_diangle)
CZ2 = Atom("CZ2", carbon_z2, 0.0, 1.0, " ", " CZ2", 0, "C")
carbon_z3 = calculateCoordinates(CG, CD2, CE3, CE3_CZ3_length,
CD2_CE3_CZ3_angle, CG_CD2_CE3_CZ3_diangle)
CZ3 = Atom("CZ3", carbon_z3, 0.0, 1.0, " ", " CZ3", 0, "C")
carbon_h2 = calculateCoordinates(CD2, CE2, CZ2, CZ2_CH2_length,
CE2_CZ2_CH2_angle,
CD2_CE2_CZ2_CH2_diangle)
CH2 = Atom("CH2", carbon_h2, 0.0, 1.0, " ", " CH2", 0, "C")
##Create Residue DS
res = Residue((" ", segID, " "), "TRP", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(CD1)
res.add(CD2)
res.add(NE1)
res.add(CE2)
res.add(CE3)
res.add(CZ2)
res.add(CZ3)
res.add(CH2)
return res
def makeArg(segID: int, N, CA, C, O, geo: ArgGeo) -> Residue:
"""Creates an Arginie residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_CD_length = geo.CG_CD_length
CB_CG_CD_angle = geo.CB_CG_CD_angle
CA_CB_CG_CD_diangle = geo.CA_CB_CG_CD_diangle
CD_NE_length = geo.CD_NE_length
CG_CD_NE_angle = geo.CG_CD_NE_angle
CB_CG_CD_NE_diangle = geo.CB_CG_CD_NE_diangle
NE_CZ_length = geo.NE_CZ_length
CD_NE_CZ_angle = geo.CD_NE_CZ_angle
CG_CD_NE_CZ_diangle = geo.CG_CD_NE_CZ_diangle
CZ_NH1_length = geo.CZ_NH1_length
NE_CZ_NH1_angle = geo.NE_CZ_NH1_angle
CD_NE_CZ_NH1_diangle = geo.CD_NE_CZ_NH1_diangle
CZ_NH2_length = geo.CZ_NH2_length
NE_CZ_NH2_angle = geo.NE_CZ_NH2_angle
CD_NE_CZ_NH2_diangle = geo.CD_NE_CZ_NH2_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
carbon_d = calculateCoordinates(CA, CB, CG, CG_CD_length, CB_CG_CD_angle,
CA_CB_CG_CD_diangle)
CD = Atom("CD", carbon_d, 0.0, 1.0, " ", " CD", 0, "C")
nitrogen_e = calculateCoordinates(CB, CG, CD, CD_NE_length, CG_CD_NE_angle,
CB_CG_CD_NE_diangle)
NE = Atom("NE", nitrogen_e, 0.0, 1.0, " ", " NE", 0, "N")
carbon_z = calculateCoordinates(CG, CD, NE, NE_CZ_length, CD_NE_CZ_angle,
CG_CD_NE_CZ_diangle)
CZ = Atom("CZ", carbon_z, 0.0, 1.0, " ", " CZ", 0, "C")
nitrogen_h1 = calculateCoordinates(CD, NE, CZ, CZ_NH1_length,
NE_CZ_NH1_angle, CD_NE_CZ_NH1_diangle)
NH1 = Atom("NH1", nitrogen_h1, 0.0, 1.0, " ", " NH1", 0, "N")
nitrogen_h2 = calculateCoordinates(CD, NE, CZ, CZ_NH2_length,
NE_CZ_NH2_angle, CD_NE_CZ_NH2_diangle)
NH2 = Atom("NH2", nitrogen_h2, 0.0, 1.0, " ", " NH2", 0, "N")
res = Residue((" ", segID, " "), "ARG", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(CD)
res.add(NE)
res.add(CZ)
res.add(NH1)
res.add(NH2)
return res
def from_bio_residue(
cls, residue: Residue,
residue_id_mapping: 'BiopythonToMmcifResidueIds.Mapping'):
return ResidueId(
residue_id_mapping.to_label_seq_id(BioResidueId(*residue.id)),
residue.get_parent().id)
def makeLys(segID: int, N, CA, C, O, geo: LysGeo) -> Residue:
"""Creates a Lysine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_CD_length = geo.CG_CD_length
CB_CG_CD_angle = geo.CB_CG_CD_angle
CA_CB_CG_CD_diangle = geo.CA_CB_CG_CD_diangle
CD_CE_length = geo.CD_CE_length
CG_CD_CE_angle = geo.CG_CD_CE_angle
CB_CG_CD_CE_diangle = geo.CB_CG_CD_CE_diangle
CE_NZ_length = geo.CE_NZ_length
CD_CE_NZ_angle = geo.CD_CE_NZ_angle
CG_CD_CE_NZ_diangle = geo.CG_CD_CE_NZ_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
carbon_d = calculateCoordinates(CA, CB, CG, CG_CD_length, CB_CG_CD_angle,
CA_CB_CG_CD_diangle)
CD = Atom("CD", carbon_d, 0.0, 1.0, " ", " CD", 0, "C")
carbon_e = calculateCoordinates(CB, CG, CD, CD_CE_length, CG_CD_CE_angle,
CB_CG_CD_CE_diangle)
CE = Atom("CE", carbon_e, 0.0, 1.0, " ", " CE", 0, "C")
nitrogen_z = calculateCoordinates(CG, CD, CE, CE_NZ_length, CD_CE_NZ_angle,
CG_CD_CE_NZ_diangle)
NZ = Atom("NZ", nitrogen_z, 0.0, 1.0, " ", " NZ", 0, "N")
res = Residue((" ", segID, " "), "LYS", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(CD)
res.add(CE)
res.add(NZ)
return res
def get_alpha_carbon(res:Residue)->Atom:
"""Get the first(only) alpha carbon in the residue or an exception"""
alpha_carbons: List[Atom] = list( filter(lambda internal_atom: internal_atom.get_id() =='CA', res.get_atoms()) )
if len(alpha_carbons) != 1:
raise Exception(f"Alpha carbon not found or duplicated in residue {res.get_full_id()}")
return alpha_carbons[0]
def calculateCoordinates(refA: Residue, refB: Residue, refC: Residue, L: float,
ang: float, di: float) -> np.ndarray:
AV = refA.get_vector()
BV = refB.get_vector()
CV = refC.get_vector()
CA = AV - CV
CB = BV - CV
##CA vector
AX = CA[0]
AY = CA[1]
AZ = CA[2]
##CB vector
BX = CB[0]
BY = CB[1]
BZ = CB[2]
##Plane Parameters
A = (AY * BZ) - (AZ * BY)
B = (AZ * BX) - (AX * BZ)
G = (AX * BY) - (AY * BX)
##Dot Product Constant
F = math.sqrt(BX * BX + BY * BY + BZ * BZ) * L * math.cos(
ang * (math.pi / 180.0))
##Constants
const = math.sqrt(
math.pow((B * BZ - BY * G), 2) *
(-(F * F) * (A * A + B * B + G * G) +
(B * B * (BX * BX + BZ * BZ) + A * A * (BY * BY + BZ * BZ) -
(2 * A * BX * BZ * G) + (BX * BX + BY * BY) * G * G - (2 * B * BY) *
(A * BX + BZ * G)) * L * L))
denom = ((B * B) * (BX * BX + BZ * BZ) + (A * A) * (BY * BY + BZ * BZ) -
(2 * A * BX * BZ * G) + (BX * BX + BY * BY) * (G * G) -
(2 * B * BY) * (A * BX + BZ * G))
X = ((B * B * BX * F) - (A * B * BY * F) + (F * G) *
(-A * BZ + BX * G) + const) / denom
if (B == 0 or BZ == 0) and (BY == 0 or G == 0):
const1 = math.sqrt(G * G * (-A * A * X * X + (B * B + G * G) *
(L - X) * (L + X)))
Y = ((-A * B * X) + const1) / (B * B + G * G)
Z = -(A * G * G * X + B * const1) / (G * (B * B + G * G))
else:
Y = ((A * A * BY * F) * (B * BZ - BY * G) + G *
(-F * math.pow(B * BZ - BY * G, 2) + BX * const) - A *
(B * B * BX * BZ * F - B * BX * BY * F * G + BZ * const)) / (
(B * BZ - BY * G) * denom)
Z = ((A * A * BZ * F) * (B * BZ - BY * G) +
(B * F) * math.pow(B * BZ - BY * G, 2) + (A * BX * F * G) *
(-B * BZ + BY * G) - B * BX * const + A * BY * const) / (
(B * BZ - BY * G) * denom)
# Get the new Vector from the origin
D = Vector(X, Y, Z) + CV
with warnings.catch_warnings():
# ignore inconsequential warning
warnings.simplefilter("ignore")
temp = calc_dihedral(AV, BV, CV, D) * (180.0 / math.pi)
di = di - temp
rot = rotaxis(math.pi * (di / 180.0), CV - BV)
D = (D - BV).left_multiply(rot) + BV
return D.get_array()
points = ReadXYZ ( args['src'], args['scale'])
if ( args['bfactor'] is not None):
print "read bfactor file column %d" % args['column']
bfactors = ReadBfactor(args['bfactor'],args['column'])
else:
bfactors = zeros(len(points))
model = Model(1)
chain = Chain("A")
structure = Structure("ref")
num_count = 0
for i in range(0,shape(points)[0]):
num_count = num_count +1
res_id = (' ',num_count,' ')
residue = Residue(res_id,'ALA',' ')
cur_coord = tuple(points[i])
bfactor = bfactors[i]
atom = Atom('CA',cur_coord,bfactor,0,' ','CA',num_count,'C')
residue.add(atom)
chain.add(residue)
model.add(chain)
structure.add(model)
# --------------------------------------------------------------------
io=PDBIO()
io.set_structure(structure)
if ( args['dst'] is None):
fn = sys.stdout
io.save(fn)
if ( args['link'] ):
def makeAsn(segID, N, CA, C, O, geo):
"""Creates an Asparagine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_OD1_length = geo.CG_OD1_length
CB_CG_OD1_angle = geo.CB_CG_OD1_angle
CA_CB_CG_OD1_diangle = geo.CA_CB_CG_OD1_diangle
CG_ND2_length = geo.CG_ND2_length
CB_CG_ND2_angle = geo.CB_CG_ND2_angle
CA_CB_CG_ND2_diangle = geo.CA_CB_CG_ND2_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
oxygen_d1 = calculateCoordinates(CA, CB, CG, CG_OD1_length,
CB_CG_OD1_angle, CA_CB_CG_OD1_diangle)
OD1 = Atom("OD1", oxygen_d1, 0.0, 1.0, " ", " OD1", 0, "O")
nitrogen_d2 = calculateCoordinates(CA, CB, CG, CG_ND2_length,
CB_CG_ND2_angle, CA_CB_CG_ND2_diangle)
ND2 = Atom("ND2", nitrogen_d2, 0.0, 1.0, " ", " ND2", 0, "N")
res = Residue((" ", segID, " "), "ASN", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(OD1)
res.add(ND2)
return res
def belongs_to_ptc(x: Residue):
return int(x.get_id()[1]) in ptc_reslist
def makeGln(segID: int, N, CA, C, O, geo: GlnGeo) -> Residue:
"""Creates a Glutamine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_CD_length = geo.CG_CD_length
CB_CG_CD_angle = geo.CB_CG_CD_angle
CA_CB_CG_CD_diangle = geo.CA_CB_CG_CD_diangle
CD_OE1_length = geo.CD_OE1_length
CG_CD_OE1_angle = geo.CG_CD_OE1_angle
CB_CG_CD_OE1_diangle = geo.CB_CG_CD_OE1_diangle
CD_NE2_length = geo.CD_NE2_length
CG_CD_NE2_angle = geo.CG_CD_NE2_angle
CB_CG_CD_NE2_diangle = geo.CB_CG_CD_NE2_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
carbon_d = calculateCoordinates(CA, CB, CG, CG_CD_length, CB_CG_CD_angle,
CA_CB_CG_CD_diangle)
CD = Atom("CD", carbon_d, 0.0, 1.0, " ", " CD", 0, "C")
oxygen_e1 = calculateCoordinates(CB, CG, CD, CD_OE1_length,
CG_CD_OE1_angle, CB_CG_CD_OE1_diangle)
OE1 = Atom("OE1", oxygen_e1, 0.0, 1.0, " ", " OE1", 0, "O")
nitrogen_e2 = calculateCoordinates(CB, CG, CD, CD_NE2_length,
CG_CD_NE2_angle, CB_CG_CD_NE2_diangle)
NE2 = Atom("NE2", nitrogen_e2, 0.0, 1.0, " ", " NE2", 0, "N")
##Create Residue DS
res = Residue((" ", segID, " "), "GLN", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(CD)
res.add(OE1)
res.add(NE2)
return res
def init_residue(self, resname, field, resseq, icode):
"""Create a new Residue object.
Arguments:
- resname - string, e.g. "ASN"
- field - hetero flag, "W" for waters, "H" for
hetero residues, otherwise blank.
- resseq - int, sequence identifier
- icode - string, insertion code
"""
if field != " ":
if field == "H":
# The hetero field consists of H_ + the residue name (e.g. H_FUC)
field = "H_" + resname
res_id = (field, resseq, icode)
if field == " ":
if self.chain.has_id(res_id):
# There already is a residue with the id (field, resseq, icode).
# This only makes sense in the case of a point mutation.
warnings.warn(
"WARNING: Residue ('%s', %i, '%s') redefined at line %i."
% (field, resseq, icode, self.line_counter),
PDBConstructionWarning,
)
duplicate_residue = self.chain[res_id]
if duplicate_residue.is_disordered() == 2:
# The residue in the chain is a DisorderedResidue object.
# So just add the last Residue object.
if duplicate_residue.disordered_has_id(resname):
# The residue was already made
self.residue = duplicate_residue
duplicate_residue.disordered_select(resname)
else:
# Make a new residue and add it to the already
# present DisorderedResidue
new_residue = Residue(res_id, resname, self.segid)
duplicate_residue.disordered_add(new_residue)
self.residue = duplicate_residue
return
else:
if resname == duplicate_residue.resname:
warnings.warn(
"WARNING: Residue ('%s', %i, '%s','%s') already defined "
"with the same name at line %i."
% (field, resseq, icode, resname, self.line_counter),
PDBConstructionWarning,
)
self.residue = duplicate_residue
return
# Make a new DisorderedResidue object and put all
# the Residue objects with the id (field, resseq, icode) in it.
# These residues each should have non-blank altlocs for all their atoms.
# If not, the PDB file probably contains an error.
if not self._is_completely_disordered(duplicate_residue):
# if this exception is ignored, a residue will be missing
self.residue = None
raise PDBConstructionException(
"Blank altlocs in duplicate residue %s ('%s', %i, '%s')"
% (resname, field, resseq, icode)
)
self.chain.detach_child(res_id)
new_residue = Residue(res_id, resname, self.segid)
disordered_residue = DisorderedResidue(res_id)
self.chain.add(disordered_residue)
disordered_residue.disordered_add(duplicate_residue)
disordered_residue.disordered_add(new_residue)
self.residue = disordered_residue
return
self.residue = Residue(res_id, resname, self.segid)
self.chain.add(self.residue)
def makeMet(segID: int, N, CA, C, O, geo: MetGeo) -> Residue:
"""Creates a Methionine residue"""
##R-Group
CA_CB_length = geo.CA_CB_length
C_CA_CB_angle = geo.C_CA_CB_angle
N_C_CA_CB_diangle = geo.N_C_CA_CB_diangle
CB_CG_length = geo.CB_CG_length
CA_CB_CG_angle = geo.CA_CB_CG_angle
N_CA_CB_CG_diangle = geo.N_CA_CB_CG_diangle
CG_SD_length = geo.CG_SD_length
CB_CG_SD_angle = geo.CB_CG_SD_angle
CA_CB_CG_SD_diangle = geo.CA_CB_CG_SD_diangle
SD_CE_length = geo.SD_CE_length
CG_SD_CE_angle = geo.CG_SD_CE_angle
CB_CG_SD_CE_diangle = geo.CB_CG_SD_CE_diangle
carbon_b = calculateCoordinates(N, C, CA, CA_CB_length, C_CA_CB_angle,
N_C_CA_CB_diangle)
CB = Atom("CB", carbon_b, 0.0, 1.0, " ", " CB", 0, "C")
carbon_g = calculateCoordinates(N, CA, CB, CB_CG_length, CA_CB_CG_angle,
N_CA_CB_CG_diangle)
CG = Atom("CG", carbon_g, 0.0, 1.0, " ", " CG", 0, "C")
sulfur_d = calculateCoordinates(CA, CB, CG, CG_SD_length, CB_CG_SD_angle,
CA_CB_CG_SD_diangle)
SD = Atom("SD", sulfur_d, 0.0, 1.0, " ", " SD", 0, "S")
carbon_e = calculateCoordinates(CB, CG, SD, SD_CE_length, CG_SD_CE_angle,
CB_CG_SD_CE_diangle)
CE = Atom("CE", carbon_e, 0.0, 1.0, " ", " CE", 0, "C")
res = Residue((" ", segID, " "), "MET", " ")
res.add(N)
res.add(CA)
res.add(C)
res.add(O)
res.add(CB)
res.add(CG)
res.add(SD)
res.add(CE)
return res
