def buildBox(self): """ Use the template structure to build the full structure by replicating it each dimension until it's bigger than the target box size, then deleting waters with centroid that fall outside the target box. The resulting AtomicGroup is self.full_system """ # figure out how many replicas we need in each direction num_x = int(self.box.x() / self.template_box.x()) + 1 num_y = int(self.box.y() / self.template_box.y()) + 1 num_z = int(self.box.z() / self.template_box.z()) + 1 # build up the new system by replicating the target box # and systematically translating it self.full_system = loos.AtomicGroup() for x in range(num_x): for y in range(num_y): for z in range(num_z): new = self.template.copy() trans = loos.GCoord() trans.x(self.template_box.x() * x) trans.y(self.template_box.y() * y) trans.z(self.template_box.z() * z) new.translate(trans) self.full_system.append(new) self.full_system.centerAtOrigin() # trim the waters outside the target box size residues = self.full_system.splitByResidue() print len(residues), len(self.full_system) half_box = 0.5 * self.box to_remove = loos.AtomicGroup() for res in residues: centroid = res.centroid() print centroid, half_box if ((abs(centroid.x()) > half_box.x()) or (abs(centroid.y()) > half_box.y()) or (abs(centroid.z()) > half_box.z())): to_remove.append(res) print "Need to remove: ", len(to_remove) print "before: ", self.full_system.boundingBox(), len(self.full_system) self.full_system.remove(to_remove) print "after: ", self.full_system.boundingBox(), len(self.full_system) self.full_system.periodicBox(self.box) # renumber atom ids and resids self.full_system.renumber() for i in range(len(self.full_system)): self.full_system[i].resid(i / 3 + 1)
def __call__(self, atomicgroup): ag = loos.AtomicGroup() ag.periodicBox(atomicgroup.periodicBox()) for a in atomicgroup: if self.min_z < a.coords().z() < self.max_z: ag.append(a) return ag
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() protein_centroid.append(loos.Atom()) # set up space to hold the neigbor time series neighbor_timeseries = numpy.zeros( [len(target_lipids), len(traj)], numpy.float) for frame in traj: # Use the centroid of the protein slice to represent the protein protein_slice = slicer(protein) centroid = protein_slice.centroid() protein_centroid[0].coords(centroid) # We assume you're using 1 atom/lipid. # Applying slice operation here allows you to be sloppy # with your selections.
# make hb detector object model_hbs = loos.HBondDetector(args.bondlength, args.angle, model) # select all nitrogens and oxygens in the model as putative donors/acceptors putative = loos.selectAtoms(model, 'name =~ "^N" || name =~ "^O"') # select all hydrogens to test which are DA pairs hydrogens = loos.selectAtoms(model, 'name =~ "^H"') # initialize donor and acceptor groups for appending donors = [] acceptors = loos.AtomicGroup() # build list of donor and acceptor groups from putative groups. for i in putative: bound_to_hydrogen = False for h in hydrogens: if i.isBoundTo(h): donors.append((h,i)) # Associate donor with its hydrogen bound_to_hydrogen = True if not bound_to_hydrogen: acceptors.append(i) # list of donor-H-acceptor triples present in reference crds ref_dhas = [] # fill out the donor-H-acceptor list
raise ValueError, "Too few waters after superposition: %d %d" % ( len(water.full_system) / 3, total_water_and_salt) sys.stderr.write("Finished bump-checking water against lipid\n") sys.stderr.write("Current # water molecules: %d\n" % (len(water.full_system) / 3)) sys.stderr.write("Adding salt\n") # regenerate the list of oxygens water_oxygens = loos.selectAtoms(water.full_system, 'name =~ "^O"') water_residues = water.full_system.splitByResidue() # now replace waters with salt salts = [] for salt in config.salt: ions = loos.AtomicGroup() for i in range(salt.numres): a = loos.Atom() a.resname(salt.resname) a.segid(salt.segname) a.name(salt.atomname) a.resid(i + 1) # pick a water oxygen at random, replace it with salt ox = random.choice(water_oxygens) a.coords(ox.coords()) ions.append(a) # remove this water for w in water_residues: if ox in w:
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) #v = VoronoiWrapper(slice)
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() for h in args.helix_ranges: first, last = h.split(":") helix_string = '(resid >= ' + first + ') ' + '&& (resid <= ' + last + ')' helix = loos.selectAtoms(protein, helix_string) helices.append(helix) helix_centroids.append(loos.Atom()) target = loos.selectAtoms(system, args.target_string) target = loos.selectAtoms(target, "!hydrogen") chains = target.splitByResidue() if (args.zmin > args.zmax): tmp = args.zmax args.zmax = args.zmin
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: current_seg = s[0].segid() # Don't need to trap failed selection here, because we # already know this segment exists seg = loos.selectAtoms(system, 'segname == "' + current_seg + '"') seg.copyMappedCoordinatesFrom(s) to_rot.append(seg) # if we asked for rotation, rotate all segments together # about a random axis if config.protrot: axis = loos.GCoord() axis.random() rot = random.uniform(0., 360.)
box = loos.GCoord(args.box_size, args.box_size, args.box_size) half_box = 0.5 * args.box_size half_z = half_box if args.zbox: box.z(args.zbox) half_z = 0.5 * args.zbox if args.z_exclude: args.z_exclude = abs(args.z_exclude) if args.protein: protein = loos.createSystem(args.protein) else: protein = loos.AtomicGroup() protein.periodicBox(box) library = LipidLibrary.LipidLibrary(args.library_location) if not args.no_center: protein.centerAtOrigin() accepts = 0 trials = 0 while accepts < args.num_ligands: trials += 1 new_molecule = library.pick_structure() new_molecule.centerAtOrigin()
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") new_group.append(a) new_group.append(b) new_group.append(c)
parser.add_argument('--selection', nargs=2, 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: