Piano Phase - After Steve Reich

Steve Reich's "Piano Phase" piece requires two parts to run at different tempi. This is achieved in this example by reducing the note lengths of one part slightly to simulate the difference in tempo. It can also be done by setting different parts or phrases to different  speeds using the setTempo() method. The compositional principle is that as the 3 beat phrase is repeated over and over the slight tempo difference results in a 'phasing' offset between the parts. This continues until they meet up again some time later one beat apart. The last few bars of this example have the parts in sync again but at a one beat displacement. In Reich's score this process continues through all beats of the phrase.

To hear the result play the MIDI file.

Here is the source code.

The first technique we will investigate is writing for a single part containing multiple lines/voices. Take a good look at it as it contains many things that you will not have seen before.

The fisrt thing is to bring in the jMusic classes required for this program:

import jm.music.data.*;
import jm.JMC;
import jm.util.*;
import jm.music.tools.Mod;

Create the jMusic data objects to hold the score. One part for each of the two pianos, and the first phrase:

public class PianoPhase implements JMC {
public static void main(String[] args){

//Create the data objects we want to use

Score score = new Score("Piano Phase", 120.0);
Part p1 = new Part("Piano1", PIANO, 0);
Part p2 = new Part("Piano2", PIANO, 1);
Phrase phrase1 = new Phrase(0.0);

There is only one phrase in the composition and the treatment of it is what is of interest. This is the basis of 'minimalism' as a style - minimal amounts of material treated in interesting ways, often with lots of repetition.

After the phrase is created it is repeated and added to the part, and score:

	//Lets write the music in a convenient way.	       
int[] pitchArray = {E4,FS4,B4,CS5,D5,FS4,E4,CS5,B4,FS4,D5,CS5};
double[] rhythmArray = {SQ, SQ, SQ, SQ, SQ, SQ, SQ, SQ, SQ, SQ, SQ, SQ};

//add the notes to the first phrase

phrase1.addNoteList(pitchArray, rhythmArray);

// repeat the stable piano part and add it to a part and score

Mod.repeat(phrase1, 52);

The second phrase, like all others, is a copy of the first. The 'trick' is that it plays slightly faster than the original phrase.
This is done by shortening the length of each of the notes slightly:

	//Make two new phrases and change starttimes to make a round	       
Phrase phrase2 = (Phrase) phrase1.copy();

// Phrase 3 is the one which extends phrase two at a different tempo

for(int i = 1; i<rhythmArray.length;i++) {
rhythmArray[i] = rhythmArray[i] * 0.975;

Other phrases are created, transposed, and repeated as required to meet the score. This example simply mimics the first minute of Steve reich's piece:

        Phrase phrase3 = new Phrase(0.0);
phrase3.addNoteList(pitchArray, rhythmArray);

//Phrse four is played after the offset period

Phrase phrase4 = (Phrase) phrase1.copy();
//one beat short of the start of bar 13
//Play different parts in different octaves for more audible clarity
Mod.transpose(phrase2, 12);
Mod.transpose(phrase3, 12);
Mod.transpose(phrase4, 12);
//loop phrases
Mod.repeat(phrase2, 7);

// stable

Mod.repeat(phrase3, 30);
/ accellerated
Mod.repeat(phrase4, 7);

//stable again

The phrases are added to the parts, then parts to the score. Finally, the score is rendered to a standard MIDI file.

	//add phrases to the two instruments	       

//add second piano instrument to the score

//OK now we SMF write
Write.midi(score, "PianoPhase.mid");

The Play.midi() method plays the score back using Java's inbuilt software synthesizer.


© 2000 Andrew R Brown