Acoustics Final Report
Northeastern University MUSC2350, Spring 2020

For this project, I used GNU Octave, an open source programming language and environment for mathematical modeling, based off of MATLAB.

Octave has an audioplayer function, which when provided with a vector of floating point numbers between \(-1\) and \(1\), treats them as a waveform and plays them back.

audioplayer (vector, bit_rate, bit_depth)

A sample is a discrete measurement of sound pressure level (SPL) averaged over a predefined duration of time. The bit_rate variable represents the number of samples to play per second. I chose to set this to be \(44100\), which is a standard bit rate used for CDs.³ The bit_depth variable has to do with the precision of the floating point numbers themselves.

My approach to simulating strings was to use additive synthesis⁴. This means that I attempted to simulate a vibrating string by building it up as a sum of partials. To start, I generated a waveform for the the fundamental frequency using octave's sinewave function (See Listing 1). Given a vector size and a period, it returns a set of values between -1 and 1 in the form of a sine wave with the specified period.

f1 = sinewave(bitRate * 4, bitRate / 440)

I defined my own convenience function puretone which would take the bit rate, duration, and frequency and return the corresponding sine wave (See Listing 2).

function puretone(seconds, frequency)
  sinewave(bitRate * seconds,
           bitRate/frequency);
endfunction

Now I had the ability to make pure tones, but I wanted harmonics. A harmonic is a partial whose frequency is an integer multiple of the fundamental.⁵ We usually only care about the first six harmonics or so, because after that they start to get to very high frequencies near the edge of human hearing. I defined a createharmonics function that returns a sum of six harmonics (See Listing 3). Notice that the returned vector must be divided by six to make sure the whole range of values is between \(-1\) and \(1\).

createharmonics(duration, fundamental):
  f1 = puretone(duration, fundamental);
  f2 = puretone(duration, fundamental * 2);
  f3 = puretone(duration, fundamental * 3);
  f4 = puretone(duration, fundamental * 4);
  f5 = puretone(duration, fundamental * 5);
  f6 = puretone(duration, fundamental * 6);

  return (f1 + f2 + f3 + f4 + f5 + f6) / 6;

I was so excited about the fact that my equations were producing the pitches that I wanted that I created a sample song using this function.

A3 = createharmonics(0.5, 220);
A4 = createharmonics(0.5, 440);
A5 = createharmonics(0.5, 880);
B4 = createharmonics(0.5, 495);
C5 = createharmonics(0.5, 523.26);
D4 = createharmonics(0.5, 293.33);
D5 = createharmonics(0.5, 293.33 * 2);
E4 = createharmonics(0.5, 330);
E5 = createharmonics(0.5, 660);
F5 = createharmonics(0.5, 348.84 * 2);
GS4 = createharmonics(0.5, 415.305);

aMinor = [A4, (C5 + E5) / 2,
          E4, (C5 + E5) / 2];
eMajor = [B4, (E5 + GS4) / 2,
          E4, (D5 + GS4) / 2];
dMinor = [A4, (D5 + F5) / 2,
          D4, (D5 + F5) / 2];

song = [aMinor, eMajor, aMinor, eMajor,
        dMinor, aMinor, eMajor,
        A4, E4, A3];
playSound(song, bitRate)

You can hear the result here:

After listening to the result, I could recognize this as music, but it sounded nothing like a guitar. What's missing?

First off, in a string, the relative amplitudes of the harmonics are not all the same.⁶ Secondly, for a plucked instrument, the amplitudes of all of the harmonics change over time, eventually diminishing to silence. Lastly, the soundboard of the instrument will act as a filter affecting the output of the instrument.⁷ Let's tackle these issues one by one.

First off, the fundamental frequency of a plucked string will always be the most prevalent harmonic.⁸ The relative amplitudes of harmonics of a plucked string depend on the pluck location.

We model a pluck as a "kink" in the string.⁹ The prevalence of each harmonic depends on whether the initial kink location is at one of that harmonic's nodes or antinodes. Put another way, it depends on the similarity of the string shape at the moment of the pluck to the shape of the resonant mode.

Similarity, in linear algebra, is defined as the dot product between two vectors. The more "aligned" those two vectors are, the higher their dot product.

If we take the fourier transform of the string shape, we should get an idea for which frequencies are represented. Let's first define the shape of our string.

Let's define a kink in terms of a piecewise function.

Let \(k\) be the kink location whose value is between \(0\) and \(1\), and \(L\) be the length of the string.

\[y_1={\frac x kL}, x \leq kL\]

\[y_2 = {\frac {1 - {\frac x L}} {1 - k}}, x > kL\]

The following pairs of graphs show the kink function on the left, and its FFT on the right. The only axis worth looking at is the x axis of the FFTs - each number corresponds to the harmonic index.

These images were generated using octave-online¹⁰ with the following call:

v = kink(1000, 0.1)
bar(abs(fft(v-mean(v)))(1:10)(2:end))

Notice that the fundamental is always the most prominent, but the behavior of the rest of the harmonics varies. Observe Figure 1 - the pluck location is in the center of the string, which emphasizes odd harmonics, and has no even harmonics because all even harmonics have a node in the center.

Moving the pluck location to the quarter point of the string (Figure 2), we see more harmonics pop up, but the fourth and eighth (and all multiples of four) are still silent, because the kink location is at the node of the fourth harmonic.

In Figure 3, all nine of the first harmonics are present. The tenth is not pictured, but it would be zero, because it has a node at the pluck location.

This is the result of scaling the harmonics using the weights from the FFT:

After listening to this result, I found that it sounded a little better - the fundamental was more prominent than before. It still did not sound like a physical string though.

When one plucks a string, it does not sustain the sound for very long. Immediately, it starts to lose energy to friction at the imperfect boundaries of the string, as well as friction with the fluid (air) in which it is vibrating.¹¹ I hoped that adding damping will at least make it sound plausible that the strings are being plucked.

Let's focus on the kinetic energy lost due to the motion of the bridge, since that is more significant than the energy lost to the air.¹² The way we take into account the bridge motion is by modeling it as an impedance mismatch, similar to how we would model a tube open on one end. This results in an exponential decay.

function y = damping(x, dampingTime, bitRate)
  y = 0.5 ^ (x / (dampingTime * bitRate));
endfunction

In this model, all of the frequencies decay at the same rate, which isn't necessarily accurate, although looking at a the spectrum of plucking my guitar string, I think this is a reasonable approximation.¹³

Okay, we've now made a generic plucked string instrument, but what makes a guitar a guitar? One of the aspects that has the biggest contribution to the timbre of a stringed instrument is its soundboard. A soundboard is a resonance chamber that takes the input vibration from a string and transforms its frequency spectrum, behaving as an acoustic filter. In a guitar, the string transfers its vibration through the bridge and into the top of the guitar. The top of the guitar is an idiophone¹⁴ that creates a pressure wave inside the body as it vibrates. It is the modes of this piece of wood plus the sound propagation inside of the body that together create this acoustic filter.¹⁵

To implement a filter in octave, I intended to use the signal library. While I did eventually manage to install it, I did not have enough time to implement this part before the project deadline. However, I read some papers about soundboard design. Luthiers install braces, which are strips of wood glued to the soundboard to create areas of greater stiffness, which encourages modes that have nodes in those locations.¹⁶ That same paper included Figure 4, which shows the frequency responses of "good" versus "bad" quality guitars. They both show peaks around 110 and 220 hertz, though the good guitars have higher amplitude peaks.

When I got this far in the project, for the first time I actually searched for "synthesizing guitar sound" on the internet.¹⁷ I found that the most commonly used algorithm for generating guitar sounds does not use additive synthesis! Instead, it uses subtractive synthesis, which means it starts with all possible frequencies (i.e. white noise), and filters them down to the frequencies of a guitar.

The sound source is responsible for generating a stream of vibrating air. We can categorize this generation into three phenomena: free edge oscillation, reeds, and vibrating lips. Here, we will only focus on free edge oscillation, since this is most relevant to the concept of edgetones.

Many wind instruments have a long tube called the bore that houses the air column. The air column vibrates at resonant modes that depend on the length²², \(L\), of the bore. \(c\) is the speed of sound in air.

\[f_n = {\frac {nc} {2L}}\]

Unlike an acoustic guitar, which typically leaves the soundboard the same and changes the sound source, woodwinds usually come with the ability to dynamically modify the acoustic properties of the bore. The way they do this is with holes. Holes in the bore force nodes at those locations because they fix the pressure at the hole location to be approximately equal to the atmospheric pressure outside of the bore.

The following is the source code for the octave program I wrote for the simulating strings section.

#pkg load signal

function y = damping(x, dampingTime, bitRate)
  y = 0.5 ^ (x / (dampingTime * bitRate));
endfunction

function y = createDamping(bitRate, duration, dampingTime)
  y = arrayfun(@(x) damping(x, bitRate, dampingTime), [1 : bitRate * duration]);
endfunction

function playSound(vector, bitRate)
  player = audioplayer (vector, bitRate, 16);
  play (player);
  while(isplaying(player))
  endwhile
endfunction

function y = puretone(bitRate, seconds, frequency, phaseShift=0)
  y = sinewave(bitRate * seconds, bitRate/frequency, phaseShift);
endfunction

function y = createtone(bitRate, duration, frequency, dampingFactors)
  y = puretone(bitRate, duration, frequency) .* dampingFactors;
endfunction

function y = createharmonics(bitRate, duration, fundamental, weights)

  dampingFactors = createDamping(bitRate, duration, 0.3);

  M = [];

  ## Build up matrix where each row is another harmonic
  for index = 1 : length(weights)
    M = [M; weights(index) * createtone(bitRate, duration, fundamental * index, dampingFactors)];
  endfor

  ## Collapse them at the end
  S = sum(M);

  y = S / max(S);
endfunction

function v = ffttest(bitRate, X, checkFreq)
  L = length(X);
  Y = fft(X);
  P2 = abs(Y / L);
  P1 = P2(1:(L / 2) + 1);
  checkIndex = checkFreq * L / bitRate;
  [checkVal, checkIndex2] = max(P1(checkIndex - 5 : checkIndex + 5));
  v = checkVal;
endfunction

## location must be between 0.0 and 1.0 
function y = kink(L, location)
  k = location;
  x = (0 : L);
  y1 = x / (k * L);
  y2 = (1 - (x / L)) / (1 - k);
  y = [y1(1:k*L), y2(k*L+1:L)];
endfunction

## Returns the first 10 harmonic weights for the given pluck location
function y = getHarmonicWeights(pluckLocation)
  v = kink(1000, pluckLocation);
  X = abs(fft(v - mean(v)));
  y = (X / max(X))(2:10);
endfunction

function filtertest()
  sf = 800; sf2 = sf/2;
  data=[[1;zeros(sf-1,1)],
        sinetone(25,sf,1,1),
        sinetone(50,sf,1,1),
        sinetone(100,sf,1,1)];
  [b,a]=butter ( 1, 50 / sf2 );
  filtered = filter(b,a,data);
endfunction

function main()
  bitRate = 44100;

  weights = getHarmonicWeights(0.15);
  duration = 2.0;

  A3 = createharmonics(bitRate, duration, 220, weights);

  C3 = createharmonics(bitRate, duration, 523.26 / 2, weights);
  E3 = createharmonics(bitRate, duration, 330, weights);
  E2 = createharmonics(bitRate, duration, 330 / 2, weights);
  aMinor = [A3, (C3 + E3) / 2, E2, (C3 + E3) / 2];

  song = [aMinor];
  playSound(song, bitRate)

  ## Uncomment the next line to save the audio to a file
  ## audiowrite("with_damping.wav", song, bitRate);
endfunction

main()