def __init__(
self,
left_rhythm=None,
right_rhythm=None,
left_markup=None,
right_markup=None,
):
from abjad.tools import indicatortools
from abjad.tools import markuptools
from abjad.tools import scoretools
# TODO: make default scope work
#self._default_scope = scoretools.Score
self._default_scope = None
left_rhythm = left_rhythm or scoretools.Note('c4')
right_rhythm = right_rhythm or scoretools.Note('c4')
left_rhythm = self._initialize_rhythm(left_rhythm)
self._left_rhythm = left_rhythm
right_rhythm = self._initialize_rhythm(right_rhythm)
self._right_rhythm = right_rhythm
self._right_rhythm = right_rhythm
if left_markup is not None:
assert isinstance(left_markup, markuptools.Markup)
self._left_markup = left_markup
if right_markup is not None:
assert isinstance(right_markup, markuptools.Markup)
self._right_markup = right_markup
def edit_second_violin_voice(score, durated_reservoir):
r'''Edits second violin voice.
'''
voice = score['Second Violin Voice']
descents = durated_reservoir['Second Violin']
last_descent = select(descents[-1])
copied_descent = mutate(last_descent).copy()
copied_descent = list(copied_descent)
copied_descent[-1].written_duration = durationtools.Duration(1, 1)
copied_descent.append(scoretools.Note('a2'))
for leaf in copied_descent:
articulation = indicatortools.Articulation('accent')
attach(articulation, leaf)
articulation = indicatortools.Articulation('tenuto')
attach(articulation, leaf)
voice.extend(copied_descent)
final_sustain = []
for _ in range(32):
final_sustain.append(scoretools.Note('a1.'))
final_sustain.append(scoretools.Note('a2'))
articulation = indicatortools.Articulation('accent')
attach(articulation, final_sustain[0])
articulation = indicatortools.Articulation('tenuto')
attach(articulation, final_sustain[0])
voice.extend(final_sustain)
tie = spannertools.Tie()
attach(tie, final_sustain)
voice.extend('r4 r2.')
def __illustrate__(self):
r'''Illustrates pitch range.
::
>>> show(pitch_range) # doctest: +SKIP
Returns LilyPond file.
'''
from abjad.tools import durationtools
from abjad.tools import lilypondfiletools
from abjad.tools import indicatortools
from abjad.tools import markuptools
from abjad.tools import pitchtools
from abjad.tools import scoretools
from abjad.tools import spannertools
from abjad.tools.topleveltools import attach
from abjad.tools.topleveltools import iterate
from abjad.tools.topleveltools import override
start_pitch_clef = pitchtools.suggest_clef_for_named_pitches(
self.start_pitch)
stop_pitch_clef = pitchtools.suggest_clef_for_named_pitches(
self.stop_pitch)
start_note = scoretools.Note(self.start_pitch, 1)
stop_note = scoretools.Note(self.stop_pitch, 1)
glissando = spannertools.Glissando()
if start_pitch_clef == stop_pitch_clef:
if start_pitch_clef == indicatortools.Clef('bass'):
bass_staff = scoretools.Staff()
attach(indicatortools.Clef('bass'), bass_staff)
bass_staff.extend([start_note, stop_note])
attach(glissando, bass_staff.select_leaves())
score = scoretools.Score([bass_staff])
else:
treble_staff = scoretools.Staff()
attach(indicatortools.Clef('treble'), treble_staff)
treble_staff.extend([start_note, stop_note])
attach(glissando, treble_staff.select_leaves())
score = scoretools.Score([treble_staff])
else:
result = scoretools.make_empty_piano_score()
score, treble_staff, bass_staff = result
bass_staff.extend([start_note, stop_note])
treble_staff.extend(scoretools.Skip(1) * 2)
attach(glissando, bass_staff.select_leaves())
attach(indicatortools.StaffChange(treble_staff), bass_staff[1])
for leaf in iterate(score).by_class(scoretools.Leaf):
attach(durationtools.Multiplier(1, 4), leaf)
override(score).bar_line.stencil = False
override(score).span_bar.stencil = False
override(score).glissando.thickness = 2
override(score).time_signature.stencil = False
lilypond_file = lilypondfiletools.make_basic_lilypond_file(score)
lilypond_file.header_block.tagline = markuptools.Markup('""')
return lilypond_file
def __illustrate__(self):
r'''Illustrates tempo inventory.
::
>>> show(inventory) # doctest: +SKIP
Returns LilyPond file.
'''
from abjad.tools import durationtools
from abjad.tools import lilypondfiletools
from abjad.tools import indicatortools
from abjad.tools import markuptools
from abjad.tools import pitchtools
from abjad.tools import scoretools
from abjad.tools import spannertools
from abjad.tools.topleveltools import attach
from abjad.tools.topleveltools import iterate
from abjad.tools.topleveltools import override
from abjad.tools.topleveltools import new
staff = scoretools.Staff()
score = scoretools.Score([staff])
time_signature = indicatortools.TimeSignature((2, 4))
attach(time_signature, staff)
# the zero note avoids a lilypond spacing problem:
# score-initial tempo indications slip to the left
zero_note = scoretools.Note("c'2")
staff.append(zero_note)
command = indicatortools.LilyPondCommand('break')
attach(command, zero_note)
for tempo in self.items:
note = scoretools.Note("c'2")
attach(tempo, note)
staff.append(note)
command = indicatortools.LilyPondCommand('break')
attach(command, note)
override(score).bar_line.transparent = True
override(score).bar_number.stencil = False
override(score).clef.stencil = False
override(score).note_head.no_ledgers = True
override(score).note_head.transparent = True
override(score).staff_symbol.transparent = True
override(score).stem.transparent = True
override(score).time_signature.stencil = False
lilypond_file = lilypondfiletools.make_basic_lilypond_file(score)
lilypond_file.layout_block.indent = 0
lilypond_file.layout_block.ragged_right = True
lilypond_file.items.remove(lilypond_file['paper'])
lilypond_file.header_block.tagline = markuptools.Markup('""')
return lilypond_file
def __illustrate__(self, **kwargs):
r'''Illustrates segment.
Returns LilyPond file.
'''
from abjad.tools import durationtools
from abjad.tools import indicatortools
from abjad.tools import lilypondfiletools
from abjad.tools import markuptools
from abjad.tools import scoretools
from abjad.tools import schemetools
from abjad.tools.topleveltools import attach
from abjad.tools.topleveltools import override
from abjad.tools.topleveltools import select
from abjad.tools.topleveltools import set_
notes = []
for item in self:
note = scoretools.Note(item, durationtools.Duration(1, 8))
notes.append(note)
voice = scoretools.Voice(notes)
staff = scoretools.Staff([voice])
score = scoretools.Score([staff])
score.add_final_bar_line()
override(score).bar_line.transparent = True
override(score).bar_number.stencil = False
override(score).beam.stencil = False
override(score).flag.stencil = False
override(score).stem.stencil = False
override(score).time_signature.stencil = False
string = 'override Score.BarLine.transparent = ##f'
command = indicatortools.LilyPondCommand(string, format_slot='after')
last_leaf = select().by_leaf()(score)[-1][-1]
attach(command, last_leaf)
moment = schemetools.SchemeMoment((1, 12))
set_(score).proportional_notation_duration = moment
lilypond_file = lilypondfiletools.make_basic_lilypond_file(
global_staff_size=12,
music=score,
)
if 'title' in kwargs:
title = kwargs.get('title')
if not isinstance(title, markuptools.Markup):
title = markuptools.Markup(title)
lilypond_file.header_block.title = title
if 'subtitle' in kwargs:
markup = markuptools.Markup(kwargs.get('subtitle'))
lilypond_file.header_block.subtitle = markup
command = indicatortools.LilyPondCommand('accidentalStyle forget')
lilypond_file.layout_block.items.append(command)
lilypond_file.layout_block.indent = 0
string = 'markup-system-spacing.padding = 8'
command = indicatortools.LilyPondCommand(string, prefix='')
lilypond_file.paper_block.items.append(command)
string = 'system-system-spacing.padding = 10'
command = indicatortools.LilyPondCommand(string, prefix='')
lilypond_file.paper_block.items.append(command)
string = 'top-markup-spacing.padding = 4'
command = indicatortools.LilyPondCommand(string, prefix='')
lilypond_file.paper_block.items.append(command)
return lilypond_file
def make_hairpin_score_03(self):
r'''Make 200-note voice with crescendo spanner on every 100 notes.
::
2.12 (r9726) initialization: 249,363 function calls
2.12 (r9726) initialization: 249,363 function calls
2.12 (r9726) LilyPond format: 133,898 function calls
2.12 (r9728) LilyPond format: 128,948 function calls
'''
from abjad.tools import scoretools
from abjad.tools import sequencetools
from abjad.tools import spannertools
from abjad.tools import topleveltools
voice = scoretools.Voice(200 * scoretools.Note("c'16"))
for part in sequencetools.partition_sequence_by_counts(
voice[:],
[100],
cyclic=True,
):
crescendo = spannertools.Crescendo()
topleveltools.attach(crescendo, part)
return voice
def make_spanner_score_03(self):
r'''Make 200-note voice with durated complex beam spanner
on every 100 notes.
::
2.12 (r9710) initialization: 251,606 function calls
2.12 (r9724) initialization: 249,369 function calls
2.12 (r9703) LilyPond format: 509,752 function calls
2.12 (r9710) LilyPond format: 510,556 function calls
2.12 (r9724) LilyPond format: 525,463 function calls
'''
from abjad.tools import scoretools
from abjad.tools import sequencetools
from abjad.tools import spannertools
from abjad.tools import topleveltools
voice = scoretools.Voice(200 * scoretools.Note("c'16"))
for part in sequencetools.partition_sequence_by_counts(
voice[:],
[100],
cyclic=True,
):
beam = spannertools.DuratedComplexBeam()
topleveltools.attach(beam, part)
return voice
def make_notes_with_multiplied_durations(
pitch,
written_duration,
multiplied_durations,
):
'''Make `written_duration` notes with `pitch` and `multiplied_durations`:
::
>>> args = [0, Duration(1, 4), [(1, 2), (1, 3), (1, 4), (1, 5)]]
>>> scoretools.make_notes_with_multiplied_durations(*args)
Selection(Note("c'4 * 2"), Note("c'4 * 4/3"), Note("c'4 * 1"), Note("c'4 * 4/5"))
Useful for making spatially positioned notes.
Returns list of notes.
'''
from abjad.tools import scoretools
from abjad.tools import selectiontools
# initialize input
written_duration = durationtools.Duration(written_duration)
# make notes
notes = []
for multiplied_duration in multiplied_durations:
multiplied_duration = durationtools.Duration(multiplied_duration)
note = scoretools.Note(pitch, written_duration)
multiplier = multiplied_duration / written_duration
attach(multiplier, note)
notes.append(note)
# return notes
notes = selectiontools.Selection(notes)
return notes
def make_spanner_score_02(self):
r'''Make 200-note voice with durated complex beam spanner
on every 20 notes.
::
2.12 (r9710) initialization: 250,954 function calls
2.12 (r9724) initialization: 248,717 function calls
2.12 (r9703) LilyPond format: 495,768 function calls
2.12 (r9710) LilyPond format: 496,572 function calls
2.12 (r9724) LilyPond format: 511,471 function calls
'''
from abjad.tools import scoretools
from abjad.tools import sequencetools
from abjad.tools import spannertools
from abjad.tools import topleveltools
voice = scoretools.Voice(200 * scoretools.Note("c'16"))
for part in sequencetools.partition_sequence_by_counts(
voice[:],
[20],
cyclic=True,
):
beam = spannertools.DuratedComplexBeam()
topleveltools.attach(beam, part)
return voice
def _bracket_inner_nodes(self, leaf_list_stack, node, voice):
from abjad.tools import durationtools
from abjad.tools import markuptools
from abjad.tools import scoretools
from abjad.tools import spannertools
from abjad.tools.topleveltools import attach
if len(node):
if node.level:
leaf_list_stack.append([])
for child_node in node:
self._bracket_inner_nodes(
leaf_list_stack,
child_node,
voice,
)
if node.level:
bracket = spannertools.HorizontalBracketSpanner()
attach(bracket, leaf_list_stack[-1])
if node.level == 1:
node_index = node.parent.index(node)
level_one_first_leaf = leaf_list_stack[-1][0]
string = r'\bold {{ {} }}'.format(node_index)
markup = markuptools.Markup(string, Up)
attach(markup, level_one_first_leaf)
leaf_list_stack.pop()
elif node.payload:
note = scoretools.Note(
node.payload,
durationtools.Duration(1, 8),
)
voice.append(note)
for leaf_list in leaf_list_stack:
leaf_list.append(note)
def make_score_with_indicators_01(self):
r'''Make 200-note voice with dynamic on every 20th note:
::
2.12 (r9704) initialization: 630,433 function calls
2.12 (r9710) initialization: 235,120 function calls
2.12 r(9726) initialization: 235,126 function calls
2.12 (r9704) LilyPond format: 136,637 function calls
2.12 (r9710) LilyPond format: 82,730 function calls
2.12 (r9726) LilyPond format: 88,382 function calls
'''
from abjad.tools import indicatortools
from abjad.tools import scoretools
from abjad.tools import sequencetools
from abjad.tools import topleveltools
staff = scoretools.Staff(200 * scoretools.Note("c'16"))
for part in sequencetools.partition_sequence_by_counts(
staff[:],
[20],
cyclic=True,
):
dynamic = indicatortools.Dynamic('f')
topleveltools.attach(dynamic, part[0])
return staff
def make_bound_hairpin_score_03(self):
r'''Make 200-note voice with p-to-f bound crescendo spanner
on every 100 notes.
::
2.12 (r9726) initialization: 267,417 function calls
2.12 (r9726) LilyPond format: 116,534 function calls
'''
from abjad.tools import indicatortools
from abjad.tools import scoretools
from abjad.tools import sequencetools
from abjad.tools import spannertools
from abjad.tools import topleveltools
voice = scoretools.Voice(200 * scoretools.Note("c'16"))
for part in sequencetools.partition_sequence_by_counts(
voice[:],
[100],
cyclic=True,
):
crescendo = spannertools.Crescendo()
topleveltools.attach(crescendo, part)
dynamic = indicatortools.Dynamic('p')
topleveltools.attach(dynamic, part[0])
dynamic = indicatortools.Dynamic('r')
topleveltools.attach(dynamic, part[-1])
return voice
def __call__(self, q_events):
r'''Calls concatenating grace handler.
'''
from abjad.tools import quantizationtools
grace_events, final_event = q_events[:-1], q_events[-1]
if isinstance(final_event, quantizationtools.PitchedQEvent):
pitches = final_event.pitches
else:
pitches = ()
if grace_events:
grace_container = scoretools.GraceContainer()
for q_event in grace_events:
if isinstance(q_event, quantizationtools.PitchedQEvent):
if len(q_event.pitches) == 1:
leaf = scoretools.Note(q_event.pitches[0],
self.grace_duration)
else:
leaf = scoretools.Chord(q_event.pitches,
self.grace_duration)
else:
leaf = scoretools.Rest(self.grace_duration)
grace_container.append(leaf)
else:
grace_container = None
return pitches, grace_container
def make_spanner_score_01(self):
r'''Make 200-note voice with durated complex beam spanner
on every 4 notes.
::
2.12 (r9710) initialization: 248,654 function calls
2.12 (r9724) initialization: 248,660 function calls
2.12 (r9703) LilyPond format: 425,848 function calls
2.12 (r9710) LilyPond format: 426,652 function calls
2.12 (r9724) LilyPond format: 441,884 function calls
'''
from abjad.tools import scoretools
from abjad.tools import sequencetools
from abjad.tools import spannertools
from abjad.tools import topleveltools
voice = scoretools.Voice(200 * scoretools.Note("c'16"))
for part in sequencetools.partition_sequence_by_counts(
voice[:],
[4],
cyclic=True,
):
beam = spannertools.DuratedComplexBeam()
topleveltools.attach(beam, part)
return voice
def make_score_with_indicators_02(self):
r'''Make 200-note staff with dynamic on every 4th note.
::
2.12 (r9704) initialization: 4,632,761 function calls
2.12 (r9710) initialization: 327,280 function calls
2.12 (r9726) initialization: 325,371 function calls
2.12 (r9704) LilyPond format: 220,277 function calls
2.12 (r9710) LilyPond format: 84,530 function calls
2.12 (r9726) LilyPond format: 90,056 function calls
'''
from abjad.tools import indicatortools
from abjad.tools import scoretools
from abjad.tools import sequencetools
from abjad.tools import topleveltools
staff = scoretools.Staff(200 * scoretools.Note("c'16"))
for part in sequencetools.partition_sequence_by_counts(
staff[:],
[4],
cyclic=True,
):
dynamic = indicatortools.Dynamic('f')
topleveltools.attach(dynamic, part[0])
return staff
def edit_cello_voice(score, durated_reservoir):
r'''Edits cello voice.
'''
voice = score['Cello Voice']
descents = durated_reservoir['Cello']
logical_tie = inspect_(voice[-1]).get_logical_tie()
for leaf in logical_tie.leaves:
parent = leaf._get_parentage().parent
index = parent.index(leaf)
parent[index] = scoretools.Chord(['e,', 'a,'], leaf.written_duration)
selection = voice[-len(descents[-1]):]
unison_descent = mutate(selection).copy()
voice.extend(unison_descent)
for chord in unison_descent:
index = inspect_(chord).get_parentage().parent.index(chord)
parent[index] = scoretools.Note(
chord.written_pitches[1], chord.written_duration)
articulation = indicatortools.Articulation('accent')
attach(articulation, parent[index])
articulation = indicatortools.Articulation('tenuto')
attach(articulation, parent[index])
voice.extend('a,1. ~ a,2')
voice.extend('b,1 ~ b,1. ~ b,1.')
voice.extend('a,1. ~ a,1. ~ a,1. ~ a,1. ~ a,1. ~ a,2')
voice.extend('r4 r2.')
def _cast_defective_chord(chord):
from abjad.tools import scoretools
if isinstance(chord, Chord):
note_head_count = len(chord.note_heads)
if not note_head_count:
return scoretools.Rest(chord)
elif note_head_count == 1:
return scoretools.Note(chord)
return chord
def _make_new_notes(anchor_pitch, anchor_written_duration, subrun_intervals):
from abjad.tools import pitchtools
from abjad.tools import scoretools
new_notes = []
for subrun_interval in subrun_intervals:
new_pc = (pitchtools.NumberedPitch(anchor_pitch).pitch_number +
subrun_interval) % 12
new_note = scoretools.Note(new_pc, anchor_written_duration)
new_notes.append(new_note)
return new_notes
def make_multiplied_quarter_notes(
pitches,
multiplied_durations,
):
r'''Make quarter notes with `pitches` and `multiplied_durations`:
::
>>> args = [[0, 2, 4, 5], [(1, 4), (1, 5), (1, 6), (1, 7)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 1"), Note("d'4 * 4/5"), Note("e'4 * 2/3"), Note("f'4 * 4/7"))
Read `pitches` cyclically where the length of `pitches` is
less than the length of `multiplied_durations`:
::
>>> args = [[0], [(1, 4), (1, 5), (1, 6), (1, 7)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 1"), Note("c'4 * 4/5"), Note("c'4 * 2/3"), Note("c'4 * 4/7"))
Read `multiplied_durations` cyclically where the length of
`multiplied_durations` is less than the length of `pitches`:
::
>>> args = [[0, 2, 4, 5], [(1, 5)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 4/5"), Note("d'4 * 4/5"), Note("e'4 * 4/5"),
Note("f'4 * 4/5"))
Returns list of zero or more newly constructed notes.
'''
from abjad.tools import scoretools
multiplied_durations = [
durationtools.Duration(x) for x in multiplied_durations
]
quarter_notes = []
sequences = [pitches, multiplied_durations]
for pitch, duration in sequencetools.zip_sequences(sequences, cyclic=True):
quarter_note = scoretools.Note(pitch, durationtools.Duration(1, 4))
duration = durationtools.Duration(duration)
multiplier = durationtools.Multiplier(duration /
durationtools.Duration(1, 4))
attach(multiplier, quarter_note)
quarter_notes.append(quarter_note)
quarter_notes = selectiontools.Selection(quarter_notes)
return quarter_notes
def __illustrate__(self):
r'''Illustrates articulation.
Returns LilyPond file.
'''
from abjad.tools import lilypondfiletools
from abjad.tools import scoretools
from abjad.tools import topleveltools
note = scoretools.Note("c'4")
articulation = copy.copy(self)
topleveltools.attach(articulation, note)
lilypond_file = lilypondfiletools.make_basic_lilypond_file(note)
lilypond_file.header_block.tagline = False
return lilypond_file
def fill_measures_in_expr_with_time_signature_denominator_notes(
expr, iterctrl=None):
r'''Fill measures in `expr` with time signature denominator notes:
::
>>> staff = Staff([Measure((3, 4), []), Measure((3, 16), []), Measure((3, 8), [])])
>>> scoretools.fill_measures_in_expr_with_time_signature_denominator_notes(staff)
.. doctest::
>>> print(format(staff))
\new Staff {
{
\time 3/4
c'4
c'4
c'4
}
{
\time 3/16
c'16
c'16
c'16
}
{
\time 3/8
c'8
c'8
c'8
}
}
Delete existing contents of measures in `expr`.
Returns none.
'''
from abjad.tools import scoretools
if iterctrl is None:
iterctrl = lambda measure, i: True
for i, measure in enumerate(iterate(expr).by_class(scoretools.Measure)):
if iterctrl(measure, i):
time_signature = measure.time_signature
denominator = mathtools.greatest_power_of_two_less_equal(
time_signature.denominator)
numerator = time_signature.numerator
notes = scoretools.Note(0, (1, denominator)) * numerator
measure[:] = notes
def make_score_00(self):
r'''Make 200-note voice (with nothing else).
::
2.12 (r9710) initialization: 156,821 function calls
2.12 (r9726) initialization: 156,827 function calls
2.12 (r9703) LilyPond format: 99,127 function calls
2.12 (r9710) LilyPond format: 100,126 function calls
2.12 (r9726) LilyPond format: 105,778 function calls
'''
from abjad.tools import scoretools
voice = scoretools.Voice(200 * scoretools.Note("c'16"))
return voice
def _notate_leaves(
self,
grace_handler=None,
voice=None,
):
for leaf in iterate(voice).by_leaf():
if leaf._has_indicator(indicatortools.Annotation):
annotation = leaf._get_indicator(indicatortools.Annotation)
pitches, grace_container = grace_handler(annotation.value)
if not pitches:
new_leaf = scoretools.Rest(leaf)
elif 1 < len(pitches):
new_leaf = scoretools.Chord(leaf)
new_leaf.written_pitches = pitches
else:
new_leaf = scoretools.Note(leaf)
new_leaf.written_pitch = pitches[0]
if grace_container:
attach(grace_container, new_leaf)
tie = spannertools.Tie()
if tie._attachment_test(new_leaf):
attach(tie, new_leaf)
mutate(leaf).replace(new_leaf)
else:
previous_leaf = leaf._get_leaf(-1)
if isinstance(previous_leaf, scoretools.Rest):
new_leaf = type(previous_leaf)(
leaf.written_duration,
)
elif isinstance(previous_leaf, scoretools.Note):
new_leaf = type(previous_leaf)(
previous_leaf.written_pitch,
leaf.written_duration,
)
else:
new_leaf = type(previous_leaf)(
previous_leaf.written_pitch,
leaf.written_duration,
)
mutate(leaf).replace(new_leaf)
tie = inspect_(previous_leaf).get_spanner(spannertools.Tie)
if tie is not None:
tie._append(new_leaf)
if leaf._has_indicator(indicatortools.Tempo):
tempo = leaf._get_indicator(indicatortools.Tempo)
detach(indicatortools.Tempo, leaf)
attach(tempo, new_leaf)
def make_desordre_cell(pitches):
'''The function constructs and returns a *Désordre cell*.
`pitches` is a list of numbers or, more generally, pitch tokens.
'''
notes = [scoretools.Note(pitch, (1, 8)) for pitch in pitches]
beam = spannertools.Beam()
attach(beam, notes)
slur = spannertools.Slur()
attach(slur, notes)
clef = indicatortools.Dynamic('f')
attach(clef, notes[0])
dynamic = indicatortools.Dynamic('p')
attach(dynamic, notes[1])
# make the lower voice
lower_voice = scoretools.Voice(notes)
lower_voice.name = 'RH Lower Voice'
command = indicatortools.LilyPondCommand('voiceTwo')
attach(command, lower_voice)
n = int(math.ceil(len(pitches) / 2.))
chord = scoretools.Chord([pitches[0], pitches[0] + 12], (n, 8))
articulation = indicatortools.Articulation('>')
attach(articulation, chord)
# make the upper voice
upper_voice = scoretools.Voice([chord])
upper_voice.name = 'RH Upper Voice'
command = indicatortools.LilyPondCommand('voiceOne')
attach(command, upper_voice)
# combine them together
container = scoretools.Container([lower_voice, upper_voice])
container.is_simultaneous = True
# make all 1/8 beats breakable
leaves = select(lower_voice).by_leaf()
for leaf in leaves[:-1]:
bar_line = indicatortools.BarLine('')
attach(bar_line, leaf)
return container
def make_score_with_indicators_03(self):
r'''Make 200-note staff with dynamic on every note.
::
2.12 (r9704) initialization: 53,450,195 function calls (!!)
2.12 (r9710) initialization: 2,124,500 function calls
2.12 (r9724) initialization: 2,122,591 function calls
2.12 (r9704) LilyPond format: 533,927 function calls
2.12 (r9710) LilyPond format: 91,280 function calls
2.12 (r9724) LilyPond format: 96,806 function calls
'''
from abjad.tools import indicatortools
from abjad.tools import scoretools
from abjad.tools import topleveltools
staff = scoretools.Staff(200 * scoretools.Note("c'16"))
for note in staff.select_leaves():
dynamic = indicatortools.Dynamic('f')
topleveltools.attach(dynamic, note)
return staff
def _to_tuplet_with_ratio(self, proportions, is_diminution=True):
from abjad.tools import scoretools
# check input
proportions = mathtools.Ratio(proportions)
# find target duration of fixed-duration tuplet
target_duration = self.written_duration
# find basic duration of note in tuplet
basic_prolated_duration = target_duration / sum(proportions.numbers)
# find basic written duration of note in tuplet
basic_written_duration = \
basic_prolated_duration.equal_or_greater_assignable
# find written duration of each note in tuplet
written_durations = [
_ * basic_written_duration for _ in proportions.numbers
]
# make tuplet notes
try:
notes = [scoretools.Note(0, x) for x in written_durations]
except AssignabilityError:
denominator = target_duration._denominator
note_durations = [
durationtools.Duration(_, denominator)
for _ in proportions.numbers
]
notes = scoretools.make_notes(0, note_durations)
# make tuplet
tuplet = scoretools.FixedDurationTuplet(target_duration, notes)
# fix tuplet contents if necessary
tuplet._fix()
# change prolation if necessary
if not tuplet.multiplier == 1:
if is_diminution:
if not tuplet.is_diminution:
tuplet.toggle_prolation()
else:
if tuplet.is_diminution:
tuplet.toggle_prolation()
# return tuplet
return tuplet
def edit_viola_voice(score, durated_reservoir):
r'''Edits viola voice.
'''
voice = score['Viola Voice']
descents = durated_reservoir['Viola']
for leaf in descents[-1]:
articulation = indicatortools.Articulation('accent')
attach(articulation, leaf)
articulation = indicatortools.Articulation('tenuto')
attach(articulation, leaf)
last_descent = select(descents[-1])
copied_descent = mutate(last_descent).copy()
for leaf in copied_descent:
if leaf.written_duration == durationtools.Duration(4, 4):
leaf.written_duration = durationtools.Duration(8, 4)
else:
leaf.written_duration = durationtools.Duration(4, 4)
voice.extend(copied_descent)
bridge = scoretools.Note('e1')
articulation = indicatortools.Articulation('tenuto')
attach(articulation, bridge)
articulation = indicatortools.Articulation('accent')
attach(articulation, bridge)
voice.append(bridge)
final_sustain_rhythm = [(6, 4)] * 21 + [(1, 2)]
final_sustain_notes = scoretools.make_notes(['e'], final_sustain_rhythm)
articulation = indicatortools.Articulation('accent')
attach(articulation, final_sustain_notes[0])
articulation = indicatortools.Articulation('tenuto')
attach(articulation, final_sustain_notes[0])
voice.extend(final_sustain_notes)
tie = spannertools.Tie()
attach(tie, final_sustain_notes)
voice.extend('r4 r2.')
def __illustrate__(self):
r'''Illustrates pitch.
Returns LilyPond file.
'''
from abjad.tools import durationtools
from abjad.tools import lilypondfiletools
from abjad.tools import markuptools
from abjad.tools import pitchtools
from abjad.tools import scoretools
from abjad.tools.topleveltools import attach
from abjad.tools.topleveltools import override
pitch = pitchtools.NamedPitch(self)
note = scoretools.Note(pitch, 1)
attach(durationtools.Multiplier(1, 4), note)
clef = pitchtools.suggest_clef_for_named_pitches([pitch])
staff = scoretools.Staff()
attach(clef, staff)
staff.append(note)
override(staff).time_signature.stencil = False
lilypond_file = lilypondfiletools.make_basic_lilypond_file(staff)
lilypond_file.header_block.tagline = markuptools.Markup('""')
return lilypond_file
def make_repeated_notes_from_time_signature(time_signature, pitch="c'"):
'''Make repeated notes from `time_signature`:
::
>>> scoretools.make_repeated_notes_from_time_signature((5, 32))
Selection([Note("c'32"), Note("c'32"), Note("c'32"), Note("c'32"), Note("c'32")])
Make repeated notes with `pitch` from `time_signature`:
::
>>> scoretools.make_repeated_notes_from_time_signature((5, 32), pitch="d''")
Selection([Note("d''32"), Note("d''32"), Note("d''32"), Note("d''32"), Note("d''32")])
Returns list of notes.
'''
from abjad.tools import indicatortools
from abjad.tools import scoretools
# afford basic input polymorphism
time_signature = indicatortools.TimeSignature(time_signature)
# check input
if time_signature.has_non_power_of_two_denominator:
raise NotImplementedError(
'TODO: extend this function for time signatures with a non-power-of-two denominators.'
)
# make and return repeated notes
duration = (1, time_signature.denominator)
result = time_signature.numerator * scoretools.Note(pitch, duration)
# return result
result = selectiontools.Selection(result)
return result
def make_spanner_score_09(self):
r'''Make 200-note voice with (vanilla) beam spanner on every 100 notes.
::
2.12 (r9724) initialization: 249,339 function calls
2.12 (r9703) LilyPond format: 121,497 function calls
2.12 (r9724) LilyPond format: 128,494 function calls
'''
from abjad.tools import scoretools
from abjad.tools import sequencetools
from abjad.tools import spannertools
from abjad.tools import topleveltools
voice = scoretools.Voice(200 * scoretools.Note("c'16"))
for part in sequencetools.partition_sequence_by_counts(
voice[:],
[100],
cyclic=True,
):
beam = spannertools.Beam()
topleveltools.attach(beam, part)
return voice
