The Bow-String Junction


Tutorial home




It’s not at all obvious how to convert a plucked string into a bowed one.  Fortunately we can take advantage of a lot of theoretical and experimental work that has already been done.


In 1953, F. G. Friedlander and J. B. Keller published papers which described the action of a bowed string.  It’s called a “stick/slip” action, where the string repeatedly switches between two states as the bow is pulled across it:



A picture of the friction function, commonly called the Friedlander-Keller function, is below.



So far, so good, what does that do for us?  It turns out that all we have to do to convert our plucked string into a bowed string is:


  1. Make a waveshaper (often called a “bow table”) that looks like that.
  2. Insert it into the string model, in the same way we created a woodwind by inserting the jet driver into the string model.
  3. Bow it with a sustained envelope instead of plucking it with a pulsed one.


That’s all.  Since the G2 has lots of modules available to build waveshapers, this won’t be too difficult.




Let’s build a Friedlander-Keller bow table


This is a rather complicated waveshaper, so we’ll build it one step at a time.  We’d like to see how it works, so we’ll excite it with a ramp LFO and examine the results on an oscilloscope.


This first patch is our starting point.  The LFO is our signal source.  It ramps up from -64 to +64, and then jumps immediately back to -64 and begins again.  The LFO rate is in the audio range, so we can see the results easily on an oscilloscope.  It’s better than a standard oscillator because it’s a clean ramp wave, containing no anti-aliasing properties.


The patch and its output are below.  It’s simply the LFO, repeatedly ramping from -64 to +64.






Creating the basic Friedlander-Keller function


Our first step will be copy the shape of the Friedlander-Keller function.  On a synthesizer with as many waveshaping functions as the G2, there are a lot of ways to do this.


We’ll use a SeqCtr module.  It can be used as a piecewise-linear waveshaper with 16 points.  Its input is limited to positive values, but we can get around that.


Below are the patch and its output.  Remember that as the input varies from 0 to 60, the SeqCtr sweeps from step 1 to step 16, transmitting the value on that step’s slider.  When the XFade control is set to 100%, the output is smoothed.


Notice that from step 1 to step 5, the SeqCtr’s output increases in a linear manner, like the Friedlander-Keller function.  From step 5 through step 16, the output decreases in a curve-like shape.  Also notice that we’re mimicking only the positive portion of the function (more on that later).







Why is the gain reducer there?


Now, let’s talk for a moment about that Gain module that’s set to 0.50.  What’s not obvious from the Friedlander-Keller diagram is that the straight-line portion of it should have a slope of 1.  It looks a lot steeper on the diagram, but that’s because the diagram is not to scale.  Our SeqCtr rises to 32 when the input reaches 16.  This gives the upward ramp portion of our SeqCtr’s output a slope of 2.  We did that so we can get more resolution out of the module.  To compensate for this, we need that gain module to reduce the output level to 16 when the input level is 16.




Handling negative input


The SeqCtr module only operates on positive inputs.  To match the entire Friedlander-Keller function, we need to handle negative inputs, as well.  Since the Friedlander-Keller function is symmetrical, all we need to do is:


  1. Rectify the input (converting negative values into positive values).
  2. Address the SeqCtr with the rectified input.
  3. Detect when the input is negative, and invert the SeqCtr’s output.


Below are the patch and its output.  Here are the changes:


  1. The input is limited, so that inputs above 64 Clavia units don’t do unexpected things.
  2. The input is rectified before being fed into the SeqCtr.
  3. We detect whether the input is positive, turn that information into a logic signal, and use that logic signal to choose whether the SeqCtr’s input should be inverted or not.


Notice that the output now looks like the Friedlander-Keller diagram.







Adding the bow table to the string


We’ll add the bow table to the string in the same way we created a reed woodwind by adding the jet driver to the string:


  1. Sum the outputs of the two delay lines, and reduce them by 50%.
  2. Feed this into the bow table.
  3. Send the output of the bow table to both delay lines.


The excitation is the “bow velocity” or the speed of the bow across the string.  This is just an envelope generator that is added to the input of the bow table.


The patch is below.  Don’t be worried that it doesn’t sound like a violin just yet.  There’s still a lot to do.  In fact, we won’t have a decent-sounding instrument until we do quite a bit more.