This calculates string tension, behind-the-nut pitch, and where the harmonic ladders on both sides of the nut line up closely enough to resonate.

Use String Tree when you want to understand one string in detail first, then see what that same setup is likely to wake up elsewhere on the instrument.

String layout scale length and note layout Gauge set string thickness only Pre-nut preset headstock and tuner geometry Units Imperial Metric inches and gauge-thou Scale length inches Material Steel approximation Nickel approximation Phosphor bronze approximation steel plain strings, steel core + wrap for wound Match window cents for overlap Min frequency lowest frequency shown Max frequency highest frequency shown Open partials speaking-length modes After partials pre-nut modes Sort mode Excitation Closeness Frequency how overlap results are ordered

Total tension 0.00 lb 0.00 N

Strings 0 editable rows below

Plain-English summary

What each side of the nut is most likely to tell the other side to do.

Afterlength hit

Select a string to see the result.

Open string hit

Select a string to see the result.

Strings

Edit notes and gauges directly. Tension updates live.

Add string

Note	Gauge (thou)	Wound	Pre-nut (in)	Tension	Afterlength	Best match

Plain and wound approximation

Plain strings are treated as solid steel. Wound strings are treated as a steel core plus a wrap layer using the selected material density. This is still an approximation, not a manufacturer unit-weight table, but it is closer than treating every string as one solid rod.

Selected string analysis

Click a string row in the configuration table, or use the selector here, to inspect the exact speaking-length and afterlength harmonic sequences.

Selected string controls the graphs and tables below

Open string spectrum

Afterlength spectrum

Overlap / excitation

Aligned harmonic ladders

Open-string and afterlength harmonics are ordered against the same frequency axis so nearby modes line up together.

Open mode	Open frequency	Open note	After mode	After frequency	After note

Open harmonics and nearest excitable after modes

The closest afterlength matches for each open-string harmonic inside the current cent window.

Open harmonic	Nearest excitable after modes

Intersection of excitation

The exact mode pairs on either side of the nut that line up inside the selected cent window.

Open mode	Open frequency	After mode	After frequency	Distance	Excitation

What else rings?

Supplementary first-order instrument response. Pick a source on the selected string and see what immediately answers elsewhere.

Source string defaults to the selected row above Source side Open string Afterlength which side gets excited first Source mode use H0 or A0 to seed the whole side Response threshold minimum first-order strength

Immediate response lanes

The same string, the cross-nut side, other open strings, and other afterlengths on one shared frequency view.

Source string modes

The open-string and afterlength mode ladders for the selected source string. For the tighter local view of this same relationship, stay in the sections above.

String	Side	Mode	Frequency	Note	Relative amplitude	Role

Immediate per-string totals

Which strings collect the strongest direct first-order response.

String	Open total	After total	Strongest mode reached

Immediate effects table

The direct first-order response only, with target, frequency, distance, strength, and path.

Target	Frequency	Distance	Strength	Path

Last Updated - 2026 March 26

String Tree

This is the first useful version of the behind-the-nut string calculator.

It now does two related jobs:

• the precise local one-string view
• the supplementary What else rings? view underneath

So the page starts with one string's own two-sided harmonic geometry, then extends that into a first-order instrument response view using the same setup data.

Right now it calculates string tension from:

• scale length
• tuning
• string diameter
• whether the string is plain or wound
• the selected wrap-material approximation for wound strings

It also calculates the open-string frequency of the segment behind the nut, between the nut and the tuning peg, using the same estimated linear density and the same tension.

It also generates the exact harmonic sequences on both sides of the nut:

• the speaking length harmonic ladder for the open string
• the afterlength harmonic ladder between the nut and the tuning peg

Then it checks where those two sequences intersect inside a chosen cent window, so you can see which open-string modes are the strongest candidates for sympathetic excitation.

It has separate defaults for common string layouts, common string sets and measured pre-nut geometries so you can start from something normal and then make it weird.

The overlap is still a frequency-domain model rather than a full mechanical transfer simulation at the nut, but it is now based on the actual derived harmonic ladders on each side instead of a vague nearest-match shortcut.

Reading the page

There are four layers to this thing.

First, the top table calculates the obvious string facts:

• the target open note
• the resulting open-string frequency
• the gauge and derived diameter
• whether the string is being treated as plain or wound
• the speaking-length tension
• the afterlength frequency behind the nut

That top table is the broad overview. If you just want to know "what pitch is that weird bit of string making?" this is the fast answer.

Second, the three graphs show different parts of the same story.

Open string spectrum

• this is the harmonic ladder of the speaking length
• each bar is one open-string harmonic
• the label under each bar is the actual frequency of that mode, not just a harmonic index
• the bar height is a simple 1 / n amplitude model, so the lower harmonics dominate

Afterlength spectrum

• this is the harmonic ladder of the string segment between the nut and the tuner
• again, each bar is labeled by its actual frequency
• because the afterlength is much shorter, those frequencies climb very quickly

Overlap / resonant excitation

• this shows only open-string modes that actually have a matching afterlength mode inside the current cent window
• if tightening the match window removes a bar, that match was not exact enough to survive stricter comparison
• if widening the match window adds bars, you are allowing looser near-misses to count as possible resonances

Third, Aligned harmonic ladders is there so you can read both sides against the same frequency axis. That is the important one if you are trying to answer questions like:

• "what is near 1400 Hz on both sides?"
• "is this open-string harmonic close to anything behind the nut?"
• "where do the two ladders drift apart?"

Fourth, the two lower tables are summaries at different levels of detail.

Open harmonics and nearest excitable after modes

• this is the fast lookup table
• left side is the open-string harmonic
• right side shows the nearest afterlength matches inside the selected window

Intersection of excitation

• this is the full exact pair list
• it shows every open/after mode pair that survived the cent comparison
• Distance is the cent difference
• Excitation is the weighting used in the current model

This means the page can be read in three different ways:

• casually from the top table
• visually from the graphs
• analytically from the aligned and overlap tables

Then below that, What else rings? takes the currently configured instrument and asks the next question:

• if I pluck this selected string on one side of the nut
• what immediately responds elsewhere
• and where do those direct responses sit in frequency

That lower section is meant as a supplementary instrument response view, not a replacement for the tighter one-string analysis above it.

Assumptions

This version assumes:

• one uniform outer diameter per string
• one estimated linear density per string
• the same tension everywhere on the string
• plain strings are solid steel
• wound strings are steel core plus wrap material with an estimated fill factor
• the same material model on both sides of the nut

That makes it a useful approximation tool, especially for comparison work and for getting the order of magnitude right.

For wound strings it is still an approximation rather than sacred text. If you want exact brand-matched tension, you need published unit weights for the specific string.

Formula

The tension calculation uses:

T = μ * (2Lf)^2

Where:

• T is tension
• μ is linear mass density
• L is scale length
• f is target frequency

For plain strings, the linear density approximation is:

μ = ρπr²

That is, material density times the cross-sectional area of the string.

For wound strings, this page now uses a simple composite model:

μ = (ρcore * Acore) + (ρwrap * Awrap * fill)

Where:

• the core is treated as steel
• the wrap is treated as the selected material
• fill is a simple correction so the wrap layer is not treated as a perfectly solid annulus

That is still not the same thing as a manufacturer unit-weight table, but it is much closer than a one-material solid-cylinder model.

For the behind-the-nut segment, once tension is known, frequency is:

f = (1 / 2L) * √(T / μ)

So if the string tension and diameter are unchanged across the nut, the afterlength frequency can be calculated directly from the pre-nut segment length.

For the harmonic-overlap estimate, this version does something simpler than a full mechanical simulation:

• it generates the first several harmonics of the afterlength
• it generates the open-string harmonic ladder on the speaking length
• it compares every open harmonic against every afterlength harmonic
• it keeps the exact mode pairs that fall within a chosen cent tolerance window
• it weights closer and stronger partial matches more strongly than looser ones

That is not the same thing as measuring real energy transfer at the nut, but it is a useful first-pass predictor of which open-string modes are likely to ring along with the afterlength.

What the controls mean

String layout

Loads a note layout and scale length.

Gauge set

Loads a common string set and its default plain/wound pattern.

Pre-nut preset

Loads measured or generic nut-to-tuner geometry.

Scale length

This is the speaking length from nut to bridge saddle. It drives the tension calculation. A longer scale at the same tuning and gauge requires more tension.

Material

This controls the wrap-material approximation used for wound strings. Plain strings are always treated as solid steel.

Wound

Each row has a Wound checkbox.

• unchecked means plain string
• checked means wound string

The gauge-set presets provide defaults, but you can override any row manually.

Match window

This is the cent tolerance for deciding whether two modes are "close enough" to count as a resonance candidate.

• lower values mean stricter matching
• higher values mean looser matching
• 0 would be fantasy-world exact coincidence

In practice, this is the control to touch when you want to decide whether the page should behave like a strict tuning inspector or a looser "probably rings with that" estimator.

Clojure

(def steel-density-kg-m3 7850.0)
(def inches->meters 0.0254)

(defn gauge-thou->radius-m
  [gauge-thou]
  (/ (* gauge-thou 0.001 inches->meters) 2.0))

(defn linear-density
  [density gauge-thou]
  (let [r (gauge-thou->radius-m gauge-thou)]
    (* density Math/PI r r)))

(defn string-tension-newtons
  [{:keys [scale-inches frequency-hz gauge-thou density]}]
  (let [mu (linear-density density gauge-thou)
        scale-m (* scale-inches inches->meters)]
    (* mu
       (Math/pow (* 2.0 scale-m frequency-hz) 2.0))))

(defn newtons->pounds
  [n]
  (* n 0.2248089431))

(defn afterlength-frequency
  [{:keys [afterlength-inches gauge-thou density tension-newtons]}]
  (let [mu (linear-density density gauge-thou)
        length-m (* afterlength-inches inches->meters)]
    (* (/ 1.0 (* 2.0 length-m))
       (Math/sqrt (/ tension-newtons mu)))))

(defn cents-between
  [f1 f2]
  (Math/abs
    (* 1200.0
       (/ (Math/log (/ f2 f1))
          (Math/log 2.0)))))

(def note-names ["C" "C#" "D" "D#" "E" "F" "F#" "G" "G#" "A" "A#" "B"])

(defn frequency->note-label
  [frequency]
  (let [midi (+ 69.0
                (* 12.0
                   (/ (Math/log (/ frequency 440.0))
                      (Math/log 2.0))))
        rounded (Math/round midi)
        note-name (nth note-names (mod rounded 12))
        octave (- (quot rounded 12) 1)
        cents (* (- midi rounded) 100.0)]
    (str note-name octave
         " "
         (if (neg? cents) "" "+")
         (format "%.1fc" cents))))

(defn harmonic-series
  [root-frequency mode-count min-frequency max-frequency]
  (mapv (fn [mode]
          (let [frequency (* root-frequency mode)]
            {:mode mode
             :frequency frequency
             :note (frequency->note-label frequency)
             :amplitude (/ 1.0 mode)}))
        (->> (range 1 (inc mode-count))
             (filter (fn [mode]
                       (let [frequency (* root-frequency mode)]
                         (and (<= min-frequency frequency)
                              (<= frequency max-frequency))))))))

(defn align-series
  [open-series after-series tolerance-cents]
  (loop [open-items open-series
         after-items after-series
         rows []]
    (let [open-item (first open-items)
          after-item (first after-items)]
      (cond
        (and (nil? open-item) (nil? after-item))
        rows

        (and open-item after-item
             (<= (cents-between (:frequency open-item)
                                (:frequency after-item))
                 tolerance-cents))
        (recur (rest open-items)
               (rest after-items)
               (conj rows {:open-item open-item
                           :after-item after-item
                           :aligned true}))

        (and open-item after-item
             (< (:frequency open-item) (:frequency after-item)))
        (recur (rest open-items)
               after-items
               (conj rows {:open-item open-item
                           :after-item nil
                           :aligned false}))

        (and open-item after-item)
        (recur open-items
               (rest after-items)
               (conj rows {:open-item nil
                           :after-item after-item
                           :aligned false}))

        open-item
        (recur (rest open-items)
               after-items
               (conj rows {:open-item open-item
                           :after-item nil
                           :aligned false}))

        :else
        (recur open-items
               (rest after-items)
               (conj rows {:open-item nil
                           :after-item after-item
                           :aligned false})))))

(defn sort-open-modes
  [open-modes sort-mode]
  (case sort-mode
    :closeness
    (sort-by (fn [{:keys [cents score]}]
               [(or cents ##Inf) (- score)])
             open-modes)

    :frequency
    (sort-by :frequency open-modes)

    (sort-by :score > open-modes)))

(defn sort-overlap-pairs
  [pairs sort-mode]
  (case sort-mode
    :closeness
    (sort-by (fn [{:keys [cents weight]}]
               [cents (- weight)])
             pairs)

    :frequency
    (sort-by (juxt :open-frequency :after-frequency) pairs)

    (sort-by :weight > pairs)))

(defn summarize-open-mode
  [open-mode]
  (when-let [best-match (first (:contributors open-mode))]
    {:open-mode (:mode open-mode)
     :open-frequency (:frequency open-mode)
     :after-mode (:after-mode best-match)
     :after-frequency (:after-frequency best-match)
     :cents (:cents best-match)}))

(defn plain-english-summary
  [{:keys [note open-frequency after-frequency open-modes overlap-pairs]}]
  (let [best-open-mode (first (filter #(pos? (:score %)) open-modes))
        best-after-pair (first overlap-pairs)]
    {:afterlength-hit
     (if best-open-mode
       (str "If you hit the afterlength on the " note
            " string, you will hear "
            (frequency->note-label after-frequency)
            " on the afterlength and the open string is most likely to answer at "
            (frequency->note-label (:frequency best-open-mode))
            " via harmonic H" (:mode best-open-mode) ".")
       (str "If you hit the afterlength on the " note
            " string, you will hear "
            (frequency->note-label after-frequency)
            ", but there is no strong open-string resonance inside the current match window."))

     :open-hit
     (if best-after-pair
       (str "If you hit the open " note
            " string, the strongest related afterlength pitch in the current window is "
            (frequency->note-label (:after-frequency best-after-pair))
            " via afterlength mode A" (:after-mode best-after-pair) ".")
       (str "If you hit the open " note
            " string, this model does not find a strong afterlength mode inside the current match window."))}))

(defn harmonic-overlap
  [{:keys [note
           open-frequency
           afterlength-frequency
           tolerance-cents
           min-frequency
           max-frequency
           open-partials
           after-partials
           sort-mode]}]
  (let [open-series (harmonic-series open-frequency
                                     open-partials
                                     min-frequency
                                     max-frequency)
        after-series (harmonic-series afterlength-frequency
                                      after-partials
                                      min-frequency
                                      max-frequency)
        raw-open-modes
        (for [{open-mode :mode
               open-hz :frequency
               open-note :note
               open-amp :amplitude} open-series]
          (let [contributors (->> (for [{after-mode :mode
                                         after-hz :frequency
                                         after-note :note
                                         after-amp :amplitude} after-series
                                        :let [cents (cents-between open-hz after-hz)]
                                        :when (<= cents tolerance-cents)]
                                    {:open-mode open-mode
                                     :open-frequency open-hz
                                     :open-note open-note
                                     :after-mode after-mode
                                     :after-frequency after-hz
                                     :after-note after-note
                                     :cents cents
                                     :weight (* open-amp
                                                after-amp
                                                (- 1.0 (/ cents tolerance-cents)))})
                                  (sort-by :weight >))
                score (reduce + (map :weight contributors))]
            {:mode open-mode
             :frequency open-hz
             :note open-note
             :score score
             :cents (:cents (first contributors))
             :contributors contributors}))
        raw-overlap-pairs (mapcat :contributors raw-open-modes)
        open-modes (sort-open-modes raw-open-modes sort-mode)
        overlap-pairs (sort-overlap-pairs raw-overlap-pairs sort-mode)]
    {:open-series open-series
     :after-series after-series
     :aligned-series (align-series open-series after-series tolerance-cents)
     :open-modes open-modes
     :mode-map (keep summarize-open-mode open-modes)
     :overlap-pairs overlap-pairs
     :summary (plain-english-summary {:note note
                                      :open-frequency open-frequency
                                      :after-frequency afterlength-frequency
                                      :open-modes open-modes
                                      :overlap-pairs overlap-pairs})}))

That is the current core of the calculator: filtered harmonic ladders, overlap detection, aligned display, sort modes, and the plain-English summary.

Support Me!

If you appreciate the information presented then please consider joining patreon or donating!