Ugrás a tartalomhoz

Impulzív jelenségek modelljei

Karsai János

Typotex

4.2. Az IDESolve programcsomag

4.2. Az IDESolve programcsomag

A rögzített pillanatokban ható impulzusok vizsgálatára készített programcsomag alapvető szerepet kap a könyv során. Használatát mutatjuk be az alábbiakban.

Parancsösszefoglaló

Az IDESolve program rögzített időpillanatokkal rendelkező impulzív rendszerek közelítő megoldását végzi több kezdeti értékből kiindulva. A program számára a rendszert az

x'=f(t,x), ha t?t_i , x(t_i+0)=I(t_i,x(t_i–0)); i=1,2,... x ' = f ? ( t , x ) , ha ? t ? t i , x ( t i + 0 ) = I ( t i , x ( t i - 0 ) ) ; i = 1 , 2 , ... (4.2.1)

alakban adjuk meg (az impulzus alakja eltér az elméleti megfontolásokban használttól). A rendszer megoldásához meg kell adni az egyenletet, az impuzusok t_k

t k időpillanatait, az impulzusfüggvényt, a kezdeti értékeket. Két impulzus között a differenciálegyenletet a beépített NDSolve program oldja meg (lásd a differenciálegyenletek számítógépes vizsgálatának módszereivel foglalkozó fejezetet). Az impulzusok 10^(–10) 10 - 10 idő alatt hatnak. A program eredménye InterpolatingFunction objektumokból álló lista lesz.

A program indítása az alábbi módon történik:

IDESolve[xdotlist,varlst,timelst,Impulse,x0lst,{t,t0,t1},option]

Az egyes paraméterek jelentése:

varlst {x1, x2, ..., xn}, függő változók listája
xdotlst {f1[t, x1, ..., xn], ..., fn[t, x1, ..., xn]} a differenciálegyenlet jobb oldala
timelst az impulzusok időpontjai: {t1, t2, ...}
Impulse impulzusfüggvény
x0lst {{x10, ..., xn0}, ..., {x1M, ..., xnM}} kezdőértékek listája, M db n-dimenziós vektor
t független változó
[t0, t1] a megoldás intervalluma
option az NDSolve opciói

Az Impulse függvény megadása az I(t_k,x)

I ? ( t k , x ) jelöléshez illeszkedik:

Impulse[i_,timelst_,xlst_]:= ...

ahol

i az adott impulzus pillanat indexe timelist-ben
timelst ugyanaz, mint fent
xlst a megoldás értéke a timelist[[i]] helyen

A függvény definíciója tetszőleges globális változót tartalmazhat, de változóit a fentiek szerint kell megadni. Például, az x(t_i+0)=x(t_i–0)+1; i=1,2,...

x ? ( t i + 0 ) = x ? ( t i - 0 ) + 1 ; i = 1 , 2 , ... impulzus az alábbi módon definiálható:

Imp[i_,tn_List,x_List]:=x+1;

Imp [ i_ , tn_List , x_List ] := x + 1 ;

A program használata

A program használatát egy példán keresztül mutatjuk be. Itt a rendszerek megoldását csupán technikai szempontból vizsgáljuk, a matematikai problémákkal később foglalkozunk.

4.2.1. Példa. Impulzívan gerjesztett oszcillátor

Tekintsük az ismert harmonikus oszcillátort

x'=y, y'=–x,
x ' = y , y ' = - x ,

var={x,y}; xdot={y,–x};

var = { x , y } ; xdot = { y , - x } ;

amelyre impulzív külső erő hat minden t_i=i (i=1,2,....)

t i = i ? ( i = 1 , 2 , ... . ) pillanatban, azaz

y(t_i+0)=y(t_i–0)+A
y ? ( t i + 0 ) = y ? ( t i - 0 ) + A

Az impulzusok leírása Mathematica-ban:

tn=Table[i,{i,0,100}];

tn = Table [ i , { i , 0 , 100 } ] ;

az impulzusok időpillanatai,

A=1; An=Table[{0,A},{i,0,100}];

A = 1 ; An = Table [ { 0 , A } , { i , 0 , 100 } ] ;

azonos nagyságú impulzusok, és az impulzusfüggvény:

Imp[i_,tn_List,x_List]:=x+An[[i]]

Imp [ i_ , tn_List , x_List ] := x + An [ i ]

amely additív, az x listához ({x(t_i–0),y(t_i–0)})

( { x ? ( t i - 0 ) , y ? ( t i - 0 ) } ) koordinátánként An[[i]]-t hozzáadja. A paraméterek (i, tn, x) ( i , tn , x ) mellett globális változók is (mint például az An impulzustömb) használhatók. A rendszer független változója t, és a [t0,t1] [ t0 , t1 ] intervallumon oldjuk meg az {1,0} és {0,1} kezdeti feltételekkel, amelyeket az x0list változóban tárolunk.

t0=0; t1=20;

t0 = 0 ; t1 = 20 ;

x0list={{1,0},{0,1}};

x0list = { { 1 , 0 } , { 0 , 1 } } ;

Az IDESolve program most már indítható:

sol=IDESolve[xdot,var, tn,Imp,x0list,{t,t0,t1}];

sol = IDESolve [ xdot , var , tn , Imp , x0list , { t , t0 , t1 } ] ;

A megoldásként kapott lista elemei InterpolatingFunction objektumok. Az első, {1,0} kezdeti feltételekhez tartozó megoldás sol[[1]]:

Plot[Evaluate[sol[[1]]],{t,t0,t1},PlotStyle›{RGBColor[0,0,1],RGBColor[1,0,0]}];

Plot [ Evaluate [ sol [ 1 ] ] , { t , t0 , t1 } , PlotStyle { RGBColor [ 0 , 0 , 1 ] , RGBColor [ 1 , 0 , 0 ] } ] ;

A második, {0,1} kezdeti feltételekhez tartozó megoldás sol[[2]]:

Plot[Evaluate[sol[[2]]],{t,t0,t1},PlotStyle›{RGBColor[0,0,1],RGBColor[1,0,0]}];

Plot [ Evaluate [ sol [ 2 ] ] , { t , t0 , t1 } , PlotStyle { RGBColor [ 0 , 0 , 1 ] , RGBColor [ 1 , 0 , 0 ] } ] ;

  • Megjegyzés

Más alakú impulzusok is könnyen megadhatók. Például az x(t_i+0)=x(t_i–0)*A_i

x ? ( t i + 0 ) = x ? ( t i - 0 ) * A i multiplikatív impulzusfüggvényt (* vektorok esetén a koordinátánkénti szorzást jelenti) fékezett oszcillátoroknál alkalmazzuk.

Imp[n_,tn_List,x_List]:=x*An[[n]];

Imp [ n_ , tn_List , x_List ] := x * An [ n ] ;

  • Megjegyzés

Ha csak egy kezdeti feltételt adunk meg, akkor is kettős listát, például {{0.5,0.5}}, kell használnunk. Ezzel kapcsolatban emlékeztetnünk kell még arra is, hogy az {1,2,3}

{ 1 , 2 , 3 } és az {{1},{2},{3}} { { 1 } , { 2 } , { 3 } } listák nem azonosak. A következő 1D példa emiatt is hasznos.

4.2.2. Példa. Impulzív lehalászás

Tekintsük a korlátozó feltételek közötti (logisztikus) szaporodás egyenletét:

x'=x(2–x)
x ' = x ? ( 2 - x )

A Mathematica utasítások:

var={x}; xdot={x(2–x)};

var = { x } ; xdot = { x ? ( 2 - x ) } ;

A populáció minden t_i=i (i=1,2,....)

t i = i ? ( i = 1 , 2 , ... . ) pillanatban, mondjuk évente A mennyiséggel csökken (emigráció, betakarítás, lehalászás, kilövés ...), azaz

x(t_i+0)=x(t_i–0)–A
x ? ( t i + 0 ) = x ? ( t i - 0 ) - A

tn=Table[i,{i,0,100}];

tn = Table [ i , { i , 0 , 100 } ] ;

az impulzusok időpillanatai,

A=0.5; An=Table[{A},{i,0,100}];

A = 0.5 ; An = Table [ { A } , { i , 0 , 100 } ] ;

az azonos nagyságú impulzusok, és az impulzusfüggvény ugyanaz, mint az előző példában:

Imp[i_,tn_List,x_List]:=x–An[[i]];

Imp [ i_ , tn_List , x_List ] := x - An [ i ] ;

A rendszer független változója t, és a [t0,t1]

[ t0 , t1 ] intervallumon oldjuk meg az {1,0} és {0,1} kezdeti feltételekkel.

t0=0; t1=10; x0list={{3},{2},{1}};

t0 = 0 ; t1 = 10 ; x0list = { { 3 } , { 2 } , { 1 } } ;

Indítsuk az IDESolve programot:

sol=IDESolve[xdot,var,tn,Imp,x0list,{t,t0,t1}];

sol = IDESolve [ xdot , var , tn , Imp , x0list , { t , t0 , t1 } ] ;

Ábrázoljuk a megoldásokat együtt:

Plot[Evaluate[sol],{t,t0,t1},PlotStyle›{{Thickness[0.01],RGBColor[0,0,1]}}];

Plot [ Evaluate [ sol ] , { t , t0 , t1 } , PlotStyle { { Thickness [ 0.01 ] , RGBColor [ 0 , 0 , 1 ] } } ] ;