Fictional Modelling?

[ProgHead]

De trilling begint bij x = 0,2 (m) met een snelheid van 0 (m/s). In de grafiek is dat op punt A. En daar kun je ook de totale energie van het massa veer systeem (gedeeld door R) aflezen. Zou energiebehoud perfect gelden dan zou de massa m enkel tussen de punten A en B in de grafiek heen en weer kunnen bewegen. Inderdaad zien we op het plaatje in Audacity dat de trilling begint met een beweging tussen ongeveer 0,2 en ongeveer 0,4. Maar de amplitude (en totale energie) groeit langzaam aan, wat waarschijnlijk is toe te schrijven aan de reeds eerder in dit topic gesignaleerde drift van de amplitude. Het gevolg is dat de massa m even later tussen C en D (en omliggende punten) heen en weer beweegt (dus tussen ongeveer -0,25 en ongeveer 0,4. Ook dit klopt met het plaatje in Audacity. Nog weer wat later gaat de beweging tussen E en F (en omliggende punten) dus tussen ongeveer -0,57 en ongeveer 0,43. Wat wederom klopt met het plaatje in Audacity. Op een dergelijke wijze kun je visueel aan de hand van een grafiek van de potentiële energie inschatten wat voor soort geluiden er te verwachten zijn.

 

[ProgHead]

Nog eentje:
Bekijk bijlage 3824377

Nu eens zien of we met behulp van de grafiek van de potentiële energie de instelling terug kunnen vinden die het hierboven geciteerde geluidstype oplevert. Het "stuiterende " effect wijst op dicht opeengepakte slingeringen in de grafiek zodat het signaal door de drift van de amplitude sprongetjes maakt. Met onderstaande progje lukt het om het effect te reproduceren:

<CsoundSynthesizer>

<CsOptions>
-o dac
</CsOptions>

<CsInstruments>
sr = 300000000
ksmps =  1
nchnls = 2
0dbfs = 1

 
instr 1

;input R
kR = 7643021
;input m
km = 1
;input alpha
kalpha = 30
;input beta
kbeta = 30

;steps of 1 sample time
kdelta_t = 1/sr

;measuring time passed
kres timeinsts

if kres < 0.001 then
kx_old = 0.5
kv_old = 0
else
kx_new = kx_old + kv_old*kdelta_t
kv_new = kv_old + -1*(kR/km)*(1 + kalpha*sin(kbeta*kx_old))*kx_old*kdelta_t

kx_old = kx_new
kv_old = kv_new
endif

aOut = kx_old
outs aOut, aOut

endin

</CsInstruments>

<CsScore>
i 1 0 1
</CsScore>

</CsoundSynthesizer>

We zien dat daarbij [imath] \alpha = \beta = 30 [/imath] , [imath] x(0.001) = 0.5 [/imath] en [imath] v(0.001) = 0 [/imath] is genomen.

Dat geeft het geluid:

En daarbij hoort onderstaande grafiek voor de potentiële energie (of eigenlijk van U(x)/R):

Met dank aan de makers van de gebruikte gratis online plotter.

 

[ProgHead]

Hier een progje met correctie voor de amplitude blow up:

<CsoundSynthesizer>

<CsOptions>
-o dac
</CsOptions>

<CsInstruments>
sr = 300000000
ksmps =  1
nchnls = 2
0dbfs = 1

 
instr 1

;input R
kR = 7643021
;input m
km = 1
;input alpha
kalpha = 30
;input beta
kbeta = 30
;input correction factor amplitude blow up
kCor = 0.00000000002

;steps of 1 sample time
kdelta_t = 1/sr

;measuring time passed
kres timeinsts


if kres < 0.0001 then
;input start values
kx_old = 0.5
kv_old = 0

;calculation total energy
kE = 0.5*kR*kx_old^2 + ((kR*kalpha)/kbeta^2)*sin(kbeta*kx_old) - ((kR*kalpha)/kbeta)*kx_old*cos(kbeta*kx_old) + 0.5*km*kv_old^2

else
;running the process
kx_new = kx_old + kv_old*kdelta_t
kv_new = kv_old + -1*(kR/km)*(1 + kalpha*sin(kbeta*kx_old))*kx_old*kdelta_t

;calculation of energy deviation
kDeltaE = 0.5*kR*kx_new^2 + ((kR*kalpha)/kbeta^2)*sin(kbeta*kx_new) - ((kR*kalpha)/kbeta)*kx_new*cos(kbeta*kx_new) + 0.5*km*kv_new^2  -  kE

;correction of energy deviation by changing the velocity

if kDeltaE < 0 && kv_new < 0 then
kv_new = kv_new + kCor*kDeltaE
endif

if kDeltaE < 0 && kv_new > 0 then
kv_new = kv_new + -kCor*kDeltaE
endif

if kDeltaE > 0 && kv_new < 0 then
kv_new = kv_new + kCor*kDeltaE
endif

if kDeltaE > 0 && kv_new > 0 then
kv_new = kv_new - kCor*kDeltaE
endif

;new becomes old for the next step
kx_old = kx_new
kv_old = kv_new

endif


aOut = kx_old
outs aOut, aOut

endin

</CsInstruments>

<CsScore>
i 1 0 1
</CsScore>

</CsoundSynthesizer>

De correctie berust op een vergelijking van de momentane berekende totale energie met de totale energie bij de start. Als de momentane berekende energie te groot is wordt de snelheid van de massa m ietsjes verminderd, en als de momentane energie te klein is wordt de snelheid van de massa m ietsjes verhoogd. Het resultaat zie er in Audacity zo uit:

En het klinkt zo:

Ter vergelijking - als ik de correctie in het progje uitzet krijgen we dit:

 

[ProgHead]

Het "stuiterende" geluidje is leuker dan de constante toon, maar geen nood want we kunnen nu de als referentie gebruikte totale startenergie vervangen door een in de tijd variërend signaal en dan opnieuw soortgelijke geluiden voortbrengen, maar nu op een gecontroleerde manier. Wat voorbeeldjes:

Het eerste doet me zelfs denken aan een pop deuntje, maar ik kan er niet zo snel opkomen welke dat was...

 

[ProgHead]

Heb de draad weer opgepakt. Ik probeer nu aanpassingen van F = m.a uit. Als ik iets muzikaal interessants gevonden heb meld ik mij weer.

 

[ProgHead]

Voor aanpassingen van F = m.a van de vorm F = m.f(a) waarin f een te kiezen functie is heb ik geen interessante nieuwe geluiden gevonden.

 

[ProgHead]

We bekijken nu onderstaande opzet voor een fictieve wereld waarin alle massa's aan een kosmisch bepaalde periodieke schommeling in grootte onderhevig zijn:


De Wet van Hooke:

[imath] F = - \mathrm{R} \cdot x \,\,\,\,\,\,\,\,\,\,\, (9) [/imath]


Aangepaste Tweede Wet van Newton:

[imath] \left . \begin{array}{lll} F = \mathrm{m}(t) \cdot \frac{\mathrm{d}^2 x}{\mathrm{d} t^2} \\ \mathrm{m}(t) =\mathrm{m}_0 (1 + \alpha \sin(\beta t + \gamma)) \end{array} \right \} \,\,\,\,\,\,\,\,\,\,\, (10) [/imath]


Schrijf nu:

[imath] \left . \begin{array}{rcl} v = \frac{\mathrm{d} x}{\mathrm{d} t} \\ a = \frac{\mathrm{d} v}{\mathrm{d} t} \end{array} \right \} \,\,\,\,\,\,\,\,\,\,\, (11) [/imath]


Dan vinden we:

[imath] - \mathrm{R} \cdot x = \mathrm{m}_0 (1 + \alpha \sin(\beta t + \gamma)) \cdot \frac{\mathrm{d}^2 x}{\mathrm{d} t^2} [/imath]

[imath] \frac{\mathrm{d}^2 x}{\mathrm{d} t^2} = \frac{- \mathrm{R} \, x}{ \mathrm{m}_0 (1 + \alpha \sin(\beta t + \gamma)) } \,\,\,\,\,\,\,\,\,\,\, (12) [/imath]


De simulatie start dan met de beginwaarden x(t0) en v(t0). Met behulp van (12) vinden we daar a(t0) uit. En vervolgens kunnen we dan steeds de situatie voor een tijdje [imath] \Delta t [/imath] later berekenen:

[imath] \left . \begin{array}{lll} \mathrm{x}(t+\Delta t) \approx \mathrm{x}(t) + \mathrm{v}(t) \cdot \Delta t \\ \mathrm{v}(t+\Delta t) \approx \mathrm{v}(t) + \mathrm{a}(t) \cdot \Delta t \\ \mathrm{a}(t+\Delta t) = \frac{- \mathrm{R} \cdot \mathrm{x}(t+\Delta t)}{ \mathrm{m}_0 (1 + \alpha \sin(\beta \cdot (t+\Delta t) \, + \, \gamma)) } \end{array} \right \} \,\,\,\,\,\,\,\,\,\,\, (13) [/imath]

 

[ProgHead]

Hieronder een voorbeeldje op basis van de opzet beschreven in mijn vorige bericht:

<CsoundSynthesizer>

<CsOptions>
-o dac
</CsOptions>

<CsInstruments>
sr = 300000000
ksmps =  1
nchnls = 2
0dbfs = 1

 
instr 1
;steps of 1 sample time
kdelta_t = 1/sr


;input kR
kR = 10000000
;input kAlpha
kAlpha= 0.9
;input kBeta
kBeta = 5120
;input kGamma
kGamma = 1
;input km0
km0 = 1
 

;measuring time passed
kres timeinsts

if kres < 0.0001 then
kx_old = 0.5
kv_old = 0
ka_old = 0

else
kx_new = kx_old + kv_old*kdelta_t
kv_new = kv_old + ka_old*kdelta_t
ka_new = (-1*kR*kx_new)/(km0*(1 + kAlpha*sin(kBeta*(kres+kdelta_t) + kGamma)))


kx_old = kx_new
kv_old = kv_new
ka_old = ka_new
endif

;correction of amplitude drift
kx_old limit kx_old, -0.9, 0.9

aOut = kx_old
outs aOut, aOut

endin

</CsInstruments>

<CsScore>
i 1 0 5
</CsScore>

</CsoundSynthesizer>

 

[ProgHead]

In veel gevallen krijg je met de bovenvermelde opzet een gecombineerd vibrato en tremolo effect.

 

[ProgHead]

Goed - weer even terug naar dit topic. Wat we ook kunnen onderzoeken zijn fictionele effect modules, dat wil zeggen effect apparaten of software die modelleert hoe het geluid op de weg van het muziekinstrument naar ons oor vervormd wordt in een denkbeeldige wereld met andere akoestische wetmatigheden dan de ons bekende.

 

[ProgHead]

Ben nu aan de slag met Faust om te proberen daarmee het stuitergeluid te reproduceren. Dat is nog niet gelukt, maar zo net vond ik met onderstaande Faust dsp-code wel een heel vreemd resultaat:

declare name "test";
declare options "[midi:on]";

import("maths.lib");
import("filters.lib");

freq = 50;

gate = button("gate");

process = ( _,0.001*gate :> _ ) ~ (_ : integrator/SR : integrator/SR : lowpass(6, 2*freq) : highpass(6, 0.5*freq) : _*(2*3.14159*freq)^2 : 0-_ : 30*atan ) ;

Luister en huiver:

Voor wie daar zelf mee wil hobbyen gebruik de online IDE: Faust IDE ; plaats daarin de boven vermelde code; en dan Run > DSP > "gate".

 

[ProgHead]

OK - weer een stapje verder gekomen. Met onderstaand Faust-progje kan ik real-time veel gevarieerder "stuiter"-geluiden maken dan wat eerder met Csound minuten lang rekenwerk vereiste. Voorbeeldje Faust-geluiden is hier bijgevoegd.

declare name "test";
declare options "[midi:on]";

import("maths.lib");
import("filters.lib");

freq = 640;

alpha = 30;
beta = 30;

f(x) = -1*((2*3.14159*freq)^2)*(1 + alpha*sin(beta*x))*x;
g(x) = (2/3.14159)*atan((3.14159/2)*x);


gate = button("start");
process = (_,0.01*gate :> f : g : _ ) ~ (_ : integrator/SR : integrator/SR : f : g : _)  ,  (_,0.01*gate :> f : g : _ ) ~ (_ : integrator/SR : integrator/SR : f : g : _) ;

 

[ProgHead]

Nog wat verder aan gesleuteld:

declare options "[midi:on]";
declare options "[nvoices:8]";
declare name "Funny Loop";

import("maths.lib");
import("filters.lib");
import("envelopes.lib");

var1   = hslider("variation 1", 0.5, 0.1, 1, 0.001);
var2   = hslider("variation 2", 0.5, 0.1, 1, 0.001);
var3   = hslider("variation 3", 0.5, 0.1, 1, 0.001);
var    = 1000000000*hslider("variation", 0.5, 0.001, 1, 0.001);

at  = hslider("Attack", 0,0,0.5,0.01);
dt  = hslider("Decay",  0,0,0.5,0.01);
sl  = hslider("Sustain", 1,0,1,0.01);
rt  = hslider("Release", 3,0,10,0.01);
gate = button("start");

linteg = _ : atan : integrator/SR : atan : _;

f1(x) = -1*var1*var*x;
f2(x) = -1*var2*var*x;
f3(x) = -1*var3*var*x;

A = _ ,0.01*gate :> _ ;
B = _ : f1 : linteg : f2 : linteg : f3 : _ ;
C = A~B ;
process = C : adsr(at,dt,sl,rt,gate)*_ <: _,_;

Het dsp programma hierboven kunt je ook zelf in de online Faust IDE plakken en afspelen.

Een opname van wat daarmee mogelijk is:

 

[Grumble]

Leuk! 1

 

[ProgHead]

Ja - het begint langzaam aan de moeite waard te worden. Het grappige is dat ik zelf niet begrijp hoe dit werkt. Dat het progje als een oscillator werkt dat vat ik wel, maar waarom er een soort van vogelgefluit riedeltjes uit komen is mij een raadsel. Dat moet ik nog uitzoeken. Verder wil ik er een plugin met een fraaie GUI van maken.

 

[ProgHead]

Het programma nog ietsjes verbeterd:

declare name "Funny Loop";

import("maths.lib");
import("filters.lib");

var1   = hslider("variation 1", 0.5, 0.1, 1, 0.001);
var2   = hslider("variation 2", 0.5, 0.1, 1, 0.001);
var3   = hslider("variation 3", 0.5, 0.1, 1, 0.001);
var    = 10^9*(hslider("variation", 0.5, 0.001, 1, 0.001))^4;
vol    = 0.1*(hslider("volume", 0.5, 0, 1, 0.0001))^2;

start  = 0.01*button("start");
po     = 1 - 0.9*button("restart");

integrate = _ : atan : pole(po)/SR : atan : _;

f1(x) = -1*var1*var*x;
f2(x) = -1*var2*var*x;
f3(x) = -1*var3*var*x;

A = _ , start :> _ ;
B = _ : f1 : integrate : f2 : integrate : f3 : _ ;
C = A~B ;
process = C : atan : _*vol <: _,_;

Dit kan gedraaid worden in de online Faust IDE. Daar kun je ook opnamen maken, en het progje als plugin exporteren (hoewel de GUI niet je van het is).

 

[Disharmonic]

Heb er even mee zitten spelen, geluiden van een soort robot-vogeltjes tot geluidseffecten uit een SF-film.

 

[ProgHead]

Ja - dat is het zo ongeveer. Niet heel spectaculair maar toch grappig dat dat met zo'n eenvoudig loopje mogelijk is. Ook komt er niet elke keer hetzelfde uit. Ik weet nog niet hoe dat kan. Mogelijk is het een chaotisch systeem?

 

[Disharmonic]

Mogelijk is het een chaotisch systeem?

Als ie dat nu niet doet, dat moet met wat extra regels code toe te voegen zijn.

 

[ProgHead]