Struct FfParamSet 

pub struct FfParamSet {
    pub peptide: Option<ForceFieldParams>,
    pub small_mol: Option<ForceFieldParams>,
    pub dna: Option<ForceFieldParams>,
    pub rna: Option<ForceFieldParams>,
    pub lipids: Option<ForceFieldParams>,
    pub carbohydrates: Option<ForceFieldParams>,
    pub peptide_ff_q_map: Option<ProtFfChargeMapSet>,
    pub lipid_ff_q_map: Option<LipidFfChargeMap>,
    pub dna_ff_q_map: Option<NucleicAcidFfChargeMap>,
    pub rna_ff_q_map: Option<NucleicAcidFfChargeMap>,
}

A set of general parameters that aren’t molecule-specific. E.g. from GAFF2, OL3, RNA, or amino19. These are used as a baseline, and in some cases, overridden by molecule-specific parameters.

Fields

peptide: Option<ForceFieldParams>

small_mol: Option<ForceFieldParams>

dna: Option<ForceFieldParams>

rna: Option<ForceFieldParams>

lipids: Option<ForceFieldParams>

carbohydrates: Option<ForceFieldParams>

peptide_ff_q_map: Option<ProtFfChargeMapSet>

In addition to charge, this also contains the mapping of res type to FF type; required to map other parameters to protein atoms. E.g. from amino19.lib, and its N and C-terminus variants.

lipid_ff_q_map: Option<LipidFfChargeMap>

dna_ff_q_map: Option<NucleicAcidFfChargeMap>

rna_ff_q_map: Option<NucleicAcidFfChargeMap>

Implementations

impl FfParamSet

pub fn new(paths: &ParamGeneralPaths) -> Result<Self>

Load general parameter files for the most common classes of organic molecules. This also populates ff type and charge for protein atoms; these are provided by molecule-specific formats for small molecules.

pub fn new_amber() -> Result<Self>

Create a parameter set using Amber parameters included with this library. This uses the param sets recommended by Amber, CAO Sept 2025: ff19SB, OL24, OL3, GLYCAM_06j, lipids21, and gaff2.

Examples found in repository

examples/minimal.rs (line 13)

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 {}
}

examples/lig_and_protein.rs (line 130)

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

    let mut protein = MmCif::load(Path::new("1c8k.cif")).unwrap();
    // let mut mol = Mol2::load(Path::new("CPB.mol2")).unwrap();
    let mut mol = Sdf::load(Path::new("123.sdf")).unwrap();
    // Optional; the library infers FRCMOD overrides on its own.
    let _mol_specific = ForceFieldParams::load_frcmod(Path::new("CPB.frcmod")).unwrap();

    // Or, instead of loading atoms and mol-specific params separately:
    // let (mol, lig_specific) = load_prmtop("my_mol.prmtop");

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

    // A variant of that function called `prepare_peptide` takes separate atom, residue, and chain
    // lists, for flexibility.

    let cfg = MdConfig {
        // Defaults to Langevin middle.
        integrator: Integrator::VerletVelocity { thermostat: None },
        // If enabled, zero the drift in center of mass of the system.
        zero_com_drift: true,
        // Kelvin. Defaults to 310 K.
        temp_target: 310.,
        // Bar (Pa/100). Defaults to 1 bar.
        barostat_cfg: Some(BarostatCfg {
            pressure_target: 1.,
            ..Default::default()
        }),
        // Allows constraining Hydrogens to be rigid with their bonded atom, using SHAKE and RATTLE
        // algorithms. This allows for higher time steps.
        hydrogen_constraint: HydrogenConstraint::Linear { order: 4, iter: 1 },
        // Deafults to in-memory, every step
        snapshot_handlers: SnapshotHandlers {
            memory: Some(1),
            dcd: Some(10),
            ..Default::default()
        },
        // Or sim_box: SimBoxInit::Fixed((Vec3::new(-10., -10., -10.), Vec3::new(10., 10., 10.)),
        sim_box: SimBoxInit::Pad(10.),
        ..Default::default()
    };

    let _md = build_dynamics(&dev, vec![&mut mol], &protein, &param_set, &cfg, 100, 0.001);
}

Trait Implementations

impl Debug for FfParamSet

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

Formats the value using the given formatter.

impl Default for FfParamSet

fn default() -> FfParamSet

Returns the “default value” for a type.