def add_interactions(self, state: interfaces.IState, system: mm.System, topology: app.Topology) -> mm.System: if self.active: if self.use_pbc: cartesian_force = mm.CustomExternalForce( "0.5 * cart_force_const * r_eff^2;" "r_eff = max(0.0, r - cart_delta);" "r = periodicdistance(x, y, z, cart_x, cart_y, cart_z)") else: cartesian_force = mm.CustomExternalForce( "0.5 * cart_force_const * r_eff^2;" "r_eff = max(0.0, r - cart_delta);" "r = sqrt(dx*dx + dy*dy + dz*dz);" "dx = x - cart_x;" "dy = y - cart_y;" "dz = z - cart_z;") cartesian_force.addPerParticleParameter("cart_x") cartesian_force.addPerParticleParameter("cart_y") cartesian_force.addPerParticleParameter("cart_z") cartesian_force.addPerParticleParameter("cart_delta") cartesian_force.addPerParticleParameter("cart_force_const") # add the atoms for r in self.restraints: weight = r.force_const cartesian_force.addParticle(r.atom_index, [r.x, r.y, r.z, r.delta, weight]) system.addForce(cartesian_force) self.force = cartesian_force return system
def add_harmonic_restraints(system: mm.System, args: ListOfArgs): """Restraints format is different here than in SM webservice. Example record: :10 :151\n or :10 :151 0.1 30000\n :i :j distance energy """ print(" Adding harmonic restraints") if args.HR_USE_FLAT_BOTTOM_FORCE: contact_force = mm.CustomBondForce('step(r-r0) * (k/2) * (r-r0)^2') contact_force.addPerBondParameter('r0') contact_force.addPerBondParameter('k') else: contact_force = mm.HarmonicBondForce() system.addForce(contact_force) with open(args.HR_RESTRAINTS_PATH) as input_file: counter = 0 for line in input_file: columns = line.split() atom_index_i = int(columns[0][1:]) - 1 atom_index_j = int(columns[1][1:]) - 1 try: r0 = float(columns[2]) k = float(columns[3]) * args.HR_K_SCALE except IndexError: r0 = args.HR_R0_PARAM k = args.HR_K_PARAM if args.HR_USE_FLAT_BOTTOM_FORCE: contact_force.addBond(atom_index_i, atom_index_j, [r0, k]) else: contact_force.addBond(atom_index_i, atom_index_j, r0, k) counter += 1 print(f" {counter} restraints added.")
def _get_charges_from_openmm_system(omm_sys: openmm.System): for force in omm_sys.getForces(): if type(force) == openmm.NonbondedForce: break for idx in range(omm_sys.getNumParticles()): param = force.getParticleParameters(idx) yield param[0].value_in_unit(simtk_unit.elementary_charge)
def setup_system_non_bonded(self, system: mm.System, cutoff: Quantity): if self.non_bonded_function_type != NB_FUNCTION_LENNARD_JONES: # TODO: Implement Buckingham potential raise NotImplementedError( f'Non bonded function {self.non_bonded_function_type} ' 'is not implemented.') if self.combination_rule in '1': potential = potentials.create_c6c12(cutoff=cutoff) elif self.combination_rule in '2': potential = potentials.create_epsilon_sigma(cutoff=cutoff) else: # TODO: implement combination rule 3 raise NotImplementedError( f'Combination rule {self.combination_rule} is not implemented.' ) for molecule_name, number_of_molecule_copies in self.molecules: molecule = self.molecule_types[molecule_name] for _ in range(number_of_molecule_copies): for atom in molecule.atoms.values(): ptype = self.atom_types[atom.type_] potential.addParticle([ptype.v, ptype.w]) system.addForce(potential) return potential
def add_interactions(self, state: interfaces.IState, openmm_system: mm.System, topology: app.Topology) -> mm.System: if not self._active: return openmm_system cmap_force = mm.CMAPTorsionForce() cmap_force.addMap(self._gly_map.shape[0], self._gly_map.flatten()) cmap_force.addMap(self._pro_map.shape[0], self._pro_map.flatten()) cmap_force.addMap(self._ala_map.shape[0], self._ala_map.flatten()) cmap_force.addMap(self._gen_map.shape[0], self._gen_map.flatten()) # loop over all of the contiguous chains of amino acids for chain in self._iterate_cmap_chains(): # loop over the interior residues n_res = len(chain) for i in range(1, n_res - 1): map_index = residue_to_map[chain[i].res_name] c_prev = chain[i - 1].index_C n = chain[i].index_N ca = chain[i].index_CA c = chain[i].index_C n_next = chain[i + 1].index_N cmap_force.addTorsion(map_index, c_prev, n, ca, c, n, ca, c, n_next) openmm_system.addForce(cmap_force) return openmm_system
def set_nonbonded_method( omm_sys: openmm.System, key: str, electrostatics: bool = True, ) -> openmm.System: if key == "cutoff": for force in omm_sys.getForces(): if type(force) == openmm.NonbondedForce: force.setNonbondedMethod(openmm.NonbondedForce.CutoffPeriodic) force.setCutoffDistance(0.9 * unit.nanometer) force.setReactionFieldDielectric(1.0) force.setUseDispersionCorrection(False) force.setUseSwitchingFunction(False) if not electrostatics: for i in range(force.getNumParticles()): params = force.getParticleParameters(i) force.setParticleParameters( i, 0, params[1], params[2], ) elif key == "PME": for force in omm_sys.getForces(): if type(force) == openmm.NonbondedForce: force.setNonbondedMethod(openmm.NonbondedForce.PME) force.setEwaldErrorTolerance(1e-6) return omm_sys
def add_reaction_coordinate( system: openmm.System, host_index: List[int], guest_index: List[int], k_z: simtk_unit.Quantity, z_0: simtk_unit.Quantity, force_group: Optional[int] = 11, ): """ Applies the umbrella reaction coordinate to the guest molecule """ # Simple umbrella potential string expression reaction = openmm.CustomCentroidBondForce( 2, "0.5 * k_z * (r_z - z_0)^2;" "r_z = z2 - z1;" ) reaction.setUsesPeriodicBoundaryConditions(False) reaction.setForceGroup(force_group) # Umbrella parameters reaction.addPerBondParameter("k_z", k_z) reaction.addPerBondParameter("z_0", z_0) # Add host and guest indices g1 = reaction.addGroup(host_index) g2 = reaction.addGroup(guest_index) # Add bond reaction.addBond([g1, g2], [k_z, z_0]) # Add force to system system.addForce(reaction)
def add_interactions( self, state: interfaces.IState, system: mm.System, topology: app.Topology ) -> mm.System: if self.active: # create the confinement force if self.use_pbc: confinement_force = mm.CustomExternalForce( "step(r - radius) * force_const * (radius - r)^2;" "r = periodicdistance(x, y, z, 0, 0 ,0)" ) else: confinement_force = mm.CustomExternalForce( "step(r - radius) * force_const * (radius - r)^2;" "r=sqrt(x*x + y*y + z*z)" ) confinement_force.addPerParticleParameter("radius") confinement_force.addPerParticleParameter("force_const") # add the atoms for r in self.restraints: weight = r.force_const confinement_force.addParticle(r.atom_index, [r.radius, weight]) system.addForce(confinement_force) self.force = confinement_force return system
def add_constraints(system: mm.System, args: ListOfArgs): print(" Adding constraints...") print(f" r = {args.POL_CONSTRAINT_DISTANCE}") counter = 0 for i in range(system.getNumParticles() - 1): system.addConstraint(i, i + 1, args.POL_CONSTRAINT_DISTANCE) counter += 1 print(f" {counter} constraints added.")
def add_interactions(self, state: interfaces.IState, system: mm.System, topology: app.Topology) -> mm.System: if self.active: meld_force = MeldForce() # Add all of the always-on restraints if self.always_on: group_list = [] for rest in self.always_on: rest_index = _add_meld_restraint(self.tracker, rest, meld_force, 0, 0) # Each restraint goes in its own group. group_index = meld_force.addGroup([rest_index], 1) group_list.append(group_index) # Add the group to the tracker, but as None, so # we won't update it. self.tracker.groups.append(None) # All of the always-on restraints go in a single collection meld_force.addCollection(group_list, len(group_list)) # Add this collection to the tracker, but as # None, so we won't update it self.tracker.collections.append(None) # Add the selectively active restraints for coll in self.selective_on: group_indices = [] for group in coll.groups: restraint_indices = [] for rest in group.restraints: rest_index = _add_meld_restraint( self.tracker, rest, meld_force, 0, 0) restraint_indices.append(rest_index) # Create the group in the meldplugin group_num_active = self._handle_num_active( group.num_active, state) group_index = meld_force.addGroup(restraint_indices, group_num_active) group_indices.append(group_index) # Add the group to the tracker so we can update it self.tracker.groups.append(group) # Create the collection in the meldplugin coll_num_active = self._handle_num_active( group.num_active, state) meld_force.addCollection(group_indices, coll_num_active) # Add the collection to the tracker so we can update it self.tracker.collections.append(coll) system.addForce(meld_force) self.force = meld_force return system
def _get_lj_params_from_openmm_system(omm_sys: openmm.System): for force in omm_sys.getForces(): if type(force) == openmm.NonbondedForce: break n_particles = omm_sys.getNumParticles() sigmas = np.asarray([*_get_sigma_from_nonbonded_force(n_particles, force)]) epsilons = np.asarray([*_get_epsilon_from_nonbonded_force(n_particles, force)]) return sigmas, epsilons
def _find_nb_force(self, system: mm.System) -> None: forces = [system.getForce(i) for i in range(system.getNumForces())] nb_forces = [f for f in forces if isinstance(f, mm.NonbondedForce)] if not nb_forces: raise RuntimeError("REST2 could not find NonbondedForce") if len(nb_forces) > 1: raise RuntimeError("REST2 found more than one NonbondedForce") self.nb_force = nb_forces[0]
def add_harmonic_angle(system: mm.System, args: ListOfArgs): print(" Adding harmonic angles...") print(f" r0 = {args.POL_HARMONIC_ANGLE_R0}") print(f" k = {args.POL_HARMONIC_ANGLE_K} kJ/mol/radian^2") bond_force = mm.HarmonicAngleForce() system.addForce(bond_force) counter = 0 for i in range(system.getNumParticles() - 2): bond_force.addAngle(i, i + 1, i + 2, args.POL_HARMONIC_ANGLE_R0, args.POL_HARMONIC_ANGLE_K) counter += 1 print(f" {counter} harmonic bonds added.")
def add_harmonic_bond(system: mm.System, args: ListOfArgs): print(" Adding harmonic bonds...") print(f" r0 = {args.POL_HARMONIC_BOND_R0}") print(f" k = {args.POL_HARMONIC_BOND_K} kJ/mol/nm^2") bond_force = mm.HarmonicBondForce() system.addForce(bond_force) counter = 0 for i in range(system.getNumParticles() - 1): bond_force.addBond(i, i + 1, args.POL_HARMONIC_BOND_R0, args.POL_HARMONIC_BOND_K) counter += 1 print(f" {counter} harmonic bonds added.")
def _find_dihedral_force(self, system: mm.System) -> None: forces = [system.getForce(i) for i in range(system.getNumForces())] dihed_forces = [ f for f in forces if isinstance(f, mm.PeriodicTorsionForce) ] if not dihed_forces: raise RuntimeError("REST2 could not find PeriodicTorsionForce") if len(dihed_forces) > 1: raise RuntimeError( "REST2 found more than one PeriodicTorsionForce") self.dihedral_force = dihed_forces[0]
def add_excluded_volume(system: mm.System, args: ListOfArgs): print(" Adding excluded volume...") print(f" epsilon = {args.EV_EPSILON}") print(f" sigma = {args.EV_SIGMA}") ev_force = mm.CustomNonbondedForce('epsilon*((sigma1+sigma2)/r)^12') ev_force.addGlobalParameter('epsilon', defaultValue=args.EV_EPSILON) ev_force.addPerParticleParameter('sigma') system.addForce(ev_force) counter = 0 for i in range(system.getNumParticles()): ev_force.addParticle([args.EV_SIGMA]) counter += 1 print(f" {counter} ev interactions added.")
def add_external_field(system: mm.System, args: ListOfArgs): """Add external forcefield for image-driven modelling purposes.""" print(' Adding external forcefield.') size = os.stat(args.EF_PATH).st_size print(f" Reading {args.EF_PATH} file ({sizeof_fmt(size)})...") img = np.load(args.EF_PATH) print(f" Array of shape {img.shape} loaded.") print(f" Number of values: {img.size}") print(f" Min: {np.min(img)}") print(f" Max: {np.max(img)}") if args.EF_NORMALIZE: print(' [INFO] Field will be normalized to [0, -1]') img = standardize_image(img) print(f' [INFO] IMG min = {np.min(img)}, max = {np.max(img)}') print(f' [INFO] Adding funnel like border to image') mask_p = (img < -0.1) mask_n = np.logical_not(mask_p) img = add_funnel(img, mask_n) print(" Creating a force based on density...") voxel_size = np.array((args.EF_VOXEL_SIZE_X, args.EF_VOXEL_SIZE_Y, args.EF_VOXEL_SIZE_Z)) real_size = img.shape * voxel_size density_fun_args = dict( xsize=img.shape[2], ysize=img.shape[1], zsize=img.shape[0], values=img.flatten().astype(np.float64), xmin=0 * simtk.unit.angstrom - 0.5 * voxel_size[0], ymin=0 * simtk.unit.angstrom - 0.5 * voxel_size[1], zmin=0 * simtk.unit.angstrom - 0.5 * voxel_size[2], xmax=(img.shape[0] - 1) * voxel_size[0] + 0.5 * voxel_size[0], ymax=(img.shape[1] - 1) * voxel_size[1] + 0.5 * voxel_size[1], zmax=(img.shape[2] - 1) * voxel_size[2] + 0.5 * voxel_size[2]) print(f' [INFO] Voxel size: ({args.EF_VOXEL_SIZE_X}, {args.EF_VOXEL_SIZE_Y}, {args.EF_VOXEL_SIZE_Z})') print(f' [INFO] Real size (Shape * voxel size): ({real_size[0]}, {real_size[1]}, {real_size[2]})') print( f" [INFO] begin coords: ({density_fun_args['xmin']}, {density_fun_args['ymin']}, {density_fun_args['zmin']})") print( f" [INFO] end coords: ({density_fun_args['xmax']}, {density_fun_args['ymax']}, {density_fun_args['zmax']})") center_x = (density_fun_args['xmax'] - density_fun_args['xmin']) / 2 + density_fun_args['xmin'] center_y = (density_fun_args['ymax'] - density_fun_args['ymin']) / 2 + density_fun_args['ymin'] center_z = (density_fun_args['zmax'] - density_fun_args['zmin']) / 2 + density_fun_args['zmin'] print(f" [INFO] Image central point: ({center_x}, {center_y}, {center_z}) ") field_function = mm.Continuous3DFunction(**density_fun_args) field_force = mm.CustomCompoundBondForce(1, 'ksi*fi(x1,y1,z1)') field_force.addTabulatedFunction('fi', field_function) field_force.addGlobalParameter('ksi', args.EF_SCALING_FACTOR) print(" Adding force to the system...") for i in range(system.getNumParticles()): field_force.addBond([i], []) system.addForce(field_force)
def add_spherical_container(system: mm.System, args: ListOfArgs): print(" Adding spherical container...") container_force = mm.CustomExternalForce( '{}*max(0, r-{})^2; r=sqrt((x-{})^2+(y-{})^2+(z-{})^2)'.format(args.SC_SCALE, args.SC_RADIUS, args.SC_CENTER_X, args.SC_CENTER_Y, args.SC_CENTER_Z, )) system.addForce(container_force) for i in range(system.getNumParticles()): container_force.addParticle(i, []) print(f" Spherical container added.") print(f" radius: {args.SC_RADIUS} nm") print(f" scale: {args.SC_SCALE} ") print(f" center: ({args.SC_CENTER_X}, {args.SC_CENTER_Y}, {args.SC_CENTER_Z})")
def _get_force(openmm_sys: openmm.System, force_type): forces = [f for f in openmm_sys.getForces() if type(f) == force_type] if len(forces) > 1: raise NotImplementedError( "Not yet able to process duplicate forces types") return forces[0]
def add_funnel_potential( system: openmm.System, host_index: List[int], guest_index: List[int], k_xy: Optional[simtk_unit.Quantity] = 10.0 * simtk_unit.kilocalorie_per_mole / simtk_unit.angstrom ** 2, z_cc: Optional[simtk_unit.Quantity] = 11.0 * simtk_unit.angstrom, alpha: Optional[simtk_unit.Quantity] = 35.0 * simtk_unit.degrees, R_cylinder: Optional[simtk_unit.Quantity] = 1.0 * simtk_unit.angstrom, force_group: Optional[int] = 10, ): """ Applies a funnel potential to a guest molecule """ # Funnel potential string expression funnel = openmm.CustomCentroidBondForce( 2, "U_funnel + U_cylinder;" "U_funnel = step(z_cc - abs(r_z))*step(r_xy - R_funnel)*Wall;" "U_cylinder = step(abs(r_z) - z_cc)*step(r_xy - R_cylinder)*Wall;" "Wall = 0.5 * k_xy * r_xy^2;" "R_funnel = (z_cc-abs(r_z))*tan(alpha) + R_cylinder;" "r_xy = sqrt((x2 - x1)^2 + (y2 - y1)^2);" "r_z = z2 - z1;", ) funnel.setUsesPeriodicBoundaryConditions(False) funnel.setForceGroup(force_group) # Funnel parameters funnel.addGlobalParameter("k_xy", k_xy) funnel.addGlobalParameter("z_cc", z_cc) funnel.addGlobalParameter("alpha", alpha) funnel.addGlobalParameter("R_cylinder", R_cylinder) # Add host and guest indices g1 = funnel.addGroup(host_index) g2 = funnel.addGroup(guest_index) # Add bond funnel.addBond([g1, g2], []) # Add force to system system.addForce(funnel)
def _add_restraints(system: openmm.System, reference_pdb: openmm_app.PDBFile, stiffness: unit.Unit, rset: str, exclude_residues: Sequence[int]): """Adds a harmonic potential that restrains the system to a structure.""" assert rset in ["non_hydrogen", "c_alpha"] force = openmm.CustomExternalForce( "0.5 * k * ((x-x0)^2 + (y-y0)^2 + (z-z0)^2)") force.addGlobalParameter("k", stiffness) for p in ["x0", "y0", "z0"]: force.addPerParticleParameter(p) for i, atom in enumerate(reference_pdb.topology.atoms()): if atom.residue.index in exclude_residues: continue if will_restrain(atom, rset): force.addParticle(i, reference_pdb.positions[i]) logger.info("Restraining %d / %d particles.", force.getNumParticles(), system.getNumParticles()) system.addForce(force)
def add_interactions(self, state: interfaces.IState, system: mm.System, topology: app.Topology) -> mm.System: if self.active: rest = self.restraints[0] # create the expression for the energy components = [] if "x" in rest.dims: components.append("(x1-abscom_x)*(x1-abscom_x)") if "y" in rest.dims: components.append("(y1-abscom_y)*(y1-abscom_y)") if "z" in rest.dims: components.append("(z1-abscom_z)*(z1-abscom_z)") dist_expr = "dist2={};".format(" + ".join(components)) energy_expr = "0.5 * com_k * dist2;" expr = "\n".join([energy_expr, dist_expr]) # create the force force = mm.CustomCentroidBondForce(1, expr) force.addPerBondParameter("com_k") force.addPerBondParameter("abscom_x") force.addPerBondParameter("abscom_y") force.addPerBondParameter("abscom_z") # create the restraint with parameters if rest.weights: g1 = force.addGroup(rest.indices, rest.weights) else: g1 = force.addGroup(rest.indices) force_const = rest.force_const pos_x = rest.position[0] pos_y = rest.position[1] pos_z = rest.position[2] force.addBond([g1], [force_const, pos_x, pos_y, pos_z]) system.addForce(force) self.force = force return system
def add_interactions(self, state: interfaces.IState, system: mm.System, topology: app.Topology) -> mm.System: if self.active: rest = self.restraints[0] # create the expression for the energy components = [] if "x" in rest.dims: components.append("(x1-x2)*(x1-x2)") if "y" in rest.dims: components.append("(y1-y2)*(y1-y2)") if "z" in rest.dims: components.append("(z1-z2)*(z1-z2)") dist_expr = "dist = sqrt({});".format(" + ".join(components)) energy_expr = "0.5 * com_k * (dist - com_ref_dist)*(dist-com_ref_dist);" expr = "\n".join([energy_expr, dist_expr]) # create the force force = mm.CustomCentroidBondForce(2, expr) force.addPerBondParameter("com_k") force.addPerBondParameter("com_ref_dist") # create the restraint with parameters if rest.weights1: g1 = force.addGroup(rest.indices1, rest.weights1) else: g1 = force.addGroup(rest.indices1) if rest.weights2: g2 = force.addGroup(rest.indices2, rest.weights2) else: g2 = force.addGroup(rest.indices2) force_const = rest.force_const pos = rest.positioner(0) force.addBond([g1, g2], [force_const, pos]) system.addForce(force) self.force = force return system
def zero_dihedral_contribution(openmm_system: openmm.System, dihedral_indices: Tuple[int, int]): """ Author Simon Boothroyd Link gist.github.com/SimonBoothroyd/667b50314c628aabe5064f0defb6ad8e Zeroes out the contributions of a particular dihedral to the total potential energy for a given OpenMM system object. Parameters ---------- openmm_system: The OpenMM system object which will be modified so the specified dihedral will not contribute to the total potential energy of the system. dihedral_indices: The indices of the two central atoms in the dihedral whose contributions should be zeroed. """ torsion_forces = [ force for force in openmm_system.getForces() if isinstance(force, openmm.PeriodicTorsionForce) ] for torsion_force in torsion_forces: for torsion_index in range(torsion_force.getNumTorsions()): ( index_i, index_j, index_k, index_l, periodicity, phase, k, ) = torsion_force.getTorsionParameters(torsion_index) if ( index_j not in [dihedral_indices[0], dihedral_indices[1]] or index_k not in [dihedral_indices[0], dihedral_indices[1]] ): continue torsion_force.setTorsionParameters( torsion_index, index_i, index_j, index_k, index_l, periodicity, phase, 0.0 )
def _get_openmm_energies( omm_sys: openmm.System, box_vectors, positions, round_positions=None, hard_cutoff=False, electrostatics: bool = True, ) -> EnergyReport: if hard_cutoff: omm_sys = set_nonbonded_method(omm_sys, "cutoff", electrostatics=electrostatics) else: omm_sys = set_nonbonded_method(omm_sys, "PME") force_names = {force.__class__.__name__ for force in omm_sys.getForces()} group_to_force = { i: force_name for i, force_name in enumerate(force_names) } force_to_group = { force_name: i for i, force_name in group_to_force.items() } for force in omm_sys.getForces(): force_name = force.__class__.__name__ force.setForceGroup(force_to_group[force_name]) integrator = openmm.VerletIntegrator(1.0 * unit.femtoseconds) context = openmm.Context(omm_sys, integrator) if not isinstance(box_vectors, unit.Quantity): box_vectors = box_vectors.magnitude * unit.nanometer context.setPeriodicBoxVectors(*box_vectors) if isinstance(positions, unit.Quantity): # Convert list of Vec3 into a NumPy array positions = np.asarray(positions.value_in_unit( unit.nanometer)) * unit.nanometer else: positions = positions.magnitude * unit.nanometer if round_positions is not None: rounded = np.round(positions, round_positions) context.setPositions(rounded) else: context.setPositions(positions) force_groups = { force.getForceGroup() for force in context.getSystem().getForces() } omm_energies = dict() for force_group in force_groups: state = context.getState(getEnergy=True, groups={force_group}) omm_energies[group_to_force[force_group]] = state.getPotentialEnergy() del state # Fill in missing keys if system does not have all typical forces for required_key in [ "HarmonicBondForce", "HarmonicAngleForce", "PeriodicTorsionForce", "NonbondedForce", ]: if required_key not in omm_energies: omm_energies[required_key] = 0.0 * kj_mol del context del integrator report = EnergyReport() report.energies.update({ "Bond": omm_energies["HarmonicBondForce"], "Angle": omm_energies["HarmonicAngleForce"], "Torsion": omm_energies["PeriodicTorsionForce"], "Nonbonded": omm_energies["NonbondedForce"], }) if "CustomNonbondedForce" in omm_energies: report.energies["Nonbonded"] += omm_energies["CustomNonbondedForce"] if "RBTorsionForce" in omm_energies: report.energies["Torsion"] += omm_energies["RBTorsionForce"] return report
def addHydrogens(self, forcefield=None, pH=None, variants=None, platform=None): """Add missing hydrogens to the model. This function automatically changes compatible residues into their constant-pH variant if no variant is specified.: Aspartic acid: AS4: Form with a 2 hydrogens on each one of the delta oxygens (syn,anti) It has 5 titration states. Alternative: AS2: Has 2 hydrogens (syn, anti) on one of the delta oxygens It has 3 titration states. Cysteine: CYS: Neutral form with a hydrogen on the sulfur CYX: No hydrogen on the sulfur (either negatively charged, or part of a disulfide bond) Glutamic acid: GL4: Form with a 2 hydrogens on each one of the epsilon oxygens (syn,anti) It has 5 titration states. Histidine: HIP: Positively charged form with hydrogens on both ND1 and NE2 It has 3 titration states. The variant to use for each residue is determined by the following rules: 1. Any Cysteine that participates in a disulfide bond uses the CYX variant regardless of pH. 2. Other residues are all set to maximally protonated state, which can be updated using a proton drive You can override these rules by explicitly specifying a variant for any residue. To do that, provide a list for the 'variants' parameter, and set the corresponding element to the name of the variant to use. A special case is when the model already contains a hydrogen that should not be present in the desired variant. If you explicitly specify a variant using the 'variants' parameter, the residue will be modified to match the desired variant, removing hydrogens if necessary. On the other hand, for residues whose variant is selected automatically, this function will only add hydrogens. It will never remove ones that are already present in the model. Definitions for standard amino acids and nucleotides are built in. You can call loadHydrogenDefinitions() to load additional definitions for other residue types. Parameters ---------- forcefield : ForceField=None the ForceField to use for determining the positions of hydrogens. If this is None, positions will be picked which are generally reasonable but not optimized for any particular ForceField. pH : None, Kept for compatibility reasons. Has no effect. variants : list=None an optional list of variants to use. If this is specified, its length must equal the number of residues in the model. variants[i] is the name of the variant to use for residue i (indexed starting at 0). If an element is None, the standard rules will be followed to select a variant for that residue. platform : Platform=None the Platform to use when computing the hydrogen atom positions. If this is None, the default Platform will be used. Returns ------- list a list of what variant was actually selected for each residue, in the same format as the variants parameter Notes ----- This function does not use a pH specification. The argument is kept for compatibility reasons. """ # Check the list of variants. if pH is not None: print("Ignored pH argument provided for constant-pH residues.") residues = list(self.topology.residues()) if variants is not None: if len(variants) != len(residues): raise ValueError( "The length of the variants list must equal the number of residues" ) else: variants = [None] * len(residues) actualVariants = [None] * len(residues) # Load the residue specifications. if not Modeller._hasLoadedStandardHydrogens: Modeller.loadHydrogenDefinitions( os.path.join( os.path.dirname(__file__), "data", "hydrogens-amber10-constph.xml" ) ) # Make a list of atoms bonded to each atom. bonded = {} for atom in self.topology.atoms(): bonded[atom] = [] for atom1, atom2 in self.topology.bonds(): bonded[atom1].append(atom2) bonded[atom2].append(atom1) # Define a function that decides whether a set of atoms form a hydrogen bond, using fairly tolerant criteria. def isHbond(d, h, a): if norm(d - a) > 0.35 * nanometer: return False deltaDH = h - d deltaHA = a - h deltaDH /= norm(deltaDH) deltaHA /= norm(deltaHA) return acos(dot(deltaDH, deltaHA)) < 50 * degree # Loop over residues. newTopology = Topology() newTopology.setPeriodicBoxVectors(self.topology.getPeriodicBoxVectors()) newAtoms = {} newPositions = [] * nanometer newIndices = [] acceptors = [ atom for atom in self.topology.atoms() if atom.element in (elem.oxygen, elem.nitrogen) ] for chain in self.topology.chains(): newChain = newTopology.addChain(chain.id) for residue in chain.residues(): newResidue = newTopology.addResidue(residue.name, newChain, residue.id) isNTerminal = residue == chain._residues[0] isCTerminal = residue == chain._residues[-1] if residue.name in Modeller._residueHydrogens: # Add hydrogens. First select which variant to use. spec = Modeller._residueHydrogens[residue.name] variant = variants[residue.index] if variant is None: if residue.name == "CYS": # If this is part of a disulfide, use CYX. sulfur = [ atom for atom in residue.atoms() if atom.element == elem.sulfur ] if len(sulfur) == 1 and any( (atom.residue != residue for atom in bonded[sulfur[0]]) ): variant = "CYX" if residue.name == "HIS": variant = "HIP" if residue.name == "GLU": variant = "GL4" if residue.name == "ASP": variant = "AS4" if variant is not None and variant not in spec.variants: raise ValueError( "Illegal variant for %s residue: %s" % (residue.name, variant) ) actualVariants[residue.index] = variant removeExtraHydrogens = variants[residue.index] is not None # Make a list of hydrogens that should be present in the residue. parents = [ atom for atom in residue.atoms() if atom.element != elem.hydrogen ] parentNames = [atom.name for atom in parents] hydrogens = [ h for h in spec.hydrogens if (variant is None) or (h.variants is None) or (h.variants is not None and variant in h.variants) ] hydrogens = [ h for h in hydrogens if h.terminal is None or (isNTerminal and h.terminal == "N") or (isCTerminal and h.terminal == "C") ] hydrogens = [h for h in hydrogens if h.parent in parentNames] # Loop over atoms in the residue, adding them to the new topology along with required hydrogens. for parent in residue.atoms(): # Check whether this is a hydrogen that should be removed. if ( removeExtraHydrogens and parent.element == elem.hydrogen and not any(parent.name == h.name for h in hydrogens) ): continue # Add the atom. newAtom = newTopology.addAtom( parent.name, parent.element, newResidue ) newAtoms[parent] = newAtom newPositions.append(deepcopy(self.positions[parent.index])) if parent in parents: # Match expected hydrogens with existing ones and find which ones need to be added. existing = [ atom for atom in bonded[parent] if atom.element == elem.hydrogen ] expected = [h for h in hydrogens if h.parent == parent.name] if len(existing) < len(expected): # Try to match up existing hydrogens to expected ones. matches = [] for e in existing: match = [h for h in expected if h.name == e.name] if len(match) > 0: matches.append(match[0]) expected.remove(match[0]) else: matches.append(None) # If any hydrogens couldn't be matched by name, just match them arbitrarily. for i in range(len(matches)): if matches[i] is None: matches[i] = expected[-1] expected.remove(expected[-1]) # Add the missing hydrogens. for h in expected: newH = newTopology.addAtom( h.name, elem.hydrogen, newResidue ) newIndices.append(newH.index) delta = Vec3(0, 0, 0) * nanometer if len(bonded[parent]) > 0: for other in bonded[parent]: delta += ( self.positions[parent.index] - self.positions[other.index] ) else: delta = ( Vec3( random.random(), random.random(), random.random(), ) * nanometer ) delta *= 0.1 * nanometer / norm(delta) delta += ( 0.05 * Vec3( random.random(), random.random(), random.random(), ) * nanometer ) delta *= 0.1 * nanometer / norm(delta) newPositions.append( self.positions[parent.index] + delta ) newTopology.addBond(newAtom, newH) else: # Just copy over the residue. for atom in residue.atoms(): newAtom = newTopology.addAtom( atom.name, atom.element, newResidue ) newAtoms[atom] = newAtom newPositions.append(deepcopy(self.positions[atom.index])) for bond in self.topology.bonds(): if bond[0] in newAtoms and bond[1] in newAtoms: newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]]) # The hydrogens were added at random positions. Now perform an energy minimization to fix them up. if forcefield is not None: # Use the ForceField the user specified. system = forcefield.createSystem(newTopology, rigidWater=False) atoms = list(newTopology.atoms()) for i in range(system.getNumParticles()): if atoms[i].element != elem.hydrogen: # This is a heavy atom, so make it immobile. system.setParticleMass(i, 0) else: # Create a System that restrains the distance of each hydrogen from its parent atom # and causes hydrogens to spread out evenly. system = System() nonbonded = CustomNonbondedForce("100/((r/0.1)^4+1)") bonds = HarmonicBondForce() angles = HarmonicAngleForce() system.addForce(nonbonded) system.addForce(bonds) system.addForce(angles) bondedTo = [] for atom in newTopology.atoms(): nonbonded.addParticle([]) if atom.element != elem.hydrogen: system.addParticle(0.0) else: system.addParticle(1.0) bondedTo.append([]) for atom1, atom2 in newTopology.bonds(): if atom1.element == elem.hydrogen or atom2.element == elem.hydrogen: bonds.addBond(atom1.index, atom2.index, 0.1, 100_000.0) bondedTo[atom1.index].append(atom2) bondedTo[atom2.index].append(atom1) for residue in newTopology.residues(): if residue.name == "HOH": # Add an angle term to make the water geometry correct. atoms = list(residue.atoms()) oindex = [ i for i in range(len(atoms)) if atoms[i].element == elem.oxygen ] if len(atoms) == 3 and len(oindex) == 1: hindex = list(set([0, 1, 2]) - set(oindex)) angles.addAngle( atoms[hindex[0]].index, atoms[oindex[0]].index, atoms[hindex[1]].index, 1.824, 836.8, ) else: # Add angle terms for any hydroxyls. for atom in residue.atoms(): index = atom.index if ( atom.element == elem.oxygen and len(bondedTo[index]) == 2 and elem.hydrogen in (a.element for a in bondedTo[index]) ): angles.addAngle( bondedTo[index][0].index, index, bondedTo[index][1].index, 1.894, 460.24, ) if platform is None: context = Context(system, VerletIntegrator(0.0)) else: context = Context(system, VerletIntegrator(0.0), platform) context.setPositions(newPositions) LocalEnergyMinimizer.minimize(context, 1.0, 50) self.topology = newTopology self.positions = context.getState(getPositions=True).getPositions() del context return actualVariants
from simtk.openmm import System from ANN import * system = System() a = ANN_Force() a.set_list_of_index_of_atoms_forming_dihedrals_from_index_of_backbone_atoms( [1, 2, 3, 4, 5, 6]) system.addForce(a) print "Python wrapper test passed!"
def addHydrogens(self, forcefield=None, pH=None, variants=None, platform=None): """Add missing hydrogens to the model. This function automatically changes compatible residues into their constant-pH variant if no variant is specified.: Aspartic acid: AS4: Form with a 2 hydrogens on each one of the delta oxygens (syn,anti) It has 5 titration states. Alternative: AS2: Has 2 hydrogens (syn, anti) on one of the delta oxygens It has 3 titration states. Cysteine: CYS: Neutral form with a hydrogen on the sulfur CYX: No hydrogen on the sulfur (either negatively charged, or part of a disulfide bond) Glutamic acid: GL4: Form with a 2 hydrogens on each one of the epsilon oxygens (syn,anti) It has 5 titration states. Histidine: HIP: Positively charged form with hydrogens on both ND1 and NE2 It has 3 titration states. The variant to use for each residue is determined by the following rules: 1. Any Cysteine that participates in a disulfide bond uses the CYX variant regardless of pH. 2. Other residues are all set to maximally protonated state, which can be updated using a proton drive You can override these rules by explicitly specifying a variant for any residue. To do that, provide a list for the 'variants' parameter, and set the corresponding element to the name of the variant to use. A special case is when the model already contains a hydrogen that should not be present in the desired variant. If you explicitly specify a variant using the 'variants' parameter, the residue will be modified to match the desired variant, removing hydrogens if necessary. On the other hand, for residues whose variant is selected automatically, this function will only add hydrogens. It will never remove ones that are already present in the model. Definitions for standard amino acids and nucleotides are built in. You can call loadHydrogenDefinitions() to load additional definitions for other residue types. Parameters ---------- forcefield : ForceField=None the ForceField to use for determining the positions of hydrogens. If this is None, positions will be picked which are generally reasonable but not optimized for any particular ForceField. pH : None, Kept for compatibility reasons. Has no effect. variants : list=None an optional list of variants to use. If this is specified, its length must equal the number of residues in the model. variants[i] is the name of the variant to use for residue i (indexed starting at 0). If an element is None, the standard rules will be followed to select a variant for that residue. platform : Platform=None the Platform to use when computing the hydrogen atom positions. If this is None, the default Platform will be used. Returns ------- list a list of what variant was actually selected for each residue, in the same format as the variants parameter Notes ----- This function does not use a pH specification. The argument is kept for compatibility reasons. """ # Check the list of variants. if pH is not None: print("Ignored pH argument provided for constant-pH residues.") residues = list(self.topology.residues()) if variants is not None: if len(variants) != len(residues): raise ValueError( "The length of the variants list must equal the number of residues" ) else: variants = [None] * len(residues) actualVariants = [None] * len(residues) # Load the residue specifications. if not Modeller._hasLoadedStandardHydrogens: Modeller.loadHydrogenDefinitions( os.path.join(os.path.dirname(__file__), "data", "hydrogens-amber10-constph.xml")) # Make a list of atoms bonded to each atom. bonded = {} for atom in self.topology.atoms(): bonded[atom] = [] for atom1, atom2 in self.topology.bonds(): bonded[atom1].append(atom2) bonded[atom2].append(atom1) # Define a function that decides whether a set of atoms form a hydrogen bond, using fairly tolerant criteria. def isHbond(d, h, a): if norm(d - a) > 0.35 * nanometer: return False deltaDH = h - d deltaHA = a - h deltaDH /= norm(deltaDH) deltaHA /= norm(deltaHA) return acos(dot(deltaDH, deltaHA)) < 50 * degree # Loop over residues. newTopology = Topology() newTopology.setPeriodicBoxVectors( self.topology.getPeriodicBoxVectors()) newAtoms = {} newPositions = [] * nanometer newIndices = [] acceptors = [ atom for atom in self.topology.atoms() if atom.element in (elem.oxygen, elem.nitrogen) ] for chain in self.topology.chains(): newChain = newTopology.addChain(chain.id) for residue in chain.residues(): newResidue = newTopology.addResidue(residue.name, newChain, residue.id) isNTerminal = residue == chain._residues[0] isCTerminal = residue == chain._residues[-1] if residue.name in Modeller._residueHydrogens: # Add hydrogens. First select which variant to use. spec = Modeller._residueHydrogens[residue.name] variant = variants[residue.index] if variant is None: if residue.name == "CYS": # If this is part of a disulfide, use CYX. sulfur = [ atom for atom in residue.atoms() if atom.element == elem.sulfur ] if len(sulfur) == 1 and any( (atom.residue != residue for atom in bonded[sulfur[0]])): variant = "CYX" if residue.name == "HIS": variant = "HIP" if residue.name == "GLU": variant = "GL4" if residue.name == "ASP": variant = "AS4" if variant is not None and variant not in spec.variants: raise ValueError("Illegal variant for %s residue: %s" % (residue.name, variant)) actualVariants[residue.index] = variant removeExtraHydrogens = variants[residue.index] is not None # Make a list of hydrogens that should be present in the residue. parents = [ atom for atom in residue.atoms() if atom.element != elem.hydrogen ] parentNames = [atom.name for atom in parents] hydrogens = [ h for h in spec.hydrogens if (variant is None) or (h.variants is None) or ( h.variants is not None and variant in h.variants) ] hydrogens = [ h for h in hydrogens if h.terminal is None or ( isNTerminal and h.terminal == "N") or ( isCTerminal and h.terminal == "C") ] hydrogens = [ h for h in hydrogens if h.parent in parentNames ] # Loop over atoms in the residue, adding them to the new topology along with required hydrogens. for parent in residue.atoms(): # Check whether this is a hydrogen that should be removed. if (removeExtraHydrogens and parent.element == elem.hydrogen and not any(parent.name == h.name for h in hydrogens)): continue # Add the atom. newAtom = newTopology.addAtom(parent.name, parent.element, newResidue) newAtoms[parent] = newAtom newPositions.append( deepcopy(self.positions[parent.index])) if parent in parents: # Match expected hydrogens with existing ones and find which ones need to be added. existing = [ atom for atom in bonded[parent] if atom.element == elem.hydrogen ] expected = [ h for h in hydrogens if h.parent == parent.name ] if len(existing) < len(expected): # Try to match up existing hydrogens to expected ones. matches = [] for e in existing: match = [ h for h in expected if h.name == e.name ] if len(match) > 0: matches.append(match[0]) expected.remove(match[0]) else: matches.append(None) # If any hydrogens couldn't be matched by name, just match them arbitrarily. for i in range(len(matches)): if matches[i] is None: matches[i] = expected[-1] expected.remove(expected[-1]) # Add the missing hydrogens. for h in expected: newH = newTopology.addAtom( h.name, elem.hydrogen, newResidue) newIndices.append(newH.index) delta = Vec3(0, 0, 0) * nanometer if len(bonded[parent]) > 0: for other in bonded[parent]: delta += ( self.positions[parent.index] - self.positions[other.index]) else: delta = (Vec3( random.random(), random.random(), random.random(), ) * nanometer) delta *= 0.1 * nanometer / norm(delta) delta += (0.05 * Vec3( random.random(), random.random(), random.random(), ) * nanometer) delta *= 0.1 * nanometer / norm(delta) newPositions.append( self.positions[parent.index] + delta) newTopology.addBond(newAtom, newH) else: # Just copy over the residue. for atom in residue.atoms(): newAtom = newTopology.addAtom(atom.name, atom.element, newResidue) newAtoms[atom] = newAtom newPositions.append( deepcopy(self.positions[atom.index])) for bond in self.topology.bonds(): if bond[0] in newAtoms and bond[1] in newAtoms: newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]]) # The hydrogens were added at random positions. Now perform an energy minimization to fix them up. if forcefield is not None: # Use the ForceField the user specified. system = forcefield.createSystem(newTopology, rigidWater=False) atoms = list(newTopology.atoms()) for i in range(system.getNumParticles()): if atoms[i].element != elem.hydrogen: # This is a heavy atom, so make it immobile. system.setParticleMass(i, 0) else: # Create a System that restrains the distance of each hydrogen from its parent atom # and causes hydrogens to spread out evenly. system = System() nonbonded = CustomNonbondedForce("100/((r/0.1)^4+1)") bonds = HarmonicBondForce() angles = HarmonicAngleForce() system.addForce(nonbonded) system.addForce(bonds) system.addForce(angles) bondedTo = [] for atom in newTopology.atoms(): nonbonded.addParticle([]) if atom.element != elem.hydrogen: system.addParticle(0.0) else: system.addParticle(1.0) bondedTo.append([]) for atom1, atom2 in newTopology.bonds(): if atom1.element == elem.hydrogen or atom2.element == elem.hydrogen: bonds.addBond(atom1.index, atom2.index, 0.1, 100_000.0) bondedTo[atom1.index].append(atom2) bondedTo[atom2.index].append(atom1) for residue in newTopology.residues(): if residue.name == "HOH": # Add an angle term to make the water geometry correct. atoms = list(residue.atoms()) oindex = [ i for i in range(len(atoms)) if atoms[i].element == elem.oxygen ] if len(atoms) == 3 and len(oindex) == 1: hindex = list(set([0, 1, 2]) - set(oindex)) angles.addAngle( atoms[hindex[0]].index, atoms[oindex[0]].index, atoms[hindex[1]].index, 1.824, 836.8, ) else: # Add angle terms for any hydroxyls. for atom in residue.atoms(): index = atom.index if (atom.element == elem.oxygen and len(bondedTo[index]) == 2 and elem.hydrogen in (a.element for a in bondedTo[index])): angles.addAngle( bondedTo[index][0].index, index, bondedTo[index][1].index, 1.894, 460.24, ) if platform is None: context = Context(system, VerletIntegrator(0.0)) else: context = Context(system, VerletIntegrator(0.0), platform) context.setPositions(newPositions) LocalEnergyMinimizer.minimize(context, 1.0, 50) self.topology = newTopology self.positions = context.getState(getPositions=True).getPositions() del context return actualVariants
def from_system(cls, system: openmm.System, indices: Dict[str, int]): """Instantiate a COOHDummyMover for a single C-COOH moiety in your system. Parameters ---------- system - The OpenMM system containting the COOH moiety indices - a dictionary labeling the indices of the C-COOH atoms with keys: HO - index in the system of the hydroxyl hydrogen. OH - index in the system of the hydroxyl oxygen OC - index in the system of the carbonyl oxygen CO - index in the system of the carbonyl carbon R - index in the system of the atom "R" this COOH group is connected to. """ obj = cls() # Hydroxyl hydrogen obj.HO = indices["HO"] # Hydroxyl oxygen obj.OH = indices["OH"] # Carbonyl oxygen obj.OC = indices["OC"] # The carbons are used as reference points for reflection obj.CO = indices["CO"] obj.R = indices["R"] # All atoms that this class may decide to move obj.movable = [indices["OC"], indices["OH"], indices["HO"]] # The parameters for angles obj.angles = [] # The parameters for dihedrals obj.dihedrals = [] # Instantiate the class variable # This is to keep track of angle and torsion force indices for all future instances if ( COOHDummyMover.angleforceindex is None or COOHDummyMover.dihedralforceindex is None ): for force_index in range(system.getNumForces()): force = system.getForce(force_index) if force.__class__.__name__ == "HarmonicAngleForce": COOHDummyMover.angleforceindex = force_index elif force.__class__.__name__ == "PeriodicTorsionForce": COOHDummyMover.dihedralforceindex = force_index if COOHDummyMover.angleforceindex is None: raise RuntimeError( "{} requires the system to have a HarmonicAngleForce!".format( COOHDummyMover.__name__ ) ) if COOHDummyMover.dihedralforceindex is None: raise RuntimeError( "{} requires the system to have a PeriodicTorsionForce!".format( COOHDummyMover.__name__ ) ) angleforce = system.getForce(COOHDummyMover.angleforceindex) torsionforce = system.getForce(COOHDummyMover.dihedralforceindex) # Loop through and collect all angle energy terms that include moving atoms for angle_index in range(angleforce.getNumAngles()): *particles, theta0, k = angleforce.getAngleParameters(angle_index) if any(particle in obj.movable for particle in particles): # Energy function for this angle. params = [k._value, theta0._value, *particles] log.debug("Found this COOH angle: %s", params) obj.angles.append(params) # Loop through and collect all torsion energy terms that include moving atoms for torsion_index in range(torsionforce.getNumTorsions()): *particles, n, theta0, k = torsionforce.getTorsionParameters(torsion_index) if any(particle in obj.movable for particle in particles): # Energy function for this dihedral. params = [k._value, n, theta0._value, *particles] log.debug("Found this COOH dihedral: %s", params) obj.dihedrals.append(params) return obj
def __simulate( positions: unit.Quantity, box_vectors: Optional[unit.Quantity], omm_topology: app.Topology, omm_system: openmm.System, n_steps: int, temperature: unit.Quantity, pressure: Optional[unit.Quantity], platform: Literal["Reference", "OpenCL", "CUDA", "CPU"] = "Reference", ): """ Parameters ---------- positions The starting coordinates of the molecules in the system. box_vectors The box vectors to use. These will overwrite the topology box vectors. omm_topology The topology detailing the system to simulate. omm_system The object which defines the systems hamiltonian. n_steps The number of steps to simulate for. temperature The temperature to simulate at. pressure The pressure to simulate at. platform The platform to simulate using. """ """A helper function for simulating a system with OpenMM.""" with open("input.pdb", "w") as file: app.PDBFile.writeFile(omm_topology, positions, file) with open("system.xml", "w") as file: file.write(openmm.XmlSerializer.serialize(omm_system)) if pressure is not None: omm_system.addForce( openmm.MonteCarloBarostat(pressure, temperature, 25)) integrator = openmm.LangevinIntegrator( temperature, # simulation temperature, 1.0 / unit.picosecond, # friction 2.0 * unit.femtoseconds, # simulation timestep ) platform = openmm.Platform.getPlatformByName(platform) simulation = app.Simulation(omm_topology, omm_system, integrator, platform) if box_vectors is not None: simulation.context.setPeriodicBoxVectors(box_vectors[0, :], box_vectors[1, :], box_vectors[2, :]) simulation.context.setPositions(positions) simulation.context.computeVirtualSites() simulation.minimizeEnergy() # Randomize the velocities from a Boltzmann distribution at a given temperature. simulation.context.setVelocitiesToTemperature(temperature * unit.kelvin) # Configure the information in the output files. pdb_reporter = openmm.app.DCDReporter("trajectory.dcd", int(0.05 * n_steps)) state_data_reporter = openmm.app.StateDataReporter( "data.csv", int(0.05 * n_steps), step=True, potentialEnergy=True, temperature=True, density=True, ) simulation.reporters.append(pdb_reporter) simulation.reporters.append(state_data_reporter) logger.debug("Starting simulation") start = time.process_time() # Run the simulation simulation.step(n_steps) end = time.process_time() logger.debug("Elapsed time %.2f seconds" % (end - start)) logger.debug("Done!")
def _get_openmm_energies( omm_sys: openmm.System, box_vectors, positions, round_positions=None, hard_cutoff=False, electrostatics: bool = True, ) -> EnergyReport: """Given a prepared `openmm.System`, run a single-point energy calculation.""" """\ if hard_cutoff: omm_sys = _set_nonbonded_method( omm_sys, "cutoff", electrostatics=electrostatics ) else: omm_sys = _set_nonbonded_method(omm_sys, "PME") """ for idx, force in enumerate(omm_sys.getForces()): force.setForceGroup(idx) integrator = openmm.VerletIntegrator(1.0 * unit.femtoseconds) context = openmm.Context(omm_sys, integrator) if box_vectors is not None: if not isinstance(box_vectors, (unit.Quantity, list)): box_vectors = box_vectors.magnitude * unit.nanometer context.setPeriodicBoxVectors(*box_vectors) if isinstance(positions, unit.Quantity): # Convert list of Vec3 into a NumPy array positions = np.asarray(positions.value_in_unit( unit.nanometer)) * unit.nanometer else: positions = positions.magnitude * unit.nanometer if round_positions is not None: rounded = np.round(positions, round_positions) context.setPositions(rounded) else: context.setPositions(positions) raw_energies = dict() omm_energies = dict() for idx in range(omm_sys.getNumForces()): state = context.getState(getEnergy=True, groups={idx}) raw_energies[idx] = state.getPotentialEnergy() del state # This assumes that only custom forces will have duplicate instances for key in raw_energies: force = omm_sys.getForce(key) if type(force) == openmm.HarmonicBondForce: omm_energies["HarmonicBondForce"] = raw_energies[key] elif type(force) == openmm.HarmonicAngleForce: omm_energies["HarmonicAngleForce"] = raw_energies[key] elif type(force) == openmm.PeriodicTorsionForce: omm_energies["PeriodicTorsionForce"] = raw_energies[key] elif type(force) in [ openmm.NonbondedForce, openmm.CustomNonbondedForce, openmm.CustomBondForce, ]: if "Nonbonded" in omm_energies: omm_energies["Nonbonded"] += raw_energies[key] else: omm_energies["Nonbonded"] = raw_energies[key] # Fill in missing keys if interchange does not have all typical forces for required_key in [ "HarmonicBondForce", "HarmonicAngleForce", "PeriodicTorsionForce", "NonbondedForce", ]: if not any(required_key in val for val in omm_energies): pass # omm_energies[required_key] = 0.0 * kj_mol del context del integrator report = EnergyReport() report.update_energies({ "Bond": omm_energies.get("HarmonicBondForce", 0.0 * kj_mol), "Angle": omm_energies.get("HarmonicAngleForce", 0.0 * kj_mol), "Torsion": _canonicalize_torsion_energies(omm_energies), "Nonbonded": omm_energies.get("Nonbonded", _canonicalize_nonbonded_energies(omm_energies)), }) report.energies.pop("vdW") report.energies.pop("Electrostatics") return report
def add_interactions(self, state: interfaces.IState, system: mm.System, topology: app.Topology) -> mm.System: # The approach we use is based on # Habeck, Nilges, Rieping, J. Biomol. NMR., 2007, 135-144. # # Rather than solving for the exact alignment tensor # every step, we sample from a distribution of alignment # tensors. # # We encode the five components of the alignment tensor in # the positions of two dummy atoms relative to the center # of mass. The value of kappa should be scaled so that the # components of the alignment tensor are approximately unity. # # There is a restraint on the z-component of the seocnd dummy # particle to ensure that it does not diffuse off to ininity, # which could cause precision issues. if self.active: rdc_force = mm.CustomCentroidBondForce( 5, "Erest + z_scaler*Ez;" "Erest = (1 - step(dev - quadcut)) * quad + step(dev - quadcut) * linear;" "linear = 0.5 * k_rdc * quadcut^2 + k_rdc * quadcut * (dev - quadcut);" "quad = 0.5 * k_rdc * dev^2;" "dev = max(0, abs(d_obs - dcalc) - flat);" "dcalc=2/3 * kappa_rdc/r^5 * (s1*(rx^2-ry^2) + s2*(3*rz^2-r^2) + s3*2*rx*ry + s4*2*rx*rz + s5*2*ry*rz);" "r=distance(g4, g5);" "rx=x4-x5;" "ry=y4-y5;" "rz=z4-z5;" "s1=x2-x1;" "s2=y2-y1;" "s3=z2-z1;" "s4=x3-x1;" "s5=y3-y1;" "Ez=(z3-z1)^2;", ) rdc_force.addPerBondParameter("d_obs") rdc_force.addPerBondParameter("kappa_rdc") rdc_force.addPerBondParameter("k_rdc") rdc_force.addPerBondParameter("flat") rdc_force.addPerBondParameter("quadcut") rdc_force.addPerBondParameter("z_scaler") for experiment in self.expt_dict: # find the set of all atoms involved in this experiment com_ind = set() for r in self.expt_dict[experiment]: com_ind.add(r.atom_index_1) com_ind.add(r.atom_index_2) # add groups for the COM and dummy particles s1 = self.expt_dict[experiment][0].s1_index s2 = self.expt_dict[experiment][0].s2_index g1 = rdc_force.addGroup(list(com_ind)) g2 = rdc_force.addGroup([s1]) g3 = rdc_force.addGroup([s2]) # add non-bonded exclusions between dummy particles and all other atoms nb_forces = [ f for f in system.getForces() if isinstance(f, mm.NonbondedForce) or isinstance(f, mm.CustomNonbondedForce) ] for nb_force in nb_forces: n_parts = nb_force.getNumParticles() for i in range(n_parts): if isinstance(nb_force, mm.NonbondedForce): if i != s1: nb_force.addException(i, s1, 0.0, 0.0, 0.0, replace=True) if i != s2: nb_force.addException(i, s2, 0.0, 0.0, 0.0, replace=True) else: if i != s1: nb_force.addExclusion(i, s1) if i != s2: nb_force.addExclusion(i, s2) for r in self.expt_dict[experiment]: # add groups for the atoms involved in the RDC g4 = rdc_force.addGroup([r.atom_index_1]) g5 = rdc_force.addGroup([r.atom_index_2]) rdc_force.addBond( [g1, g2, g3, g4, g5], [ r.d_obs, r.kappa, 0.0, r.tolerance, r.quadratic_cut, 0, ], # z_scaler initial value shouldn't matter ) system.addForce(rdc_force) self.force = rdc_force return system