I could not understand why only certain discrete frequencies are allowed in a fixed-ended string. How does the string behave if we excite it with frequencies other than resonant frequencies?


One way to explain it is to look at the string as a waveguide. You can send wave packets over the string, and they're reflected at the ends:

Single wave packet being reflected

Now, you can send in wave packets repeatedly rather than just once:

Many wavepackets at non-resonant interval

This is essentially exciting the string with a (non-sinuoidal) periodic signal of pulses. But it is not resonance: the new pulses don't amplify the old ones in a meaningful way, they just randomly add or cancel.

However, when you send the next pulse always after exactly one period of the string, it will consistently add to the old pulse's amplitude, and that's where you get resonance: a small input amplifies to a large oscillation over time.

Resonance of peaks

This works (in case of a wave equation with linear dispersion) for any periodic signal, i.e. for a regular stream of pulses as well as a sine input:

Resonant sine input

...Again, only if you hit the correct frequency. If not, the behavious is something like that:

Non-resonant sine input

Source code: (Haskell with dynamic-plot)

{-# LANGUAGE TypeFamilies #-}

import Graphics.Dynamic.Plot.R2
import Text.Printf

import Data.VectorSpace
import Data.VectorSpace.Free

import qualified Data.Vector.Unboxed as VU

import Data.Semigroup

rk₄ :: (VectorSpace v, t ~ Scalar v, Fractional t)
            => t -> (t -> v -> v) -> v -> [(t,v)]
rk₄ h f y₀ = go 0 y₀
 where go t y = (t, y) : go (t+h)
          (y ^+^ (h/6)*^(k₁ ^+^ 2*^(k₂^+^k₃) ^+^ k₄))
        where k₁ = f  t        y
              k₂ = f (t+h/2) $ y^+^(h/2)*^k₁
              k₃ = f (t+h/2) $ y^+^(h/2)*^k₂
              k₄ = f (t+h)   $ y^+^h*^k₃

type Time = Double
type Amplitude = Double
type Velo = Double

newtype StringState
  = StringState { getFDSState :: VU.Vector (Amplitude, Velo) }

instance AdditiveGroup StringState where
  zeroV = StringState $ VU.replicate 128 zeroV
  negateV (StringState ys) = StringState $ VU.map negateV ys
  StringState ys ^+^ StringState zs
      = StringState $ VU.zipWith (^+^) ys zs

instance VectorSpace StringState where
  type Scalar StringState = Double
  μ *^ StringState ys = StringState $ VU.map (μ*^) ys

spatDeriv² :: StringState -> VU.Vector Double
spatDeriv² (StringState ys)
 = VU.singleton 0
   <> VU.zipWith3 (\(l,_) (m,_) (r,_)
                    -> (l + r - 2*m)*fromIntegral (VU.length ys)^2)
             ys (VU.drop 1 ys) (VU.drop 2 ys)
   <> VU.singleton 0

stringDynamics :: (Time -> Amplitude) -> StringState
                     -> [(Time,StringState)]
stringDynamics excite y₀
   = sparsen $ rk₄ (1/(20*fromIntegral oversampling)) propag y₀
 where propag t st@(StringState ys) = StringState
           $ VU.zip
              (VU.map snd ys
                 VU.// [(0, 9 * (excite t - fst (ys VU.! 0)))])
              (VU.map (^*(0.1)) (spatDeriv² st))
       oversampling = 4
       sparsen (q:qs) = q : sparsen (drop (oversampling - 1) qs)

stringPlot :: StringState -> DynamicPlottable
stringPlot (StringState ys)
  = lineSegPlot $ zip [0, 1/fromIntegral (VU.length ys)..]
                      (map fst $ VU.toList ys)

period :: Time
period = 2*sqrt 10

animateResponse :: (Time -> Amplitude) -> DynamicPlottable
animateResponse excite
  = plotLatest
     [ legendName (printf "t = %.1g" t) $ stringPlot ys
     | (t,ys) <- stringDynamics excite zeroV

main :: IO ()
main = do
 plotWindow [
   animateResponse $ \t -> let ccl = floor $ t/period
                               t' = t - fromIntegral ccl*period
                           in exp (-8*(t'-5)^2)/3
 plotWindow [
   animateResponse $ \t -> sin (2*pi*t/period)/4
 plotWindow [
   animateResponse $ \t -> sin (2*pi*t*1.20124)/4
 return ()

Are you familiar with the steady-state solutions to the equation $$ \frac{d^2 x}{dt^2}+\Omega_0^2 x= F \sin (\Omega t)? $$ (If not, look for a solution $x(t) \propto \sin (\Omega t)$ and find the constant of proportionality)

When you solve this you can immediately see that you can excite an oscillator with frequency $\Omega$ even when $\Omega$ is not equal to the resonant frequency $\Omega_0$. You can then apply this to each mode in the normal mode decomposition of the string and see that the string will vibrate at the applied frequency $\Omega$, but not very much unless $\Omega\approx \Omega_n$ where $\Omega_n$, for some $n$, is the frequency of the $n$-th mode.

Note added: To expand on what I said above: if you apply a force $F(x) \sin \omega t$ you first decompose into normal modes $$ y(x,t)= \sum_n a_n(t) \sin\left (\frac{n\pi x}{L}\right) $$ and then each mode $a_n(t)$ obeys $$ \frac{d^2 a_n(t)}{dt^2}+\Omega_n^2 a_n(t)= F_n \sin (\Omega t) $$ where $\Omega_n$ is the frequency of the mode $n$ and $ F_n$ is the $n$-th Fourier coefficient of $F(x)$.

  • $\begingroup$ I understand it for damp deiven oscillator but i want to know how it applicable to wave on string. $\endgroup$ – uv raj Jan 22 at 8:54
  • $\begingroup$ I'll a few lines $\endgroup$ – mike stone Jan 22 at 12:58

In addition to mike stone's answer. A damped driven oscillator can oscillate with any frequency. However the oscillation amplitude will be the largest only if the driving force frequency is close to the resonance frequency. The less damping, the more peaked the dependence is. Search information about driven oscillator, e.g. https://en.wikipedia.org/wiki/Harmonic_oscillator#Sinusoidal_driving_force


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.