sol_vars.f90

Go to the documentation of this file.

!------------------------------------------------------------------------------!
!------------------------------------------------------------------------------!
module sol_vars
#include <PB3D_macros.h>
    use str_utilities
    use messages
    use num_vars, only: dp, max_str_ln, iu, weight_dp
    use grid_vars, only: grid_type
    use x_vars, only: modes_type
    use output_ops
    
    implicit none
    
    private
#if ldebug
    public n_alloc_sols
#endif
    
    ! global variables
#if ldebug
    integer :: n_alloc_sols
#endif
    
    type, public :: sol_type
        integer :: n_mod
        integer :: lim_sec_x(2)
        integer, allocatable :: n(:,:)
        integer, allocatable :: m(:,:)
        complex(dp), allocatable :: vec(:,:,:)
        complex(dp), allocatable :: val(:)
#if ldebug
        real(dp) :: estim_mem_usage
#endif
    contains
        procedure :: init => init_sol
        procedure :: dealloc => dealloc_sol
    end type
    
contains
    subroutine init_sol(sol,mds,grid_sol,n_EV,lim_sec_X)
        use x_vars, only: set_nm_x
#if ldebug
        use num_vars, only: print_mem_usage, rank
#endif
        
        ! input / output
        class(sol_type), intent(inout) :: sol
        type(modes_type), intent(in) :: mds
        type(grid_type), intent(in) :: grid_sol
        integer, intent(in) :: n_EV
        integer, intent(in), optional :: lim_sec_X(2)
        
#if ldebug
        ! initialize memory usage
        if (print_mem_usage) sol%estim_mem_usage = 0._dp
#endif
        
        ! set mode numbers
        call set_nm_x(mds,grid_sol,sol%lim_sec_X,sol%n,sol%m,lim_sec_x)
        
        ! set n_mod
        sol%n_mod = size(sol%n,2)
        
        ! allocate val
        allocate(sol%val(1:n_ev))
        
        ! allocate vec
        allocate(sol%vec(1:sol%n_mod,1:grid_sol%loc_n_r,1:n_ev))
        
#if ldebug
        ! set estimated memory usage
        if (print_mem_usage) sol%estim_mem_usage = sol%estim_mem_usage + &
            &n_ev * (1 + sol%n_mod*grid_sol%loc_n_r)
        
        ! increment n_alloc_sols
        n_alloc_sols = n_alloc_sols + 1
        if (print_mem_usage) call writo('[rank '//trim(i2str(rank))//&
            &' - Expected memory usage of sol: '//&
            &trim(r2strt(sol%estim_mem_usage*weight_dp*2))//' kB]',alert=.true.)
#endif
    end subroutine init_sol
    
    subroutine dealloc_sol(sol)
#if ldebug
        use num_vars, only: rank, print_mem_usage
#endif
        
        ! input / output
        class(sol_type), intent(inout) :: sol
        
#if ldebug
        ! local variables
        integer :: mem_diff                                                     ! difference in memory
        real(dp) :: estim_mem_usage                                             ! estimated memory usage
        
        ! memory usage before deallocation
        if (print_mem_usage) then
            mem_diff = get_mem_usage()
            estim_mem_usage = sol%estim_mem_usage
        end if
#endif
        
        ! deallocate allocatable variables
        call dealloc_sol_final(sol)
        
#if ldebug
        ! decrement n_alloc_sols
        n_alloc_sols = n_alloc_sols - 1
        
        ! memory usage difference after deallocation
        if (print_mem_usage) then
            mem_diff = mem_diff - get_mem_usage()
            call writo('[Rank '//trim(i2str(rank))//' - liberated '//&
                &trim(i2str(mem_diff))//'kB deallocating sol ('//&
                &trim(i2str(nint(100*mem_diff/&
                &(estim_mem_usage*weight_dp*2))))//&
                &'% of estimated)]',alert=.true.)
        end if
#endif
    contains
        ! Note: intent(out) automatically deallocates the variable
        subroutine dealloc_sol_final(sol)
            ! input / output
            type(sol_type), intent(out) :: sol                                      ! solution to be deallocated
        end subroutine dealloc_sol_final
    end subroutine dealloc_sol
end module sol_vars