pub fn build<P>(
        &self,
        lock: InstanceLockGuard,
        potential: P,
        initial_coords: Coords,
        initial_meta: P::Meta,
    ) -> FailResult<Lammps<P>>
    where P: Potential,
    { Lammps::from_builder(self, lock, potential, initial_coords, initial_meta) }
/// Call out to the LAMMPS C API to create an instance of Lammps,
/// and configure it according to this builder.
///
/// # Modifying the structure post-build
///
/// `Lammps` has a number of methods that allow you to modify the structure
/// after it has been built.  This can be significantly faster for running
/// multiple computations than it would be to build an instance per structure.
///
/// Ideally, modifying the structure after `build` should result in the same
/// physical quantities as if you were to supply the modified structure from the start.
/// But this is difficult to guarantee, and small numerical disturbances may arise.
///
/// To simplify the implementation of `Lammps`, the following properties
/// are effectively **set in stone** after this method:
///
/// * The number of atoms
/// * The masses of each atom type
/// * The sequence of `pair_style` and `pair_coeff` commands needed
///   to initialize the potential
///
/// The `compute_*` methods on `Lammps` will check these properties on every
/// computed structure, and will fail if they disagree with the structure
/// that was initially provided to `build`.
Call out to the LAMMPS C API to create an instance of Lammps,
and configure it according to this builder.
Call out to the LAMMPS C API to create an instance of Lammps and configure it according to this builder .
pub fn build<P>(
        &self,
        lock: InstanceLockGuard,
        potential: P,
        initial_coords: Coords,
        initial_meta: P::Meta,
    ) -> FailResult<Lammps<P>>
    where P: Potential,
    { Lammps::from_builder(self, lock, potential, initial_coords, initial_meta) }
pub fn build < P > ( & self , lock : InstanceLockGuard , potential : P , initial_coords : Coords , initial_meta : P :: Meta , ) -> FailResult < Lammps < P > > where P : Potential , { Lammps :: from_builder ( self , lock , potential , initial_coords , initial_meta ) }
Call out to the LAMMPS C API to create an instance of Lammps,
and configure it according to this builder.
Call out to the LAMMPS C API to create an instance of Lammps and configure it according to this builder .
&self
lock
InstanceLockGuard
potential
P
initial_coords
Coords
initial_meta
P::Meta
&self
lock
InstanceLockGuard
potential
P
initial_coords
Coords
initial_meta
P::Meta
modifying the structure post-build
`Lammps` has a number of methods that allow you to modify the structure
after it has been built.  This can be significantly faster for running
multiple computations than it would be to build an instance per structure.

Ideally, modifying the structure after `build` should result in the same
physical quantities as if you were to supply the modified structure from the start.
But this is difficult to guarantee, and small numerical disturbances may arise.

To simplify the implementation of `Lammps`, the following properties
are effectively **set in stone** after this method.

The number of atoms
The masses of each atom type
The sequence of `pair_style` and `pair_coeff` commands needed
to initialize the potential

The `compute_*` methods on `Lammps` will check these properties on every
computed structure, and will fail if they disagree with the structure
that was initially provided to `build`.
` Lammps ` has a number of methods that allow you to modify the structure after it has been built . This can be significantly faster for running multiple computations than it would be to build an instance per structure . Ideally modifying the structure after ` build ` should result in the same physical quantities as if you were to supply the modified structure from the start . But this is difficult to guarantee and small numerical disturbances may arise . To simplify the implementation of ` Lammps ` the following properties are effectively ** set in stone ** after this method . The number of atoms The masses of each atom type The sequence of ` pair_style ` and ` pair_coeff ` commands needed to initialize the potential The ` compute_ * ` methods on ` Lammps ` will check these properties on every computed structure and will fail if they disagree with the structure that was initially provided to ` build ` .