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 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()
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 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