/home/runner/work/amr-wind/amr-wind/amr-wind/ocean_waves/relaxation_zones/stokes_waves_K.H Source File

AMR-Wind API: /home/runner/work/amr-wind/amr-wind/amr-wind/ocean_waves/relaxation_zones/stokes_waves_K.H Source File
AMR-Wind API v0.1.0
CFD solver for wind plant simulations
Loading...
Searching...
No Matches
stokes_waves_K.H
Go to the documentation of this file.
1#ifndef STOKES_WAVES_H_
2#define STOKES_WAVES_H_
3
4#include <AMReX_FArrayBox.H>
5#include <cmath>
6
7// Stokes waves theory adapted from
8// Fenton, J., Fifth Order Stokes Theory for Steady Waves
9// Journal of Waterway, Port, Coastal and Ocean Engineering, 1985, 111, 216-234
10
11namespace amr_wind::ocean_waves::relaxation_zones {
12
13// Compute wavelength as a function of wave period, water depth, and g
14AMREX_FORCE_INLINE amrex::Real stokes_wave_length(
15 const amrex::Real T,
16 const amrex::Real d,
17 const amrex::Real H,
18 const int order,
19 const amrex::Real g,
20 const amrex::Real tol,
21 const int iter_max)
22{
23 // Calculate constants and derivatives that do not change with iteration
24 const amrex::Real omega = 2.0 * M_PI / T;
25 const amrex::Real depsdk = H / 2.0;
26
27 // Begin Newton-Raphson iterations
28 int iter = 0;
29 // First guess is first-order
30 amrex::Real k = (omega * omega) / g;
31 // Cannot skip loop
32 amrex::Real f = tol + 1.0;
33 while (std::abs(f) > tol && iter < iter_max) {
34 // Calculate current constants
35 const amrex::Real S = 1.0 / std::cosh(2.0 * k * d);
36 const amrex::Real C = 1.0 - S;
37 const amrex::Real eps = k * H / 2.0;
38 const amrex::Real C0 = std::sqrt(std::tanh(k * d));
39 const amrex::Real C2 = C0 * (2.0 + 7.0 * S * S) / (4.0 * C * C);
40 const amrex::Real numterm_C4 =
41 (4.0 + 32.0 * S - 116.0 * std::pow(S, 2) - 400.0 * std::pow(S, 3) -
42 71.0 * std::pow(S, 4) + 146.0 * std::pow(S, 5));
43 const amrex::Real C4 = C0 * numterm_C4 / (32.0 * std::pow(C, 5));
44 // Calculate pure derivates
45 const amrex::Real dSdk = -2.0 * d * std::sinh(2.0 * k * d) /
46 std::pow(std::cosh(2.0 * k * d), 2);
47 const amrex::Real dCdk = -dSdk;
48 const amrex::Real dC0dk =
49 d / (2.0 * C0 * std::pow(std::cosh(k * d), 2));
50 // Calculate derivatives with products
51 const amrex::Real dC2dk =
52 (4 * std::pow(C, 2) *
53 (dC0dk * (2.0 + 7.0 * std::pow(S, 2)) + C0 * 14.0 * S * dSdk) -
54 C0 * (2.0 + 7.0 * std::pow(S, 2)) * 8.0 * C * dCdk) /
55 (16.0 * std::pow(C, 4));
56 const amrex::Real dC4dk =
57 (32.0 * std::pow(C, 5) *
58 (dC0dk * numterm_C4 +
59 C0 * (32.0 * dSdk - 232.0 * S * dSdk -
60 1200 * std::pow(S, 2) * dSdk -
61 284.0 * std::pow(S, 3) * dSdk + 730 * std::pow(S, 4))) -
62 C0 * numterm_C4 * 160.0 * std::pow(C, 4) * dCdk) /
63 (1024.0 * std::pow(C, 10));
64
65 // Calculate derivative for loop convergence
66 amrex::Real dfdk = g * std::pow(C0, 2) + g * k * 2.0 * C0 * dC0dk;
67 // Add additional terms depending on order
68 if (order >= 2) {
69 dfdk +=
70 g * (2.0 * C0 * std::pow(eps, 2) * C2 +
71 std::pow(eps, 4) * std::pow(C2, 2)) +
72 g * k *
73 (2.0 * dC0dk * std::pow(eps, 2) * C2 +
74 2.0 * C0 *
75 (2.0 * eps * depsdk * C2 + std::pow(eps, 2) * dC2dk) +
76 4.0 * std::pow(eps, 3) * std::pow(C2, 2) * depsdk +
77 std::pow(eps, 4) * 2.0 * C2 * dC2dk);
78 }
79 if (order >= 4) {
80 dfdk += g * (2.0 * std::pow(eps, 4) * C0 * C4 +
81 2.0 * std::pow(eps, 6) * C2 * C4 +
82 std::pow(eps, 8) * std::pow(C4, 2)) +
83 g * k *
84 (8.0 * std::pow(eps, 3) * depsdk * C0 * C4 +
85 2.0 * std::pow(eps, 4) * (C0 * dC4dk + C4 * dC0dk) +
86 12 * std::pow(eps, 5) * depsdk * C2 * C4 +
87 2.0 * std::pow(eps, 6) * (C2 * dC4dk + C4 * dC2dk) +
88 8.0 * std::pow(eps, 7) * depsdk * std::pow(C4, 2) +
89 std::pow(eps, 8) * 2.0 * C4 * dC4dk);
90 }
91 k = k - f / dfdk;
92
93 iter += 1;
94 f = g * k * std::pow(C0, 2);
95 // Add additional terms depending on order
96 if (order >= 2) {
97 f += g * k *
98 (2.0 * C0 * std::pow(eps, 2) * C2 +
99 std::pow(eps, 4) * std::pow(C2, 2));
100 }
101 if (order >= 4) {
102 f += g * k *
103 (2.0 * std::pow(eps, 4) * C0 * C4 +
104 2.0 * std::pow(eps, 6) * C2 * C4 +
105 std::pow(eps, 8) * std::pow(C4, 2));
106 }
107 // Subtract omega^2 to measure convergence
108 f -= omega * omega;
109 }
110
111 if (k < tol) {
112 // Return negative wavelength if faulty result
113 return -1;
114 }
115 if (std::isnan(k)) {
116 return -2;
117 }
118 if (iter == iter_max) {
119 return -3;
120 }
121 // Return wavelength calculated from wavenumber
122 return 2.0 * M_PI / k;
123}
124
125AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void stokes_coefficients(
126 int StokesOrder,
127 amrex::Real wavenumber,
128 amrex::Real waterdepth,
129 amrex::Real& c0,
130 amrex::Real& a11,
131 amrex::Real& a22,
132 amrex::Real& b22,
133 amrex::Real& c2,
134 amrex::Real& d2,
135 amrex::Real& e2,
136 amrex::Real& a31,
137 amrex::Real& a33,
138 amrex::Real& b31,
139 amrex::Real& a42,
140 amrex::Real& a44,
141 amrex::Real& b42,
142 amrex::Real& b44,
143 amrex::Real& c4,
144 amrex::Real& d4,
145 amrex::Real& e4,
146 amrex::Real& a51,
147 amrex::Real& a53,
148 amrex::Real& a55,
149 amrex::Real& b53,
150 amrex::Real& b55)
151{
152
153 amrex::Real kd = wavenumber * waterdepth;
154 if (kd > 50. * M_PI) {
155 kd = 50 * M_PI;
156 }
157
158 amrex::Real S = 2. * std::exp(2. * kd) / (std::exp(4. * kd) + 1.);
159 amrex::Real Sh = std::sinh(kd);
160 amrex::Real Th = std::tanh(kd);
161 amrex::Real CTh = (1. + std::exp(-2 * kd)) / (1. - std::exp(-2 * kd));
162
163 c0 = std::sqrt(Th);
164 a11 = 1. / std::sinh(kd); // Hyperbolic cosecant
165 // Second order coefficients
166 a22 = 3. * std::pow(S, 2) / (2 * std::pow(1 - S, 2));
167 b22 = CTh * (1 + 2. * S) / (2 * (1 - S));
168 c2 = std::sqrt(Th) * (2 + 7 * std::pow(S, 2)) / (4 * std::pow(1 - S, 2));
169 d2 = -std::sqrt(CTh) / 2.;
170 e2 = Th * (2 + 2 * S + 5 * std::pow(S, 2)) / (4 * std::pow(1 - S, 2));
171 if (StokesOrder == 2) {
172 return;
173 }
174
175 // Third order coefficients
176 a31 = (-4 - 20 * S + 10 * std::pow(S, 2) - 13 * std::pow(S, 3)) /
177 (8 * Sh * std::pow(1 - S, 3));
178 a33 = (-2 * std::pow(S, 2) + 11 * std::pow(S, 3)) /
179 (8 * Sh * std::pow(1 - S, 3));
180 b31 = -3 * (1 + 3 * S + 3 * std::pow(S, 2) + 2 * std::pow(S, 3)) /
181 (8 * std::pow(1 - S, 3));
182 if (StokesOrder == 3) {
183 return;
184 }
185
186 // Fourth order coefficients
187 a42 = (12 * S - 14 * std::pow(S, 2) - 264 * std::pow(S, 3) -
188 45 * std::pow(S, 4) - 13 * std::pow(S, 5)) /
189 (24 * std::pow(1 - S, 5));
190 a44 = (10 * std::pow(S, 3) - 174 * std::pow(S, 4) + 291 * std::pow(S, 5) +
191 278 * std::pow(S, 6)) /
192 (48 * (3 + 2 * S) * std::pow(1 - S, 5));
193 b42 = CTh *
194 (6 - 26 * S - 182 * std::pow(S, 2) - 204 * std::pow(S, 3) -
195 25 * std::pow(S, 4) + 26 * std::pow(S, 5)) /
196 (6 * (3 + 2 * S) * std::pow(1 - S, 4));
197 b44 = CTh *
198 (24 + 92 * S + 122 * std::pow(S, 2) + 66 * std::pow(S, 3) +
199 67 * std::pow(S, 4) + 34 * std::pow(S, 5)) /
200 (24 * (3 + 2 * S) * std::pow(1 - S, 4));
201 c4 = std::sqrt(Th) *
202 (4 + 32 * S - 116 * std::pow(S, 2) - 400 * std::pow(S, 3) -
203 71 * std::pow(S, 4) + 146 * std::pow(S, 5)) /
204 (32 * std::pow(1 - S, 5));
205 d4 = std::sqrt(CTh) * (2 + 4 * S + std::pow(S, 2) + 2 * std::pow(S, 3)) /
206 (8 * std::pow(1 - S, 3));
207 e4 = Th *
208 (8 + 12 * S - 152 * std::pow(S, 2) - 308 * std::pow(S, 3) -
209 42 * std::pow(S, 4) + 77 * std::pow(S, 5)) /
210 (32 * std::pow(1 - S, 5));
211 if (StokesOrder == 4) {
212 return;
213 }
214
215 // Fifth order coefficients
216 a51 =
217 (-1184 + 32 * S + 13232 * std::pow(S, 2) + 21712 * std::pow(S, 3) +
218 20940 * std::pow(S, 4) + 12554 * std::pow(S, 5) -
219 500 * std::pow(S, 6) - 3341 * std::pow(S, 7) - 670 * std::pow(S, 8)) /
220 (64 * Sh * (3 + 2 * S) * (4 + S) * std::pow(1 - S, 6));
221 a53 = (4 * S + 105 * pow(S, 2) + 198 * std::pow(S, 3) -
222 1376 * std::pow(S, 4) - 1302 * std::pow(S, 5) -
223 117 * std::pow(S, 6) + 58 * std::pow(S, 7)) /
224 (32 * Sh * (3 + 2 * S) * std::pow(1 - S, 6));
225 a55 =
226 (-6 * std::pow(S, 3) + 272 * std::pow(S, 4) - 1552 * std::pow(S, 5) +
227 852 * std::pow(S, 6) + 2029 * std::pow(S, 7) + 430 * std::pow(S, 8)) /
228 (64 * Sh * (3 + 2 * S) * (4 + S) * std::pow(1 - S, 6));
229 b53 = 9 *
230 (132 + 17 * S - 2216 * std::pow(S, 2) - 5897 * std::pow(S, 3) -
231 6292 * std::pow(S, 4) - 2687 * std::pow(S, 5) +
232 194 * std::pow(S, 6) + 467 * std::pow(S, 7) + 82 * std::pow(S, 8)) /
233 (128 * (3 + 2 * S) * (4 + S) * std::pow(1 - S, 6));
234 b55 =
235 5 *
236 (300 + 1579 * S + 3176 * std::pow(S, 2) + 2949 * std::pow(S, 3) +
237 1188 * std::pow(S, 4) + 675 * std::pow(S, 5) + 1326 * std::pow(S, 6) +
238 827 * std::pow(S, 7) + 130 * std::pow(S, 8)) /
239 (384 * (3 + 2 * S) * (4 + S) * std::pow(1 - S, 6));
240 if (StokesOrder == 5) {
241 return;
242 }
243
244 if (StokesOrder > 5 || StokesOrder < 2) {
245 amrex::Abort(
246 "invalid stokes order specified. It should be between 2,3,4 or 5 ");
247 }
248}
249
250AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real stokes_sinh_sin(
251 int m,
252 int n,
253 amrex::Real phase,
254 amrex::Real a11,
255 amrex::Real a22,
256 amrex::Real a31,
257 amrex::Real a33,
258 amrex::Real a42,
259 amrex::Real a44,
260 amrex::Real a51,
261 amrex::Real a53,
262 amrex::Real a55,
263 amrex::Real eps,
264 amrex::Real wavenumber,
265 amrex::Real waterdepth,
266 amrex::Real zsl,
267 amrex::Real z)
268{
269 amrex::Real D = 0.0;
270 if (m == 1 && n == 1) {
271 D = a11;
272 }
273 if (m == 2 && n == 2) {
274 D = a22;
275 }
276 if (m == 3 && n == 1) {
277 D = a31;
278 }
279 if (m == 3 && n == 3) {
280 D = a33;
281 }
282 if (m == 4 && n == 2) {
283 D = a42;
284 }
285 if (m == 4 && n == 4) {
286 D = a44;
287 }
288 if (m == 5 && n == 1) {
289 D = a51;
290 }
291 if (m == 5 && n == 3) {
292 D = a53;
293 }
294 if (m == 5 && n == 5) {
295 D = a55;
296 }
297
298 return std::pow(eps, m) * D * n * wavenumber *
299 std::sinh(n * wavenumber * (waterdepth + (z - zsl))) *
300 std::sin(n * phase);
301}
302
303AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real stokes_cosh_cos(
304 int m,
305 int n,
306 amrex::Real phase,
307 amrex::Real a11,
308 amrex::Real a22,
309 amrex::Real a31,
310 amrex::Real a33,
311 amrex::Real a42,
312 amrex::Real a44,
313 amrex::Real a51,
314 amrex::Real a53,
315 amrex::Real a55,
316 amrex::Real eps,
317 amrex::Real wavenumber,
318 amrex::Real waterdepth,
319 amrex::Real zsl,
320 amrex::Real z)
321{
322 amrex::Real D = 0.0;
323 if (m == 1 && n == 1) {
324 D = a11;
325 }
326 if (m == 2 && n == 2) {
327 D = a22;
328 }
329 if (m == 3 && n == 1) {
330 D = a31;
331 }
332 if (m == 3 && n == 3) {
333 D = a33;
334 }
335 if (m == 4 && n == 2) {
336 D = a42;
337 }
338 if (m == 4 && n == 4) {
339 D = a44;
340 }
341 if (m == 5 && n == 1) {
342 D = a51;
343 }
344 if (m == 5 && n == 3) {
345 D = a53;
346 }
347 if (m == 5 && n == 5) {
348 D = a55;
349 }
350
351 return std::pow(eps, m) * D * n * wavenumber *
352 std::cosh(n * wavenumber * (waterdepth + (z - zsl))) *
353 std::cos(n * phase);
354}
355
356// Based on Fenton 1985
357AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void stokes_waves(
358 int StokesOrder,
359 amrex::Real wavelength,
360 amrex::Real waterdepth,
361 amrex::Real waveheight,
362 amrex::Real zsl,
363 amrex::Real g,
364 amrex::Real x,
365 amrex::Real z,
366 amrex::Real time,
367 amrex::Real& eta,
368 amrex::Real& u_w,
369 amrex::Real& v_w,
370 amrex::Real& w_w)
371{
372 const amrex::Real wavenumber = 2.0 * M_PI / wavelength;
373
374 // some parameters
375 amrex::Real c0{0.0};
376 amrex::Real a11{0.0}, a22{0.0}, b22{0.0}, c2{0.0}, d2{0.0}, e2{0.0};
377 amrex::Real a31{0.0}, a33{0.0}, b31{0.0}, a42{0.0}, a44{0.0};
378 amrex::Real b42{0.0}, b44{0.0}, c4{0.0}, d4{0.0}, e4{0.0};
379 amrex::Real a51{0.0}, a53{0.0}, a55{0.0}, b53{0.0}, b55{0.0};
380
381 stokes_coefficients(
382 StokesOrder, wavenumber, waterdepth, c0, a11, a22, b22, c2, d2, e2, a31,
383 a33, b31, a42, a44, b42, b44, c4, d4, e4, a51, a53, a55, b53, b55);
384
385 const amrex::Real eps = wavenumber * waveheight / 2.; // Steepness (ka)
386 const amrex::Real c = (c0 + std::pow(eps, 2) * c2 + std::pow(eps, 4) * c4) *
387 std::sqrt(g / wavenumber);
388 // const amrex::Real Q =
389 // c * waterdepth * std::sqrt(std::pow(k, 3) / g) +
390 // d2 * std::pow(eps, 2) +
391 // d4 * std::pow(eps, 4) * std::sqrt(g / std::pow(k, 3));
392
393 const amrex::Real omega = c * wavenumber;
394 const amrex::Real phase = wavenumber * x - omega * time;
395
396 eta = (eps * std::cos(phase) // first order term
397 + std::pow(eps, 2) * b22 * std::cos(2. * phase) // second order term
398 + std::pow(eps, 3) * b31 * (std::cos(phase) - std::cos(3. * phase)) +
399 std::pow(eps, 4) * b42 *
400 (std::cos(2. * phase) + b44 * std::cos(4. * phase)) +
401 std::pow(eps, 5) *
402 (-(b53 + b55) * std::cos(phase) + b53 * std::cos(3 * phase) +
403 b55 * std::cos(5 * phase))) +
404 zsl;
405
406 // Compute cosines
407 const amrex::Real cc11 = stokes_cosh_cos(
408 1, 1, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
409 wavenumber, waterdepth, zsl, z);
410 const amrex::Real cc22 = stokes_cosh_cos(
411 2, 2, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
412 wavenumber, waterdepth, zsl, z);
413 const amrex::Real cc31 = stokes_cosh_cos(
414 3, 1, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
415 wavenumber, waterdepth, zsl, z);
416 const amrex::Real cc33 = stokes_cosh_cos(
417 3, 3, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
418 wavenumber, waterdepth, zsl, z);
419 const amrex::Real cc42 = stokes_cosh_cos(
420 4, 2, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
421 wavenumber, waterdepth, zsl, z);
422 const amrex::Real cc44 = stokes_cosh_cos(
423 4, 4, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
424 wavenumber, waterdepth, zsl, z);
425 const amrex::Real cc51 = stokes_cosh_cos(
426 5, 1, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
427 wavenumber, waterdepth, zsl, z);
428 const amrex::Real cc53 = stokes_cosh_cos(
429 5, 3, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
430 wavenumber, waterdepth, zsl, z);
431 const amrex::Real cc55 = stokes_cosh_cos(
432 5, 5, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
433 wavenumber, waterdepth, zsl, z);
434
435 // Compute sines
436 const amrex::Real ss11 = stokes_sinh_sin(
437 1, 1, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
438 wavenumber, waterdepth, zsl, z);
439 const amrex::Real ss22 = stokes_sinh_sin(
440 2, 2, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
441 wavenumber, waterdepth, zsl, z);
442 const amrex::Real ss31 = stokes_sinh_sin(
443 3, 1, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
444 wavenumber, waterdepth, zsl, z);
445 const amrex::Real ss33 = stokes_sinh_sin(
446 3, 3, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
447 wavenumber, waterdepth, zsl, z);
448 const amrex::Real ss42 = stokes_sinh_sin(
449 4, 2, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
450 wavenumber, waterdepth, zsl, z);
451 const amrex::Real ss44 = stokes_sinh_sin(
452 4, 4, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
453 wavenumber, waterdepth, zsl, z);
454 const amrex::Real ss51 = stokes_sinh_sin(
455 5, 1, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
456 wavenumber, waterdepth, zsl, z);
457 const amrex::Real ss53 = stokes_sinh_sin(
458 5, 3, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
459 wavenumber, waterdepth, zsl, z);
460 const amrex::Real ss55 = stokes_sinh_sin(
461 5, 5, phase, a11, a22, a31, a33, a42, a44, a51, a53, a55, eps,
462 wavenumber, waterdepth, zsl, z);
463
464 u_w = c0 * std::sqrt(g / std::pow(wavenumber, 3)) *
465 (cc11 + cc22 + cc31 + cc33 + cc42 + cc44 + cc51 + cc53 + cc55);
466 v_w = 0.0;
467 w_w = c0 * std::sqrt(g / std::pow(wavenumber, 3)) *
468 (ss11 + ss22 + ss31 + ss33 + ss42 + ss44 + ss51 + ss53 + ss55);
469}
470
471} // namespace amr_wind::ocean_waves::relaxation_zones
472#endif
amr_wind::ocean_waves::relaxation_zones
Definition relaxation_zones_ops.cpp:13
amr_wind::ocean_waves::relaxation_zones::stokes_waves
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void stokes_waves(int StokesOrder, amrex::Real wavelength, amrex::Real waterdepth, amrex::Real waveheight, amrex::Real zsl, amrex::Real g, amrex::Real x, amrex::Real z, amrex::Real time, amrex::Real &eta, amrex::Real &u_w, amrex::Real &v_w, amrex::Real &w_w)
Definition stokes_waves_K.H:357
amr_wind::ocean_waves::relaxation_zones::stokes_cosh_cos
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real stokes_cosh_cos(int m, int n, amrex::Real phase, amrex::Real a11, amrex::Real a22, amrex::Real a31, amrex::Real a33, amrex::Real a42, amrex::Real a44, amrex::Real a51, amrex::Real a53, amrex::Real a55, amrex::Real eps, amrex::Real wavenumber, amrex::Real waterdepth, amrex::Real zsl, amrex::Real z)
Definition stokes_waves_K.H:303
amr_wind::ocean_waves::relaxation_zones::stokes_sinh_sin
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real stokes_sinh_sin(int m, int n, amrex::Real phase, amrex::Real a11, amrex::Real a22, amrex::Real a31, amrex::Real a33, amrex::Real a42, amrex::Real a44, amrex::Real a51, amrex::Real a53, amrex::Real a55, amrex::Real eps, amrex::Real wavenumber, amrex::Real waterdepth, amrex::Real zsl, amrex::Real z)
Definition stokes_waves_K.H:250
amr_wind::ocean_waves::relaxation_zones::stokes_coefficients
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void stokes_coefficients(int StokesOrder, amrex::Real wavenumber, amrex::Real waterdepth, amrex::Real &c0, amrex::Real &a11, amrex::Real &a22, amrex::Real &b22, amrex::Real &c2, amrex::Real &d2, amrex::Real &e2, amrex::Real &a31, amrex::Real &a33, amrex::Real &b31, amrex::Real &a42, amrex::Real &a44, amrex::Real &b42, amrex::Real &b44, amrex::Real &c4, amrex::Real &d4, amrex::Real &e4, amrex::Real &a51, amrex::Real &a53, amrex::Real &a55, amrex::Real &b53, amrex::Real &b55)
Definition stokes_waves_K.H:125
amr_wind::ocean_waves::relaxation_zones::stokes_wave_length
AMREX_FORCE_INLINE amrex::Real stokes_wave_length(const amrex::Real T, const amrex::Real d, const amrex::Real H, const int order, const amrex::Real g, const amrex::Real tol, const int iter_max)
Definition stokes_waves_K.H:14
Generated by doxygen 1.12.0