def _create_dodecane_acrylate_topology(self): if self._topology is None: topology = Topology() if self.box_vectors is not None: topology.setPeriodicBoxVectors(self.box_vectors) for chain_option in self.chains: id_to_sequence = chain_option.add_chain_to_topology(topology) self.id_to_sequence.update(id_to_sequence) for branched_chain_option in self.branched_chains: branched_chain_option.add_chain_to_topology(topology) for _ in range(self.numDodecane): dodecane_id = self._add_dodecane_to_topology(topology) self.id_to_sequence[dodecane_id] = "C12" for _ in range(self.numSqualane): squalane_id = self._add_squalane_to_topology(topology) self.id_to_sequence[squalane_id] = "squalane" self._topology = topology
def __init__(self, file, periodicBoxVectors=None, unitCellDimensions=None, includeDir=None, defines=None): """Load a top file. Parameters ---------- file : str the name of the file to load periodicBoxVectors : tuple of Vec3=None the vectors defining the periodic box unitCellDimensions : Vec3=None the dimensions of the crystallographic unit cell. For non-rectangular unit cells, specify periodicBoxVectors instead. includeDir : string=None A directory in which to look for other files included from the top file. If not specified, we will attempt to locate a gromacs installation on your system. When gromacs is installed in /usr/local, this will resolve to /usr/local/gromacs/share/gromacs/top defines : dict={} preprocessor definitions that should be predefined when parsing the file """ if includeDir is None: includeDir = _defaultGromacsIncludeDir() self._includeDirs = (os.path.dirname(file), includeDir) # Most of the gromacs water itp files for different forcefields, # unless the preprocessor #define FLEXIBLE is given, don't define # bonds between the water hydrogen and oxygens, but only give the # constraint distances and exclusions. self._defines = OrderedDict() self._defines['FLEXIBLE'] = True self._genpairs = True if defines is not None: for define, value in defines.iteritems(): self._defines[define] = value # Parse the file. self._currentCategory = None self._ifStack = [] self._elseStack = [] self._moleculeTypes = {} self._molecules = [] self._currentMoleculeType = None self._atomTypes = {} self._bondTypes= {} self._angleTypes = {} self._dihedralTypes = {} self._implicitTypes = {} self._pairTypes = {} self._cmapTypes = {} self._processFile(file) # Create the Topology from it. top = Topology() ## The Topology read from the prmtop file self.topology = top if periodicBoxVectors is not None: if unitCellDimensions is not None: raise ValueError("specify either periodicBoxVectors or unitCellDimensions, but not both") top.setPeriodicBoxVectors(periodicBoxVectors) else: top.setUnitCellDimensions(unitCellDimensions) PDBFile._loadNameReplacementTables() for moleculeName, moleculeCount in self._molecules: if moleculeName not in self._moleculeTypes: raise ValueError("Unknown molecule type: "+moleculeName) moleculeType = self._moleculeTypes[moleculeName] if moleculeCount > 0 and moleculeType.has_virtual_sites: raise ValueError('Virtual sites not yet supported by Gromacs parsers') # Create the specified number of molecules of this type. for i in range(moleculeCount): atoms = [] lastResidue = None c = top.addChain() for index, fields in enumerate(moleculeType.atoms): resNumber = fields[2] if resNumber != lastResidue: lastResidue = resNumber resName = fields[3] if resName in PDBFile._residueNameReplacements: resName = PDBFile._residueNameReplacements[resName] r = top.addResidue(resName, c) if resName in PDBFile._atomNameReplacements: atomReplacements = PDBFile._atomNameReplacements[resName] else: atomReplacements = {} atomName = fields[4] if atomName in atomReplacements: atomName = atomReplacements[atomName] # Try to guess the element. upper = atomName.upper() if upper.startswith('CL'): element = elem.chlorine elif upper.startswith('NA'): element = elem.sodium elif upper.startswith('MG'): element = elem.magnesium else: try: element = elem.get_by_symbol(atomName[0]) except KeyError: element = None atoms.append(top.addAtom(atomName, element, r)) # Add bonds to the topology for fields in moleculeType.bonds: top.addBond(atoms[int(fields[0])-1], atoms[int(fields[1])-1])
def __init__(self, file): """Load a prmtop file.""" top = Topology() ## The Topology read from the prmtop file self.topology = top self.elements = [] # Load the prmtop file prmtop = amber_file_parser.PrmtopLoader(file) self._prmtop = prmtop # Add atoms to the topology PDBFile._loadNameReplacementTables() lastResidue = None c = top.addChain() for index in range(prmtop.getNumAtoms()): resNumber = prmtop.getResidueNumber(index) if resNumber != lastResidue: lastResidue = resNumber resName = prmtop.getResidueLabel(iAtom=index).strip() if resName in PDBFile._residueNameReplacements: resName = PDBFile._residueNameReplacements[resName] r = top.addResidue(resName, c) if resName in PDBFile._atomNameReplacements: atomReplacements = PDBFile._atomNameReplacements[resName] else: atomReplacements = {} atomName = prmtop.getAtomName(index).strip() if atomName in atomReplacements: atomName = atomReplacements[atomName] # Get the element from the prmtop file if available if prmtop.has_atomic_number: try: element = elem.Element.getByAtomicNumber(int(prmtop._raw_data['ATOMIC_NUMBER'][index])) except KeyError: element = None else: # Try to guess the element from the atom name. upper = atomName.upper() if upper.startswith('CL'): element = elem.chlorine elif upper.startswith('NA'): element = elem.sodium elif upper.startswith('MG'): element = elem.magnesium elif upper.startswith('ZN'): element = elem.zinc else: try: element = elem.get_by_symbol(atomName[0]) except KeyError: element = None top.addAtom(atomName, element, r) self.elements.append(element) # Add bonds to the topology atoms = list(top.atoms()) for bond in prmtop.getBondsWithH(): top.addBond(atoms[bond[0]], atoms[bond[1]]) for bond in prmtop.getBondsNoH(): top.addBond(atoms[bond[0]], atoms[bond[1]]) # Set the periodic box size. if prmtop.getIfBox(): box = prmtop.getBoxBetaAndDimensions() top.setPeriodicBoxVectors(computePeriodicBoxVectors(*(box[1:4] + box[0:1]*3)))
def remove_molecules(self, simulation_old, system_options, ensemble_options): topology_old = simulation_old.topology system_old = simulation_old.system state = simulation_old.context.getState(getPositions=True, getVelocities=True) positions_old = state.getPositions(asNumpy=True) velocities_old = state.getVelocities(asNumpy=True) periodic_box_vectors = state.getPeriodicBoxVectors(asNumpy=True) # randomly determine which molecules are removed removed_molecules = random.sample(range(topology_old.getNumChains()), self.numVoid) # create new topology and dictionary mapping old atom indices to new atom indices removed_atoms = [] topology_new = Topology() old_to_new = {} atom_index_new = 0 for chain_index, chain_old in enumerate(topology_old.chains()): if chain_index not in removed_molecules: chain_id = chain_old.id.split('-', 1)[-1] chain_new = topology_new.addChain(id="{}-{}".format(topology_new.getNumChains()+1, chain_id)) for residue_old in chain_old.residues(): residue_new = topology_new.addResidue(residue_old.name, chain_new) for atom_old in residue_old.atoms(): topology_new.addAtom(atom_old.name, atom_old.element, residue_new) old_to_new[atom_old.index] = atom_index_new atom_index_new += 1 else: for atom_old in chain_old.atoms(): removed_atoms.append(atom_old.index) # add bonds to new topology atoms_new = list(topology_new.atoms()) for bond_old in topology_old.bonds(): atom1_index_old = bond_old[0].index atom2_index_old = bond_old[1].index try: atom1_new = atoms_new[old_to_new[atom1_index_old]] atom2_new = atoms_new[old_to_new[atom2_index_old]] topology_new.addBond(atom1_new, atom2_new) except KeyError: pass # set box vectors for topology topology_new.setPeriodicBoxVectors(periodic_box_vectors) # create system system_new = system_options.create_system_with_new_topology(topology_new) # check if old system had barostat and add to new system if applicable if self._has_barostat(system_old): barostat_old = self._get_barostat(system_old) defaultPressure = barostat_old.getDefaultPressure() defaultTemperature = barostat_old.getDefaultTemperature() frequency = barostat_old.getFrequency() if isinstance(barostat_old, MonteCarloAnisotropicBarostat): scaleX = barostat_old.getScaleX() scaleY = barostat_old.getScaleY() scaleZ = barostat_old.getScaleZ() barostat_new = MonteCarloAnisotropicBarostat(defaultPressure, defaultTemperature, scaleX, scaleY, scaleZ, frequency) else: barostat_new = MonteCarloBarostat(defaultPressure, defaultTemperature, frequency) system_new.addForce(barostat_new) barostat_new.setForceGroup(system_new.getNumForces() - 1) # create integrator integrator = ensemble_options.create_integrator() # create new positions and velocities arrays positions_new = np.delete(positions_old, removed_atoms, axis=0) velocities_new = np.delete(velocities_old, removed_atoms, axis=0) # create new simulation simulation_new = Simulation(topology_new, system_new, integrator) simulation_new.context.setPositions(positions_new) simulation_new.context.setVelocities(velocities_new) simulation_new.context.setPeriodicBoxVectors(*periodic_box_vectors) # move reporters from old simulation to new simulation while simulation_old.reporters: simulation_new.reporters.append(simulation_old.reporters.pop(0)) # create pdb file if specified if self.file is not None: PDBFile.writeFile(topology_new, positions_new, open(self.file, 'w')) return simulation_new
def __init__(self, file): """Load a prmtop file.""" top = Topology() ## The Topology read from the prmtop file self.topology = top self.elements = [] # Load the prmtop file prmtop = amber_file_parser.PrmtopLoader(file) self._prmtop = prmtop # Add atoms to the topology PDBFile._loadNameReplacementTables() lastResidue = None c = top.addChain() for index in range(prmtop.getNumAtoms()): resNumber = prmtop.getResidueNumber(index) if resNumber != lastResidue: lastResidue = resNumber resName = prmtop.getResidueLabel(iAtom=index).strip() if resName in PDBFile._residueNameReplacements: resName = PDBFile._residueNameReplacements[resName] r = top.addResidue(resName, c) if resName in PDBFile._atomNameReplacements: atomReplacements = PDBFile._atomNameReplacements[resName] else: atomReplacements = {} atomName = prmtop.getAtomName(index).strip() if atomName in atomReplacements: atomName = atomReplacements[atomName] # Get the element from the prmtop file if available if prmtop.has_atomic_number: try: element = elem.Element.getByAtomicNumber( int(prmtop._raw_data['ATOMIC_NUMBER'][index])) except KeyError: element = None else: # Try to guess the element from the atom name. upper = atomName.upper() if upper.startswith('CL'): element = elem.chlorine elif upper.startswith('NA'): element = elem.sodium elif upper.startswith('MG'): element = elem.magnesium elif upper.startswith('ZN'): element = elem.zinc else: try: element = elem.get_by_symbol(atomName[0]) except KeyError: element = None top.addAtom(atomName, element, r) self.elements.append(element) # Add bonds to the topology atoms = list(top.atoms()) for bond in prmtop.getBondsWithH(): top.addBond(atoms[bond[0]], atoms[bond[1]]) for bond in prmtop.getBondsNoH(): top.addBond(atoms[bond[0]], atoms[bond[1]]) # Set the periodic box size. if prmtop.getIfBox(): box = prmtop.getBoxBetaAndDimensions() top.setPeriodicBoxVectors( computePeriodicBoxVectors(*(box[1:4] + box[0:1] * 3)))