Struct SelfAvoidingWalk 

pub struct SelfAvoidingWalk<S: GrowthStrategy> {
    pub n_chains: usize,
    pub chain_length: usize,
    pub bond_length: F,
    pub target_density: F,
    pub pbc: Pbc3,
    pub seed: u64,
    pub strategy: S,
}

Configuration for a periodic/reflective, fixed-bond-length self-avoiding random walk that grows n_chains independent chains of chain_length monomers each.

Construct it as a struct literal and inject a GrowthStrategy via the strategy field, then call generate:

use molrs::builder::{OffLattice, SelfAvoidingWalk};

let walk = SelfAvoidingWalk {
    n_chains: 2,
    chain_length: 20,
    bond_length: 1.53,
    target_density: 0.05,
    pbc: [true, true, true],
    seed: 9062,
    strategy: OffLattice { excluded_radius: 1.0 },
};
let out = walk.generate().unwrap();
assert_eq!(out.paths.len(), 2);

target_density is in monomers per unit volume — mass is out of scope, so the cubic box edge is a = (n_chains * chain_length / target_density).cbrt() (a lattice strategy may round it up to stay commensurate).

Fields

n_chains: usize

Number of independent chains to grow.

chain_length: usize

Number of monomers per chain.

bond_length: F

Fixed distance between consecutive monomers.

target_density: F

Target number density (monomers per unit volume) used to size the box.

pbc: Pbc3

Per-axis boundary flags: true = periodic (wrap), false = reflective.

seed: u64

Seed for the deterministic RNG; equal seeds give identical paths.

strategy: S

The monomer-placement policy (a struct implementing GrowthStrategy).

Implementations

impl<S: GrowthStrategy> SelfAvoidingWalk<S>

pub fn generate(&self) -> Result<WalkOutput, WalkError>

Grow all chains and return their paths plus the box used.

Deterministic in seed. Returns WalkError::InvalidConfig for out-of-range parameters, WalkError::BoxError if the box cannot be built, and WalkError::DeadEnd if a chain cannot be completed within the retry/backtrack/restart budget.