• # Lesson 30. Clusters, Repeats and Ornaments

## Annotation

Clusters have become a feature of piano writing since the experiments of Henry Cowell in the early 20th century. Written ornaments and repeat signs appeared much earlier, around the 16th century. This piece brings these additions together.

This composition introduces manually written OMN ornaments and articulations into an existing part. It also processes the resultant OMN list produced initially from MAKE-OMN with GEN-PAUSE and GET-TIME-SIGNATURE. It shows how, with GEN-PAUSE, a keyboard texture can be split between the hands.

The first focus is on using the function GEN-CLUSTER. This a formidable function with many parameters and keywords:

```(setf clusters-mix
(gen-cluster cluster-size :type '?
:rotate '(0 2 -1 3 0 -2 2 -2 2 -1)
:transpose (rnd-sample 10 integers :seed 72)))```

The variable cluster-size is a list of cluster lengths:

`(setf cluster-size '(2 4 3 5 2 4 3 1 3 4))`

These cluster-size values can be processed as chords or separate pitches (melodies) or as a random selection of both.The keyword :type may have the value 'c, 'm or '?. So in clusters-mix we have a random selection ('?). The keyword :rotate is a musical rather than mathematical rotation, thus moving rotated pitches into higher or lower octaves. Notice how chords and single pitches in a list are rotated with minus values. Then, there’s the keyword :transpose:

`. . . :transpose (rnd-sample 10 transp-values :seed 72)`

The variable transp-values gives a list of the transposition values associated with the Slonimsky pattern we’ve used in almost all the tutorials:

`=> (0 1 6 7 12)`

The result here is that 10 RND-SAMPLE values from transp-values move the clusters into different transpositions.

```=> ((c5cs5) (gs4 a4 fs5 g5) (d3c4cs4)
(a4 as4 fs5 g5 gs5) (c5 cs5) . . .)```

When examining this output, keep in mind the effect of rotation on the pitch order.

Before we move to the next cluster expression Audition the variable cl-1. You’ll hear that the piano texture moves obliquely from treble to bass and back: it needs to be played using both hands. Using GEN-PAUSE we can achieve this . . . but there are ornaments and articulations to add first.

The second cluster expression is almost identical to the first, but the output is melodic and the random :seed that dealt with the :transpose keyword is different.

Now to the rhythm. This calls for a straightforward span of pitch lists to a note-length value:

```(setf rhy (span clusters-mix '(e)))
=> ((1/8) (1/8 1/8 1/8 1/8) (1/8)
(1/8 1/8 1/8 1/8 1/8) (1/8 1/8) (1/8) . . .)```

However, the sensible composer wants a longer duration on those lists that contain a single note-length, partly because the pitches that occupy these lists are in the bass register and need more sounding space. So those values are augmented by using the :section keyword to manually specify the lists to be replaced with longer length values:

```(setf rhy-aug
(position-replace '(0) '(1/4) rhy :section '(0 2 5 7)))
=> ((1/4) (1/8 1/8 1/8 1/8) (1/4)
(1/8 1/8 1/8 1/8 1/8) . . .)```

We can use the same technique to replace dynamics when single list values occur:

```(setf dyn-ff
(position-replace '(0) '(ff) dyn :section '(0 2 5 7)))```

We could end the basic composing here, but there’s an opportunity, once we’ve created an OMN list for each cluster expression, to add musical detail and articulations. Here’s the basic output:

```(setf cl-1
(make-omn
:length rhy-aug
:pitch clusters-mix
:velocity dyn-ff))

=> ((q c5cs5 ff) (e gs4 mp a4 fs5 g5)
(q d3c4cs4 ff) (e a4 mp as4 fs5 g5 gs5) . . .)```

And here is a new OMN sequence of sublists complete with added repeats, arpeggiation of chords, legato and a glissando:

```(setf cl-1a
'((q c5cs5 ff =)
(e gs4 mp leg a4 leg fs5 leg g5)
(q d3c4cs4 ff =)
(e a4 mp leg as4 leg fs5 leg g5 leg gs5)
(e c5 mp leg cs5)
(q d3ds3c4cs4 fff arp)
(e ds4 mp leg cs5 leg d5)
(q c2 key-gliss c4 ff)
(e ds4 mp leg cs5 leg d5)
(e ds4 mp leg c5 p leg cs5 pp leg d5 ppp :repeat 2)))```

A new variable cl-1a has been created and the edits and additions written by hand. These include repeats like :repeat 2, arpeggiation arp, and glissandi key-gliss. In the other cluster expression there are trills tr1, acciaccaturas (acc c5), appoggiaturas (app b5) and staccato stacc:

```(setf cl-2a
'((e c5 p cs5 tr1)
(e d5 p (acc c5) ds5 c6 cs6)
(e a3 p g4 gs4 tr1)
(e as4 p b4 g5 gs5 a5)
(e fs4 p g4)
(e d3 p ds3 c4 cs4)
(e d5 p (app b5) c6 cs6)
(e c3 fff)
(e gs4 p stacc fs5 stacc g5 stacc)
(e ds3 p stacc c4 stacc cs4 stacc d4 stacc)))```

Now, to bring this material together and in a different way from previous tutorials, as all the lists we are using are OMN lists:

```(setf rh-1 (gen-pause cl-1a :section '(0 2 5 7)))
(setf lh-1 (gen-pause cl-1a :section (find-complement '(0 2 5 7) :high 9)))```

These expressions using GEN-PAUSE with the addition of FIND-COMPLEMENT split the keyboard texture between right and left hands.

Finally, notice how the function GET-TIME-SIGNATURES flawlessly interprets the OMN lists to produce the time-signature:

```(setf timesigs (get-time-signature rh-1))
=> ((2 4 1) (2 4 1) (2 4 1) (5 8 1) (1 4 1) . . .)```

Coda: Using and extending OMN script is a great way to add the sort of detail that is often left out of a parametric score-script. Composers often feel it’s easier to add such detail when working on the final notated piece on a score-writer. With Opusmodus, and with a little practice, adding performance detail can be achieved successfully, and the MIDI realisation of ornaments, for example, is excellent.

Sometimes it is also very useful and necessary to examine the elements of an OMN list separately, which can easily be done with the function DISESSEMBLE-OMN:

```(disassemble-omn cl-2a)
=> (:length ((1/8 1/8) (1/8 0 1/8 1/8 1/8) (1/8 1/8 1/8)
(1/8 1/8 1/8 1/8 1/8) (1/8 1/8)
(1/8 1/8 1/8 1/8) (1/8 0 1/8 1/8)
(1/8) (1/8 1/8 1/8) (1/8 1/8 1/8 1/8))
:pitch ((c5 cs5) (d5 c5 ds5 c6 cs6) (a3 g4 gs4)
(as4 b4 g5 gs5 a5) (fs4 g3)
(d3 ds3 c4 cs4) (d5 b5 c6 cs6)
(c3) (gs4 fs5 g5) (ds3 c4 cs4 d4))
:velocity ((p p) (p p p p p) (p p p)
(p p p p p) (p p)
(p p p p) (p p p p)
(fff) (p p p) (p p p p))
:articulation ((- tr1) (- acc - - -) (- - tr1)
(- - - - -) (- -)
(- - - -) (- app - -)
(-) (stacc stacc stacc)
(stacc stacc stacc stacc)))```

Finally, note how the function RESPELL has been added to the left hand part of the piano within the final DEF-SCORE expression.

``` (piano-lh
:omn (respell lh-2 :type :chord))
)```

## Score

```(setf pitches '(c4 cs4 fs4 g4 c5))
(setf transp-values (pitch-to-integer pitches))
(setf cluster-size '(2 4 3 5 2 4 3 1 3 4))

(setf clusters-mix
(gen-cluster cluster-size
:type '? :rotate '(0 2 -1 3 0 -2 2 -2 2 -1)
:transpose (rnd-sample 10 transp-values :seed 72)))

(setf clusters-mel
(gen-cluster cluster-size
:type 'm :rotate '(0 2 -1 3 0 -2 2 -2 2 -1)
:transpose (rnd-sample 10 transp-values :seed 51)))

(setf rhy (span clusters-mix '(e)))
(setf rhy-2 (span clusters-mel '(e)))
(setf rhy-aug (position-replace '(0) '(1/4) rhy :section '(0 2 5 7)))

(setf dyn (span rhy '(mp)))
(setf dyn-ff (position-replace '(0) '(ff) dyn :section '(0 2 5 7)))

(setf cl-1 (make-omn
:length rhy-aug
:pitch clusters-mix
:velocity dyn-ff))

(setf cl-2 (make-omn
:length rhy-2
:pitch clusters-mel
:velocity '(p)))

;; Edited output from cl-1
(setf cl-1a
'((q c5cs5 ff =)
(e gs4 mp leg a4 leg fs5 leg g5)
(q d3c4cs4 ff =)
(e a4 mp leg as4 leg fs5 leg g5 leg gs5)
(e c5 mp leg cs5)
(q d3ds3c4cs4 fff arp)
(e ds4 mp leg cs5 leg d5)
(q c2 kgliss c4 ff)
(e ds4 mp leg cs5 leg d5)
(e ds4 mp leg c5 p leg cs5 pp leg d5 ppp :repeat 2)))

;; Edited output from cl-2
(setf cl-2a
'((e c5 p cs5 tr1)
(e d5 p (acc c5) ds5 c6 cs6)
(e a3 p g4 gs4 tr1)
(e as4 p b4 g5 gs5 a5)
(e fs4 p g4)
(e d3 p ds3 c4 cs4)
(e d5 p (app s b5) e c6 cs6)
(e c3 fff)
(e gs4 p stacc fs5 stacc g5 stacc)
(e ds3 p stacc c4 stacc cs4 stacc d4 stacc)))

#| Examine the elements of an OMN list separately
(disassemble-omn cl-2a)
|#
(setf rh-1 (gen-pause cl-1a :section '(0 2 5 7)))
(setf lh-1 (gen-pause cl-1a :section (find-complement '(0 2 5 7) :high 9)))
(setf rh-2 (assemble-seq rh-1 cl-2a rh-1))
(setf lh-2 (assemble-seq lh-1 (pitch-transpose -12 cl-2a) lh-1))
(setf timesigs (get-time-signature rh-2 :group '((5))))

(def-score lesson-30
(:key-signature 'chromatic
:time-signature timesigs
:tempo 120
:layout (piano-layout 'piano-rh 'piano-lh))
(piano-rh
:omn rh-2
:channel 1
:sound 'gm
:program 'acoustic-grand-piano)

(piano-lh
:omn (respell lh-2 :type :chord))
)```

## Notation

Go back to Reference page.

Edited by opmo

• ### Introduction to OMN the language

OMN is designed as a scripting language for musical events. It’s not about sounds themselves, it is about their control and organisation in a musical composition. As a linear script rather than a graphic stave, musical events can be transformed, extended, reorganised by powerful computer algorithms. Some sequencers and score writers provide basic algorithms, but they do not represent the way composers now think about the process of music composition. Composing has become such a multi-faceted pro

opmo
OMN The Language 0
• ### Introduction to Opusmodus

Contents A Contemporary Language for Making Music The Parametric World of Music The Parametric Instrument Learning Opusmodus : A Strategy Important Questions: Necessary Answers

opmo
Tutorial Guide 0
• ### CLM Installation

Contents CLM Installation Command Line Tools Load and Compile Instruments CLM Installation Common Lisp Music, by William Schottstaedt is a powerful sound synthesis language implemented in Lisp and C. CLM is essentiall

opmo
CLM Examples 0
×

• Lessons