Generate geometrically-spaced dump sequences for LAMMPS simulations of glassy systems. This tool creates the timing files needed for LAMMPS loops and visualizes the resulting dump schedule.

Required Parameters

aging (long + short sequences) equilibrated (short sequences only)

aging timestep (dt1) [LJ time] ?

Simulation timestep for the long aging sequence. Required; there is no default because it is model-dependent. When dt1 and dt2 differ, the LAMMPS loop switches to dt2 at the long/short seam, and companion separations must land exactly on both timestep grids. Prefer simple dt1/dt2 ratios (for example 1, 1/2, or 2/3).

equilibrium timestep (dt2) [LJ time] ?

Simulation timestep for the repeated short sequences. Required whenever short sequences are generated; typical values are 0.001–0.005. When dt1 and dt2 differ, the LAMMPS loop switches to this timestep at the seam, and companion separations must land exactly on both grids. For a long-only aging schedule (total_time_short_sequence = 0), this may be left blank.

tau_relax_1 [LJ time] ?

Primary relaxation time. Defaults to 10. Sets the default short-sequence length (0.90*tau_relax_1) and production length (150*tau_relax_1), and is marked on the Resolution plot. If both relaxation times are supplied, tau_relax_1 should be the longer one.

tau_equil [LJ time] ?

Target duration of the long equilibration / aging segment after the quench. Defaults to 50*tau_relax_1. Unless you override total_time_long_sequence, this is the seam where the long sequence ends. Accepts expressions such as 100*tau_relax_1.

total_time_long_sequence [LJ time] ?

End time of the long sequence (the seam). Defaults to tau_equil. The long runtimes are required to sum to this time, while their largest runtime matches the short sequence’s largest gap; first_run_time_long then sets how many long dumps you get. Accepts expressions such as 0.5*tau_equil.

total_time_short_sequence [LJ time] ?

Total duration of all repeated short sequences after the seam. Defaults to 150*tau_relax_1. Divided by length_of_short_sequence to get the repeat count. Enter 0 for a long-only aging schedule (no short DCD files). Advanced Settings still show the short-cycle template (tau_relax_2, length, and dynamic-range fields) used to size the long sequence.

[+] Advanced Settings

first_run_time_long [LJ time] ?

Dynamic-range parameter: first (shortest) runtime of the long sequence, and the earliest waiting time it records. Defaults to 20*dt1 (a typical thermostat settle scale), and is at least one dt1 step. Smaller values keep more early waiting times; larger values thin out the start of the long sequence. Must stay below the short sequence’s largest gap. Accepts expressions such as 10*dt1 or 0.001*tau_relax_1.

first_run_time_short [LJ time] ?

Dynamic-range parameter: first (shortest) runtime of each short sequence. Together with largest_run_time_fraction, this sets how many dumps each cycle needs. Defaults to 0.001*length_of_short_sequence, and is at least one dt2 step. Lowering it adds dumps; it must stay below the largest-runtime share of the cycle. In long-only aging (total_time_short_sequence = 0), this still shapes the reference cycle used to size the long sequence. Accepts expressions such as 2*dt2 or 0.001*tau_relax_1.

companion_dumps ?

enabled

After each long-sequence dump, add nearby companion dump(s) so a relaxation rate can be measured at that waiting time. Defaults to enabled. With the default of one companion shift, turning this off roughly halves the aging file count. Aging mode only; short production already has small separations from its own cycles.

companion_shifts [count] ?

How many companion dumps follow each long-sequence main dump. Defaults to 1. Each added shift adds about one dump per main long dump.

companion_offset_index [1-based index] ?

Which short-sequence dump offset to use as the first companion separation (counting from 1). Defaults to 1. Using short-sequence offsets keeps the same physical separations in aging and production. If dt1 and dt2 differ, unusable offsets are skipped and the index advances; Reality Checks report the separations actually used.

tau_relax_2 [LJ time, optional] ?

Optional rotational relaxation time. Leave blank to ignore it. If set, it appears on the Resolution plot; a blank short-sequence length then defaults to 0.90*tau_relax_2; and it can be used in expressions such as 0.9*tau_relax_2. Optimize/Compare can use it as a second local-gap target when present. In long-only aging it still feeds the reference short cycle that sizes the long sequence.

length_of_short_sequence [LJ time] ?

Duration of each short sequence (one cycle). Leave blank for 0.90*tau_relax_1, or 0.90*tau_relax_2 when tau_relax_2 is set. Prefer total_time_short_sequence = 0 for long-only output; this field then still defines the reference cycle for the long-sequence gap match. Entering 0 here also disables short files but falls back to the blank-field default length for that reference. Accepts expressions using tau_relax_1, tau_relax_2, tau_equil, dt1, and dt2.

largest_run_time_fraction [of cycle length] ?

Information-resolution parameter: largest runtime in a short sequence, as a share of that sequence’s length (between 0 and 1). Together with first_run_time_short, this determines how many dumps each cycle has; the app derives that count. Defaults to 0.18. In aging mode, the long sequence is matched to this largest short runtime (including long-only, where the short cycle is only a reference), and optimize storage will not propose a coarser cycle than this. Accepts expressions.

Not recommended to change

optimize_storage ?

enabled

When enabled, Generate builds your baseline schedule, then may replace it with a lower-storage alternative that still meets the local-gap target under the limits below. Defaults to enabled. Density is capped by largest_run_time_fraction. If nothing qualifies, the baseline is kept. Turn off to always keep the baseline. Compare schedules remains available afterward for manual exploration.

max local gap [% of target] ?

How wide the worst unsampled lag near tau_relax_1 may be (and near tau_relax_2 when set), as a percent of that relaxation time. Defaults to 10.

max added storage [% of baseline] ?

How much larger the estimated total DCD size may be than the baseline (short + long in aging mode). Defaults to 0 (no extra storage).

min repeats [count] ?

Fewest short-sequence repeats the optimize search may use. Defaults to total_time_short_sequence / tau_relax_1 (shown in the placeholder from your current inputs). Avoid entering fewer than 100.

long_sequence_filename [pattern] ?

Filename pattern for long-sequence DCD files. Default traj<n>.dcd matches 2_time_aging.py. Must include <n> as the file-number placeholder.

short_sequence_filename [pattern] ?

Filename pattern for short-sequence DCD files. Defaults to short<n>.dcd. Must include <n> as the file-number placeholder.

Generating schedule — this can take a moment.

Generated Commands

Run these commands with geo-rev11.py to generate the LAMMPS loop files, or download them directly below.

Long Sequence Command

[Show explanation]

Short Sequence Command

[Show explanation]

Reality Checks

- Long sequence first filename correct

- Long sequence starts at its first run_time

- Long runtimes sum exactly to the seam

- Short sequence first dump_time == long_last + its first run_time

- Short sequence first filename == long_count + 1

- Last dump within 1% of target

Summary & Downloads

Estimated Trajectory File Size (from LAMMPS simulation)

Number of particles [atoms] ?

Atom/particle count for size estimates only. Defaults to 100000. Uses 12 * particles + 100 bytes per single-frame DCD; does not change the dump schedule.

Note: This is the size of the .dcd files LAMMPS will write, not of the downloads below. Each single-frame file costs 12 * particles + 100 bytes.

Sequence	Dumps	Timestep Range	Time Range (LJ)	Est. Trajectory Size
Long (Equilibration)	--	--	--	--
Short (Production)	--	--	--	--
Total	--			--

Analysis Script Parameters

Analysis Command Examples

Generate a schedule to fill the cyclic analysis command examples.

2-time cyclic command

--

S4 cyclic command

--

Download LAMMPS Loop Files

Each ZIP holds the three schedule files (dump_times.txt, run_times.txt, file_names.txt), the LAMMPS loop templates, the analysis commands, and reproduction.txt recording every input used. All are small text files (~KB).

Visualization

Preview the dump schedule that will be used in your LAMMPS simulation.

Dump Times Linear Log

On log scale, geometrically spaced points appear linearly spaced.

Run Times (Intervals)

Resolution at tau_relax_1

Available time separations (lags) that the short-sequence schedule provides. Red: tau_relax_1. Purple, when tau_relax_2 is entered: rotational relaxation time. Filled regions bracket each target using its nearest available lag on either side. Dashed outlines mark the widest unsampled interval from 0.8 to 1.2 times that relaxation time; smaller local worst gaps mean denser useful information around the target.

Compare storage-aware schedules

This comparison does not change the generated schedule. It searches repeated, identical short sequences whose combined duration stays within 1% of the requested production length, and reports the ones with the smallest local lag gap. The storage allowance is relative to the current schedule's estimated total DCD size: short production plus, in aging mode, the matching long sequence. Denser short sequences that force a longer long sequence are charged for both. Every candidate keeps the current schedule's first_run_time_short, so what varies is the cycle length, the repeat count, and how tail-heavy each cycle is. The four limits below bound the search: it will not propose a coarser sequence or fewer repeats than you allow, nor more total storage. Dump counts are reported rather than requested, since each follows from the candidate's largest-runtime share and the fixed first runtime. tau_relax_2 is optional; when it is set, both relaxation times must meet the local-gap target. Each reported option includes its own resolution plot and a direct schedule ZIP; aging exports regenerate the matching long sequence for that option.

Maximum local gap near each target [%] ?

How wide the worst unsampled interval near each relaxation time may be, as a percent of that relaxation time. Defaults to 5. Smaller values demand denser sampling around tau_relax_1 (and tau_relax_2 when set) and therefore more dumps per short sequence. This comparison tool only reports alternatives; it does not change the generated schedule until you download one.

Maximum additional storage per run [%] ?

How much larger a candidate's estimated total DCD size may be than the current schedule's. In aging mode that total is short production plus the matching long sequence, so a denser short sequence that forces more long dumps is not treated as free. Defaults to 10. Raise it to see denser options; set it to 0 to require no extra storage.

Maximum largest_run_time_fraction ?

The largest share of a cycle its final runtime may take. This is the density limit: a smaller fraction means a flatter, denser sequence, so capping it stops the search from proposing anything coarser. Defaults to whatever the current schedule realized, so the comparison never suggests giving up resolution you already have. Raise it to let the search trade density for a different cycle length, or lower it to force denser candidates; the storage allowance still applies, so a tight cap can leave nothing qualifying. Dump counts are reported as an outcome, since they follow from this and first_run_time_short.

Minimum repeats ?

The number of short sequences the search is not allowed to go below. Defaults to whatever the current schedule used. Because the production length is fixed, repeats and cycle length are locked together: more repeats means a shorter cycle, so this is really a ceiling on cycle length. Lower it to let the search consider longer cycles than yours, raise it to force shorter ones.

Searching schedules — this can take a moment.

Generate a schedule with short sequences to compare storage-aware alternatives.

Geometric Dump Sequence Generator