Algorithmic Smoothing for High-Dimensional Molecular Dynamics

## The data

A trajectory of N atoms over T frames is a matrix M ∈ R^3N×T. For a modest protein this is tens of thousands of rows and tens of thousands of columns: too large to inspect by eye, and dominated by motion that is fast, local, and meaningless. Each coordinate is the sum of a slow collective component and high-frequency thermal noise,

Naive frame averaging destroys the collective signal along with the noise; what is needed is a filter that respects the timescale separation between the two.

## Two-stage filtering

Stage one, alignment. Rigid-body tumbling masquerades as internal motion. Each frame is superposed onto a reference by minimizing RMSD over a stable atom selection, removing global rotation and translation so the remaining variance is internal:

Stage two, temporal smoothing. A Savitzky–Golay filter runs along the time axis of each coordinate. It fits a low-order polynomial in a sliding window, which suppresses high-frequency jitter while preserving the amplitude and phase of slow motions. Unlike a moving average, it does not flatten the peaks of the collective modes:

Window width w sets the cutoff timescale; polynomial degree d sets how aggressively sharp features survive. The pair is the only tuning the user touches.

## Essential dynamics

Smoothing makes the animation legible; principal component analysis of the coordinate covariance makes it interpretable. Diagonalizing the covariance of the aligned trajectory,

concentrates nearly all positional variance into the top handful of eigenvectors, the essential subspace. Projecting the trajectory onto the leading modes yields a denoised, low-dimensional description of what the protein actually does, and projecting back from the top modes alone reconstructs a trajectory containing only collective motion. The same diagonalization that denoises also names the motion.

  raw trajectory            aligned              filtered + projected
  3N x T matrix    -->    remove rigid    -->    Sav-Gol in time   -->   animate
  (thermal jitter)         tumbling (2)          + top PCA modes (3,4)   top modes
       |                                                  |
       |  variance spread over thousands of dofs          |  variance in ~3-5 modes
       +--------------------------------------------------+

# Chimera-side: parse coordinate matrix, denoise, drive the viewer
M       = parse_traj(path)              # [3N, T] coordinate matrix
M       = superpose(M, ref, sel=core)   # Eq (2): kill rigid-body tumbling

M_s     = savgol(M, axis=time,          # Eq (3): polynomial time filter
                 window=w, degree=d)
V, L    = eig(cov(M_s))                 # Eq (4): essential dynamics
M_ess   = project(M_s, V[:, :k])        # keep top-k collective modes

for frame in reconstruct(M_ess):        # push denoised frames to Chimera
    viewer.set_coords(frame)

## Design notes

• Filtering is applied after superposition; reversing the order lets tumbling leak into the smoothed signal and corrupts the covariance in (4).
• Savitzky–Golay over moving-average specifically because collective modes are oscillatory; a boxcar filter attenuates exactly the peaks of interest.
• Memory: the 3N×T matrix is streamed and filtered in coordinate-blocked chunks so trajectories larger than RAM still process; only the covariance and top modes are held resident.
• The scripts are Chimera-native, so denoised trajectories drive the existing rendering and selection machinery directly, with no export to a second tool.