---
pretty_name: "MLFF_CGMD: coarse-grained polymer MD trajectories"
tags:
  - molecular-dynamics
  - coarse-grained
  - polymer
  - lammps
  - trajectories
---

# MLFF_CGMD: coarse-grained polymer MD trajectories

Langevin-dynamics trajectories of single coarse-grained bead-spring polymers
in implicit solvent, generated with LAMMPS (LJ reduced units throughout).
Intended as training data for machine-learned force fields / ML models of
coarse-grained polymer dynamics.

All code, the LAMMPS input script, and the exact sampling configuration used
to generate this dataset are at
[github.com/ljding94/MLFF_CGMD](https://github.com/ljding94/MLFF_CGMD).

## Repository layout

| Path | Campaign | Runs |
|---|---|---|
| `multi_topo/{topology}_run{N}.tar.gz` | **Multi-topology campaign** (main) | 5 topologies x runs 0-499 = 2500 |
| `linear_L100_box40_run{N}.tar.gz` (root) | Legacy linear-only campaign | runs 0-999, chain length fixed at 100 |

## Multi-topology campaign

One tarball per run, named `{topology}_run{N}.tar.gz` with
`topology ∈ {linear, ring, brush, star, dendrimer}` and `N ∈ [0, 499]`.

Every run independently samples **all** of its parameters (structural,
interaction strength epsilon, bending stiffness kappa) uniformly from the
ranges below, using a deterministic seed (see *Reproducibility*). The values
actually used are recorded in each run's `parameters.json`.

Shared by all topologies:

| Parameter | Range | Meaning |
|---|---|---|
| `epsilon` | [0.0, 2.0] | LJ well depth for all nonbonded bead pairs (self-attraction) |
| `kappa` | [0.0, 10.0] | cosine angle stiffness, E = kappa (1 + cos theta) |
| `box_size` | 40 (fixed) | cubic periodic box edge |

Structural parameters (integers sampled inclusive):

| Topology | Parameters | Description |
|---|---|---|
| `linear` | `chain_length` [50, 200] | open chain of N beads |
| `ring` | `ring_length` [50, 200] | closed loop (bond between first and last bead) |
| `brush` | `backbone_length` [30, 80], `grafting_density` [0.1, 0.5], `side_chain_length` [3, 10] | linear backbone with side chains grafted at ~`grafting_density` fraction of backbone beads, evenly spaced |
| `star` | `arm_length` [10, 50], `num_arms` [3, 8] | `num_arms` linear arms bonded to one central core bead |
| `dendrimer` | `generations` [2, 4], `branching_factor` [2, 3], `spacer` [2, 6] | tree built outward from a core bead; each branch segment is `spacer` beads; the core spawns `branching_factor` branches, later branch points spawn `branching_factor - 1` |

## Contents of each tarball

```
{topology}_run{N}/
├── parameters.json        # every parameter of this run (sampled + fixed + seed)
├── polymer_{topology}.data  # LAMMPS datafile of the initial configuration
├── log.lammps             # full LAMMPS log (thermo output every 100 steps)
├── coord/dump.*.txt       # 1001 trajectory frames (see format below)
└── final_state.data       # LAMMPS datafile of the final configuration
```

`parameters.json` example (star, run 0):

```json
{
  "mode": "rand", "topology": "star",
  "arm_length": 15, "num_arms": 4,
  "box_size": 40.0,
  "epsilon": 1.546645536562463, "kappa": 6.086129988363434,
  "timestep": 0.01, "equilibration_steps": 10000,
  "production_steps": 100000, "dump_every": 100,
  "run": 0, "seed": 3067890
}
```

Trajectory frames are LAMMPS `dump custom` text files written every 100 steps
of the 100,000-step production run (frames at step 0, 100, ..., 100000).
Columns:

```
id type x y z xu yu zu
```

`x y z` are wrapped coordinates, `xu yu zu` unwrapped; all beads are type 1 —
the molecular topology (bond table) is in the `.data` files.

## Simulation protocol

Coarse-grained bead-spring model, LJ units, all beads mass 1:

- **Bonds**: FENE, K = 30, R0 = 1.5, sigma = 1, epsilon = 1
  (`special_bonds fene`)
- **Angles**: cosine, E = kappa (1 + cos theta), on all bonded bead triplets
  (branch points get one angle per neighbor pair)
- **Nonbonded**: LJ, sigma = 1, epsilon sampled per run, cutoff 2.5,
  potential shifted to zero at the cutoff
- **Dynamics**: Langevin thermostat, T = 1.0, damping 1.0, with `fix nve`;
  timestep 0.01
- **Workflow**: random-walk initial configuration → 10,000 equilibration
  steps with `nve/limit 0.1` (removes overlaps; not dumped) → timer reset →
  100,000 production steps, dumped every 100 steps

## Reproducibility

Every run is fully determined by its `(topology, run index)`:
`seed = 67890 + topology_offset + run`, with offsets linear 0, ring 1e6,
brush 2e6, star 3e6, dendrimer 4e6. The seed drives both the parameter
sampling and the initial-configuration generation (the seed is also stored in
`parameters.json`). Regenerate any run with the code repository:

```
python run_simulation.py --mode rand --topology star --box_size 40 --run 0
```

## Legacy linear campaign (repo root)

1000 runs, `linear_L100_box40_run{N}.tar.gz`, N in [0, 999]: fixed
`chain_length = 100`, box 40; only epsilon [0, 2] and kappa [0, 10] were
sampled (seed = 67890 + N). Same model, protocol, and per-tarball layout;
`parameters.json` there predates the multi-topology schema (no `topology` or
run-length fields).

## Example: download and extract one run

```bash
hf download ljding94/MLFF_CGMD multi_topo/star_run0.tar.gz \
    --repo-type dataset --local-dir .
tar -xzf multi_topo/star_run0.tar.gz
```