scalar_source_term.f90

Go to the documentation of this file.

 
! Copyright (c) 2024, The Neko Authors
! All rights reserved.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
!   * Redistributions of source code must retain the above copyright
!     notice, this list of conditions and the following disclaimer.
!
!   * Redistributions in binary form must reproduce the above
!     copyright notice, this list of conditions and the following
!     disclaimer in the documentation and/or other materials provided
!     with the distribution.
!
!   * Neither the name of the authors nor the names of its
!     contributors may be used to endorse or promote products derived
!     from this software without specific prior written permission.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! POSSIBILITY OF SUCH DAMAGE.
!
module scalar_source_term
  use neko_config, only : neko_bcknd_device
  use num_types, only : rp
  use scalar_user_source_term, only: scalar_user_source_term_t
  use source_term, only : source_term_wrapper_t, source_term_t
  use source_term_fctry, only : source_term_factory
  use field, only : field_t
  use field_list, only : field_list_t
  use json_utils, only : json_get
  use json_module, only : json_file, json_core, json_value
  use coefs, only : coef_t
  use user_intf, only : user_t
  use utils, only : neko_warning
  implicit none
  private
 
  type, public :: scalar_source_term_t
     class(source_term_wrapper_t), allocatable :: source_terms(:)
     type(field_t), pointer :: f => null()
   contains
     procedure, pass(this) :: init => scalar_source_term_init
     procedure, pass(this) :: free => scalar_source_term_free
     procedure, pass(this) :: compute => scalar_source_term_compute
     procedure, nopass, private :: init_user_source
 
  end type scalar_source_term_t
 
contains
 
  subroutine scalar_source_term_init(this, json, f, coef, user)
    class(scalar_source_term_t), intent(inout) :: this
    type(json_file), intent(inout) :: json
    type(field_t), pointer, intent(in) :: f
    type(coef_t), intent(inout) :: coef
    type(user_t), intent(in) :: user
 
    type(field_list_t) :: rhs_fields
    ! Json low-level manipulator.
    type(json_core) :: core
    ! Pointer to the source_terms JSON object and the individual sources.
    type(json_value), pointer :: source_object, source_pointer
    ! Buffer for serializing the json.
    character(len=:), allocatable :: buffer
    ! A single source term as its own json_file.
    type(json_file) :: source_subdict
    ! Source type
    character(len=:), allocatable :: type
    ! Dummy source strenth values
    real(kind=rp) :: values(3)
    logical :: found
    integer :: n_sources, i
 
    call this%free()
 
    this%f => f
 
 
    if (json%valid_path('case.scalar.source_terms')) then
       ! We package the fields for the source term to operate on in a field list.
       allocate(rhs_fields%fields(1))
       rhs_fields%fields(1)%f => f
 
       call json%get_core(core)
       call json%get('case.scalar.source_terms', source_object, found)
 
       n_sources = core%count(source_object)
       allocate(this%source_terms(n_sources))
 
 
       do i=1, n_sources
          ! Create a new json containing just the subdict for this source.
          call core%get_child(source_object, i, source_pointer, found)
          call core%print_to_string(source_pointer, buffer)
          call source_subdict%load_from_string(buffer)
          call json_get(source_subdict, "type", type)
 
          ! The user source is treated separately
          if ((trim(type) .eq. "user_vector") .or. &
              (trim(type) .eq. "user_pointwise")) then
             if (source_subdict%valid_path("start_time") .or. &
                 source_subdict%valid_path("end_time")) then
                 call neko_warning("The start_time and end_time parameters have&
                                    & no effect on the scalar user source term")
             end if
 
             call init_user_source(this%source_terms(i)%source_term, &
                                    rhs_fields, coef, type, user)
          else
 
             call source_term_factory(this%source_terms(i)%source_term, &
                                       source_subdict, rhs_fields, coef)
          end if
       end do
    end if
 
  end subroutine scalar_source_term_init
 
  subroutine init_user_source(source_term, rhs_fields, coef, type, user)
    class(source_term_t), allocatable, intent(inout) :: source_term
    type(field_list_t) :: rhs_fields
    type(coef_t), intent(inout) :: coef
    character(len=*) :: type
    type(user_t), intent(in) :: user
 
    allocate(scalar_user_source_term_t::source_term)
 
    select type (source_term)
    type is (scalar_user_source_term_t)
       call source_term%init_from_components(rhs_fields, coef, type, &
                                            user%scalar_user_f_vector, &
                                            user%scalar_user_f)
    end select
  end subroutine init_user_source
 
  subroutine scalar_source_term_free(this)
    class(scalar_source_term_t), intent(inout) :: this
    integer :: i
 
    nullify(this%f)
 
    if (allocated(this%source_terms)) then
       do i=1, size(this%source_terms)
          call this%source_terms(i)%free()
       end do
       deallocate(this%source_terms)
    end if
 
  end subroutine scalar_source_term_free
 
  subroutine scalar_source_term_compute(this, t, tstep)
    class(scalar_source_term_t), intent(inout) :: this
    real(kind=rp), intent(in) :: t
    integer, intent(in) :: tstep
    integer :: i, n
 
    this%f = 0.0_rp
 
    ! Add contribution from all source terms.
    if (allocated(this%source_terms)) then
       do i=1, size(this%source_terms)
          call this%source_terms(i)%source_term%compute(t, tstep)
       end do
    end if
 
  end subroutine scalar_source_term_compute
end module scalar_source_term