Mercurial > repos > public > sbplib

comparison +time/SBPInTimeScaled.m @ 746:e95a0f2f7a8d feature/grids

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add file that was forgotten.
author Jonatan Werpers <jonatan@werpers.com>
date Wed, 28 Mar 2018 12:51:05 +0200
parents
children 47e86b5270ad
comparison
equal deleted inserted replaced
745:00eb5db89da5 746:e95a0f2f7a8d
1 classdef SBPInTimeScaled < time.Timestepper
2 % The SBP in time method.
3 % Implemented for A*v_t = B*v + f(t), v(0) = v0
4 % The resulting system of equations is
5 % M*u_next= K*u_prev_end + f
6 properties
7 A,B
8 f
9
10 k % total time step.
11
12 blockSize % number of points in each block
13 N % Number of components
14
15 order
16 nodes
17
18 Mtilde,Ktilde % System matrices
19 L,U,p,q % LU factorization of M
20 e_T
21
22 scaling
23 S, Sinv % Scaling matrices
24
25 % Time state
26 t
27 vtilde
28 n
29 end
30
31 methods
32 function obj = SBPInTimeScaled(A, B, f, k, t0, v0, scaling, TYPE, order, blockSize)
33 default_arg('TYPE','gauss');
34 default_arg('f',[]);
35
36 if(strcmp(TYPE,'gauss'))
37 default_arg('order',4)
38 default_arg('blockSize',4)
39 else
40 default_arg('order', 8);
41 default_arg('blockSize',time.SBPInTimeImplicitFormulation.smallestBlockSize(order,TYPE));
42 end
43
44 obj.A = A;
45 obj.B = B;
46 obj.scaling = scaling;
47
48 if ~isempty(f)
49 obj.f = f;
50 else
51 obj.f = @(t)sparse(length(v0),1);
52 end
53
54 obj.k = k;
55 obj.blockSize = blockSize;
56 obj.N = length(v0);
57
58 obj.n = 0;
59 obj.t = t0;
60
61 %==== Build the time discretization matrix =====%
62 switch TYPE
63 case 'equidistant'
64 ops = sbp.D2Standard(blockSize,{0,obj.k},order);
65 case 'optimal'
66 ops = sbp.D1Nonequidistant(blockSize,{0,obj.k},order);
67 case 'minimal'
68 ops = sbp.D1Nonequidistant(blockSize,{0,obj.k},order,'minimal');
69 case 'gauss'
70 ops = sbp.D1Gauss(blockSize,{0,obj.k});
71 end
72
73 I = speye(size(A));
74 I_t = speye(blockSize,blockSize);
75
76 D1 = kron(ops.D1, I);
77 HI = kron(ops.HI, I);
78 e_0 = kron(ops.e_l, I);
79 e_T = kron(ops.e_r, I);
80 obj.nodes = ops.x;
81
82 % Convert to form M*w = K*v0 + f(t)
83 tau = kron(I_t, A) * e_0;
84 M = kron(I_t, A)*D1 + HI*tau*e_0' - kron(I_t, B);
85
86 K = HI*tau;
87
88 obj.S = kron(I_t, spdiag(scaling));
89 obj.Sinv = kron(I_t, spdiag(1./scaling));
90
91 obj.Mtilde = obj.Sinv*M*obj.S;
92 obj.Ktilde = obj.Sinv*K*spdiag(scaling);
93 obj.e_T = e_T;
94
95
96 % LU factorization
97 [obj.L,obj.U,obj.p,obj.q] = lu(obj.Mtilde, 'vector');
98
99 obj.vtilde = (1./obj.scaling).*v0;
100 end
101
102 function [v,t] = getV(obj)
103 v = obj.scaling.*obj.vtilde;
104 t = obj.t;
105 end
106
107 function obj = step(obj)
108 forcing = zeros(obj.blockSize*obj.N,1);
109
110 for i = 1:obj.blockSize
111 forcing((1 + (i-1)*obj.N):(i*obj.N)) = obj.f(obj.t + obj.nodes(i));
112 end
113
114 RHS = obj.Sinv*forcing + obj.Ktilde*obj.vtilde;
115
116 y = obj.L\RHS(obj.p);
117 z = obj.U\y;
118
119 w = zeros(size(z));
120 w(obj.q) = z;
121
122 obj.vtilde = obj.e_T'*w;
123
124 obj.t = obj.t + obj.k;
125 obj.n = obj.n + 1;
126 end
127 end
128
129 methods(Static)
130 function N = smallestBlockSize(order,TYPE)
131 default_arg('TYPE','gauss')
132
133 switch TYPE
134 case 'gauss'
135 N = 4;
136 end
137 end
138 end
139 end