3.6. James Tenney: Spectral Canon

Der Spectral Canon ist eine Komposition für harmonic player-piano aus dem Jahr 1974, die dem Komponisten Conlon Nancarrow gewidmet ist. Es hat auffallend viele Ähnlichkeiten zur drei Jahre älteren Komposition "Falling Music" von Frederic Rzewski13:

Ein Artikel über die algorithmische Realisation mit OpenMusic findet sich hier.

Jede kanonische Stimme besteht aus Tonrepetitionen, deren Einsatzabstände aus der Partialtonreihe abgeleitet sind. Ihre absoluten Zeitwerte entsprechen den logarithmischen Werten eines "Partialtonspektrums" der Partialtöne 8 bis (8 * 24), bezogen auf einen "Grundton" mit einer "Frequenz" von 4 Sekunden.

Das gesamte "Spektrum" ("Partialtöne" 1-24) aller Zeiten lässt sich folgendermaßen errechnen:

(loop for p from 1 to (* 8 24) collect (* 4 (log p 2)))

#|
-> (0.0 4.0 6.33985 8.0 9.287712 10.33985 11.22942 12.0 12.6797 13.287712
  13.837727 14.33985 14.801759 15.22942 15.6275625 16.0 16.349852 16.6797
  16.99171 17.287712 17.56927 17.837727 18.094248 18.33985 ...)
|#

Diese Zahlenreihe mit den Einsatzpunkten der Tonrepetionen in einer Stimme kann wie eine Obertonreihe gelesen werden: Die 0.0 entspricht dem Grundton, die 4.0 der Oktave, 6.33985 der Oktave+Quinte, 8.0 zwei Oktaven usw. Insofern entspricht eine "Oktave" genau 4 Sekunden.

James Tenney verwendet aus dieser Reihe für seinen Spectral Canon die "Partialtöne" 8 bis (24*8), d.h. die ersten 7 Zahlen der Reihe werden entfernt. Da der 8. Wert der Reihe 12 beträgt, muss bei der Ergebnisreihe von jedem Wert die Zahl 12 subtrahiert werden, um die absoluten Zeitwerte der ersten Hälfte der ersten Stimme zu erhalten:

   (loop for p from 8 to (* 8 24) collect (- (* 4 (log p 2)) 12))

   #|
   -> (0.0 0.6796999 1.2877121 1.8377266 2.3398504 2.8017588 3.2294197 3.6275625 4.0
    4.3498516 4.679701 4.9917107 5.287712 5.569269 5.8377266 6.094248 6.3398495 ...)
   |#

Die Einsatzzeiten der verschiedenen Kanonstimmen sind an jedem achten Ton der ersten Stimme. Sie berechnen sich also folgendermaßen:

      (loop
      for x from 1 to 24
      collect (- (* 4 (log (* x 8) 2)) 12))

   #|
   -> (0.0 4.0 6.3398495 8.0 9.287712 10.339849 11.22942 12.0 12.679701 13.287712
       13.837727 14.339849 14.80176 15.22942 15.627562 16.0 16.349852 16.6797
       16.99171 17.287712 17.56927 17.837727 18.094248 18.33985)
   |#

Die Tonhöhen der verschiedenen Stimmen des Spectral Canon verwenden die Partialtonreihe vom Kontra A in aufsteigender Reihenfolge, beginnend mit dem Grundton.

In der Komposition gibt es 24 Stimmen, deren Einsätze der auch für die Stimmen verwendeten "Partialtonreihe" entnommen sind, jedoch mit dem ersten Partialton beginnend. Dies führt dazu, dass jeder Neueinsatz einer Stimme zeitgleich mit jedem 8. Ton der ersten Stimme erfolgt.

Daraus lässt sich die erste Hälfte der Kanonstimme (nur accelerando) komplett errechnen und als Midisequenz exportieren (die Keynums sind dabei in Midicent).

(events
 (loop
   with tscale = 1
   for partial from 1 to 24
   for keynum = (keynum (* partial (hertz 44)) :hertz)
   for onset = (* 4 (log partial 2))
   append (loop
            for n from 8 to (* 8 24)
            collect (new midi
                      :time (+ onset (* tscale (- (* 4 (log n 2)) 12)))
                      :keynum keynum
                      :amplitude 1.0
                      :duration (* tscale 0.015))))
 "/tmp/test.svg")

#|
(0.0 4.0 6.3398495 8.0 9.287712 10.339849 11.22942 12.0 12.679701 13.287712
 13.837727 14.339849 14.80176 15.22942 15.627562 16.0 16.349852 16.6797
     16.99171 17.287712 17.56927 17.837727 18.094248 18.33985)
|#

Um die absoluten Zeiten für den umgekehrten Verlauf der Rhythmen zu errechnen, verwenden wir die "Untertonreihe". Sie wird durch den Kehrwert der Partialtonindizes errechnet:

Der gesamte Canon (vorwärts und rückwärts):

(loop for p from 1 to (* 8 24) collect (* 4 (log (/ p) 2)))

#|
(0.0 -4.0 -6.33985 -8.0 -9.287712 -10.33985 -11.22942 -12.0 -12.6797 -13.287712
 -13.837727 -14.33985 -14.801759 -15.22942 -15.6275625 -16.0 -16.349852
 -16.6797 -16.99171 -17.287712 -17.569271 -17.837727 -18.094248 -18.33985 ...)
|#

Auch in dieser Reihe werden die ersten 7 Elemente entfernt und das Ergebnis um 12 verschoben (diesmal aber wegen der umgekehrten Richtung addiert, statt subtrahiert!).

(loop for p from 8 to (* 8 24) collect (+ (* 4 (log (/ p) 2)) 12))

#|
(0.0 -0.6796999 -1.2877121 -1.8377266 -2.3398504 -2.8017588 -3.2294197
 -3.6275625 -4.0 -4.3498516 -4.679701 -4.9917107 -5.287712 -5.569271 -5.8377266
 -6.094248 -6.3398495 ...)
|#

Die Reihenfolge wird umgekehrt und bei allen Werte die Einsatzzeit des letzten Wertes dazuaddiert:

(loop
  for p from (* 8 24) downto 8
  collect (+ (* 4 (log (/ p) 2)) 12
             (- (* 4 (log (* 24 8) 2)) 12)))

#|
(0.0 0.030134201 0.060426712 0.09088135 0.12149429 0.15227127 0.18321419
 0.21432304 0.24560165 0.27705193 0.30867195 0.34046745 0.37243652 0.40458488...)
|#

Dabei lässt sich das Addieren und Subtrahieren der 12 eliminieren:

(loop
  for p from (* 8 24) downto 8
  collect (+ (* 4 (log (/ p) 2))
             (* 4 (log (* 24 8) 2))))

Dieses Ergebnis muss dann um die Gesamtdauer des accelerandos verschoben werden, um die Einsatzzeiten für die Stimme zu erhalten:

(loop
  for p from (* 8 24) downto 8
  collect (+ 12 (* 4 (log (* 24 8) 2))
             (* 4 (log (/ p) 2))
             (* 4 (log (* 24 8) 2))))

Etwas vereinfacht umgestellt:

(loop
  for p from (* 8 24) downto 8
  collect (+ -12
             (* 4 (log (/ p) 2))
             (* 8 (log (* 24 8) 2))))

Der gesamte Canon (vorwärts und rückwärts):

(events
 (loop
   with tscale = 2
   for voice from 0
   for keynum from 60 by 2
   for onset in (loop
                  for x from 1 to 24
                  collect (* 4 (log x 2)))
   append (append
           (loop
             for n from 8 to (* 8 24)
             collect (new midi :time
                          (* tscale (+ onset (- (* 4 (log n 2)) 12)))
                          :keynum keynum
                          :amplitude 1.0
                          :duration (* tscale 0.015)))
           (cdr (loop
                  for n from (* 8 24) downto (+ 8 (* voice 8))
                  collect (new midi :time
                               (* tscale
                                  (+ onset
                                     (+ (* 8 (log (* 8 24) 2))
                                        (* 4 (log (/ n) 2))
                                        -12)))
                               :keynum keynum
                               :amplitude 1.0
                               :duration (* tscale 0.015)))))))

Von der Komposition existiert auch eine Extended Version von Clarence Barlow aus dem Jahr 1991. In dieser Version bricht das Stück nicht am Ende der ersten Stimme ab, sondern alle Stimmen werden vollständig zu Ende gespielt, so dass die gesamte Komposition rhythmisch symmetrisch ist.

Der Algorithmus lässt sich leicht modifizieren, um diese version zu erhalten. Lediglich die Abbruchbedingung für den loop muss dafür von (+ 8 (* voice 8)) auf 8 geändert werden:

(events
 (loop
   with tscale = 2
   for voice from 0
   for keynum from 60 by 2
   for onset in (loop
                  for x from 1 to 24
                  collect (* 4 (log x 2)))
   append (append
           (loop
             for n from 8 to (* 8 24)
             collect (new midi :time
                          (* tscale (+ onset (- (* 4 (log n 2)) 12)))
                          :keynum keynum
                          :amplitude 1.0
                          :duration (* tscale 0.015)))
           (cdr (loop
                  for n from (* 8 24) downto (+ 8 (* voice 8))
                  collect (new midi :time
                               (* tscale
                                  (+ onset
                                     (+ (* 8 (log (* 8 24) 2))
                                        (* 4 (log (/ n) 2))
                                        -12)))
                               :keynum keynum
                               :amplitude 1.0
                               :duration (* tscale 0.015)))))))
13: Der wesentliche Unterschied zwischen beiden Kompositionen besteht darin, dass die Prozesse auf der Tonhöhen- und Zeitebene bei Tenney mit einer der Spektralmusik entlehnten exponentiellen Skalierung verlaufen, statt linear, wie bei Rzewski. Bei Rzewski ist das sicher auch dem Umstand geschuldet, dass die Komposition von einem Pianisten aufgeführt wird und die Notier- und Ausführbarkeit im Falle exponentieller Skalierung der Zeit erheblich erschwert würde.

results matching ""

    No results matching ""