Loading [MathJax]/extensions/tex2jax.js
Neko 0.9.99
A portable framework for high-order spectral element flow simulations
All Classes Namespaces Files Functions Variables Typedefs Enumerator Macros Pages
scalar_pnpn.f90
Go to the documentation of this file.
1! Copyright (c) 2022-2024, The Neko Authors
2! All rights reserved.
3!
4! Redistribution and use in source and binary forms, with or without
5! modification, are permitted provided that the following conditions
6! are met:
7!
8! * Redistributions of source code must retain the above copyright
9! notice, this list of conditions and the following disclaimer.
10!
11! * Redistributions in binary form must reproduce the above
12! copyright notice, this list of conditions and the following
13! disclaimer in the documentation and/or other materials provided
14! with the distribution.
15!
16! * Neither the name of the authors nor the names of its
17! contributors may be used to endorse or promote products derived
18! from this software without specific prior written permission.
19!
20! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
28! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31! POSSIBILITY OF SUCH DAMAGE.
32!
34
36 use comm
37 use num_types, only: rp
38 use, intrinsic :: iso_fortran_env, only: error_unit
40 rhs_maker_ext_fctry, rhs_maker_bdf_fctry, rhs_maker_oifs_fctry
42 use field, only : field_t
43 use bc_list, only : bc_list_t
44 use mesh, only : mesh_t
45 use checkpoint, only : chkp_t
46 use coefs, only : coef_t
48 use gather_scatter, only : gs_t, gs_op_add
49 use scalar_residual, only : scalar_residual_t, scalar_residual_factory
50 use ax_product, only : ax_t, ax_helm_factory
53 use krylov, only : ksp_monitor_t
57 use projection, only : projection_t
58 use math, only : glsc2, col2, add2s2
60 use advection, only : advection_t, advection_factory
63 use json_module, only : json_file, json_core, json_value
64 use user_intf, only : user_t
69 use bc, only : bc_t
70 implicit none
71 private
72
73
74 type, public, extends(scalar_scheme_t) :: scalar_pnpn_t
75
77 type(field_t) :: s_res
78
80 type(field_t) :: ds
81
83 class(ax_t), allocatable :: ax
84
86 type(projection_t) :: proj_s
87
91 type(zero_dirichlet_t) :: bc_res
92
97 type(bc_list_t) :: bclst_ds
98
100 class(advection_t), allocatable :: adv
101
102 ! Time interpolation scheme
103 logical :: oifs
104
105 ! Lag arrays for the RHS.
106 type(field_t) :: abx1, abx2
107
108 ! Advection terms for the oifs method
109 type(field_t) :: advs
110
112 class(scalar_residual_t), allocatable :: res
113
115 class(rhs_maker_ext_t), allocatable :: makeext
116
118 class(rhs_maker_bdf_t), allocatable :: makebdf
119
121 class(rhs_maker_oifs_t), allocatable :: makeoifs
122
123 contains
125 procedure, pass(this) :: init => scalar_pnpn_init
127 procedure, pass(this) :: restart => scalar_pnpn_restart
129 procedure, pass(this) :: free => scalar_pnpn_free
131 procedure, pass(this) :: step => scalar_pnpn_step
133 procedure, pass(this) :: setup_bcs_ => scalar_pnpn_setup_bcs_
134 end type scalar_pnpn_t
135
136 interface
137
143 module subroutine bc_factory(object, scheme, json, coef, user)
144 class(bc_t), pointer, intent(inout) :: object
145 type(scalar_pnpn_t), intent(in) :: scheme
146 type(json_file), intent(inout) :: json
147 type(coef_t), intent(in) :: coef
148 type(user_t), intent(in) :: user
149 end subroutine bc_factory
150 end interface
151
152contains
153
165 subroutine scalar_pnpn_init(this, msh, coef, gs, params, user, &
166 ulag, vlag, wlag, time_scheme, rho)
167 class(scalar_pnpn_t), target, intent(inout) :: this
168 type(mesh_t), target, intent(in) :: msh
169 type(coef_t), target, intent(in) :: coef
170 type(gs_t), target, intent(inout) :: gs
171 type(json_file), target, intent(inout) :: params
172 type(user_t), target, intent(in) :: user
173 type(field_series_t), target, intent(in) :: ulag, vlag, wlag
174 type(time_scheme_controller_t), target, intent(in) :: time_scheme
175 real(kind=rp), intent(in) :: rho
176 integer :: i
177 class(bc_t), pointer :: bc_i
178 character(len=15), parameter :: scheme = 'Modular (Pn/Pn)'
179 logical :: advection
180
181 call this%free()
182
183 ! Initiliaze base type.
184 call this%scheme_init(msh, coef, gs, params, scheme, user, rho)
185
186 ! Setup backend dependent Ax routines
187 call ax_helm_factory(this%ax, full_formulation = .false.)
188
189 ! Setup backend dependent scalar residual routines
190 call scalar_residual_factory(this%res)
191
192 ! Setup backend dependent summation of extrapolation scheme
193 call rhs_maker_ext_fctry(this%makeext)
194
195 ! Setup backend dependent contributions to F from lagged BD terms
196 call rhs_maker_bdf_fctry(this%makebdf)
197
198 ! Setup backend dependent contributions of the OIFS scheme
199 call rhs_maker_oifs_fctry(this%makeoifs)
200
201 ! Initialize variables specific to this plan
202 associate(xh_lx => this%Xh%lx, xh_ly => this%Xh%ly, xh_lz => this%Xh%lz, &
203 dm_xh => this%dm_Xh, nelv => this%msh%nelv)
204
205 call this%s_res%init(dm_xh, "s_res")
206
207 call this%abx1%init(dm_xh, "abx1")
208
209 call this%abx2%init(dm_xh, "abx2")
210
211 call this%advs%init(dm_xh, "advs")
212
213 call this%ds%init(dm_xh, 'ds')
214
215 end associate
216
217 ! Set up boundary conditions
218 call this%setup_bcs_(user)
219
220 ! Initialize dirichlet bcs for scalar residual
221 call this%bc_res%init(this%c_Xh, params)
222 do i = 1, this%bcs%size()
223 if (this%bcs%strong(i)) then
224 bc_i => this%bcs%get(i)
225 call this%bc_res%mark_facets(bc_i%marked_facet)
226 end if
227 end do
228
229! call this%bc_res%mark_zones_from_list('d_s', this%bc_labels)
230 call this%bc_res%finalize()
231
232 call this%bclst_ds%init()
233 call this%bclst_ds%append(this%bc_res)
234
235
236 ! Initialize projection space
237 call this%proj_s%init(this%dm_Xh%size(), this%projection_dim, &
238 this%projection_activ_step)
239
240 ! Add lagged term to checkpoint
241 ! @todo Init chkp object, note, adding 3 slags
242 ! call this%chkp%add_lag(this%slag, this%slag, this%slag)
243
244 ! Determine the time-interpolation scheme
245 call json_get_or_default(params, 'case.numerics.oifs', this%oifs, .false.)
246
247 ! Initialize advection factory
248 call json_get_or_default(params, 'case.scalar.advection', advection, .true.)
249 call advection_factory(this%adv, params, this%c_Xh, &
250 ulag, vlag, wlag, this%chkp%dtlag, &
251 this%chkp%tlag, time_scheme, .not. advection, &
252 this%slag)
253 end subroutine scalar_pnpn_init
254
256 subroutine scalar_pnpn_restart(this, dtlag, tlag)
257 class(scalar_pnpn_t), target, intent(inout) :: this
258 real(kind=rp) :: dtlag(10), tlag(10)
259 integer :: n
260
261
262 n = this%s%dof%size()
263
264 call col2(this%s%x, this%c_Xh%mult, n)
265 call col2(this%slag%lf(1)%x, this%c_Xh%mult, n)
266 call col2(this%slag%lf(2)%x, this%c_Xh%mult, n)
267 if (neko_bcknd_device .eq. 1) then
268 call device_memcpy(this%s%x, this%s%x_d, &
269 n, host_to_device, sync = .false.)
270 call device_memcpy(this%slag%lf(1)%x, this%slag%lf(1)%x_d, &
271 n, host_to_device, sync = .false.)
272 call device_memcpy(this%slag%lf(2)%x, this%slag%lf(2)%x_d, &
273 n, host_to_device, sync = .false.)
274 call device_memcpy(this%abx1%x, this%abx1%x_d, &
275 n, host_to_device, sync = .false.)
276 call device_memcpy(this%abx2%x, this%abx2%x_d, &
277 n, host_to_device, sync = .false.)
278 call device_memcpy(this%advs%x, this%advs%x_d, &
279 n, host_to_device, sync = .false.)
280 end if
281
282 call this%gs_Xh%op(this%s, gs_op_add)
283 call this%gs_Xh%op(this%slag%lf(1), gs_op_add)
284 call this%gs_Xh%op(this%slag%lf(2), gs_op_add)
285
286 end subroutine scalar_pnpn_restart
287
288 subroutine scalar_pnpn_free(this)
289 class(scalar_pnpn_t), intent(inout) :: this
290
291 !Deallocate scalar field
292 call this%scheme_free()
293
294 call this%bclst_ds%free()
295 call this%proj_s%free()
296
297 call this%s_res%free()
298
299 call this%ds%free()
300
301 call this%abx1%free()
302 call this%abx2%free()
303
304 call this%advs%free()
305
306 if (allocated(this%Ax)) then
307 deallocate(this%Ax)
308 end if
309
310 if (allocated(this%res)) then
311 deallocate(this%res)
312 end if
313
314 if (allocated(this%makeext)) then
315 deallocate(this%makeext)
316 end if
317
318 if (allocated(this%makebdf)) then
319 deallocate(this%makebdf)
320 end if
321
322 if (allocated(this%makeoifs)) then
323 deallocate(this%makeoifs)
324 end if
325
326 end subroutine scalar_pnpn_free
327
328 subroutine scalar_pnpn_step(this, t, tstep, dt, ext_bdf, dt_controller)
329 class(scalar_pnpn_t), intent(inout) :: this
330 real(kind=rp), intent(in) :: t
331 integer, intent(in) :: tstep
332 real(kind=rp), intent(in) :: dt
333 type(time_scheme_controller_t), intent(in) :: ext_bdf
334 type(time_step_controller_t), intent(in) :: dt_controller
335 ! Number of degrees of freedom
336 integer :: n
337 ! Linear solver results monitor
338 type(ksp_monitor_t) :: ksp_results(1)
339 character(len=LOG_SIZE) :: log_buf
340
341 n = this%dm_Xh%size()
342
343 call profiler_start_region('Scalar', 2)
344 associate(u => this%u, v => this%v, w => this%w, s => this%s, &
345 cp => this%cp, rho => this%rho, &
346 ds => this%ds, &
347 s_res => this%s_res, &
348 ax => this%Ax, f_xh => this%f_Xh, xh => this%Xh, &
349 c_xh => this%c_Xh, dm_xh => this%dm_Xh, gs_xh => this%gs_Xh, &
350 slag => this%slag, oifs => this%oifs, &
351 lambda_field => this%lambda_field, &
352 projection_dim => this%projection_dim, &
353 msh => this%msh, res => this%res, makeoifs => this%makeoifs, &
354 makeext => this%makeext, makebdf => this%makebdf, &
355 if_variable_dt => dt_controller%if_variable_dt, &
356 dt_last_change => dt_controller%dt_last_change)
357
358 ! Logs extra information the log level is NEKO_LOG_DEBUG or above.
359 call print_debug(this)
360 ! Compute the source terms
361 call this%source_term%compute(t, tstep)
362
363 ! Compute the grandient jump penalty term
364 if (this%if_gradient_jump_penalty .eqv. .true.) then
365 call this%gradient_jump_penalty%compute(u, v, w, s)
366 call this%gradient_jump_penalty%perform(f_xh)
367 end if
368
369 ! Apply weak boundary conditions, that contribute to the source terms.
370 call this%bcs%apply_scalar(this%f_Xh%x, dm_xh%size(), t, tstep, .false.)
371
372 if (oifs) then
373 ! Add the advection operators to the right-hans-side.
374 call this%adv%compute_scalar(u, v, w, s, this%advs, &
375 xh, this%c_Xh, dm_xh%size())
376
377 call makeext%compute_scalar(this%abx1, this%abx2, f_xh%x, rho, &
378 ext_bdf%advection_coeffs, n)
379
380 call makeoifs%compute_scalar(this%advs%x, f_xh%x, rho, dt, n)
381 else
382 ! Add the advection operators to the right-hans-side.
383 call this%adv%compute_scalar(u, v, w, s, f_xh, &
384 xh, this%c_Xh, dm_xh%size())
385
386 ! At this point the RHS contains the sum of the advection operator,
387 ! Neumann boundary sources and additional source terms, evaluated using
388 ! the scalar field from the previous time-step. Now, this value is used in
389 ! the explicit time scheme to advance these terms in time.
390 call makeext%compute_scalar(this%abx1, this%abx2, f_xh%x, rho, &
391 ext_bdf%advection_coeffs, n)
392
393 ! Add the RHS contributions coming from the BDF scheme.
394 call makebdf%compute_scalar(slag, f_xh%x, s, c_xh%B, rho, dt, &
395 ext_bdf%diffusion_coeffs, ext_bdf%ndiff, n)
396 end if
397
398 call slag%update()
399
401 call this%bcs%apply_scalar(this%s%x, this%dm_Xh%size(), t, tstep, .true.)
402
403 ! Update material properties if necessary
404 call this%update_material_properties()
405
406 ! Compute scalar residual.
407 call profiler_start_region('Scalar_residual', 20)
408 call res%compute(ax, s, s_res, f_xh, c_xh, msh, xh, lambda_field, &
409 rho*cp, ext_bdf%diffusion_coeffs(1), dt, dm_xh%size())
410
411 call gs_xh%op(s_res, gs_op_add)
412
413
414 ! Apply a 0-valued Dirichlet boundary conditions on the ds.
415 call this%bclst_ds%apply_scalar(s_res%x, dm_xh%size())
416
417 call profiler_end_region('Scalar_residual', 20)
418
419 call this%proj_s%pre_solving(s_res%x, tstep, c_xh, n, dt_controller)
420
421 call this%pc%update()
422 call profiler_start_region('Scalar_solve', 21)
423 ksp_results(1) = this%ksp%solve(ax, ds, s_res%x, n, &
424 c_xh, this%bclst_ds, gs_xh)
425 call profiler_end_region('Scalar_solve', 21)
426
427 call this%proj_s%post_solving(ds%x, ax, c_xh, this%bclst_ds, gs_xh, &
428 n, tstep, dt_controller)
429
430 ! Update the solution
431 if (neko_bcknd_device .eq. 1) then
432 call device_add2s2(s%x_d, ds%x_d, 1.0_rp, n)
433 else
434 call add2s2(s%x, ds%x, 1.0_rp, n)
435 end if
436
437 call scalar_step_info(tstep, t, dt, ksp_results)
438
439 end associate
440 call profiler_end_region('Scalar', 2)
441 end subroutine scalar_pnpn_step
442
443 subroutine print_debug(this)
444 class(scalar_pnpn_t), intent(inout) :: this
445 character(len=LOG_SIZE) :: log_buf
446 integer :: n
447
448 n = this%dm_Xh%size()
449
450 write(log_buf,'(A,A,E15.7,A,E15.7,A,E15.7)') 'Scalar debug', &
451 ' l2norm s', glsc2(this%s%x, this%s%x, n), &
452 ' slag1', glsc2(this%slag%lf(1)%x, this%slag%lf(1)%x, n), &
453 ' slag2', glsc2(this%slag%lf(2)%x, this%slag%lf(2)%x, n)
454 call neko_log%message(log_buf, lvl=neko_log_debug)
455 write(log_buf,'(A,A,E15.7,A,E15.7)') 'Scalar debug2', &
456 ' l2norm abx1', glsc2(this%abx1%x, this%abx1%x, n), &
457 ' abx2', glsc2(this%abx2%x, this%abx2%x, n)
458 call neko_log%message(log_buf, lvl=neko_log_debug)
459 end subroutine print_debug
460
463 subroutine scalar_pnpn_setup_bcs_(this, user)
464 class(scalar_pnpn_t), intent(inout) :: this
465 type(user_t), target, intent(in) :: user
466 integer :: i, j, n_bcs, zone_size, global_zone_size, ierr
467 type(json_core) :: core
468 type(json_value), pointer :: bc_object
469 type(json_file) :: bc_subdict
470 class(bc_t), pointer :: bc_i
471 logical :: found
472 ! Monitor which boundary zones have been marked
473 logical, allocatable :: marked_zones(:)
474 integer, allocatable :: zone_indices(:)
475
476
477 if (this%params%valid_path('case.scalar.boundary_conditions')) then
478 call this%params%info('case.scalar.boundary_conditions', &
479 n_children = n_bcs)
480 call this%params%get_core(core)
481 call this%params%get('case.scalar.boundary_conditions', bc_object, found)
482
483 call this%bcs%init(n_bcs)
484
485 allocate(marked_zones(size(this%msh%labeled_zones)))
486 marked_zones = .false.
487
488 do i = 1, n_bcs
489 ! Create a new json containing just the subdict for this bc
490 call json_extract_item(core, bc_object, i, bc_subdict)
491
492 ! Check that we are not trying to assing a bc to zone, for which one
493 ! has already been assigned and that the zone has more than 0 size
494 ! in the mesh.
495 call json_get(bc_subdict, "zone_indices", zone_indices)
496
497 do j = 1, size(zone_indices)
498 zone_size = this%msh%labeled_zones(zone_indices(j))%size
499 call mpi_allreduce(zone_size, global_zone_size, 1, &
500 mpi_integer, mpi_max, neko_comm, ierr)
501
502 if (global_zone_size .eq. 0) then
503 write(error_unit, '(A, A, I0, A, A, I0, A)') "*** ERROR ***: ",&
504 "Zone index ", zone_indices(j), &
505 " is invalid as this zone has 0 size, meaning it ", &
506 "does not in the mesh. Check scalar boundary condition ", &
507 i, "."
508 error stop
509 end if
510
511 if (marked_zones(zone_indices(j)) .eqv. .true.) then
512 write(error_unit, '(A, A, I0, A, A, A, A)') "*** ERROR ***: ", &
513 "Zone with index ", zone_indices(j), &
514 " has already been assigned a boundary condition. ", &
515 "Please check your boundary_conditions entry for the ", &
516 "scalar and make sure that each zone index appears only ",&
517 "in a single boundary condition."
518 error stop
519 else
520 marked_zones(zone_indices(j)) = .true.
521 end if
522 end do
523
524 bc_i => null()
525
526 call bc_factory(bc_i, this, bc_subdict, this%c_Xh, user)
527 call this%bcs%append(bc_i)
528 end do
529
530 ! Make sure all labeled zones with non-zero size have been marked
531 do i = 1, size(this%msh%labeled_zones)
532 if ((this%msh%labeled_zones(i)%size .gt. 0) .and. &
533 (marked_zones(i) .eqv. .false.)) then
534 write(error_unit, '(A, A, I0)') "*** ERROR ***: ", &
535 "No scalar boundary condition assigned to zone ", i
536 error stop
537 end if
538 end do
539 end if
540 end subroutine scalar_pnpn_setup_bcs_
541
542end module scalar_pnpn
Copy data between host and device (or device and device)
Definition device.F90:65
Retrieves a parameter by name or assigns a provided default value. In the latter case also adds the m...
Retrieves a parameter by name or throws an error.
Subroutines to add advection terms to the RHS of a transport equation.
Definition advection.f90:34
Defines a Matrix-vector product.
Definition ax.f90:34
Defines a list of bc_t.
Definition bc_list.f90:34
Defines a boundary condition.
Definition bc.f90:34
Defines a checkpoint.
Coefficients.
Definition coef.f90:34
Definition comm.F90:1
subroutine, public device_col2(a_d, b_d, n)
Vector multiplication .
subroutine, public device_add2s2(a_d, b_d, c1, n)
Vector addition with scalar multiplication (multiplication on first argument)
Device abstraction, common interface for various accelerators.
Definition device.F90:34
integer, parameter, public host_to_device
Definition device.F90:46
Dirichlet condition applied in the facet normal direction.
Stores a series fields.
Defines a field.
Definition field.f90:34
Gather-scatter.
Utilities for retrieving parameters from the case files.
Implements the base abstract type for Krylov solvers plus helper types.
Definition krylov.f90:34
Logging routines.
Definition log.f90:34
integer, parameter, public neko_log_debug
Debug log level.
Definition log.f90:73
type(log_t), public neko_log
Global log stream.
Definition log.f90:65
integer, parameter, public log_size
Definition log.f90:42
Definition math.f90:60
real(kind=rp) function, public glsc2(a, b, n)
Weighted inner product .
Definition math.f90:875
subroutine, public col2(a, b, n)
Vector multiplication .
Definition math.f90:728
subroutine, public add2s2(a, b, c1, n)
Vector addition with scalar multiplication (multiplication on second argument)
Definition math.f90:672
Defines a mesh.
Definition mesh.f90:34
Build configurations.
integer, parameter neko_bcknd_device
integer, parameter, public rp
Global precision used in computations.
Definition num_types.f90:12
Profiling interface.
Definition profiler.F90:34
subroutine, public profiler_start_region(name, region_id)
Started a named (name) profiler region.
Definition profiler.F90:78
subroutine, public profiler_end_region(name, region_id)
End the most recently started profiler region.
Definition profiler.F90:109
Project x onto X, the space of old solutions and back again.
Routines to generate the right-hand sides for the convection-diffusion equation. Employs the EXT/BDF ...
Definition rhs_maker.f90:38
Auxiliary routines for fluid solvers.
Definition scalar_aux.f90:2
subroutine scalar_step_info(step, t, dt, ksp_results)
Prints for prs, velx, vely, velz the following: Number of iterations, start residual,...
Contains the scalar_pnpn_t type.
subroutine scalar_pnpn_setup_bcs_(this, user)
Initialize boundary conditions.
subroutine scalar_pnpn_init(this, msh, coef, gs, params, user, ulag, vlag, wlag, time_scheme, rho)
Boundary condition factory. Both constructs and initializes the object.
subroutine scalar_pnpn_step(this, t, tstep, dt, ext_bdf, dt_controller)
subroutine scalar_pnpn_restart(this, dtlag, tlag)
I envision the arguments to this func might need to be expanded.
subroutine scalar_pnpn_free(this)
Defines the residual for the scalar transport equation.
Contains the scalar_scheme_t type.
Defines a registry for storing and requesting temporary fields This can be used when you have a funct...
type(scratch_registry_t) function init(dof, size, expansion_size)
Constructor, optionally taking initial registry and expansion size as argument.
type(scratch_registry_t), target, public neko_scratch_registry
Global scratch registry.
Compound scheme for the advection and diffusion operators in a transport equation.
Base class for time integration schemes.
Implements type time_step_controller.
Interfaces for user interaction with NEKO.
Definition user_intf.f90:34
Defines a zero-valued Dirichlet boundary condition.
Base abstract type for computing the advection operator.
Definition advection.f90:46
Base type for a matrix-vector product providing .
Definition ax.f90:43
Base type for a boundary condition.
Definition bc.f90:57
A list of allocatable `bc_t`. Follows the standard interface of lists.
Definition bc_list.f90:47
Coefficients defined on a given (mesh, ) tuple. Arrays use indices (i,j,k,e): element e,...
Definition coef.f90:55
Dirichlet condition in facet normal direction.
Type for storing initial and final residuals in a Krylov solver.
Definition krylov.f90:56
Abstract type to add contributions to F from lagged BD terms.
Definition rhs_maker.f90:59
Abstract type to sum up contributions to kth order extrapolation scheme.
Definition rhs_maker.f90:52
Abstract type to add contributions of kth order OIFS scheme.
Definition rhs_maker.f90:66
Abstract type to compute scalar residual.
Base type for a scalar advection-diffusion solver.
Implements the logic to compute the time coefficients for the advection and diffusion operators in a ...
Zero-valued Dirichlet boundary condition. Used for no-slip walls, but also for various auxillary cond...