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_scheme.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 gather_scatter, only : gs_t
37 use checkpoint, only : chkp_t
38 use num_types, only: rp
39 use field, only : field_t
40 use field_list, only: field_list_t
41 use space, only : space_t
42 use dofmap, only : dofmap_t
43 use krylov, only : ksp_t, krylov_solver_factory, krylov_solver_destroy, &
45 use coefs, only : coef_t
46 use dirichlet, only : dirichlet_t
47 use neumann, only : neumann_t
48 use jacobi, only : jacobi_t
50 use sx_jacobi, only : sx_jacobi_t
51 use hsmg, only : hsmg_t
52 use bc, only : bc_t
53 use bc_list, only : bc_list_t
54 use precon, only : pc_t, precon_factory, precon_destroy
57 use facet_zone, only : facet_zone_t
63 use json_module, only : json_file
66 use utils, only : neko_error
67 use comm, only: neko_comm, mpi_integer, mpi_sum
70 use math, only : cfill, add2s2
71 use field_math, only : field_add2s2
77 implicit none
78
80 type, abstract :: scalar_scheme_t
82 type(field_t), pointer :: u
84 type(field_t), pointer :: v
86 type(field_t), pointer :: w
88 type(field_t), pointer :: s
90 type(field_series_t) :: slag
92 type(space_t), pointer :: xh
94 type(dofmap_t), pointer :: dm_xh
96 type(gs_t), pointer :: gs_xh
98 type(coef_t), pointer :: c_xh
100 type(field_t), pointer :: f_xh => null()
104 class(ksp_t), allocatable :: ksp
106 integer :: ksp_maxiter
108 integer :: projection_dim
109
110 integer :: projection_activ_step
112 class(pc_t), allocatable :: pc
114 type(bc_list_t) :: bcs
116 type(json_file), pointer :: params
118 type(mesh_t), pointer :: msh => null()
120 type(chkp_t) :: chkp
122 real(kind=rp) :: lambda
124 type(field_t) :: lambda_field
126 character(len=:), allocatable :: nut_field_name
128 real(kind=rp) :: rho
130 real(kind=rp) :: cp
132 real(kind=rp) :: pr_turb
134 logical :: variable_material_properties = .false.
136 logical :: if_gradient_jump_penalty
138 contains
140 procedure, pass(this) :: scheme_init => scalar_scheme_init
142 procedure, pass(this) :: scheme_free => scalar_scheme_free
144 procedure, pass(this) :: validate => scalar_scheme_validate
146 procedure, pass(this) :: set_material_properties => &
149 procedure, pass(this) :: update_material_properties => &
152 procedure(scalar_scheme_init_intrf), pass(this), deferred :: init
154 procedure(scalar_scheme_free_intrf), pass(this), deferred :: free
156 procedure(scalar_scheme_step_intrf), pass(this), deferred :: step
158 procedure(scalar_scheme_restart_intrf), pass(this), deferred :: restart
159 end type scalar_scheme_t
160
162 abstract interface
163 subroutine scalar_scheme_init_intrf(this, msh, coef, gs, params, user, &
164 ulag, vlag, wlag, time_scheme, rho)
165 import scalar_scheme_t
166 import json_file
167 import coef_t
168 import gs_t
169 import mesh_t
170 import user_t
171 import field_series_t
173 import rp
174 class(scalar_scheme_t), target, intent(inout) :: this
175 type(mesh_t), target, intent(in) :: msh
176 type(coef_t), target, intent(in) :: coef
177 type(gs_t), target, intent(inout) :: gs
178 type(json_file), target, intent(inout) :: params
179 type(user_t), target, intent(in) :: user
180 type(field_series_t), target, intent(in) :: ulag, vlag, wlag
181 type(time_scheme_controller_t), target, intent(in) :: time_scheme
182 real(kind=rp), intent(in) :: rho
183 end subroutine scalar_scheme_init_intrf
184 end interface
185
187 abstract interface
188 subroutine scalar_scheme_restart_intrf(this, dtlag, tlag)
189 import scalar_scheme_t
190 import chkp_t
191 import rp
192 class(scalar_scheme_t), target, intent(inout) :: this
193 real(kind=rp) :: dtlag(10), tlag(10)
194 end subroutine scalar_scheme_restart_intrf
195 end interface
196
198 abstract interface
200 import scalar_scheme_t
201 class(scalar_scheme_t), intent(inout) :: this
202 end subroutine scalar_scheme_free_intrf
203 end interface
204
206 abstract interface
207 subroutine scalar_scheme_step_intrf(this, t, tstep, dt, ext_bdf, &
208 dt_controller)
209 import scalar_scheme_t
212 import rp
213 class(scalar_scheme_t), intent(inout) :: this
214 real(kind=rp), intent(in) :: t
215 integer, intent(in) :: tstep
216 real(kind=rp), intent(in) :: dt
217 type(time_scheme_controller_t), intent(in) :: ext_bdf
218 type(time_step_controller_t), intent(in) :: dt_controller
219 end subroutine scalar_scheme_step_intrf
220 end interface
221
222contains
223
232 subroutine scalar_scheme_init(this, msh, c_Xh, gs_Xh, params, scheme, user, &
233 rho)
234 class(scalar_scheme_t), target, intent(inout) :: this
235 type(mesh_t), target, intent(in) :: msh
236 type(coef_t), target, intent(in) :: c_Xh
237 type(gs_t), target, intent(inout) :: gs_Xh
238 type(json_file), target, intent(inout) :: params
239 character(len=*), intent(in) :: scheme
240 type(user_t), target, intent(in) :: user
241 real(kind=rp), intent(in) :: rho
242 ! IO buffer for log output
243 character(len=LOG_SIZE) :: log_buf
244 ! Variables for retrieving json parameters
245 logical :: logical_val
246 real(kind=rp) :: real_val, solver_abstol
247 integer :: integer_val, ierr
248 character(len=:), allocatable :: solver_type, solver_precon
249 real(kind=rp) :: gjp_param_a, gjp_param_b
250
251 this%u => neko_field_registry%get_field('u')
252 this%v => neko_field_registry%get_field('v')
253 this%w => neko_field_registry%get_field('w')
254
255 call neko_log%section('Scalar')
256 call json_get(params, 'case.scalar.solver.type', solver_type)
257 call json_get(params, 'case.scalar.solver.preconditioner', &
258 solver_precon)
259 call json_get(params, 'case.scalar.solver.absolute_tolerance', &
260 solver_abstol)
261
262 call json_get_or_default(params, &
263 'case.scalar.solver.projection_space_size', &
264 this%projection_dim, 20)
265 call json_get_or_default(params, &
266 'case.scalar.solver.projection_hold_steps', &
267 this%projection_activ_step, 5)
268
269
270 write(log_buf, '(A, A)') 'Type : ', trim(scheme)
271 call neko_log%message(log_buf)
272 call neko_log%message('Ksp scalar : ('// trim(solver_type) // &
273 ', ' // trim(solver_precon) // ')')
274 write(log_buf, '(A,ES13.6)') ' `-abs tol :', solver_abstol
275 call neko_log%message(log_buf)
276
277 this%Xh => this%u%Xh
278 this%dm_Xh => this%u%dof
279 this%params => params
280 this%msh => msh
281 if (.not. neko_field_registry%field_exists('s')) then
282 call neko_field_registry%add_field(this%dm_Xh, 's')
283 end if
284 this%s => neko_field_registry%get_field('s')
285
286 call this%slag%init(this%s, 2)
287
288 this%gs_Xh => gs_xh
289 this%c_Xh => c_xh
290
291 !
292 ! Material properties
293 !
294 this%rho = rho
295 call this%set_material_properties(params, user)
296
297 write(log_buf, '(A,ES13.6)') 'rho :', this%rho
298 call neko_log%message(log_buf)
299 write(log_buf, '(A,ES13.6)') 'lambda :', this%lambda
300 call neko_log%message(log_buf)
301 write(log_buf, '(A,ES13.6)') 'cp :', this%cp
302 call neko_log%message(log_buf)
303
304 !
305 ! Turbulence modelling and variable material properties
306 !
307 if (params%valid_path('case.scalar.nut_field')) then
308 call json_get(params, 'case.scalar.Pr_t', this%pr_turb)
309 call json_get(params, 'case.scalar.nut_field', this%nut_field_name)
310 this%variable_material_properties = .true.
311 else
312 this%nut_field_name = ""
313 end if
314
315 write(log_buf, '(A,L1)') 'LES : ', this%variable_material_properties
316 call neko_log%message(log_buf)
317
318 ! Fill lambda field with the physical value
319 call this%lambda_field%init(this%dm_Xh, "lambda")
320 if (neko_bcknd_device .eq. 1) then
321 call device_cfill(this%lambda_field%x_d, this%lambda, &
322 this%lambda_field%size())
323 else
324 call cfill(this%lambda_field%x, this%lambda, this%lambda_field%size())
325 end if
326
327 !
328 ! Setup right-hand side field.
329 !
330 allocate(this%f_Xh)
331 call this%f_Xh%init(this%dm_Xh, fld_name = "scalar_rhs")
332
333 ! Initialize the source term
334 call this%source_term%init(this%f_Xh, this%c_Xh, user)
335 call this%source_term%add(params, 'case.scalar.source_terms')
336
337 ! todo parameter file ksp tol should be added
338 call json_get_or_default(params, &
339 'case.fluid.velocity_solver.max_iterations', &
340 integer_val, ksp_max_iter)
341 call json_get_or_default(params, &
342 'case.fluid.velocity_solver.monitor', &
343 logical_val, .false.)
344 call scalar_scheme_solver_factory(this%ksp, this%dm_Xh%size(), &
345 solver_type, integer_val, solver_abstol, logical_val)
346 call scalar_scheme_precon_factory(this%pc, this%ksp, &
347 this%c_Xh, this%dm_Xh, this%gs_Xh, this%bcs, solver_precon)
348
349 ! Initiate gradient jump penalty
350 call json_get_or_default(params, &
351 'case.scalar.gradient_jump_penalty.enabled',&
352 this%if_gradient_jump_penalty, .false.)
353
354 if (this%if_gradient_jump_penalty .eqv. .true.) then
355 if ((this%dm_Xh%xh%lx - 1) .eq. 1) then
356 call json_get_or_default(params, &
357 'case.scalar.gradient_jump_penalty.tau',&
358 gjp_param_a, 0.02_rp)
359 gjp_param_b = 0.0_rp
360 else
361 call json_get_or_default(params, &
362 'case.scalar.gradient_jump_penalty.scaling_factor',&
363 gjp_param_a, 0.8_rp)
364 call json_get_or_default(params, &
365 'case.scalar.gradient_jump_penalty.scaling_exponent',&
366 gjp_param_b, 4.0_rp)
367 end if
368 call this%gradient_jump_penalty%init(params, this%dm_Xh, this%c_Xh, &
369 gjp_param_a, gjp_param_b)
370 end if
371
372 call neko_log%end_section()
373
374 end subroutine scalar_scheme_init
375
376
378 subroutine scalar_scheme_free(this)
379 class(scalar_scheme_t), intent(inout) :: this
380
381 nullify(this%Xh)
382 nullify(this%dm_Xh)
383 nullify(this%gs_Xh)
384 nullify(this%c_Xh)
385 nullify(this%params)
386
387 if (allocated(this%ksp)) then
388 call krylov_solver_destroy(this%ksp)
389 deallocate(this%ksp)
390 end if
391
392 if (allocated(this%pc)) then
393 call precon_destroy(this%pc)
394 deallocate(this%pc)
395 end if
396
397 call this%source_term%free()
398
399 call this%bcs%free()
400
401 call this%lambda_field%free()
402 call this%slag%free()
403
404 ! Free gradient jump penalty
405 if (this%if_gradient_jump_penalty .eqv. .true.) then
406 call this%gradient_jump_penalty%free()
407 end if
408
409 end subroutine scalar_scheme_free
410
413 subroutine scalar_scheme_validate(this)
414 class(scalar_scheme_t), target, intent(inout) :: this
415
416 if ( (.not. allocated(this%u%x)) .or. &
417 (.not. allocated(this%v%x)) .or. &
418 (.not. allocated(this%w%x)) .or. &
419 (.not. allocated(this%s%x))) then
420 call neko_error('Fields are not allocated')
421 end if
422
423 if (.not. allocated(this%ksp)) then
424 call neko_error('No Krylov solver for velocity defined')
425 end if
426
427 if (.not. associated(this%Xh)) then
428 call neko_error('No function space defined')
429 end if
430
431 if (.not. associated(this%dm_Xh)) then
432 call neko_error('No dofmap defined')
433 end if
434
435 if (.not. associated(this%c_Xh)) then
436 call neko_error('No coefficients defined')
437 end if
438
439 if (.not. associated(this%f_Xh)) then
440 call neko_error('No rhs allocated')
441 end if
442
443 if (.not. associated(this%params)) then
444 call neko_error('No parameters defined')
445 end if
446
447 !
448 ! Setup checkpoint structure (if everything is fine)
449 !
450! @todo no io for now
451! call this%chkp%init(this%u, this%v, this%w, this%p)
452
453 end subroutine scalar_scheme_validate
454
457 subroutine scalar_scheme_solver_factory(ksp, n, solver, max_iter, &
458 abstol, monitor)
459 class(ksp_t), allocatable, target, intent(inout) :: ksp
460 integer, intent(in), value :: n
461 integer, intent(in) :: max_iter
462 character(len=*), intent(in) :: solver
463 real(kind=rp) :: abstol
464 logical, intent(in) :: monitor
465
466 call krylov_solver_factory(ksp, n, solver, max_iter, &
467 abstol, monitor = monitor)
468
469 end subroutine scalar_scheme_solver_factory
470
472 subroutine scalar_scheme_precon_factory(pc, ksp, coef, dof, gs, bclst, &
473 pctype)
474 class(pc_t), allocatable, target, intent(inout) :: pc
475 class(ksp_t), target, intent(inout) :: ksp
476 type(coef_t), target, intent(in) :: coef
477 type(dofmap_t), target, intent(in) :: dof
478 type(gs_t), target, intent(inout) :: gs
479 type(bc_list_t), target, intent(inout) :: bclst
480 character(len=*) :: pctype
481
482 call precon_factory(pc, pctype)
483
484 select type (pcp => pc)
485 type is (jacobi_t)
486 call pcp%init(coef, dof, gs)
487 type is (sx_jacobi_t)
488 call pcp%init(coef, dof, gs)
489 type is (device_jacobi_t)
490 call pcp%init(coef, dof, gs)
491 type is (hsmg_t)
492 if (len_trim(pctype) .gt. 4) then
493 if (index(pctype, '+') .eq. 5) then
494 call pcp%init(dof%msh, dof%Xh, coef, dof, gs, bclst, &
495 trim(pctype(6:)))
496 else
497 call neko_error('Unknown coarse grid solver')
498 end if
499 else
500 call pcp%init(dof%msh, dof%Xh, coef, dof, gs, bclst)
501 end if
502 end select
503
504 call ksp%set_pc(pc)
505
506 end subroutine scalar_scheme_precon_factory
507
510 class(scalar_scheme_t), intent(inout) :: this
511 type(field_t), pointer :: nut
512 integer :: n
513 ! Factor to transform nu_t to lambda_t
514 real(kind=rp) :: lambda_factor
515
516 lambda_factor = this%rho*this%cp/this%pr_turb
517 this%lambda_field = this%lambda
518
519 if (this%variable_material_properties) then
520 nut => neko_field_registry%get_field(this%nut_field_name)
521 n = nut%size()
522 call field_add2s2(this%lambda_field, nut, lambda_factor, n)
523 end if
524
526
530 subroutine scalar_scheme_set_material_properties(this, params, user)
531 class(scalar_scheme_t), intent(inout) :: this
532 type(json_file), intent(inout) :: params
533 type(user_t), target, intent(in) :: user
534 character(len=LOG_SIZE) :: log_buf
535 ! A local pointer that is needed to make Intel happy
536 procedure(user_material_properties), pointer :: dummy_mp_ptr
537 real(kind=rp) :: dummy_mu, dummy_rho
538
539 dummy_mp_ptr => dummy_user_material_properties
540
541 if (.not. associated(user%material_properties, dummy_mp_ptr)) then
542
543 write(log_buf, '(A)') "Material properties must be set in the user&
544 & file!"
545 call neko_log%message(log_buf)
546 call user%material_properties(0.0_rp, 0, dummy_rho, dummy_mu, &
547 this%cp, this%lambda, params)
548 else
549 if (params%valid_path('case.scalar.Pe') .and. &
550 (params%valid_path('case.scalar.lambda') .or. &
551 params%valid_path('case.scalar.cp'))) then
552 call neko_error("To set the material properties for the scalar,&
553 & either provide Pe OR lambda and cp in the case file.")
554 ! Non-dimensional case
555 else if (params%valid_path('case.scalar.Pe')) then
556 write(log_buf, '(A)') 'Non-dimensional scalar material properties &
557 & input.'
558 call neko_log%message(log_buf, lvl = neko_log_verbose)
559 write(log_buf, '(A)') 'Specific heat capacity will be set to 1,'
560 call neko_log%message(log_buf, lvl = neko_log_verbose)
561 write(log_buf, '(A)') 'conductivity to 1/Pe. Assumes density is 1.'
562 call neko_log%message(log_buf, lvl = neko_log_verbose)
563
564 ! Read Pe into lambda for further manipulation.
565 call json_get(params, 'case.scalar.Pe', this%lambda)
566 write(log_buf, '(A,ES13.6)') 'Pe :', this%lambda
567 call neko_log%message(log_buf)
568
569 ! Set cp and rho to 1 since the setup is non-dimensional.
570 this%cp = 1.0_rp
571 this%rho = 1.0_rp
572 ! Invert the Pe to get conductivity
573 this%lambda = 1.0_rp/this%lambda
574 ! Dimensional case
575 else
576 call json_get(params, 'case.scalar.lambda', this%lambda)
577 call json_get(params, 'case.scalar.cp', this%cp)
578 end if
579
580 end if
582
583end module scalar_scheme
Abstract interface defining a dirichlet condition on a list of fields.
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.
Abstract interface to dealocate a scalar formulation.
Abstract interface to initialize a scalar formulation.
Abstract interface to restart a scalar formulation.
Abstract interface to compute a time-step.
Abstract interface for setting material properties.
Abstract interface defining a user defined scalar boundary condition (pointwise) Just imitating inflo...
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
type(mpi_comm) neko_comm
MPI communicator.
Definition comm.F90:38
Jacobi preconditioner accelerator backend.
subroutine, public device_add2s2(a_d, b_d, c1, n)
Vector addition with scalar multiplication (multiplication on first argument)
subroutine, public device_cfill(a_d, c, n)
Set all elements to a constant c .
Defines a dirichlet boundary condition.
Definition dirichlet.f90:34
Defines a mapping of the degrees of freedom.
Definition dofmap.f90:35
Defines a zone as a subset of facets in a mesh.
Defines user dirichlet condition for a scalar field.
subroutine, public field_add2s2(a, b, c1, n)
Vector addition with scalar multiplication (multiplication on second argument)
Defines a registry for storing solution fields.
type(field_registry_t), target, public neko_field_registry
Global field registry.
Stores a series fields.
Defines a field.
Definition field.f90:34
Gather-scatter.
Implements gradient_jump_penalty_t.
Krylov preconditioner.
Definition pc_hsmg.f90:61
Jacobi preconditioner.
Definition pc_jacobi.f90:34
Utilities for retrieving parameters from the case files.
Implements the base abstract type for Krylov solvers plus helper types.
Definition krylov.f90:34
integer, parameter, public ksp_max_iter
Maximum number of iters.
Definition krylov.f90:51
Logging routines.
Definition log.f90:34
integer, parameter, public neko_log_verbose
Verbose log level.
Definition log.f90:71
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
subroutine, public cfill(a, c, n)
Set all elements to a constant c .
Definition math.f90:347
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
integer, parameter, public neko_msh_max_zlbls
Max num. zone labels.
Definition mesh.f90:56
integer, parameter, public neko_msh_max_zlbl_len
Max length of a zone label.
Definition mesh.f90:58
Build configurations.
integer, parameter neko_bcknd_device
Defines a Neumann boundary condition.
Definition neumann.f90:34
integer, parameter, public rp
Global precision used in computations.
Definition num_types.f90:12
Krylov preconditioner.
Definition precon.f90:34
Contains the scalar_scheme_t type.
subroutine scalar_scheme_init(this, msh, c_xh, gs_xh, params, scheme, user, rho)
Initialize all related components of the current scheme.
subroutine scalar_scheme_free(this)
Deallocate a scalar formulation.
subroutine scalar_scheme_solver_factory(ksp, n, solver, max_iter, abstol, monitor)
Initialize a linear solver.
subroutine scalar_scheme_validate(this)
Validate that all fields, solvers etc necessary for performing time-stepping are defined.
subroutine scalar_scheme_update_material_properties(this)
Update the values of lambda_field if necessary.
subroutine scalar_scheme_precon_factory(pc, ksp, coef, dof, gs, bclst, pctype)
Initialize a Krylov preconditioner.
subroutine scalar_scheme_set_material_properties(this, params, user)
Set lamdba and cp.
Implements the scalar_source_term_t type.
Implements the source_term_t type and a wrapper source_term_wrapper_t.
Defines a function space.
Definition space.f90:34
Jacobi preconditioner SX-Aurora backend.
Compound scheme for the advection and diffusion operators in a transport equation.
Implements type time_step_controller.
Interfaces for user interaction with NEKO.
Definition user_intf.f90:34
subroutine, public dummy_user_material_properties(t, tstep, rho, mu, cp, lambda, params)
Defines dirichlet conditions for scalars.
Utilities.
Definition utils.f90:35
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
Defines a jacobi preconditioner.
Generic Dirichlet boundary condition on .
Definition dirichlet.f90:47
User defined dirichlet condition, for which the user can work with an entire field....
field_list_t, To be able to group fields together
Defines a jacobi preconditioner.
Definition pc_jacobi.f90:45
Base abstract type for a canonical Krylov method, solving .
Definition krylov.f90:68
A Neumann boundary condition for scalar fields. Sets the flux of the field to the chosen value.
Definition neumann.f90:51
Defines a canonical Krylov preconditioner.
Definition precon.f90:40
Base type for a scalar advection-diffusion solver.
Wrapper contaning and executing the scalar source terms.
The function space for the SEM solution fields.
Definition space.f90:62
Defines a jacobi preconditioner for SX-Aurora.
Implements the logic to compute the time coefficients for the advection and diffusion operators in a ...
User defined dirichlet condition for scalars.