def alignWithBackbone(target, fiducial):
tbb = loos.selectAtoms(target, 'backbone')
fbb = loos.selectAtoms(fiducial, 'backbone')
M = tbb.superposition(fbb)
X = loos.XForm()
X.load(M)
target.applyTransform(X)
def buildMassTable(model_name, psf_name, subset_selection):
model = loos.createSystem(model_name)
psf = loos.createSystem(psf_name)
# First, fix masses...
mass_table = {}
for atom in psf:
name = atom.name()
mass = atom.mass()
if name in mass_table:
if mass != mass_table[name]:
print('Error- multiple masses found for {} ({} vs {})'.format(
name, mass, mass_table[name]))
sys.exit(-10)
else:
mass_table[name] = mass
protein = loos.selectAtoms(model, subset_selection)
masses = []
for atom in protein:
name = atom.name()
if name not in mass_table:
print('Error- could not find {} in mass table'.format(name))
sys.exit(-11)
atom.mass(mass_table[name])
masses.append(mass_table[name])
return masses
def _align(self):
"""
Align the frames (called implicitly on iterator or array access)
"""
current_traj = None
current_subset = None
ensemble = []
if self._stale:
self._initFrameList()
if self._reference: # Align to a reference structure
self._xformlist = []
for i in range(len(self._framelist)):
t = self._trajectories[self._trajlist[i]]
if t != current_traj:
current_traj = t
current_subset = loos.selectAtoms(t.model(),
self._alignwith)
t.readFrame(self._framelist[i])
m = current_subset.superposition(self._reference)
x = loos.XForm()
x.load(m)
self._xformlist.append(x)
self._rmsd = 0.0
self._iters = 0
else: # Iterative alignment
ensemble = loos.DoubleVectorMatrix()
for i in range(len(self._framelist)):
t = self._trajectories[self._trajlist[i]]
if t != current_traj:
current_traj = t
current_subset = loos.selectAtoms(t.model(),
self._alignwith)
t.readFrame(self._framelist[i])
ensemble.push_back(current_subset.coordsAsVector())
result = loos.iterativeAlignmentPy(ensemble)
(self._xformlist, self._rmsd,
self._iters) = (loos.xformVectorToList(result.transforms),
result.rmsd, result.iterations)
self._aligned = True
def makeRestraints(model, selection_string = 'name == "CA"', konst = 1.0):
duplicate = model.copy()
for atom in duplicate:
atom.bfactor(0.0)
subset = loos.selectAtoms(model, selection_string)
for atom in subset:
atom.bfactor(konst)
return(duplicate)
def _align(self):
"""
Align the frames (called implicitly on iterator or array access)
"""
current_traj = None
current_subset = None
ensemble = []
if self._stale:
self._initFrameList()
if self._reference: # Align to a reference structure
self._xformlist = []
for i in range(len(self._framelist)):
t = self._trajectories[self._trajlist[i]]
if t != current_traj:
current_traj = t
current_subset = loos.selectAtoms(t.model(), self._alignwith)
t.readFrame(self._framelist[i])
m = current_subset.superposition(self._reference)
x = loos.XForm()
x.load(m)
self._xformlist.append(x)
self._rmsd = 0.0
self._iters = 0
else: # Iterative alignment
ensemble = loos.DoubleVectorMatrix()
for i in range(len(self._framelist)):
t = self._trajectories[self._trajlist[i]]
if t != current_traj:
current_traj = t
current_subset = loos.selectAtoms(t.model(), self._alignwith)
t.readFrame(self._framelist[i])
ensemble.push_back(current_subset.coordsAsVector())
result = loos.iterativeAlignmentPy(ensemble)
(self._xformlist, self._rmsd, self._iters) = (loos.xformVectorToList(result.transforms), result.rmsd, result.iterations)
self._aligned = True
def write_restraintfile(self, directory, atomicgroup, spring=10.0):
pdb = loos.PDB.fromAtomicGroup(atomicgroup.copy())
for atom in pdb:
atom.coords().zero()
heavy = loos.selectAtoms(pdb, '!(name =~ "^H")' )
for atom in heavy:
atom.coords().x(spring)
pdb_file = open(os.path.join(directory,self.cons_k_filename), "w")
pdb_file.write(str(pdb))
pdb_file.close()
def write_restraintfile(self, directory, atomicgroup, spring=10.0):
pdb = loos.PDB.fromAtomicGroup(atomicgroup.copy())
for atom in pdb:
atom.coords().zero()
heavy = loos.selectAtoms(pdb, '!(name =~ "^H")')
for atom in heavy:
atom.coords().x(spring)
pdb_file = open(os.path.join(directory, self.cons_k_filename), "w")
pdb_file.write(str(pdb))
pdb_file.close()
def __init__(self, fname, model, **kwargs):
self._skip = 0
self._stride = 1
self._iterator = None
if 'skip' in kwargs:
self._skip = kwargs['skip']
if 'stride' in kwargs:
self._stride = kwargs['stride']
if 'iterator' in kwargs:
self._iterator = kwargs['iterator']
if 'subset' in kwargs:
self._subset = loos.selectAtoms(model, kwargs['subset'])
else:
self._subset = model
self._model = model
self._fname = fname
self._traj = loos.createTrajectory(fname, model)
self._stale = 1
self._initFrameList()
def __init__(self, fname, model, **kwargs):
self._skip = 0
self._stride = 1
self._iterator = None
if 'skip' in kwargs:
self._skip = kwargs['skip']
if 'stride' in kwargs:
self._stride = kwargs['stride']
if 'iterator' in kwargs:
self._iterator = kwargs['iterator']
if 'subset' in kwargs:
self._subset = loos.selectAtoms(model, kwargs['subset'])
else:
self._subset = model
self._model = model
self._fname = fname
self._traj = loos.createTrajectory(fname, model)
self._stale = 1
self._initFrameList()
parser.add_argument("-d", "--directory",
help="Directory to create output files",
default=".")
parser.add_argument("-t", "--threshold",
default=7,
type=int,
help="Number of atoms inside for the chain to be considered inside")
args = parser.parse_args()
system = loos.createSystem(args.system_file)
traj = loos.createTrajectory(args.traj_file, system)
protein = loos.selectAtoms(system, args.protein_string)
output_directory = args.directory
if not os.path.exists(output_directory):
try:
os.mkdir(output_directory)
except OSError as inst:
print 'Error creating output directory %s : ' % output_directory
print inst
sys.exit(1)
if not os.access(output_directory, os.W_OK):
print "Error: no permission to write to output directory ", output_directory
sys.exit(1)
helices = []
def setSubset(self, selection):
"""
Set the subset used when iterating over a trajectory.
The selection is a LOOS selection string.
"""
self._subset = loos.selectAtoms(self._model, selection)
#!/bin/env python
import loos
import sys
model = loos.createSystem(sys.argv[1])
for atom in model:
atom.bfactor(0.0)
subset = loos.selectAtoms(model, sys.argv[2])
for atom in subset:
atom.bfactor(1.0)
pdb = loos.PDB.fromAtomicGroup(model)
print str(pdb)
"""
simple_model_calc.py : simple skeleton of a program that reads in a
structure, makes a selection, then loops over the atoms.
Alan Grossfield
University of Rochester Medical Center
"""
import loos
import sys
header = " ".join(sys.argv)
print("#", header)
# parse the command line arguments -- in a more complex example,
# you'd use the argparse module
model_filename = sys.argv[1]
selection_string = sys.argv[2]
# Create the system
model = loos.createSystem(model_filename)
# Select a subset of the system
subset = loos.selectAtoms(model, selection_string)
# Iterate over atoms and calculate something#
for atom in subset:
# do something
continue
7:] # first selection gives the all atoms to use
# in area calculations, all others tell you
# how to group the areas
print("# ", " ".join(sys.argv))
system = loos.createSystem(system_filename)
traj = loos.createTrajectory(traj_filename, system)
traj.readFrame(skip)
traj.updateGroupCoords(system)
slicer = ZSliceSelector(zmin, zmax)
selections = []
selections.append(loos.selectAtoms(system, selection_strings[0]))
for s in selection_strings[1:]:
selections.append(loos.selectAtoms(selections[0], s))
frame = skip
string = ""
for i in range(len(selections)):
string += "\tArea" + str(i)
print("# Frame", string)
while (traj.readFrame()):
traj.updateGroupCoords(system)
system.reimageByAtom()
slice_atoms = slicer(selections[0])
default=1)
parser.add_argument('--no_h',
help="Exclude hydrogens from calculation",
action='store_true')
parser.add_argument('--pca',
help="Perform PCA on the per-residue profiles",
action='store_true')
parser.add_argument('--fullhelp',
help="Print detailed description of all options",
action=FullHelp)
args = parser.parse_args()
system = loos.createSystem(args.system_file)
protein = loos.selectAtoms(system, args.protein_selection)
probe = loos.selectAtoms(system, args.probe_selection)
if args.no_h:
protein = loos.selectAtoms(protein, '!hydrogen')
probe = loos.selectAtoms(probe, '!hydrogen')
residues = protein.splitByResidue()
probes = probe.splitByMolecule()
frame_index = 0
traj = loos.pyloos.Trajectory(args.traj[0],
system,
skip=args.skip,
stride=args.stride)
vtraj = loos.pyloos.VirtualTrajectory(traj)
for t in args.traj[1:]:
zmax = float(sys.argv[6])
num_slices = int(sys.argv[7])
padding = float(sys.argv[8])
all_selection = sys.argv[9]
target_selection = sys.argv[10]
print("# ", " ".join(sys.argv))
system = loos.createSystem(system_filename)
pytraj = loos.pyloos.Trajectory(traj_filename,
system,
skip=skip,
stride=stride)
all_atoms = loos.selectAtoms(system, all_selection)
target_atoms = loos.selectAtoms(all_atoms, target_selection)
slicers = []
slice_width = (zmax - zmin) / num_slices
for i in range(num_slices):
low = zmin + i * slice_width
high = zmin + (i + 1) * slice_width
slicers.append(ZSliceSelector(low, high))
areas = numpy.zeros([num_slices])
areas2 = numpy.zeros([num_slices])
for snap in pytraj:
system.reimageByAtom()
for r in self.regions:
r.print_indices()
print
if __name__ == '__main__':
import sys
structure = loos.createSystem("trj_1.pdb")
#structure = loos.createSystem("example.pdb")
#structure = loos.createSystem("b2ar.pdb")
#box = loos.GCoord(55., 77, 100)
#box = loos.GCoord(55., 77, 100)
phos = loos.selectAtoms(structure, 'name == "P"')
upper = loos.AtomicGroup()
for p in phos:
if p.coords().z() > 0:
upper.append(p)
upper.periodicBox(structure.periodicBox())
print upper.isPeriodic()
"""
slice = loos.AtomicGroup()
for a in structure:
if a.coords().z() > 20 and a.coords().z() < 21:
slice.append(a)
slice.periodicBox(box)
"""
v = VoronoiWrapper(upper)
system_file = sys.argv[1]
traj_file = sys.argv[2]
centering_selection_string = sys.argv[3]
target_selection_string = sys.argv[4]
zmin = float(sys.argv[5])
zmax = float(sys.argv[6])
znum_bins = int(sys.argv[7])
rmin = float(sys.argv[8])
rmax = float(sys.argv[9])
rnum_bins = int(sys.argv[10])
system = loos.createSystem(system_file)
traj = loos.pyloos.Trajectory(traj_file, system)
centering = loos.selectAtoms(system, centering_selection_string)
target = loos.selectAtoms(system, target_selection_string)
zbin_width = (zmax - zmin) / znum_bins
rbin_width = (rmax - rmin) / rnum_bins
rmin2 = rmin * rmin
rmax2 = rmax * rmax
hist = numpy.zeros([rnum_bins, znum_bins])
for frame in traj:
centroid = centering.centroid()
target.translate(-centroid)
target.reimageByAtom()
action='append',
help="segid selection-string")
parser.add_argument('--default',
nargs=1,
default="OTH",
help="default segid to apply to unmatched atoms")
parser.add_argument('--fullhelp',
help="Print detailed description of all options",
action=FullHelp)
args = parser.parse_args()
system = loos.createSystem(args.system_file)
all_selections = loos.AtomicGroup()
for seg, sel in args.selection:
selection = loos.selectAtoms(system, sel)
# SEGIDs are supposed to be 4 characters
if len(seg) > 4:
seg = seg[:4]
for a in selection:
a.segid(seg)
all_selections.append(selection)
remaining_atoms = system.clone()
remaining_atoms.remove(all_selections)
print(len(remaining_atoms), " atoms unlabeled, applying default segid ",
args.default)
for a in remaining_atoms:
a.segid(args.default)
header = " ".join(sys.argv) + "\n"
system = loos.createSystem(args.system_file)
all_trajs = []
out_names = []
num_trajs = len(args.traj_files)
for t in args.traj_files:
traj = loos.pyloos.Trajectory(t, system)
all_trajs.append(traj)
if (num_trajs > 1) and args.individual:
t_base = basename(t)
core, ext = splitext(t_base)
out_names.append(core + ".dat")
if args.no_hydrogens:
no_hydrogens = loos.selectAtoms(system, "!hydrogen")
target = loos.selectAtoms(no_hydrogens, args.selection)
else:
target = loos.selectAtoms(system, args.selection)
residues = target.splitByResidue()
# now remove the backbone -- doing before the split loses the glycines
if args.no_backbone:
residues = list([loos.selectAtoms(r, "!backbone") for r in residues])
frac_contacts = numpy.zeros(
[len(residues), len(residues), num_trajs], numpy.float)
for traj_id in range(num_trajs):
traj = all_trajs[traj_id]
for frame in traj:
except OSError:
sys.stderr.write(" Unable to change permissions on directory\n")
os.exit(-1)
# We need a model containing just the protein and lipid, so we'll
# make a psfgen script, run it, use the psf to make the AtomicGroup,
temporary_psfname = os.path.join(config.directory, config.psfname)
psfgen_script = config.generate_psf(True, False, True, True, temporary_psfname)
psfgen = PSFGen.PSFGen(psfgen_script, config.psfgen_binary)
psfgen.run()
system = loos.createSystem(temporary_psfname)
segments = []
for segment in config.segments:
s = loos.selectAtoms(system, 'segname == "' + segment.segname + '"')
if (len(s) == 0):
sys.stderr.write("Selection failed assembling system: segment %s doesn't exist\n" % (segment.segname))
sys.stderr.write("Exiting...\n")
sys.exit(0)
segments.append(s)
# copy the protein coordinates into the system
if (config.protein is not None):
# create AtomicGroup containing all protein segments in case
# we want to rotate it
to_rot = loos.AtomicGroup()
for s in config.protein.segments:
import loos
import loos.pyloos
import math
header = " ".join(sys.argv)
print("# ", header)
system_file = sys.argv[1]
traj_file = sys.argv[2]
sel_string1 = sys.argv[3]
sel_string2 = sys.argv[4]
system = loos.createSystem(system_file)
traj = loos.pyloos.Trajectory(traj_file, system)
sel1 = loos.selectAtoms(system, sel_string1)
sel2 = loos.selectAtoms(system, sel_string2)
for frame in traj:
# compute distance
centroid1 = sel1.centroid()
centroid2 = sel2.centroid()
diff = centroid2 - centroid1
distance = diff.length()
# Compute angle between principal axes
vectors1 = sel1.principalAxes()
axis1 = vectors1[0]
stride = int(sys.argv[4])
zmin = float(sys.argv[5])
zmax = float(sys.argv[6])
num_slices = int(sys.argv[7])
padding = float(sys.argv[8])
all_selection = sys.argv[9]
target_selection = sys.argv[10]
print "# ", " ".join(sys.argv)
system = loos.createSystem(system_filename)
pytraj = loos.pyloos.Trajectory(traj_filename, system, skip=skip, stride=stride)
all_atoms = loos.selectAtoms(system, all_selection)
target_atoms = loos.selectAtoms(all_atoms, target_selection)
slicers = []
slice_width = (zmax - zmin) / num_slices
for i in range(num_slices):
low = zmin + i*slice_width
high = zmin + (i+1)*slice_width
slicers.append(ZSliceSelector(low, high))
areas = numpy.zeros([num_slices])
areas2 = numpy.zeros([num_slices])
for snap in pytraj:
system.reimageByAtom()
sys.exit()
header = " ".join(sys.argv)
system_filename = sys.argv[1]
traj_filename = sys.argv[2]
out_prefix = sys.argv[3]
selections = sys.argv[4:]
system = loos.createSystem(system_filename)
traj = loos.pyloos.Trajectory(traj_filename, system)
helices = []
for s in selections:
helices.append(loos.selectAtoms(system, s))
# Make a fake atomicgroup to hold the placeholder atoms
new_group = loos.AtomicGroup()
resnum = 1
for i in range(len(helices)):
a = loos.Atom()
b = loos.Atom()
c = loos.Atom()
a.resid(resnum)
b.resid(resnum)
c.resid(resnum)
a.name("CENT")
b.name("PLUS")
c.name("MIN")
import argparse
import loos
import loos.pyloos
import numpy as np
# Parse command line
parser = argparse.ArgumentParser()
parser.add_argument('prefix', help='Handle for output files.')
parser.add_argument('model', help='Structure to be used')
parser.add_argument('datafile', help='Profile file')
parser.add_argument('selection', help='Atom selection')
args = parser.parse_args()
# System setup
model = loos.createSystem(args.model)
selection = loos.selectAtoms(model,args.selection)
residues = selection.splitByResidue()
# Read in data file
with open(args.datafile, 'r', encoding='utf-8-sig') as datafile:
data = np.genfromtxt(datafile, delimiter=',',dtype=float)
RESID = data[:,0]
VALUE = data[:,1]
if RESID.shape[0] != VALUE.shape[0]:
print ("Column 1 and 2 have different size. Format it accordingly")
exit()
print("\nData file detected :\n")
header = " ".join(sys.argv) + "\n"
system = loos.createSystem(args.system_file)
all_trajs = []
out_names = []
num_trajs = len(args.traj_files)
for t in args.traj_files:
traj = loos.pyloos.Trajectory(t, system)
all_trajs.append(traj)
if (num_trajs > 1) and args.individual:
t_base = basename(t)
core, ext = splitext(t_base)
out_names.append(core + ".dat")
if args.no_hydrogens:
no_hydrogens = loos.selectAtoms(system, "!hydrogen")
target = loos.selectAtoms(no_hydrogens, args.selection)
else:
target = loos.selectAtoms(system, args.selection)
residues = target.splitByResidue()
# now remove the backbone -- doing before the split loses the glycines
# Woohoo, look at me, I used a lambda!
if args.no_backbone:
residues = list(map(lambda r: loos.selectAtoms(r, "!backbone"), residues))
frac_contacts = numpy.zeros(
[len(residues), len(residues), num_trajs], numpy.float)
for traj_id in range(num_trajs):
traj = all_trajs[traj_id]
"U": ["O2", "O4", "O2'", "O3'", "O4'", "O5'", "OP1", "OP2"]
}
N_acceptor = {s: len(rna_acceptors[s]) for s in rna_acceptors}
# Compare to square of distance and angle cutoffs because sqrt() is expensive
# Compare to sin of angle cutoff because planar groups can have normal
# vectors that are close to parallel or close to anti-parallel
dist_cutoff_sq = numpy.square(args.distance_cutoff)
stack_cutoff_sq = numpy.square(args.stack_cutoff)
angle_cutoff_sq = numpy.square(numpy.sin(args.angle_cutoff / rad2deg))
# Create system model
system = loos.createSystem(args.input_pdb)
# Get arginine residues
arg_atoms = loos.selectAtoms(system, args.protein)
all_arg_residues = arg_atoms.splitByResidue()
arg_residues = [res for res in all_arg_residues if is_valid_arg_residue(res)]
N_arg = len(arg_residues)
# If there are no arginines, then exit
if N_arg == 0:
quit()
# Get RNA residues
rna_atoms = loos.selectAtoms(system, args.rna)
all_rna_residues = rna_atoms.splitByResidue()
rna_residues = [res for res in all_rna_residues if is_valid_rna_residue(res)]
N_rna = len(rna_residues)
# Get resids and resnames for Arg and RNA
def setSubset(self, selection):
"""
Set the subset used when iterating over a trajectory.
The selection is a LOOS selection string.
"""
self._subset = loos.selectAtoms(self._model, selection)
def is_valid_arg_residue(residue):
return (len(loos.selectAtoms(residue, 'name == "NE"')) == 1
and len(loos.selectAtoms(residue, 'name == "NH1"')) == 1
and len(loos.selectAtoms(residue, 'name == "NH2"')) == 1)
def is_valid_rna_residue(residue):
return (len(loos.selectAtoms(residue, 'name == "C2"')) == 1
and len(loos.selectAtoms(residue, 'name == "C4"')) == 1
and len(loos.selectAtoms(residue, 'name == "C6"')) == 1)
print "#", " ".join(sys.argv)
system_file = sys.argv[1]
traj_file = sys.argv[2]
zmin = float(sys.argv[3])
zmax = float(sys.argv[4])
protein_selection = sys.argv[5]
all_lipid_selection = sys.argv[6]
target_lipid_selection = sys.argv[7]
system = loos.createSystem(system_file)
# TODO: go back and support skip/stride later
traj = loos.pyloos.Trajectory(traj_file, system)
protein = loos.selectAtoms(system, protein_selection)
all_lipids = loos.selectAtoms(system, all_lipid_selection)
# NOTE: target_lipids must be a subset of all_lipids
target_lipids = loos.selectAtoms(all_lipids, target_lipid_selection)
slicer = ZSliceSelector(zmin, zmax)
# TODO: this should probably be a command line option
# Note: normally, this small a padding might be a problem for Voronoi
# decomposition with 1 atom/lipid. However, we're not using the areas
# (which is what gets screwed up by lack of padding), and 15 ought
# to be big enough to make sure we've got 1 layer of lipid around
# the protein.
padding = 15.
protein_centroid = loos.AtomicGroup()
"--directory",
help="Directory to create output files",
default=".")
parser.add_argument(
"-t",
"--threshold",
default=7,
type=int,
help="Number of atoms inside for the chain to be considered inside")
args = parser.parse_args()
system = loos.createSystem(args.system_file)
traj = loos.createTrajectory(args.traj_file, system)
protein = loos.selectAtoms(system, args.protein_string)
output_directory = args.directory
if not os.path.exists(output_directory):
try:
os.mkdir(output_directory)
except OSError as inst:
print 'Error creating output directory %s : ' % output_directory
print inst
sys.exit(1)
if not os.access(output_directory, os.W_OK):
print "Error: no permission to write to output directory ", output_directory
sys.exit(1)
helices = []
helix_centroids = loos.AtomicGroup()
print " individual selections, assuming each individual vector "
print " points in the +z direction"
sys.exit()
#print len(sys.argv)
print "#", " ".join(sys.argv)
system_filename = sys.argv[1]
traj_filename = sys.argv[2]
selections = sys.argv[3:]
system = loos.createSystem(system_filename)
traj = loos.pyloos.Trajectory(traj_filename, system)
helices = []
for s in selections:
helices.append(loos.selectAtoms(system, s))
print "#Frame\tAngle\tCosine"
for frame in traj:
vec = loos.GCoord(0., 0., 0.)
for h in helices:
pca = h.principalAxes()
v = pca[0]
if v.z() < 0:
v *= -1.
vec += v
cosine = vec.z() / vec.length()
system_file = sys.argv[1]
traj_file = sys.argv[2]
centering_selection_string = sys.argv[3]
target_selection_string = sys.argv[4]
zmin = float(sys.argv[5])
zmax = float(sys.argv[6])
znum_bins = int(sys.argv[7])
rmin = float(sys.argv[8])
rmax = float(sys.argv[9])
rnum_bins = int(sys.argv[10])
system = loos.createSystem(system_file)
traj = loos.pyloos.Trajectory(traj_file, system)
centering = loos.selectAtoms(system, centering_selection_string)
target = loos.selectAtoms(system, target_selection_string)
zbin_width = (zmax - zmin) / znum_bins
rbin_width = (rmax - rmin) / rnum_bins
rmin2 = rmin*rmin
rmax2 = rmax*rmax
hist = numpy.zeros( [rnum_bins, znum_bins])
for frame in traj:
centroid = centering.centroid()
target.translate(-centroid)
sys.stderr.write(" Unable to change permissions on directory\n")
os.exit(-1)
# We need a model containing just the protein and lipid, so we'll
# make a psfgen script, run it, use the psf to make the AtomicGroup,
temporary_psfname = os.path.join(config.directory, config.psfname)
psfgen_script = config.generate_psf(True, False, True, True, temporary_psfname)
psfgen = PSFGen.PSFGen(psfgen_script, config.psfgen_binary)
psfgen.run()
system = loos.createSystem(temporary_psfname)
segments = []
for segment in config.segments:
s = loos.selectAtoms(system, 'segname == "' + segment.segname + '"')
if (len(s) == 0):
sys.stderr.write("Selection failed assembling system: segment %s doesn't exist\n" %
(segment.segname)
)
sys.stderr.write("Exiting...\n")
sys.exit(0)
segments.append(s)
# copy the protein coordinates into the system
if config.protein is not None:
for s in config.protein.segments:
current_seg = s[0].segid()
# Don't need to trap failed selection here, because we
# If the "protein" is actually a bunch of independent molecules (e.g. a bunch of peptides),
# we'll want to scale them in x & y to match the expanded box.
if config.protein is not None and config.protein.scale:
protein_molecules = config.protein.model.splitByMolecule()
for m in protein_molecules:
centroid = m.centroid()
scaled = box_scaling * centroid
diff = scaled - centroid
diff.z(0.0) # we only want to translate in the xy plane
m.translate(diff)
molecules = system.splitByMolecule()
segments = []
for segment in config.segments:
s = loos.selectAtoms(system, 'segname == "' + segment.segname + '"')
if (len(s) == 0):
sys.stderr.write(
"Selection failed assembling system: segment %s doesn't exist\n"
% (segment.segname))
sys.stderr.write("Exiting...\n")
sys.exit(0)
segments.append(s)
x_axis = loos.GCoord(1, 0, 0)
z_axis = loos.GCoord(0, 0, 1)
for j in range(len(segments)):
seg_ag = segments[j]
seg_ag_arr = seg_ag.splitByMolecule()
prev_side = side
# test the closing line segment
side = test_side(p, self.coords(self.vertices[-1]),
self.coords(self.vertices[0]))
match = (((side >= 0) and (prev_side >= 0)) or
((side <= 0) and (prev_side <= 0)))
return match
if __name__ == '__main__':
ag = loos.createSystem("rhod_only.pdb")
slicer = ZSliceSelector(-3.0, 3.0)
ag = loos.selectAtoms(ag, 'name == "CA"')
ag_slice = slicer(ag)
hull = ConvexHull(ag_slice)
hull.generate_hull()
hull.generate_vertices()
i = 0
for v in hull.vertices:
c = hull.coords(v)
print(i, v, c.x(), c.y(), c.z())
i += 1
print(hull.is_inside(loos.GCoord(0.0, 0.0, 0.0)))
print(hull.is_inside(loos.GCoord(20.0, 0.0, 0.0)))
print(hull.is_inside(loos.GCoord(0.0, 20.0, 0.0)))
parser.add_argument('-m', '--model', help='filename of Structure to use')
parser.add_argument('-c', '--coords', help='filename of reference coordinates, if they are not contained in supplied model', default='')
parser.add_argument('-x', '--traj', help='Filename of trajectory or trajectories', nargs='+')
parser.add_argument('-k', '--skip', help='Skip this amount from the start of the trajectory', type=int, default=0)
parser.add_argument('-i', '--stride', help='Step through the trajectory by this many frames', type=int, default=1)
parser.add_argument('-s', '--selection', help='Use this selection for computing the native hbonds', default='all')
parser.add_argument('-n', '--nativeHBs', help='a filename to write PDB with just the native HBs used', type=str, default='')
parser.add_argument('-b', '--bondlength', help='maximum length for HB.', type=float, default = 3.0)
parser.add_argument('-o', '--outfile', help='file to write timeseries to.', type=str, default='')
parser.add_argument('-a', '--angle', help='maximum valid D-H-A angle.', type=float, default = 30.0)
args = parser.parse_args()
# define the model, subset to selection at this point
if args.coords:
model = loos.selectAtoms(loos.loadStructureWithCoords(args.model, args.coords), args.selection)
else:
model = loos.selectAtoms(loos.createSystem(args.model), args.selection)
# add connectivity, anything within 1.65 A (loos default) is assumed covalently bound
if model.hasCoords():
if not model.hasBonds():
model.findBonds()
else: # if model doesn't have any coordinates, this analysis is nonsensical; exit with error.
print('Error: You must supply a model structure with coordinates.')
exit(-1)
# If the "protein" is actually a bunch of independent molecules (e.g. a bunch of peptides),
# we'll want to scale them in x & y to match the expanded box.
if config.protein is not None and config.protein.scale:
protein_molecules = config.protein.model.splitByMolecule()
for m in protein_molecules:
centroid = m.centroid()
scaled = box_scaling*centroid
diff = scaled - centroid
diff.z(0.0) # we only want to translate in the xy plane
m.translate(diff)
molecules = system.splitByMolecule()
segments = []
for segment in config.segments:
s = loos.selectAtoms(system, 'segname == "' + segment.segname + '"')
if (len(s) == 0):
sys.stderr.write("Selection failed assembling system: segment %s doesn't exist\n" %
(segment.segname)
)
sys.stderr.write("Exiting...\n")
sys.exit(0)
segments.append(s)
x_axis = loos.GCoord(1,0,0)
z_axis = loos.GCoord(0,0,1)
for j in range(len(segments)):
seg_ag = segments[j]
seg_ag_arr = seg_ag.splitByMolecule()
side = test_side(p, self.coords(self.vertices[-1]),
self.coords(self.vertices[0]))
match = ( ((side >= 0) and (prev_side >=0) ) or
((side <= 0) and (prev_side <=0) ) )
return match
if __name__ == '__main__':
from numpy import random
ag = loos.createSystem("rhod_only.pdb")
slicer = ZSliceSelector(-3.0,3.0)
ag = loos.selectAtoms(ag, 'name == "CA"')
ag_slice = slicer(ag)
hull = ConvexHull(ag_slice)
hull.generate_hull()
#print hull.hull.simplices
#print hull.hull.neighbors
hull.generate_vertices()
#print hull.vertices
#print hull.num_atoms()
i = 0
for v in hull.vertices:
c = hull.coords(v)
print i, v, c.x(), c.y(), c.z()
i += 1
selection_strings = sys.argv[7:] # first selection gives the all atoms to use
# in area calculations, all others tell you
# how to group the areas
print "# ", " ".join(sys.argv)
system = loos.createSystem(system_filename)
traj = loos.createTrajectory(traj_filename, system)
traj.readFrame(skip)
traj.updateGroupCoords(system)
slicer = ZSliceSelector(zmin, zmax)
selections = []
selections.append(loos.selectAtoms(system, selection_strings[0]))
for s in selection_strings[1:]:
selections.append(loos.selectAtoms(selections[0], s))
frame = skip
string = ""
for i in range(len(selections)):
string += "\tArea" + str(i)
print "# Frame", string
while (traj.readFrame()):
traj.updateGroupCoords(system)
system.reimageByAtom()
slice_atoms = slicer(selections[0])
print("#", " ".join(sys.argv))
system_file = sys.argv[1]
traj_file = sys.argv[2]
zmin = float(sys.argv[3])
zmax = float(sys.argv[4])
protein_selection = sys.argv[5]
all_lipid_selection = sys.argv[6]
target_lipid_selection = sys.argv[7]
system = loos.createSystem(system_file)
# TODO: go back and support skip/stride later
traj = loos.pyloos.Trajectory(traj_file, system)
protein = loos.selectAtoms(system, protein_selection)
all_lipids = loos.selectAtoms(system, all_lipid_selection)
# NOTE: target_lipids must be a subset of all_lipids
target_lipids = loos.selectAtoms(all_lipids, target_lipid_selection)
slicer = ZSliceSelector(zmin, zmax)
# TODO: this should probably be a command line option
# Note: normally, this small a padding might be a problem for Voronoi
# decomposition with 1 atom/lipid. However, we're not using the areas
# (which is what gets screwed up by lack of padding), and 15 ought
# to be big enough to make sure we've got 1 layer of lipid around
# the protein.
padding = 15.
protein_centroid = loos.AtomicGroup()
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import loos
import sys
if len(sys.argv) == 1 or sys.argv[1] == '-h':
print 'Usage- renum-by-mol.py model [selection]'
sys.exit(0)
model = loos.createSystem(sys.argv[1])
if len(sys.argv) > 2:
model = loos.selectAtoms(model, sys.argv[2])
model.pruneBonds()
if model.hasBonds():
molecules = model.splitByMolecule()
else:
molecules = model.splitByUniqSegid()
for molecule in molecules:
residues = molecule.splitByResidue()
resid = 1
for residue in residues:
for atom in residue:
atom.resid(resid)
resid += 1
for r in self.regions:
r.print_indices()
print
if __name__ == '__main__':
import sys
structure = loos.createSystem("trj_1.pdb")
#structure = loos.createSystem("example.pdb")
#structure = loos.createSystem("b2ar.pdb")
#box = loos.GCoord(55., 77, 100)
#box = loos.GCoord(55., 77, 100)
phos = loos.selectAtoms(structure, 'name == "P"')
upper = loos.AtomicGroup()
for p in phos:
if p.coords().z() > 0:
upper.append(p)
upper.periodicBox(structure.periodicBox())
print upper.isPeriodic()
"""
slice = loos.AtomicGroup()
for a in structure:
if a.coords().z() > 20 and a.coords().z() < 21:
slice.append(a)
slice.periodicBox(box)
"""
print " points in the +z direction"
sys.exit()
#print len(sys.argv)
print "#", " ".join(sys.argv)
system_filename = sys.argv[1]
traj_filename = sys.argv[2]
selections = sys.argv[3:]
system = loos.createSystem(system_filename)
traj = loos.pyloos.Trajectory(traj_filename, system)
helices = []
for s in selections:
helices.append(loos.selectAtoms(system, s))
print "#Frame\tAngle\tCosine"
for frame in traj:
vec = loos.GCoord(0.,0.,0.)
for h in helices:
pca = h.principalAxes()
v = pca[0]
if v.z() < 0:
v *= -1.
vec += v
