def _make_solutepdb(atoms, masses, ligand):
"""
Make a solute PDB file
"""
mass2elem = {
1.0080000: "H",
12.0100000: "C",
14.0100000: "N",
16.0000000: "O",
32.0600000: "S",
35.4500000: "Cl",
19.0000000: "F",
79.9000000: "Br"
}
pdbout = pdb.PDBFile()
res = pdb.Residue()
res.resname = ligand
res.serial = 1
for i, (a, m) in enumerate(zip(atoms, masses), 1):
atom = pdb.Atom()
atom.serial = i
atom.hetatm = False
atom.name = "%s%d" % (mass2elem[m], i
) # Atom names from masses and serial number
atom.resname = ligand
atom.residue = 1
atom.set_xyz(a.xyz)
res.atoms.append(atom)
pdbout.atoms.append(atom)
pdbout.residues.append(res)
pdbout.write(ligand + ".pdb")
def write_singlepdb(filename, resname, atomname):
struct = pdb.PDBFile()
res = pdb.Residue()
atm = pdb.Atom()
atm.serial = 1
atm.name = atomname
atm.resname = resname
atm.residue = 1
res.append(atm)
struct.residues.append(res)
struct.write(filename)
def __init__(self, d, converter):
ran, nam = d.split(":")
# Parse the range
if ran.find("-") > -1:
first, last = ran.split("-")
else:
first = ran
last = ran
self.first = int(first)
self.last = int(last)
# Parse the name
internal_res = {
res.name.strip().lower(): res.cg_names
for res in converter.residues
}
internal_bonds = {
res.name.strip().lower() + "_bonds": res.bonds
for res in converter.residues
}
if nam.strip().lower() in internal_res:
self.resname = nam
self.atom_names = internal_res[nam.strip().lower()]
self.bonds = [
(b[1], b[2])
for b in internal_bonds[nam.strip().lower() + "_bonds"]
]
elif os.path.isfile(nam):
pdbfile = pdb.PDBFile(filename=nam)
if len(pdbfile.residues) > 1:
self.resname = "FILE!"
self.atom_names = []
self.bonds = []
self.pdbfile = pdbfile
else:
self.resname = pdbfile.residues[0].resname
self.atom_names = [
atom.name for atom in pdbfile.residues[0].atoms
]
self.bonds = []
else:
raise Exception(
"Could not find %s in the converter dictionary and it is not a file"
% nam)
def load_xray(mol, loadsigma=False, loadaa=False) :
"""
Load an XrayDensity object from a standard location
"""
template = load_template(mol)
filename = os.path.join(PROT_INFO_PATH,"xray_%s.gro"%mol)
if os.path.isfile(filename) :
sigmafile = None
# Optionally give the sigma file
if loadsigma :
sigmafile = os.path.join(PROT_INFO_PATH,"sigmas_%s"%mol)
if not os.path.isfile(sigmafile) : sigmafile = None
if loadaa :
filename2 = os.path.join(PROT_INFO_PATH,"xray_%s-aa.gro"%mol)
return XrayDensity(filename,template,sigmafile), pdb.PDBFile(filename2)
else:
return XrayDensity(filename,template,sigmafile)
else :
raise Exception("File is missing (%s)"%filename)
def __init__(self, filename, template, sigmafile=None):
# Read in a structure from file
cholxyz = []
protxyz = []
protflag = []
self.pdbfile = pdb.PDBFile(filename)
flag = {"BB": 1, "SC": -1}
for atom in self.pdbfile.atoms:
if atom.resname[0:3] == "CHO":
cholxyz.append(atom.xyz)
elif atom.name.strip()[:2] in ["BB", "SC"]:
protflag.append(flag[atom.name.strip()[:2]])
protxyz.append(atom.xyz)
self.box = self.pdbfile.box
self.cholxyz = np.array(cholxyz)
self.protxyz = np.array(protxyz)
self.protflag = np.array(protflag, dtype=int)
self.helices = template.helices
self.template = template
self.cholleaf = ""
if self.cholxyz.shape[0] > 0:
if self.cholxyz.mean(axis=0)[2] < self.protxyz.mean(axis=0)[2]:
self.cholleaf = "low"
else:
self.cholleaf = "upp"
# Optionally, read a file of Lennard-Jones sigma parameters
if sigmafile is None:
self.sigmas = np.ones(self.protxyz.shape[0]) * 2.3
else:
self.sigmas = []
with open(sigmafile, 'r') as f:
line = f.readline()
while line:
self.sigmas.append(float(line.strip()))
line = f.readline()
self.sigmas = np.array(self.sigmas)
def make(self, bd=3.0):
struct = pdb.PDBFile()
res = pdb.Residue()
for i, bead in enumerate(self.beads):
atom = pdb.Atom()
atom.idx = i
atom.serial = i + 1
atom.name = bead.name
atom.resname = self.name
atom.residue = 1
atom.set_xyz(bead.xyz * bd)
res.atoms.append(atom)
struct.atoms.append(atom)
struct.residues.append(res)
allcoord = np.asarray([a.xyz for a in struct.atoms])
offset = allcoord.mean(axis=0) + 50.0
for a in struct.atoms:
a.set_xyz(a.xyz + offset)
struct.box = np.asarray([100, 100, 100])
return struct
type=float,
help="the insertion radius from the liposome center")
parser.add_argument('-p',
'--patom',
help="the name of the phosphate atom",
default="PO4")
parser.add_argument('-n',
'--nvec',
type=int,
help="the index of a previously employed vector")
args = parser.parse_args()
rads_rev = args.radii[::-1]
rads_pack = zip(args.radii, rads_rev)
boxfile = pdb.PDBFile(filename=args.box)
solutefile1 = pdb.PDBFile(filename=args.file)
solutefile2 = pdb.PDBFile(filename=args.file)
solxyz = np.array(solutefile1.xyz, copy=True)
solcent = solxyz.mean(axis=0)
# Add the atoms of the two solutes to the membrane structure
# the coordinates of the atoms will be subsequently changed
for i, atom in enumerate(solutefile1.atoms, 1):
atom.serial = len(boxfile.atoms) + i
atom.residue = len(boxfile.residues) + 1
boxfile.extend(solutefile1)
for i, atom in enumerate(solutefile2.atoms, 1):
atom.serial = len(boxfile.atoms) + i
default="cg")
#parser.add_argument('-p','--pairfunc',help="the pair function for the AA",default="lj/charmm/coul/long")
args = parser.parse_args()
# Load a converter
converter = lammps.Aa2Cg()
if args.converter is None:
converter.read(lammps.get_filename("aa2cg.dat")) # The default
else:
converter.read(args.converter)
# Load the force field file
include = lammps.Includefile(args.include)
# Create a Datafile and PDBFile
pdbfile = pdb.PDBFile(args.file) # Input PDB
takeres = [True for res in pdbfile.residues]
data = lammps.Datafile()
# Convert residues
all_coords = []
nwat = 0
moli = 0
for i, (res, takethis) in enumerate(zip(pdbfile.residues, takeres)):
if not takethis: continue
moli += 1
res2 = res.resname.strip().lower()
found = False
for residue in converter.residues:
if residue.name == res2:
coord = residue.generate_cg(res, moli + 1, data, mapping=False)
elif atom.mass == 32.06 :
return 1.85
else :
return 2.0
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Program make a PQR file")
parser.add_argument('-f','--file',help="the input gro-file")
parser.add_argument('-p','--topol',help="the topology file")
parser.add_argument('-o','--out',help="the output pqr-file",default="conv.pqr")
parser.add_argument('-m','--mol',nargs="+",help="the molecule to write out",default=["protein"])
args = parser.parse_args()
ref = gmx.TopFile(args.topol)
pdbfile = pdb.PDBFile(args.file)
mols = []
for topol_mol in ref.moleculetypes :
for argmol in args.mol :
if topol_mol.name.lower() == argmol.lower() :
mols.append(topol_mol)
break
natom = sum([len(mol.atoms) for mol in mols])
pdbfile.residues = [res for res in pdbfile.residues if res.atoms[0].serial <= natom]
pdbfile.atoms = pdbfile.atoms[:natom]
start = 0
for mol in mols :
patoms = pdbfile.atoms[start:start+len(mol.atoms)]
if atom.name.strip() == atomnam and atom.resname.strip() == resname :
return i
return None
if __name__ == '__main__':
argparser = argparse.ArgumentParser(description="Script to LAMMPS restraints for APR")
argparser.add_argument('-i','--input',help="the apr.in file",default="apr.in")
argparser.add_argument('-s','--structure',help="a structure file",default="align_z.pdb")
argparser.add_argument('-p','--pull',type=int,help="the number of pull windows")
argparser.add_argument('-d','--displ',type=float,nargs="+",help="the displacement vector")
argparser.add_argument('-f','--force',type=float,nargs=2,help="the bond and angle force respectively",default=[5, 100])
argparser.add_argument('-l','--label',help="a label for the output files",default="restraints")
args = argparser.parse_args()
struct = pdb.PDBFile(args.structure)
h1 = ""
h2 = ""
h3 = ""
g1 = ""
g2 = ""
with open(args.input, "r") as f :
for line in f.readlines() :
if line.strip().startswith("H1") :
h1 = line.strip().split("=")[1].strip()
elif line.strip().startswith("H2") :
h2 = line.strip().split("=")[1].strip()
elif line.strip().startswith("H3") :
h3 = line.strip().split("=")[1].strip()
elif line.strip().startswith("G1") :
parser.add_argument('-o',
'--out',
help="the output file",
default="splitted.gro")
parser.add_argument('-p',
'--patom',
help="the name of the phosphate atom",
default="P")
parser.add_argument('-d',
'--displacement',
type=float,
help="the displacement length",
default="10.0")
args = parser.parse_args()
boxfile = pdb.PDBFile(filename=args.box)
# Calculate the center of membrane
memz = []
for atom in boxfile.atoms:
if atom.name.strip() == args.patom:
memz.append(atom.z)
memcent = np.asarray(memz).mean()
print "Membrane center = %.3f" % memcent
for residue in boxfile.residues:
com = residue.collect("centerofmass")
if com[2] > memcent:
for atom in residue.atoms:
new_xyz = atom.xyz + [0, 0, args.displacement]
atom.set_xyz(new_xyz)
parser.add_argument('--nwater',
type=int,
help="the number of water per lipids",
default=40)
args = parser.parse_args()
lipidbook = build_lipid.LipidCollection()
if args.xml is None:
thispath = os.path.dirname(os.path.abspath(__file__))
args.xml = os.path.join(thispath, "lipid_templates.xml")
lipidbook.load(args.xml)
structs = []
lipids = []
for l in args.lipids:
structs.append(pdb.PDBFile())
structs[-1].read(l)
lipids.append(lipidbook.lipids[structs[-1].residues[0].resname])
newfilename = os.path.splitext(l)[0] + ".pdb"
if not os.path.exists(newfilename):
structs[-1].write(newfilename)
zlen = np.max([l.head[0].xyz - l.tail[0].xyz for l in lipids], axis=0)[2]
# Parse the number of lipids of each kind in each leaflet
if len(args.nlipid) == 1:
args.nlipid.append(args.nlipid[0])
nlipid = [map(int, nspec.split(":")) for nspec in args.nlipid]
# Calculate the side of the box in x and y, assuming 60 A2 area per lipid
xylen = np.sqrt(np.max([args.area * np.sum(n) for n in nlipid]))
parser.add_argument('-w',
'--watom',
help="the name of the water atom",
default="OH2")
parser.add_argument('-n',
'--n',
type=int,
nargs=2,
help="the number of water to remove in each monolayer")
parser.add_argument('--nobox',
action="store_true",
help="do not modify the box",
default=False)
args = parser.parse_args()
struct = pdb.PDBFile(filename=args.file)
# Calculate the center of membrane
memz = []
for atom in struct.atoms:
if atom.name.strip() == args.patom:
memz.append(atom.z)
memcent = np.asarray(memz).mean()
print "Membrane center = %.3f" % memcent
water_z = []
water_resid = []
for i, residue in enumerate(struct.residues):
if residue.atoms[0].name.strip() == args.watom:
water_z.append(residue.atoms[0].z)
water_resid.append(i)
parser.add_argument('-s',
'--shift',
type=float,
nargs=3,
help="the amount to shift in each direction")
parser.add_argument(
'--fromedge',
action="store_true",
help="if the shift should be from the edge of the mobile structure",
default=False)
parser.add_argument('-o',
'--out',
help="the output filename, default=[overwrite]")
args = parser.parse_args()
pdbref = pdb.PDBFile(args.reference)
pdbmob = pdb.PDBFile(args.mobile)
# Calculate the delta that will make the centroid of the two structures to overlap
avref = np.average(pdbref.xyz, axis=0)
avmob = np.average(pdbmob.xyz, axis=0)
delta = avref - avmob
# By command line arguments we can shift the overlay
if args.shift is None:
pdbmob.update_xyz(pdbmob.xyz + delta)
else:
# If we should place the mobile next to the edge of the reference structure
if args.fromedge:
delta2 = pdbref.xyz[:, 0].max() - avref
args.shift = [
parser = argparse.ArgumentParser(
description="Program to convert a POPI membrane to a membrane with IPC"
)
parser.add_argument('-f', '--file', help="the input gro-file")
parser.add_argument('-t', '--template', help="a template IPC pdb-file")
parser.add_argument('-z', '--zmat', help="the IPC z-matrix")
parser.add_argument('-i', '--itp', help="the IPC itp-file")
parser.add_argument('-n',
'--nreplace',
type=int,
help="how many POPI molecules to replace")
args = parser.parse_args()
# Read in a gro-file
popimem = pdb.PDBFile()
popimem.read(args.file, gro=True)
# Read in a template IPC-file
ipc_pdb = pdb.PDBFile(filename=args.template)
# Read in the z-matrix of the IPC molecule
ipc_zmat = [
line.strip().split() for line in open(args.zmat, "r").readlines()
]
# Read in the atom order of the IPC itp-file
ipctop = gmx.TopFile(args.itp)
ipc_atomlist = [atom.name for atom in ipctop.moleculetypes[0].atoms]
nreplace = args.nreplace
# Check where the middle of the membrane is
midz = popimem.xyz[:, 2].mean()
default=[])
args = parser.parse_args()
if len(args.files) == 0:
print "Nothing to do. Exiting."
quit()
prot_con = None
if args.pbonds == "":
print "No connectivity information will be added for the protein"
else:
prot_con = make_con(args.pbonds)
het_con = None
if len(args.hbonds) == 0:
print "No connectivity information will be added for the hetero residues"
else:
het_con = {}
for filename in args.hbonds:
filebase, fileext = os.path.splitext(filename)
het_con[filebase.upper()] = make_con(filename)
print het_con
for filename in args.files:
filebase, fileext = os.path.splitext(filename)
pdbfile = pdb.PDBFile()
pdbfile.read(filename, gro=True)
print len(pdbfile.chains)
pdbfile.write(filebase + ".pdb", ter=True, add_extra=add_con)
parser.add_argument('-reference',
'--reference',
help="the reference PDB file")
parser.add_argument('-mobile', '--mobile', help="the mobile PDB file")
parser.add_argument('-ranges',
'--ranges',
nargs="+",
help="list of residues ranges to match")
parser.add_argument('-offset',
'--offset',
default=0,
type=int,
help="reference offset")
args = parser.parse_args()
pdb1 = pdb.PDBFile(args.reference, renumber=False)
pdb2 = pdb.PDBFile(args.mobile, renumber=False)
naa1 = sum([1 for r in pdb1.residues if r.resname in pdb.std_aa_names])
naa2 = sum([1 for r in pdb2.residues if r.resname in pdb.std_aa_names])
if naa1 != naa2:
raise Exception(
"The two PDB files does not have the same number of residues (%d, %d)."
% (naa1, naa2))
if args.offset != 0:
for res in pdb1.residues:
res.serial += args.offset
print "[Residue match]"
print "Command= " + " ".join(sys.argv)
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Program to place a protein next to a membrane")
parser.add_argument('-prot', '--protein', help="the protein PDB file")
parser.add_argument('-mem', '--membrane', help="the membrane PDB file")
parser.add_argument('--lipidref',
help="the name of the lipid reference atom",
default="P")
parser.add_argument('-o',
'--out',
help="the output filename",
default="placed.gro")
args = parser.parse_args()
prot = pdb.PDBFile(args.protein)
mem = pdb.PDBFile(args.membrane)
# Calculate the delta that will make the centroid of the two structures to overlap
avmem = np.average(
[atom.xyz for atom in mem.atoms if atom.name.strip() == args.lipidref],
axis=0)
avprot = np.average(prot.xyz, axis=0)
delta = avmem - avprot
# Calculate how much from the edge of the membrane to shift the protein
minprot = np.min(prot.xyz, axis=0)
minatmx = np.argmin(prot.xyz, axis=0)[0]
prot_lenx = (avprot - minprot)[0]
mem_lenx = mem.xyz[:, 0].max() - avmem[0]
shift = np.array([prot_lenx + mem_lenx, 0, 0])
from sgenlib import pdb
from sgenlib import groups
if __name__ == "__main__":
# Setup a parser of the command-line arguments
parser = argparse.ArgumentParser(description="Program make S2 group files")
parser.add_argument('-f', '--file', help="the input gro-file")
parser.add_argument('-g', '--groups', help="the group definitions")
parser.add_argument('-o', '--out', help="the output prefix", default="")
args = parser.parse_args()
residue_groups = groups.read_groups(args.groups)
# Loop over all residues in the input pdb-file
for residue in pdb.PDBFile(filename=args.file).residues:
if residue.resname not in residue_groups: continue
for atom in residue.atoms:
for group in residue_groups[residue.resname].groups:
if not group.has_atom(atom.name.strip()): continue
group.add_serial(atom.name.strip(), atom.serial)
# Check for consistency
for residue in residue_groups:
residue_groups[residue].check_consistency()
print "[%s]" % residue
for g in residue_groups[residue].groups:
if g.expressed:
print "\t%s = %d" % (g.name, len(g.serials[g.atoms[0]]))
# Write output file
help="the dihedral function for the solute")
parser.add_argument('--dihfunc_box',
help="the dihedral function for the box")
parser.add_argument('--pairmix',
nargs="+",
help="pair functions to use when mixing pairs")
parser.add_argument('--noff',
action="store_true",
help="turns off the creating of force field file",
default=False)
args = parser.parse_args()
# Read solute data file
solute_data = lammps.Datafile(filename=args.solute)
if args.pdb is not None:
pdbfile = pdb.PDBFile(filename=args.pdb)
for datom, patom in zip(solute_data.atoms, pdbfile.atoms):
datom.set_xyz(patom.xyz)
# Read box data file and force field
box_data = lammps.Datafile(filename=args.box)
for atom in box_data.atoms:
atom.ix = None
atom.iy = None
atom.iz = None
box_ff = lammps.Includefile(filename=args.ff)
if args.dihfunc_box is not None:
for dih in box_ff.dihedralparams:
if dih.func == "": dih.func = args.dihfunc_box
parser = argparse.ArgumentParser(
description="Calculate ligand-protein interaction energies")
parser.add_argument('files', nargs="+", help="the Gromacs xvg-files")
parser.add_argument('-o', '--out', help="the output file")
parser.add_argument('-p', '--pdb', help="the protein", default=[])
parser.add_argument('-r',
'--repeats',
help="repeat replacement",
default=[
"r1_", "r2_", "r3_", "r4_", "r5_", "r6_", "r8_",
"r9_", "r10_"
])
args = parser.parse_args()
residues = ["CU", "CL"]
for res in pdb.PDBFile(args.pdb).residues[:235]:
residues.append("%s%d" % (res.resname.capitalize(), res.serial))
all_data = None
for ri, replacement in enumerate(args.repeats):
r_data = []
if ri == 0:
outname = args.out
else:
outname = args.out.replace(args.repeats[0], replacement)
with open(outname, "w") as f:
if ri == 0:
files = args.files
else:
files = [
file.replace(args.repeats[0], replacement)
import sys
import os
from sgenlib import pdb
def atom_by_name(residue, atom):
atom = atom.strip()
if atom[0] in ["1", "2", "3"]:
atom = atom[1:] + atom[0]
if residue.resname == "ILE" and atom == "CD":
atom = "CD1"
return residue.atom_by_name(atom)
converted_pdb = pdb.PDBFile(sys.argv[1])
crystal_pdb = pdb.PDBFile(sys.argv[2])
nprotres = len(crystal_pdb.residues)
for conv_res, crys_res in zip(converted_pdb.residues[:nprotres],
crystal_pdb.residues):
for conv_atom in conv_res.atoms:
crys_atom = atom_by_name(crys_res, conv_atom.name)
if crys_atom is None:
print "Could not find %s in %s%d" % (
conv_atom.name, conv_atom.resname, conv_atom.residue)
else:
conv_atom.set_xyz(crys_atom.xyz)
name, ext = os.path.splitext(sys.argv[1])
'--checkpoint',
help="the format checkpoint file")
argparser.add_argument(
'-s',
'--struct',
help="a gro or pdb file with atom/residue information")
argparser.add_argument('-b', '--bonds', nargs="+", help="the bonds")
argparser.add_argument('--scaling',
type=float,
help="the frequency scaling factor",
default=0.963)
args = argparser.parse_args()
crds, hess = _parse_fchk(args.checkpoint)
struct_orig = pdb.PDBFile(args.struct)
struct = pdb.PDBFile(args.struct)
for i, atom in enumerate(struct.atoms, 1):
# 0.529177249 is Bohr to A
atom.set_xyz(crds[3 * i - 3:3 * i] * 0.529177249)
base, ext = os.path.splitext(args.struct)
struct.write(base + "_opt" + ext)
print "Bond\tr(x-ray)\tr(opt) [nm]\tk [kJ/mol/nm2]"
for bond in args.bonds:
atm1, atm2 = _find_pair(struct, bond)
dist = np.sqrt(atm1.distance2(atm2))
atm1_orig = struct_orig.atoms[atm1.idx]
atm2_orig = struct_orig.atoms[atm2.idx]
dist_orig = np.sqrt(atm1_orig.distance2(atm2_orig))
default="lj/charmm/coul/long")
parser.add_argument('-w',
'--watrad',
type=float,
help="the water radius to keep atomistic")
args = parser.parse_args()
# Load a converter
converter = lammps.Aa2Cg()
if args.converter is None:
converter.read(lammps.get_filename("aa2cg.dat")) # The default
else:
converter.read(args.converter)
# Create a Datafile and PDBFile
pdbfile = pdb.PDBFile(args.file) # Input PDB
takeres = [True for res in pdbfile.residues]
data = lammps.Datafile()
pdbout = pdb.PDBFile() # Output PDB
# Load the force field file
include = lammps.Includefile(args.include)
if args.atomistic:
# At the moment, multiple AA solutes are not supported with atomistic water radius
if len(args.atomistic) > 1:
args.watrad = None
natomtypes = _ntypes(include.masses)
contypes = [
_ntypes(include.bondparams),
_ntypes(include.angleparams),
"""
Program to flip the z-coordinate
Examples
--------
"""
import argparse
import numpy as np
from sgenlib import pdb
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Program to rename atoms and residue")
parser.add_argument('file', help="the PDB file")
parser.add_argument('-o', '--out', help="the output filename")
args = parser.parse_args()
pdbin = pdb.PDBFile(args.file)
pdbin.box[2] *= 2
for atom in pdbin.atoms:
new = np.array(atom.xyz, copy=True)
new[2] = pdbin.box[2] - new[2]
atom.set_xyz(new)
pdbin.write(args.out)
'--charge',
type=float,
help="The net charge of the molecule(s)",
default=0)
parser.add_argument('-p',
'--processors',
type=int,
help="The number of processors to use",
default=1)
args = parser.parse_args()
method = {"ff94": "HF/6-31G* SCF", "ff03": "B3LYP/cc-pVTZ SCRF"}
for filename in args.file:
h, t = os.path.splitext(filename)
pdbfile = pdb.PDBFile(filename=filename)
with open("%s_mk.com" % h, "w") as fout:
fout.write("%Mem=256MB\n")
fout.write("%snproc=%d\n" % ('%', args.processors))
fout.write("\n")
fout.write(
"#P %s Pop=(Minimal,MK) IOp(6/33=2,6/41=10,6/42=17)\n\n" %
method[args.version])
fout.write("MK ESP on %s, at %s\n" %
(filename, time.strftime("%d/%m/%Y")))
fout.write("\n")
fout.write("%d 1\n" % args.charge)
for atom in pdbfile.atoms:
fout.write("%s %8.3f %8.3f %8.3f\n" %
(atom.element(), atom.x, atom.y, atom.z))
fout.write("\n")
if __name__ == '__main__':
argparser = argparse.ArgumentParser(
description="Script to displace a small solute")
argparser.add_argument('-f',
'--file',
help="the input structure",
default="align_z.pdb")
argparser.add_argument('-o',
'--output',
help="the output structure file",
default="align_z.pdb")
argparser.add_argument('-r',
'--resname',
help="the residue name",
default="MOL")
argparser.add_argument('-d',
'--displace',
type=float,
nargs=+3,
help="the displace vector",
default=[0.0, 0.0, 0.0])
args = argparser.parse_args()
struct = pdb.PDBFile(args.file)
for atom in struct.atoms:
if atom.resname.strip() == args.resname:
atom.set_xyz(atom.xyz + args.displace)
struct.write(args.output)
import numpy as np
from sgenlib import pdb
if __name__ == '__main__':
# Setup a parser of the command-line arguments
parser = argparse.ArgumentParser(
description="Program to make a box size for a structure")
parser.add_argument('file', help="the PDB file")
parser.add_argument('-p',
'--padding',
type=float,
nargs=3,
help="the padding of each axis",
default=[10, 10, 10])
args = parser.parse_args()
coord = pdb.PDBFile(filename=args.file).xyz
av = np.average(coord, axis=0)
mina = np.min(coord, axis=0)
maxa = np.max(coord, axis=0)
lo = mina - args.padding
hi = maxa + args.padding
len = hi - lo
print "Low: %.3f %.3f %.3f" % tuple(lo)
print "High: %.3f %.3f %.3f" % tuple(hi)
print "Length: %.3f %.3f %.3f" % tuple(len)
# Author: Samuel Genheden [email protected] """ Program to calculate the extent of PDB structure """ import sys import numpy as np from sgenlib import pdb if __name__ == '__main__': coord = pdb.PDBFile(filename=sys.argv[1]).xyz av = np.average(coord, axis=0) mina = np.min(coord, axis=0) maxa = np.max(coord, axis=0) print "Mean: %.3f %.3f %.3f" % (av[0], av[1], av[2]) print "Min: %.3f %.3f %.3f" % (mina[0], mina[1], mina[2]) print "Max: %.3f %.3f %.3f" % (maxa[0], maxa[1], maxa[2]) print "Len: %.3f %.3f %.3f" % (maxa[0] - mina[0], maxa[1] - mina[1], maxa[2] - mina[2])
# Author: Samuel Genheden [email protected] """ Program to concatenate structure in PDB or GRO format Example: pdb_cat.py pdb1.pdb pdb2.pdb pdb3.pdb -o pdb_all.pdb """ import argparse import os from sgenlib import pdb if __name__ == "__main__": # Setup a parser of the command-line arguments parser = argparse.ArgumentParser( description="Program to concatenate structures") parser.add_argument('file', nargs="+", help="the PDB file") parser.add_argument('-o', '--out', help="the output filename") args = parser.parse_args() pdbfile = pdb.PDBFile(filename=args.file[0], renumber=False) for filename in args.file[1:]: pdbfile2 = pdb.PDBFile(filename, renumber=False) pdbfile.extend_residues(pdbfile2.residues) pdbfile.write(args.out)