Struct MolDynamics 

pub struct MolDynamics {
    pub ff_mol_type: FfMolType,
    pub atoms: Vec<AtomGeneric>,
    pub atom_posits: Option<Vec<Vec3>>,
    pub atom_init_velocities: Option<Vec<Vec3>>,
    pub bonds: Vec<BondGeneric>,
    pub adjacency_list: Option<Vec<Vec<usize>>>,
    pub static_: bool,
    pub mol_specific_params: Option<ForceFieldParams>,
    pub bonded_only: bool,
}

Packages information required to perform dynamics on a Molecule. This is used to initialize the simulation with atoms and related; one or more of these is passed at init.

Fields

ff_mol_type: FfMolType

atoms: Vec<AtomGeneric>

These must hold force field type and partial charge.

atom_posits: Option<Vec<Vec3>>

Separate from atoms; this may be more convenient than mutating the atoms as they may move! If None, we use the positions stored in the atoms.

atom_init_velocities: Option<Vec<Vec3>>

This may have uses if “shooting” a molecule into a docking position?

bonds: Vec<BondGeneric>

Not required if static.

adjacency_list: Option<Vec<Vec<usize>>>

A fast lookup for finding atoms, by index, covalently bonded to each atom. If None, will be generated automatically from atoms and bonds. Use this if you wish to cache.

static_: bool

If true, the atoms in the molecule don’t move, but exert LJ and Coulomb forces on other atoms in the system.

mol_specific_params: Option<ForceFieldParams>

If present, any values here override molecule-type general parameters.

bonded_only: bool

todo experimentin If true, this atom exerts and experiences non-bonded forces only. This may be useful for protein atoms that aren’t near a docking site.

Implementations

impl MolDynamics

pub fn from_mol2( mol: &Mol2, mol_specific_params: Option<ForceFieldParams>, ) -> Self

Load a molecule from a Mol2 file. Includes optional molecule-specific pararmeters. To work directly, this assumes that forcefield names, and partial charge are present in the Mol2 struct for all atoms.

You may wish to modify the atom_posits field after to position this relative to other molecules.

Examples found in repository

examples/minimal.rs (line 29)

fn main() {
    let dev = ComputationDevice::Cpu;
    let param_set = FfParamSet::new_amber().unwrap();

    let mut protein = MmCif::load(Path::new("1c8k.cif")).unwrap();
    let mol = Mol2::load(Path::new("CPB.mol2")).unwrap();

    // Add Hydrogens, force field type, and partial charge to atoms in the protein; these usually aren't
    // included from RSCB PDB. You can also call `populate_hydrogens_dihedrals()`, and
    // `populate_peptide_ff_and_q() separately. Add bonds.
    let (_bonds, _dihedrals) = prepare_peptide_mmcif(
        &mut protein,
        &param_set.peptide_ff_q_map.as_ref().unwrap(),
        7.0,
    )
    .unwrap();

    let mols = vec![
        MolDynamics::from_mol2(&mol, None),
        MolDynamics {
            ff_mol_type: FfMolType::Peptide,
            atoms: protein.atoms.clone(),
            static_: true,
            ..Default::default()
        },
    ];

    let (mut md, _) = MdState::new(&dev, &MdConfig::default(), &mols, &param_set).unwrap();

    let n_steps = 100;
    let dt = 0.002; // picoseconds.

    for _ in 0..n_steps {
        md.step(&dev, dt, None);
    }

    let snap = &md.snapshots[md.snapshots.len() - 1]; // A/R.
    let energy = snap.energy_data.as_ref().unwrap();
    println!(
        "KE: {}, PE: {}, Atom posits:",
        energy.energy_kinetic, energy.energy_potential
    );
    for posit in &snap.atom_posits {
        println!("Posit: {posit}");
        // Also keeps track of velocities, and solvent molecule positions/velocity
    }

    // Do something with snapshot data, like displaying atom positions in your UI.
    // You can save to DCD file, and adjust the ratio they're saved at using the `MdConfig.snapshot_setup`
    // field: See the example below.
    for _snap in &md.snapshots {}
}

pub fn from_sdf( mol: &Sdf, mol_specific_params: Option<ForceFieldParams>, ) -> Self

Load a molecule from a SDF file. Includes optional molecule-specific pararmeters. To work directly, this assumes that forcefield names, and partial charge are present in the Mol2 struct for all atoms. Note that these are not present in SDF files that come from most online databases.

You may wish to modify the atom_posits field after to position this relative to other molecules.

pub fn from_amber_geostd(ident: &str) -> Result<Self>

Load an Amber Geostd molecule from an online database, from its unique identifier. This includes molecule-specific parameters.

You may wish to modify the atom_posits field after to position this relative to other molecules.

Trait Implementations

impl Clone for MolDynamics

fn clone(&self) -> MolDynamics

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MolDynamics

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MolDynamics

This is mainly for overriding, while specifying atoms, bonds, posits, and mol type explicitly.

fn default() -> Self

Returns the “default value” for a type.