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 __init__(
self,
descriptor='<',
direction=None,
include_rests=False,
overrides=None,
):
Spanner.__init__(
self,
overrides=overrides,
)
direction = stringtools.expr_to_tridirectional_lilypond_symbol(
direction)
self._direction = direction
self._include_rests = include_rests
start_dynamic, shape_string, stop_dynamic = \
self._parse_descriptor(descriptor)
self._descriptor = descriptor
assert shape_string in ('<', '>')
self._shape_string = shape_string
if start_dynamic is not None:
start_dynamic = indicatortools.Dynamic(start_dynamic)
self._start_dynamic = start_dynamic
if stop_dynamic is not None:
stop_dynamic = indicatortools.Dynamic(stop_dynamic)
self._stop_dynamic = stop_dynamic
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 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 __call__(self, logical_ties, timespan=None, offset=0):
r'''Calls note and chord hairpin handler on `logical_ties`
with `offset`.
Returns none.
'''
if (self.span == 'contiguous notes and chords'
or isinstance(self.span, (tuple, list))):
groups = self._group_contiguous_logical_ties(logical_ties)
elif self.span == 'nontrivial ties':
groups = [[_] for _ in logical_ties]
else:
raise ValueError(self.span)
if isinstance(self.span, (tuple, list)):
new_groups = []
for group in groups:
leaves = iterate(group).by_class(scoretools.Leaf)
leaves = list(leaves)
shards = sequencetools.partition_sequence_by_counts(
leaves,
counts=self.span,
cyclic=True,
)
new_groups.extend(shards)
groups = new_groups
groups = [[_] for _ in groups]
for group_index, group in enumerate(groups):
notes = []
for logical_tie in group:
for note in logical_tie:
notes.append(note)
if len(notes) == 0:
continue
total_notes = len(notes)
notes_to_span = []
for note_index, note in enumerate(notes):
if self._index_matches_patterns(note_index, total_notes):
notes_to_span.append(note)
if not notes_to_span:
continue
if (len(notes_to_span) == 1
and not self.attach_start_dynamic_to_lone_notes):
continue
if (len(notes_to_span) == 1
and self.attach_start_dynamic_to_lone_notes):
hairpin_token = self.hairpin_token[group_index]
start_dynamic = hairpin_token[0]
dynamic = indicatortools.Dynamic(start_dynamic)
attach(dynamic, notes[0])
continue
hairpin_token = self.hairpin_token[group_index]
descriptor = ' '.join([_ for _ in hairpin_token if _])
hairpin = spannertools.Hairpin(
descriptor=descriptor,
include_rests=False,
)
attach(hairpin, notes_to_span)
def execute_against_score(self, score):
r'''Execute dynamic set expression against `score`.
'''
dynamic = self.source_expression.payload
for leaf in self._iterate_selected_leaves_in_score(score):
for mark in leaf._get_indicators(indicatortools.Dynamic):
mark.detach()
dynamic = indicatortools.Dynamic(dynamic)
attach(dynamic, 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 set_dynamic(self, source_expression):
r'''Set dynamic to `source_expression`.
Returns dynamic set expression.
'''
from experimental.tools import musicexpressiontools
dynamic = indicatortools.Dynamic(source_expression)
source_expression = \
musicexpressiontools.PayloadExpression(payload=dynamic)
attribute = 'dynamic'
return self._store_leaf_set_expression(attribute, source_expression)
def _resolve_event_identifier(self, identifier):
from abjad.tools import lilypondparsertools
# without any leading slash
lookup = self._current_module[identifier]
name = lookup['name']
if name == 'ArticulationEvent':
return indicatortools.Articulation(lookup['articulation-type'])
elif name == 'AbsoluteDynamicEvent':
return indicatortools.Dynamic(lookup['text'])
elif name == 'LaissezVibrerEvent':
return indicatortools.LilyPondCommand('laissezVibrer', 'after')
event = lilypondparsertools.LilyPondEvent(name)
if 'span-direction' in lookup:
if lookup['span-direction'] == -1:
event.span_direction = 'start'
else:
event.span_direction = 'stop'
return event
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 __call__(self, logical_ties):
r'''Calls hairpin handler on `logical_ties`.
Passes silently when `logical_ties` is empty.
Returns none.
'''
if not logical_ties:
return
if not isinstance(logical_ties[0], selectiontools.LogicalTie):
assert isinstance(logical_ties[0], scoretools.Leaf)
logical_ties = [selectiontools.LogicalTie(_) for _ in logical_ties]
if (self.span == 'contiguous notes and chords'
or isinstance(self.span, (tuple, list))):
groups = self._group_contiguous_logical_ties(logical_ties)
elif self.span == 'nontrivial ties':
groups = [[_] for _ in logical_ties]
else:
raise ValueError(self.span)
if isinstance(self.span, (tuple, list)):
if not self.enchain_hairpins:
groups = self._partition_groups(groups)
else:
groups = self._partition_enchained_groups(groups)
hairpin_tokens = self.hairpin_tokens
for group_index, group in enumerate(groups):
notes = []
for logical_tie in group:
for note in logical_tie:
notes.append(note)
if len(notes) == 0:
continue
total_notes = len(notes)
notes_to_span = []
for note_index, note in enumerate(notes):
if self._index_matches_patterns(note_index, total_notes):
notes_to_span.append(note)
if not notes_to_span:
continue
if self.include_following_rests:
last_note = notes_to_span[-1]
next_leaf = inspect_(last_note).get_leaf(1)
prototype = (scoretools.Rest, scoretools.MultimeasureRest)
if isinstance(next_leaf, prototype):
notes_to_span.append(next_leaf)
if len(notes_to_span) == 1 and self.omit_lone_note_dynamic:
continue
if len(notes_to_span) == 1 and not self.omit_lone_note_dynamic:
hairpin_token = hairpin_tokens[group_index]
start_dynamic = hairpin_token[0]
if start_dynamic == 'niente':
message = 'can not attach niente dynamics to components.'
raise Exception(message)
dynamic = indicatortools.Dynamic(start_dynamic)
attach(dynamic, notes[0])
continue
hairpin_token = hairpin_tokens[group_index]
if hairpin_token is None:
continue
if isinstance(hairpin_token, tuple):
descriptor = ' '.join([_ for _ in hairpin_token if _])
include_rests = bool(self.include_following_rests)
hairpin = spannertools.Hairpin(
descriptor=descriptor,
include_rests=include_rests,
)
attach(hairpin, notes_to_span)
# hook to allow callable custom classes like SwellSpecifier
else:
hairpin_token(notes_to_span)
if self.flare:
first_note = notes_to_span[0]
prototype = scoretools.Note
assert isinstance(first_note, prototype), repr(first_note)
stencil = schemetools.Scheme('flared-hairpin')
override(first_note).hairpin.stencil = stencil
guitar_strummed_music_specifier = consort.MusicSpecifier(
attachment_handler=consort.AttachmentHandler(
damped=consort.AttachmentExpression(
attachments=consort.LeafExpression(
leaf=scoretools.Note("f'4"),
attachments=[
lilypondnametools.LilyPondGrobOverride(
grob_name='NoteHead',
is_once=True,
property_path='transparent',
value=True,
),
markuptools.Markup.musicglyph('scripts.coda'),
indicatortools.Articulation('accent'),
indicatortools.Dynamic('sfz'),
],
),
is_destructive=True,
selector=selectortools.Selector()
.by_logical_tie(pitched=True)
.by_contiguity()
.by_length('>', 1)
.by_leaf()
[-1]
),
dynamic_expressions=consort.DynamicExpression(
dynamic_tokens='p ppp p ppp mf p',
only_first=True,
),
laissez_vibrer=abbreviations.laissez_vibrer,
# -*- encoding: utf-8 -*-
import consort
import ersilia
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import spannertools
from ersilia.materials import abbreviations
percussion_snare_interruption_music_specifier = consort.MusicSpecifier(
attachment_handler=consort.AttachmentHandler(
accents=consort.AttachmentExpression(
attachments=[[
indicatortools.Articulation('accent'),
indicatortools.Dynamic('fff'),
]],
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration('==', (1, 16), preprolated=True)[0],
),
shimmer=consort.AttachmentExpression(
attachments=[
[
indicatortools.Articulation('accent'),
indicatortools.Dynamic('fp'),
],
],
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration(
'>', (1, 16),
preprolated=True).by_leaf().by_length('==', 1)[0]),
swell=consort.AttachmentExpression(
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
piano_arm_cluster_music_specifier = consort.MusicSpecifier(
attachment_handler=consort.AttachmentHandler(
accents=consort.AttachmentExpression(
attachments=indicatortools.Articulation('accent'),
selector=selectortools.Selector().by_logical_tie(pitched=True)[0],
),
dynamic_expressions=consort.AttachmentExpression(
attachments=indicatortools.Dynamic('fff'),
selector=selectortools.Selector().by_logical_tie(pitched=True)[0]),
),
color='yellow',
labels=['piano arm cluster'],
pitch_handler=consort.AbsolutePitchHandler(logical_tie_expressions=[
consort.KeyClusterExpression(staff_space_width=19, ),
]),
rhythm_maker=rhythmmakertools.IncisedRhythmMaker(
incise_specifier=rhythmmakertools.InciseSpecifier(
fill_with_notes=False,
prefix_counts=[1],
prefix_talea=[1],
talea_denominator=8,
), ),
)
# -*- encoding: utf-8 -*-
import consort
import ersilia
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import spannertools
from ersilia.materials import abbreviations
percussion_bamboo_windchimes_music_specifier = consort.MusicSpecifier(
attachment_handler=consort.AttachmentHandler(
accents=consort.AttachmentExpression(
attachments=[[
indicatortools.Articulation('accent'),
indicatortools.Dynamic('f'),
]],
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration('==', (1, 16), preprolated=True)[0],
),
piano=consort.AttachmentExpression(
attachments=indicatortools.Dynamic('pp'),
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration('>', (1, 16), preprolated=True)[0]),
text_spanner=consort.AttachmentExpression(
attachments=abbreviations.make_text_spanner('windchimes'),
selector=selectortools.select_pitched_runs(),
),
tremolo=consort.AttachmentExpression(
attachments=spannertools.StemTremoloSpanner(),
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration('>', (1, 16), preprolated=True)),
def apply_dynamics(score):
r'''Applies dynamics to score.
'''
voice = score['Bell Voice']
dynamic = indicatortools.Dynamic('ppp')
attach(dynamic, voice[0][1])
dynamic = indicatortools.Dynamic('pp')
attach(dynamic, voice[8][1])
dynamic = indicatortools.Dynamic('p')
attach(dynamic, voice[18][1])
dynamic = indicatortools.Dynamic('mp')
attach(dynamic, voice[26][1])
dynamic = indicatortools.Dynamic('mf')
attach(dynamic, voice[34][1])
dynamic = indicatortools.Dynamic('f')
attach(dynamic, voice[42][1])
dynamic = indicatortools.Dynamic('ff')
attach(dynamic, voice[52][1])
dynamic = indicatortools.Dynamic('fff')
attach(dynamic, voice[60][1])
dynamic = indicatortools.Dynamic('ff')
attach(dynamic, voice[68][1])
dynamic = indicatortools.Dynamic('f')
attach(dynamic, voice[76][1])
dynamic = indicatortools.Dynamic('mf')
attach(dynamic, voice[84][1])
dynamic = indicatortools.Dynamic('pp')
attach(dynamic, voice[-1][0])
voice = score['First Violin Voice']
dynamic = indicatortools.Dynamic('ppp')
attach(dynamic, voice[6][1])
dynamic = indicatortools.Dynamic('pp')
attach(dynamic, voice[15][0])
dynamic = indicatortools.Dynamic('p')
attach(dynamic, voice[22][3])
dynamic = indicatortools.Dynamic('mp')
attach(dynamic, voice[31][0])
dynamic = indicatortools.Dynamic('mf')
attach(dynamic, voice[38][3])
dynamic = indicatortools.Dynamic('f')
attach(dynamic, voice[47][0])
dynamic = indicatortools.Dynamic('ff')
attach(dynamic, voice[55][2])
dynamic = indicatortools.Dynamic('fff')
attach(dynamic, voice[62][2])
voice = score['Second Violin Voice']
dynamic = indicatortools.Dynamic('pp')
attach(dynamic, voice[7][0])
dynamic = indicatortools.Dynamic('p')
attach(dynamic, voice[12][0])
dynamic = indicatortools.Dynamic('p')
attach(dynamic, voice[16][0])
dynamic = indicatortools.Dynamic('mp')
attach(dynamic, voice[25][1])
dynamic = indicatortools.Dynamic('mf')
attach(dynamic, voice[34][1])
dynamic = indicatortools.Dynamic('f')
attach(dynamic, voice[44][1])
dynamic = indicatortools.Dynamic('ff')
attach(dynamic, voice[54][0])
dynamic = indicatortools.Dynamic('fff')
attach(dynamic, voice[62][1])
voice = score['Viola Voice']
dynamic = indicatortools.Dynamic('p')
attach(dynamic, voice[8][0])
dynamic = indicatortools.Dynamic('mp')
attach(dynamic, voice[19][1])
dynamic = indicatortools.Dynamic('mf')
attach(dynamic, voice[30][0])
dynamic = indicatortools.Dynamic('f')
attach(dynamic, voice[36][0])
dynamic = indicatortools.Dynamic('f')
attach(dynamic, voice[42][0])
dynamic = indicatortools.Dynamic('ff')
attach(dynamic, voice[52][0])
dynamic = indicatortools.Dynamic('fff')
attach(dynamic, voice[62][0])
voice = score['Cello Voice']
dynamic = indicatortools.Dynamic('p')
attach(dynamic, voice[10][0])
dynamic = indicatortools.Dynamic('mp')
attach(dynamic, voice[21][0])
dynamic = indicatortools.Dynamic('mf')
attach(dynamic, voice[31][0])
dynamic = indicatortools.Dynamic('f')
attach(dynamic, voice[43][0])
dynamic = indicatortools.Dynamic('ff')
attach(dynamic, voice[52][1])
dynamic = indicatortools.Dynamic('fff')
attach(dynamic, voice[62][0])
voice = score['Bass Voice']
dynamic = indicatortools.Dynamic('mp')
attach(dynamic, voice[14][0])
dynamic = indicatortools.Dynamic('mf')
attach(dynamic, voice[27][0])
dynamic = indicatortools.Dynamic('f')
attach(dynamic, voice[39][0])
dynamic = indicatortools.Dynamic('ff')
attach(dynamic, voice[51][0])
dynamic = indicatortools.Dynamic('fff')
attach(dynamic, voice[62][0])
