Mercurial > repos > public > sbplib

comparison +time/SBPInTimeImplicitFormulation.m @ 460:e0caae9ef6ed feature/grids

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