memorymanagermodule Module Reference

Data Types
interface	mem_allocate
interface	mem_checkin
interface	mem_reallocate
interface	mem_setptr
interface	mem_copyptr
interface	mem_reassignptr
interface	mem_deallocate

Functions/Subroutines
subroutine, public	get_mem_type (name, mem_path, var_type)
	@ brief Get the variable memory type More...
subroutine, public	get_mem_rank (name, mem_path, rank)
	@ brief Get the variable rank More...
subroutine, public	get_mem_elem_size (name, mem_path, size)
	@ brief Get the memory size of a single element of the stored variable More...
subroutine, public	get_mem_shape (name, mem_path, mem_shape)
	@ brief Get the variable memory shape More...
subroutine, public	get_isize (name, mem_path, isize)
	@ brief Get the number of elements for this variable More...
subroutine, public	get_from_memorylist (name, mem_path, mt, found, check)
	@ brief Get a memory type entry from the memory list More...
subroutine	allocate_error (varname, mem_path, istat, isize)
	Issue allocation error message and stop program execution. More...
subroutine	allocate_logical (sclr, name, mem_path)
	Allocate a logical scalar. More...
subroutine	allocate_str (sclr, ilen, name, mem_path)
	Allocate a character string. More...
subroutine	allocate_str1d (astr1d, ilen, nrow, name, mem_path)
	Allocate a 1-dimensional defined length string array. More...
subroutine	allocate_charstr1d (acharstr1d, ilen, nrow, name, mem_path)
	Allocate a 1-dimensional array of deferred-length CharacterStringType. More...
subroutine	allocate_int (sclr, name, mem_path)
	Allocate a integer scalar. More...
subroutine	allocate_int1d (aint, nrow, name, mem_path)
	Allocate a 1-dimensional integer array. More...
subroutine	allocate_int2d (aint, ncol, nrow, name, mem_path)
	Allocate a 2-dimensional integer array. More...
subroutine	allocate_int3d (aint, ncol, nrow, nlay, name, mem_path)
	Allocate a 3-dimensional integer array. More...
subroutine	allocate_dbl (sclr, name, mem_path)
	Allocate a real scalar. More...
subroutine	allocate_dbl1d (adbl, nrow, name, mem_path)
	Allocate a 1-dimensional real array. More...
subroutine	allocate_dbl2d (adbl, ncol, nrow, name, mem_path)
	Allocate a 2-dimensional real array. More...
subroutine	allocate_dbl3d (adbl, ncol, nrow, nlay, name, mem_path)
	Allocate a 3-dimensional real array. More...
subroutine	checkin_int1d (aint, name, mem_path, name2, mem_path2)
	Check in an existing 1d integer array with a new address (name + path) More...
subroutine	checkin_int2d (aint2d, name, mem_path, name2, mem_path2)
	Check in an existing 2d integer array with a new address (name + path) More...
subroutine	checkin_dbl1d (adbl, name, mem_path, name2, mem_path2)
	Check in an existing 1d double precision array with a new address (name + path) More...
subroutine	checkin_dbl2d (adbl2d, name, mem_path, name2, mem_path2)
	Check in an existing 2d double precision array with a new address (name + path) More...
subroutine	checkin_charstr1d (acharstr1d, ilen, name, mem_path, name2, mem_path2)
	Check in an existing 1d CharacterStringType array with a new address (name + path) More...
subroutine	reallocate_str1d (astr, ilen, nrow, name, mem_path)
	Reallocate a 1-dimensional defined length string array. More...
subroutine	reallocate_charstr1d (acharstr1d, ilen, nrow, name, mem_path)
	Reallocate a 1-dimensional deferred length string array. More...
subroutine	reallocate_int1d (aint, nrow, name, mem_path)
	Reallocate a 1-dimensional integer array. More...
subroutine	reallocate_int2d (aint, ncol, nrow, name, mem_path)
	Reallocate a 2-dimensional integer array. More...
subroutine	reallocate_dbl1d (adbl, nrow, name, mem_path)
	Reallocate a 1-dimensional real array. More...
subroutine	reallocate_dbl2d (adbl, ncol, nrow, name, mem_path)
	Reallocate a 2-dimensional real array. More...
subroutine	setptr_logical (sclr, name, mem_path)
	Set pointer to a logical scalar. More...
subroutine	setptr_int (sclr, name, mem_path)
	Set pointer to integer scalar. More...
subroutine	setptr_int1d (aint, name, mem_path)
	Set pointer to 1d integer array. More...
subroutine	setptr_int2d (aint, name, mem_path)
	Set pointer to 2d integer array. More...
subroutine	setptr_int3d (aint, name, mem_path)
	Set pointer to 3d integer array. More...
subroutine	setptr_dbl (sclr, name, mem_path)
	Set pointer to a real scalar. More...
subroutine	setptr_dbl1d (adbl, name, mem_path)
	Set pointer to a 1d real array. More...
subroutine	setptr_dbl2d (adbl, name, mem_path)
	Set pointer to a 2d real array. More...
subroutine	setptr_dbl3d (adbl, name, mem_path)
	Set pointer to a 3d real array. More...
subroutine	setptr_str (asrt, name, mem_path)
	Set pointer to a string (scalar) More...
subroutine	setptr_str1d (astr1d, name, mem_path)
	Set pointer to a fixed-length string array. More...
subroutine	setptr_charstr1d (acharstr1d, name, mem_path)
	Set pointer to an array of CharacterStringType. More...
subroutine	copyptr_int1d (aint, name, mem_path, mem_path_copy)
	Make a copy of a 1-dimensional integer array. More...
subroutine	copyptr_int2d (aint, name, mem_path, mem_path_copy)
	Make a copy of a 2-dimensional integer array. More...
subroutine	copyptr_dbl1d (adbl, name, mem_path, mem_path_copy)
	Make a copy of a 1-dimensional real array. More...
subroutine	copyptr_dbl2d (adbl, name, mem_path, mem_path_copy)
	Make a copy of a 2-dimensional real array. More...
subroutine, public	copy_dbl1d (adbl, name, mem_path)
	Copy values from a 1-dimensional real array in the memory. More...
subroutine	reassignptr_int (sclr, name, mem_path, name_target, mem_path_target)
	Set the pointer for an integer scalar to. More...
subroutine	reassignptr_int1d (aint, name, mem_path, name_target, mem_path_target)
	Set the pointer for a 1-dimensional integer array to. More...
subroutine	reassignptr_int2d (aint, name, mem_path, name_target, mem_path_target)
	Set the pointer for a 2-dimensional integer array to. More...
subroutine	reassignptr_dbl1d (adbl, name, mem_path, name_target, mem_path_target)
	Set the pointer for a 1-dimensional real array to. More...
subroutine	reassignptr_dbl2d (adbl, name, mem_path, name_target, mem_path_target)
	Set the pointer for a 2-dimensional real array to. More...
subroutine	deallocate_str (sclr, name, mem_path)
	Deallocate a variable-length character string. More...
subroutine	deallocate_str1d (astr1d, name, mem_path)
	Deallocate an array of defined-length character strings. More...
subroutine	deallocate_charstr1d (astr1d, name, mem_path)
	Deallocate an array of deferred-length character strings. More...
subroutine	deallocate_logical (sclr)
	Deallocate a logical scalar. More...
subroutine	deallocate_int (sclr)
	Deallocate a integer scalar. More...
subroutine	deallocate_dbl (sclr)
	Deallocate a real scalar. More...
subroutine	deallocate_int1d (aint, name, mem_path)
	Deallocate a 1-dimensional integer array. More...
subroutine	deallocate_int2d (aint, name, mem_path)
	Deallocate a 2-dimensional integer array. More...
subroutine	deallocate_int3d (aint, name, mem_path)
	Deallocate a 3-dimensional integer array. More...
subroutine	deallocate_dbl1d (adbl, name, mem_path)
	Deallocate a 1-dimensional real array. More...
subroutine	deallocate_dbl2d (adbl, name, mem_path)
	Deallocate a 2-dimensional real array. More...
subroutine	deallocate_dbl3d (adbl, name, mem_path)
	Deallocate a 3-dimensional real array. More...
subroutine, public	mem_set_print_option (iout, keyword, error_msg)
	Set the memory print option. More...
subroutine	mem_summary_table (iout, nrows, cunits)
	Create a table if memory_print_option is 'SUMMARY'. More...
subroutine	mem_detailed_table (iout, nrows)
	Create a table if memory_print_option is 'ALL'. More...
subroutine	mem_summary_line (component, rchars, rlog, rint, rreal, bytes)
	Write a row for the memory_print_option 'SUMMARY' table. More...
subroutine	mem_units (bytes, fact, cunits)
	Determine appropriate memory unit and conversion factor. More...
subroutine	mem_summary_total (iout, bytes)
	Create and fill a table with the total allocated memory. More...
subroutine	mem_cleanup_table ()
	Generic function to clean a memory manager table. More...
subroutine, public	mem_write_usage (iout)
	Write memory manager memory usage based on the user-specified memory_print_option. More...
subroutine, public	mem_print_detailed (iout)
real(dp) function	calc_virtual_mem ()
	Sum up virtual memory, i.e. memory. More...
subroutine, public	mem_da ()
	Deallocate memory in the memory manager. More...
subroutine	mem_unique_origins (cunique)
	Create a array with unique first components from all memory paths. Only the first component of the memory path is evaluated. More...

Variables
type(memorylisttype), public	memorylist
type(tabletype), pointer	memtab => null()
integer(i8b)	nvalues_alogical = 0
integer(i8b)	nvalues_astr = 0
integer(i8b)	nvalues_aint = 0
integer(i8b)	nvalues_adbl = 0
integer(i4b)	iprmem = 0

Function/Subroutine Documentation

allocate_charstr1d()

subroutine memorymanagermodule::allocate_charstr1d ( type(characterstringtype), dimension(:), intent(inout), pointer, contiguous  acharstr1d, integer(i4b), intent(in)  ilen, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	acharstr1d	variable for allocation
[in]	ilen	string length
[in]	nrow	number of strings in array
[in]	name	variable name
[in]	mem_path	path where the variable is stored

Definition at line 539 of file MemoryManager.f90.

    type(CharacterStringType), dimension(:), &
      pointer, contiguous, intent(inout) :: acharstr1d !< variable for allocation
    integer(I4B), intent(in) :: ilen !< string length
    integer(I4B), intent(in) :: nrow !< number of strings in array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    ! -- local variables
    character(len=ilen) :: string
    type(MemoryType), pointer :: mt
    integer(I4B) :: n
    integer(I4B) :: istat
    integer(I4B) :: isize
    ! -- code
    !
    ! -- initialize string
    string = ''
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- calculate isize
    isize = nrow
    !
    ! -- allocate deferred length string array
    allocate (acharstr1d(nrow), stat=istat, errmsg=errmsg)
    !
    ! -- check for error condition
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    !
    ! -- fill deferred length string with empty string
    do n = 1, nrow
      acharstr1d(n) = string
    end do
    !
    ! -- update counter
    nvalues_astr = nvalues_astr + isize
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%acharstr1d => acharstr1d
    mt%element_size = ilen
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' LEN=',i0,' (',i0,')')") 'STRING', ilen, nrow
    !
    ! -- add deferred length character array to the memory manager list
    call memorylist%add(mt)
    !
    ! -- return
    return

allocate_dbl()

subroutine memorymanagermodule::allocate_dbl ( real(dp), intent(inout), pointer  sclr, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	sclr	variable for allocation
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 781 of file MemoryManager.f90.

    real(DP), pointer, intent(inout) :: sclr !< variable for allocation
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    ! -- code
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- allocate real scalar
    allocate (sclr, stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, 1)
    end if
    !
    ! -- update counter
    nvalues_aint = nvalues_aint + 1
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%dblsclr => sclr
    mt%element_size = dp
    mt%isize = 1
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a)") 'DOUBLE'
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

allocate_dbl1d()

subroutine memorymanagermodule::allocate_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous  adbl, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	adbl	variable for allocation
[in]	nrow	number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 822 of file MemoryManager.f90.

    real(DP), dimension(:), pointer, contiguous, intent(inout) :: adbl !< variable for allocation
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check the variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = nrow
    !
    ! -- allocate the real array
    allocate (adbl(nrow), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    !
    ! -- update counter
    nvalues_adbl = nvalues_adbl + isize
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%adbl1d => adbl
    mt%element_size = dp
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,')')") 'DOUBLE', isize
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

Here is the caller graph for this function:

allocate_dbl2d()

subroutine memorymanagermodule::allocate_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous  adbl, integer(i4b), intent(in)  ncol, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	adbl	variable for allocation
[in]	ncol	number of columns
[in]	nrow	number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 868 of file MemoryManager.f90.

    real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: adbl !< variable for allocation
    integer(I4B), intent(in) :: ncol !< number of columns
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check the variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = ncol * nrow
    !
    ! -- allocate the real array
    allocate (adbl(ncol, nrow), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    !
    ! -- update counter
    nvalues_adbl = nvalues_adbl + isize
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%adbl2d => adbl
    mt%element_size = dp
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,',',i0,')')") 'DOUBLE', ncol, nrow
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

Here is the caller graph for this function:

allocate_dbl3d()

subroutine memorymanagermodule::allocate_dbl3d ( real(dp), dimension(:, :, :), intent(inout), pointer, contiguous  adbl, integer(i4b), intent(in)  ncol, integer(i4b), intent(in)  nrow, integer(i4b), intent(in)  nlay, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	adbl	variable for allocation
[in]	ncol	number of columns
[in]	nrow	number of rows
[in]	nlay	number of layers
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 915 of file MemoryManager.f90.

    real(DP), dimension(:, :, :), pointer, contiguous, intent(inout) :: adbl !< variable for allocation
    integer(I4B), intent(in) :: ncol !< number of columns
    integer(I4B), intent(in) :: nrow !< number of rows
    integer(I4B), intent(in) :: nlay !< number of layers
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check the variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = ncol * nrow * nlay
    !
    ! -- allocate the real array
    allocate (adbl(ncol, nrow, nlay), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    !
    ! -- update the counter
    nvalues_adbl = nvalues_adbl + isize
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%adbl3d => adbl
    mt%element_size = dp
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,',',i0,',',i0,')')") 'DOUBLE', ncol, &
      nrow, nlay
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

allocate_error()

subroutine memorymanagermodule::allocate_error ( character(len=*), intent(in)  varname, character(len=*), intent(in)  mem_path, integer(i4b), intent(in)  istat, integer(i4b), intent(in)  isize  )

private

Parameters

[in]	varname	variable name
[in]	mem_path	path where the variable is stored
[in]	istat	status code
[in]	isize	size of allocation

Definition at line 351 of file MemoryManager.f90.

    character(len=*), intent(in) :: varname !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    integer(I4B), intent(in) :: istat !< status code
    integer(I4B), intent(in) :: isize !< size of allocation
    ! -- local
    character(len=20) :: csize
    character(len=20) :: cstat
    ! -- code
    !
    ! -- initialize character variables
    write (csize, '(i0)') isize
    write (cstat, '(i0)') istat
    !
    ! -- create error message
    errmsg = "Error trying to allocate memory. Path '"//trim(mem_path)// &
             "' variable name '"//trim(varname)//"' size '"//trim(csize)// &
             "'. Error message is '"//trim(adjustl(errmsg))// &
             "'. Status code is "//trim(cstat)//'.'
    !
    ! -- store error and stop program execution
    call store_error(errmsg, terminate=.true.)

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_int()

subroutine memorymanagermodule::allocate_int ( integer(i4b), intent(inout), pointer  sclr, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	sclr	variable for allocation
[in]	name	variable name
[in]	mem_path	path where the variable is stored

Definition at line 599 of file MemoryManager.f90.

    integer(I4B), pointer, intent(inout) :: sclr !< variable for allocation
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    ! -- code
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- allocate integer scalar
    allocate (sclr, stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, 1)
    end if
    !
    ! -- update counter
    nvalues_aint = nvalues_aint + 1
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%intsclr => sclr
    mt%element_size = i4b
    mt%isize = 1
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a)") 'INTEGER'
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

allocate_int1d()

subroutine memorymanagermodule::allocate_int1d ( integer(i4b), dimension(:), intent(inout), pointer, contiguous  aint, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	aint	variable for allocation
[in]	nrow	integer array number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 640 of file MemoryManager.f90.

    integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: aint !< variable for allocation
    integer(I4B), intent(in) :: nrow !< integer array number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! --local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = nrow
    !
    ! -- allocate integer array
    allocate (aint(nrow), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    !
    ! -- update counter
    nvalues_aint = nvalues_aint + isize
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%aint1d => aint
    mt%element_size = i4b
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,')')") 'INTEGER', isize
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

Here is the caller graph for this function:

allocate_int2d()

subroutine memorymanagermodule::allocate_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous  aint, integer(i4b), intent(in)  ncol, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	aint	variable for allocation
[in]	ncol	number of columns
[in]	nrow	number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 686 of file MemoryManager.f90.

    integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: aint !< variable for allocation
    integer(I4B), intent(in) :: ncol !< number of columns
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check the variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = ncol * nrow
    !
    ! -- allocate the integer array
    allocate (aint(ncol, nrow), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    !
    ! -- update the counter
    nvalues_aint = nvalues_aint + isize
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%aint2d => aint
    mt%element_size = i4b
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,',',i0,')')") 'INTEGER', ncol, nrow
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return

Here is the caller graph for this function:

allocate_int3d()

subroutine memorymanagermodule::allocate_int3d ( integer(i4b), dimension(:, :, :), intent(inout), pointer, contiguous  aint, integer(i4b), intent(in)  ncol, integer(i4b), intent(in)  nrow, integer(i4b), intent(in)  nlay, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	aint	variable for allocation
[in]	ncol	number of columns
[in]	nrow	number of rows
[in]	nlay	number of layers
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 732 of file MemoryManager.f90.

    integer(I4B), dimension(:, :, :), pointer, contiguous, intent(inout) :: aint !< variable for allocation
    integer(I4B), intent(in) :: ncol !< number of columns
    integer(I4B), intent(in) :: nrow !< number of rows
    integer(I4B), intent(in) :: nlay !< number of layers
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = ncol * nrow * nlay
    !
    ! -- allocate integer array
    allocate (aint(ncol, nrow, nlay), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    !
    ! -- update counter
    nvalues_aint = nvalues_aint + isize
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%aint3d => aint
    mt%element_size = i4b
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,',',i0,',',i0,')')") 'INTEGER', ncol, &
      nrow, nlay
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

allocate_logical()

subroutine memorymanagermodule::allocate_logical ( logical(lgp), intent(inout), pointer  sclr, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	sclr	variable for allocation
[in]	name	variable name
[in]	mem_path	path where the variable is stored

Definition at line 377 of file MemoryManager.f90.

    logical(LGP), pointer, intent(inout) :: sclr !< variable for allocation
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    ! -- local
    integer(I4B) :: istat
    type(MemoryType), pointer :: mt
    ! -- code
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- allocate the logical scalar
    allocate (sclr, stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, 1)
    end if
    !
    ! -- update counter
    nvalues_alogical = nvalues_alogical + 1
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%logicalsclr => sclr
    mt%element_size = lgp
    mt%isize = 1
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a)") 'LOGICAL'
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

allocate_str()

subroutine memorymanagermodule::allocate_str ( character(len=ilen), intent(inout), pointer  sclr, integer(i4b), intent(in)  ilen, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in]	ilen	string length
[in,out]	sclr	variable for allocation
[in]	name	variable name
[in]	mem_path	path where the variable is stored

Definition at line 418 of file MemoryManager.f90.

    integer(I4B), intent(in) :: ilen !< string length
    character(len=ilen), pointer, intent(inout) :: sclr !< variable for allocation
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    ! -- local
    integer(I4B) :: istat
    type(MemoryType), pointer :: mt
    ! -- format
    ! -- code
    !
    ! -- make sure ilen is greater than 0
    if (ilen < 1) then
      errmsg = 'Programming error in allocate_str. ILEN must be greater than 0.'
      call store_error(errmsg, terminate=.true.)
    end if
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- allocate string
    allocate (character(len=ilen) :: sclr, stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, 1)
    end if
    !
    ! -- set sclr to a empty string
    sclr = ' '
    !
    ! -- update counter
    nvalues_astr = nvalues_astr + ilen
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%strsclr => sclr
    mt%element_size = ilen
    mt%isize = 1
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' LEN=',i0)") 'STRING', ilen
    !
    ! -- add defined length string to the memory manager list
    call memorylist%add(mt)
    !
    ! -- return
    return

allocate_str1d()

subroutine memorymanagermodule::allocate_str1d ( character(len=ilen), dimension(:), intent(inout), pointer, contiguous  astr1d, integer(i4b), intent(in)  ilen, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in]	ilen	string length
[in,out]	astr1d	variable for allocation
[in]	nrow	number of strings in array
[in]	name	variable name
[in]	mem_path	path where the variable is stored

Definition at line 470 of file MemoryManager.f90.

    integer(I4B), intent(in) :: ilen !< string length
    character(len=ilen), dimension(:), &
      pointer, contiguous, intent(inout) :: astr1d !< variable for allocation
    integer(I4B), intent(in) :: nrow !< number of strings in array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    ! -- local variables
    type(MemoryType), pointer :: mt
    character(len=ilen) :: string
    integer(I4B) :: n
    integer(I4B) :: istat
    integer(I4B) :: isize
    ! -- code
    !
    ! -- initialize string
    string = ''
    !
    ! -- make sure ilen is greater than 0
    if (ilen < 1) then
      errmsg = 'Programming error in allocate_str1d. '// &
               'ILEN must be greater than 0.'
      call store_error(errmsg, terminate=.true.)
    end if
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- calculate isize
    isize = nrow
    !
    ! -- allocate defined length string array
    allocate (character(len=ilen) :: astr1d(nrow), stat=istat, errmsg=errmsg)
    !
    ! -- check for error condition
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    !
    ! -- fill deferred length string with empty string
    do n = 1, nrow
      astr1d(n) = string
    end do
    !
    ! -- update counter
    nvalues_astr = nvalues_astr + isize
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    ! this does not work with gfortran 11.3 and 12.1
    ! so we have to disable the pointing to astr1d
    ! mt%astr1d => astr1d
    mt%element_size = ilen
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' LEN=',i0,' (',i0,')')") 'STRING', ilen, nrow
    !
    ! -- add deferred length character array to the memory manager list
    call memorylist%add(mt)
    !
    ! -- return
    return

calc_virtual_mem()

real(dp) function memorymanagermodule::calc_virtual_mem

private

Definition at line 2942 of file MemoryManager.f90.

    real(DP) :: vmem_size
    ! local
    integer(I4B) :: i
    type(MemoryType), pointer :: mt
 
    vmem_size = dzero
    do i = 1, memorylist%count()
      mt => memorylist%Get(i)
      if (index(mt%path, "__P") == 1) then
        vmem_size = mt%element_size * mt%isize + vmem_size
      end if
    end do
 

Here is the caller graph for this function:

checkin_charstr1d()

subroutine memorymanagermodule::checkin_charstr1d ( type(characterstringtype), dimension(:), intent(inout), pointer, contiguous  acharstr1d, integer(i4b), intent(in)  ilen, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name2, character(len=*), intent(in)  mem_path2  )

private

Parameters

[in,out]	acharstr1d	the existing array
[in]	name	new variable name
[in]	mem_path	new path where variable is stored
[in]	name2	existing variable name
[in]	mem_path2	existing path where variable is stored

Definition at line 1134 of file MemoryManager.f90.

    type(CharacterStringType), dimension(:), &
      pointer, contiguous, intent(inout) :: acharstr1d !< the existing array
    integer(I4B), intent(in) :: ilen
    character(len=*), intent(in) :: name !< new variable name
    character(len=*), intent(in) :: mem_path !< new path where variable is stored
    character(len=*), intent(in) :: name2 !< existing variable name
    character(len=*), intent(in) :: mem_path2 !< existing path where variable is stored
    ! --local
    type(MemoryType), pointer :: mt
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = size(acharstr1d)
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%acharstr1d => acharstr1d
    mt%element_size = ilen
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' LEN=',i0,' (',i0,')')") 'STRING', ilen, isize
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name2
    mt%masterPath = mem_path2
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

checkin_dbl1d()

subroutine memorymanagermodule::checkin_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous  adbl, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name2, character(len=*), intent(in)  mem_path2  )

private

Parameters

[in,out]	adbl	the existing array
[in]	name	new variable name
[in]	mem_path	new path where variable is stored
[in]	name2	existing variable name
[in]	mem_path2	existing path where variable is stored

Definition at line 1049 of file MemoryManager.f90.

    real(DP), dimension(:), pointer, contiguous, intent(inout) :: adbl !< the existing array
    character(len=*), intent(in) :: name !< new variable name
    character(len=*), intent(in) :: mem_path !< new path where variable is stored
    character(len=*), intent(in) :: name2 !< existing variable name
    character(len=*), intent(in) :: mem_path2 !< existing path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check the variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = size(adbl)
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%adbl1d => adbl
    mt%element_size = dp
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,')')") 'DOUBLE', isize
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name2
    mt%masterPath = mem_path2
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

checkin_dbl2d()

subroutine memorymanagermodule::checkin_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous  adbl2d, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name2, character(len=*), intent(in)  mem_path2  )

private

Parameters

[in,out]	adbl2d	the existing 2d array
[in]	name	new variable name
[in]	mem_path	new path where variable is stored
[in]	name2	existing variable name
[in]	mem_path2	existing path where variable is stored

Definition at line 1091 of file MemoryManager.f90.

    real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: adbl2d !< the existing 2d array
    character(len=*), intent(in) :: name !< new variable name
    character(len=*), intent(in) :: mem_path !< new path where variable is stored
    character(len=*), intent(in) :: name2 !< existing variable name
    character(len=*), intent(in) :: mem_path2 !< existing path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: ncol, nrow, isize
    ! -- code
    !
    ! -- check the variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    ncol = size(adbl2d, dim=1)
    nrow = size(adbl2d, dim=2)
    isize = ncol * nrow
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%adbl2d => adbl2d
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,',',i0,')')") 'DOUBLE', ncol, nrow
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name2
    mt%masterPath = mem_path2
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

checkin_int1d()

subroutine memorymanagermodule::checkin_int1d ( integer(i4b), dimension(:), intent(in), pointer, contiguous  aint, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name2, character(len=*), intent(in)  mem_path2  )

private

Parameters

[in]	aint	the existing array
[in]	name	new variable name
[in]	mem_path	new path where variable is stored
[in]	name2	existing variable name
[in]	mem_path2	existing path where variable is stored

Definition at line 964 of file MemoryManager.f90.

    integer(I4B), dimension(:), pointer, contiguous, intent(in) :: aint !< the existing array
    character(len=*), intent(in) :: name !< new variable name
    character(len=*), intent(in) :: mem_path !< new path where variable is stored
    character(len=*), intent(in) :: name2 !< existing variable name
    character(len=*), intent(in) :: mem_path2 !< existing path where variable is stored
    ! --local
    type(MemoryType), pointer :: mt
    integer(I4B) :: isize
    ! -- code
    !
    ! -- check variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    isize = size(aint)
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%aint1d => aint
    mt%element_size = i4b
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,')')") 'INTEGER', isize
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name2
    mt%masterPath = mem_path2
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

checkin_int2d()

subroutine memorymanagermodule::checkin_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous  aint2d, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name2, character(len=*), intent(in)  mem_path2  )

private

Parameters

[in,out]	aint2d	the existing 2d array
[in]	name	new variable name
[in]	mem_path	new path where variable is stored
[in]	name2	existing variable name
[in]	mem_path2	existing path where variable is stored

Definition at line 1006 of file MemoryManager.f90.

    integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: aint2d !< the existing 2d array
    character(len=*), intent(in) :: name !< new variable name
    character(len=*), intent(in) :: mem_path !< new path where variable is stored
    character(len=*), intent(in) :: name2 !< existing variable name
    character(len=*), intent(in) :: mem_path2 !< existing path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: ncol, nrow, isize
    ! -- code
    !
    ! -- check the variable name length
    call mem_check_length(name, lenvarname, "variable")
    !
    ! -- set isize
    ncol = size(aint2d, dim=1)
    nrow = size(aint2d, dim=2)
    isize = ncol * nrow
    !
    ! -- allocate memory type
    allocate (mt)
    !
    ! -- set memory type
    mt%aint2d => aint2d
    mt%isize = isize
    mt%name = name
    mt%path = mem_path
    write (mt%memtype, "(a,' (',i0,',',i0,')')") 'INTEGER', ncol, nrow
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name2
    mt%masterPath = mem_path2
    !
    ! -- add memory type to the memory list
    call memorylist%add(mt)
    !
    ! -- return
    return

copy_dbl1d()

subroutine, public memorymanagermodule::copy_dbl1d	(	real(dp), dimension(:), intent(inout)	adbl,
		character(len=*), intent(in)	name,
		character(len=*), intent(in)	mem_path
	)

Parameters

[in,out]	adbl	target array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1887 of file MemoryManager.f90.

    real(DP), dimension(:), intent(inout) :: adbl !< target array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: n
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    do n = 1, size(mt%adbl1d)
      adbl(n) = mt%adbl1d(n)
    end do
    !
    ! -- return
    return

Here is the call graph for this function:

copyptr_dbl1d()

subroutine memorymanagermodule::copyptr_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous  adbl, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in), optional  mem_path_copy  )

private

Parameters

[in,out]	adbl	returned copy of 1d real array
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	mem_path_copy	optional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1818 of file MemoryManager.f90.

    real(DP), dimension(:), pointer, contiguous, intent(inout) :: adbl !< returned copy of 1d real array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
                                                            !! if passed then the copy is added to the
                                                            !! memory manager
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: n
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    adbl => null()
    ! -- check the copy into the memory manager
    if (present(mem_path_copy)) then
      call allocate_dbl1d(adbl, size(mt%adbl1d), mt%name, mem_path_copy)
      ! -- create a local copy
    else
      allocate (adbl(size(mt%adbl1d)))
    end if
    do n = 1, size(mt%adbl1d)
      adbl(n) = mt%adbl1d(n)
    end do
    !
    ! -- return
    return

copyptr_dbl2d()

subroutine memorymanagermodule::copyptr_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous  adbl, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in), optional  mem_path_copy  )

private

Parameters

[in,out]	adbl	returned copy of 2d real array
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	mem_path_copy	optional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1849 of file MemoryManager.f90.

    real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: adbl !< returned copy of 2d real array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
                                                            !! if passed then the copy is added to the
                                                            !! memory manager
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: i
    integer(I4B) :: j
    integer(I4B) :: ncol
    integer(I4B) :: nrow
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    adbl => null()
    ncol = size(mt%adbl2d, dim=1)
    nrow = size(mt%adbl2d, dim=2)
    ! -- check the copy into the memory manager
    if (present(mem_path_copy)) then
      call allocate_dbl2d(adbl, ncol, nrow, mt%name, mem_path_copy)
      ! -- create a local copy
    else
      allocate (adbl(ncol, nrow))
    end if
    do i = 1, nrow
      do j = 1, ncol
        adbl(j, i) = mt%adbl2d(j, i)
      end do
    end do
    !
    ! -- return
    return

copyptr_int1d()

subroutine memorymanagermodule::copyptr_int1d ( integer(i4b), dimension(:), intent(inout), pointer, contiguous  aint, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in), optional  mem_path_copy  )

private

Parameters

[in,out]	aint	returned copy of 1d integer array
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	mem_path_copy	optional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1749 of file MemoryManager.f90.

    integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: aint !< returned copy of 1d integer array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
                                                            !! if passed then the copy is added to the
                                                            !! memory manager
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: n
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    aint => null()
    ! -- check the copy into the memory manager
    if (present(mem_path_copy)) then
      call allocate_int1d(aint, size(mt%aint1d), mt%name, mem_path_copy)
      ! -- create a local copy
    else
      allocate (aint(size(mt%aint1d)))
    end if
    do n = 1, size(mt%aint1d)
      aint(n) = mt%aint1d(n)
    end do
    !
    ! -- return
    return

copyptr_int2d()

subroutine memorymanagermodule::copyptr_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous  aint, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in), optional  mem_path_copy  )

private

Parameters

[in,out]	aint	returned copy of 2d integer array
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	mem_path_copy	optional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1780 of file MemoryManager.f90.

    integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: aint !< returned copy of 2d integer array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
                                                            !! if passed then the copy is added to the
                                                            !! memory manager
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: i
    integer(I4B) :: j
    integer(I4B) :: ncol
    integer(I4B) :: nrow
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    aint => null()
    ncol = size(mt%aint2d, dim=1)
    nrow = size(mt%aint2d, dim=2)
    ! -- check the copy into the memory manager
    if (present(mem_path_copy)) then
      call allocate_int2d(aint, ncol, nrow, mt%name, mem_path_copy)
      ! -- create a local copy
    else
      allocate (aint(ncol, nrow))
    end if
    do i = 1, nrow
      do j = 1, ncol
        aint(j, i) = mt%aint2d(j, i)
      end do
    end do
    !
    ! -- return
    return

deallocate_charstr1d()

subroutine memorymanagermodule::deallocate_charstr1d ( type(characterstringtype), dimension(:), intent(inout), pointer, contiguous  astr1d, character(len=*), intent(in), optional  name, character(len=*), intent(in), optional  mem_path  )

private

Parameters

[in,out]	astr1d	array of strings
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 2167 of file MemoryManager.f90.

    type(CharacterStringType), dimension(:), pointer, contiguous, &
      intent(inout) :: astr1d !< array of strings
    character(len=*), optional, intent(in) :: name !< variable name
    character(len=*), optional, intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    !
    ! -- process optional variables
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%acharstr1d)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%acharstr1d, astr1d)) then
          nullify (mt%acharstr1d)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found .and. size(astr1d) > 0) then
      call store_error('programming error in deallocate_charstr1d', &
                       terminate=.true.)
    else
      if (mt%master) then
        deallocate (astr1d)
      else
        nullify (astr1d)
      end if
    end if
    !
    ! -- return
    return

deallocate_dbl()

subroutine memorymanagermodule::deallocate_dbl ( real(dp), intent(inout), pointer  sclr )

private

Parameters

[in,out]

sclr

real variable to deallocate

Definition at line 2275 of file MemoryManager.f90.

    real(DP), pointer, intent(inout) :: sclr !< real variable to deallocate
    ! -- local
    class(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    found = .false.
    do ipos = 1, memorylist%count()
      mt => memorylist%Get(ipos)
      if (associated(mt%dblsclr, sclr)) then
        nullify (mt%dblsclr)
        found = .true.
        exit
      end if
    end do
    if (.not. found) then
      call store_error('Programming error in deallocate_dbl.', terminate=.true.)
    else
      if (mt%master) then
        deallocate (sclr)
      else
        nullify (sclr)
      end if
    end if
    !
    ! -- return
    return

deallocate_dbl1d()

subroutine memorymanagermodule::deallocate_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous  adbl, character(len=*), optional  name, character(len=*), optional  mem_path  )

private

Parameters

[in,out]	adbl	1d real array to deallocate
	name	variable name
	mem_path	path where variable is stored

Definition at line 2430 of file MemoryManager.f90.

    real(DP), dimension(:), pointer, contiguous, intent(inout) :: adbl !< 1d real array to deallocate
    character(len=*), optional :: name !< variable name
    character(len=*), optional :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    !
    ! -- process optional variables
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%adbl1d)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%adbl1d, adbl)) then
          nullify (mt%adbl1d)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found .and. size(adbl) > 0) then
      call store_error('programming error in deallocate_dbl1d', terminate=.true.)
    else
      if (mt%master) then
        deallocate (adbl)
      else
        nullify (adbl)
      end if
    end if
    !
    ! -- return
    return

deallocate_dbl2d()

subroutine memorymanagermodule::deallocate_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous  adbl, character(len=*), optional  name, character(len=*), optional  mem_path  )

private

Parameters

[in,out]	adbl	2d real array to deallocate
	name	variable name
	mem_path	path where variable is stored

Definition at line 2471 of file MemoryManager.f90.

    real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: adbl !< 2d real array to deallocate
    character(len=*), optional :: name !< variable name
    character(len=*), optional :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    !
    ! -- process optional variables
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%adbl2d)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%adbl2d, adbl)) then
          nullify (mt%adbl2d)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found .and. size(adbl) > 0) then
      call store_error('programming error in deallocate_dbl2d', terminate=.true.)
    else
      if (mt%master) then
        deallocate (adbl)
      else
        nullify (adbl)
      end if
    end if
    !
    ! -- return
    return

deallocate_dbl3d()

subroutine memorymanagermodule::deallocate_dbl3d ( real(dp), dimension(:, :, :), intent(inout), pointer, contiguous  adbl, character(len=*), optional  name, character(len=*), optional  mem_path  )

private

Parameters

[in,out]	adbl	3d real array to deallocate
	name	variable name
	mem_path	path where variable is stored

Definition at line 2512 of file MemoryManager.f90.

    real(DP), dimension(:, :, :), pointer, contiguous, intent(inout) :: adbl !< 3d real array to deallocate
    character(len=*), optional :: name !< variable name
    character(len=*), optional :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    !
    ! -- process optional variables
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%adbl3d)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%adbl3d, adbl)) then
          nullify (mt%adbl3d)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found .and. size(adbl) > 0) then
      call store_error('programming error in deallocate_dbl3d', terminate=.true.)
    else
      if (mt%master) then
        deallocate (adbl)
      else
        nullify (adbl)
      end if
    end if
    !
    ! -- return
    return

deallocate_int()

subroutine memorymanagermodule::deallocate_int ( integer(i4b), intent(inout), pointer  sclr )

private

Parameters

[in,out]

sclr

integer variable to deallocate

Definition at line 2243 of file MemoryManager.f90.

    integer(I4B), pointer, intent(inout) :: sclr !< integer variable to deallocate
    ! -- local
    class(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    found = .false.
    do ipos = 1, memorylist%count()
      mt => memorylist%Get(ipos)
      if (associated(mt%intsclr, sclr)) then
        nullify (mt%intsclr)
        found = .true.
        exit
      end if
    end do
    if (.not. found) then
      call store_error('Programming error in deallocate_int.', terminate=.true.)
    else
      if (mt%master) then
        deallocate (sclr)
      else
        nullify (sclr)
      end if
    end if
    !
    ! -- return
    return

deallocate_int1d()

subroutine memorymanagermodule::deallocate_int1d ( integer(i4b), dimension(:), intent(inout), pointer, contiguous  aint, character(len=*), optional  name, character(len=*), optional  mem_path  )

private

Parameters

[in,out]	aint	1d integer array to deallocate
	name	variable name
	mem_path	path where variable is stored

Definition at line 2307 of file MemoryManager.f90.

    integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: aint !< 1d integer array to deallocate
    character(len=*), optional :: name !< variable name
    character(len=*), optional :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    !
    ! -- process optional variables
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%aint1d)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%aint1d, aint)) then
          nullify (mt%aint1d)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found .and. size(aint) > 0) then
      call store_error('programming error in deallocate_int1d', terminate=.true.)
    else
      if (mt%master) then
        deallocate (aint)
      else
        nullify (aint)
      end if
    end if
    !
    ! -- return
    return

deallocate_int2d()

subroutine memorymanagermodule::deallocate_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous  aint, character(len=*), optional  name, character(len=*), optional  mem_path  )

private

Parameters

[in,out]	aint	2d integer array to deallocate
	name	variable name
	mem_path	path where variable is stored

Definition at line 2348 of file MemoryManager.f90.

    integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: aint !< 2d integer array to deallocate
    character(len=*), optional :: name !< variable name
    character(len=*), optional :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    !
    ! -- process optional variables
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%aint2d)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%aint2d, aint)) then
          nullify (mt%aint2d)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found .and. size(aint) > 0) then
      call store_error('programming error in deallocate_int2d', terminate=.true.)
    else
      if (mt%master) then
        deallocate (aint)
      else
        nullify (aint)
      end if
    end if
    !
    ! -- return
    return

deallocate_int3d()

subroutine memorymanagermodule::deallocate_int3d ( integer(i4b), dimension(:, :, :), intent(inout), pointer, contiguous  aint, character(len=*), optional  name, character(len=*), optional  mem_path  )

private

Parameters

[in,out]	aint	3d integer array to deallocate
	name	variable name
	mem_path	path where variable is stored

Definition at line 2389 of file MemoryManager.f90.

    integer(I4B), dimension(:, :, :), pointer, contiguous, intent(inout) :: aint !< 3d integer array to deallocate
    character(len=*), optional :: name !< variable name
    character(len=*), optional :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    !
    ! -- process optional variables
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%aint3d)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%aint3d, aint)) then
          nullify (mt%aint3d)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found .and. size(aint) > 0) then
      call store_error('programming error in deallocate_int3d', terminate=.true.)
    else
      if (mt%master) then
        deallocate (aint)
      else
        nullify (aint)
      end if
    end if
    !
    ! -- return
    return

deallocate_logical()

subroutine memorymanagermodule::deallocate_logical ( logical(lgp), intent(inout), pointer  sclr )

private

Parameters

[in,out]

sclr

logical scalar to deallocate

Definition at line 2210 of file MemoryManager.f90.

    logical(LGP), pointer, intent(inout) :: sclr !< logical scalar to deallocate
    ! -- local
    class(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    found = .false.
    do ipos = 1, memorylist%count()
      mt => memorylist%Get(ipos)
      if (associated(mt%logicalsclr, sclr)) then
        nullify (mt%logicalsclr)
        found = .true.
        exit
      end if
    end do
    if (.not. found) then
      call store_error('programming error in deallocate_logical', &
                       terminate=.true.)
    else
      if (mt%master) then
        deallocate (sclr)
      else
        nullify (sclr)
      end if
    end if
    !
    ! -- return
    return

deallocate_str()

subroutine memorymanagermodule::deallocate_str ( character(len=*), intent(inout), pointer  sclr, character(len=*), intent(in), optional  name, character(len=*), intent(in), optional  mem_path  )

private

Parameters

[in,out]	sclr	pointer to string
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 2085 of file MemoryManager.f90.

    character(len=*), pointer, intent(inout) :: sclr !< pointer to string
    character(len=*), intent(in), optional :: name !< variable name
    character(len=*), intent(in), optional :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%strsclr)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%strsclr, sclr)) then
          nullify (mt%strsclr)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found) then
      call store_error('Programming error in deallocate_str.', terminate=.true.)
    else
      if (mt%master) then
        deallocate (sclr)
      else
        nullify (sclr)
      end if
    end if
    !
    ! -- return
    return

deallocate_str1d()

subroutine memorymanagermodule::deallocate_str1d ( character(len=*), dimension(:), intent(inout), pointer, contiguous  astr1d, character(len=*), intent(in), optional  name, character(len=*), intent(in), optional  mem_path  )

private

Parameters

[in,out]	astr1d	array of strings
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 2125 of file MemoryManager.f90.

    character(len=*), dimension(:), pointer, contiguous, intent(inout) :: astr1d !< array of strings
    character(len=*), optional, intent(in) :: name !< variable name
    character(len=*), optional, intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: ipos
    ! -- code
    !
    ! -- process optional variables
    found = .false.
    if (present(name) .and. present(mem_path)) then
      call get_from_memorylist(name, mem_path, mt, found)
      nullify (mt%astr1d)
    else
      do ipos = 1, memorylist%count()
        mt => memorylist%Get(ipos)
        if (associated(mt%astr1d, astr1d)) then
          nullify (mt%astr1d)
          found = .true.
          exit
        end if
      end do
    end if
    if (.not. found .and. size(astr1d) > 0) then
      call store_error('programming error in deallocate_str1d', terminate=.true.)
    else
      if (mt%master) then
        deallocate (astr1d)
      else
        nullify (astr1d)
      end if
    end if
    !
    ! -- return
    return

get_from_memorylist()

subroutine, public memorymanagermodule::get_from_memorylist	(	character(len=*), intent(in)	name,
		character(len=*), intent(in)	mem_path,
		type(memorytype), intent(inout), pointer	mt,
		logical(lgp), intent(out)	found,
		logical(lgp), intent(in), optional	check
	)

Default value for

check is .true. which means that this

routine will kill the program when the memory entry cannot be found.

Parameters

[in]	name	variable name
[in]	mem_path	path where the variable is stored
[in,out]	mt	memory type entry
[out]	found	set to .true. when found
[in]	check	to suppress aborting the program when not found, set check = .false.

Definition at line 308 of file MemoryManager.f90.

    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    type(MemoryType), pointer, intent(inout) :: mt !< memory type entry
    logical(LGP), intent(out) :: found !< set to .true. when found
    logical(LGP), intent(in), optional :: check !< to suppress aborting the program when not found,
                                                !! set check = .false.
    ! -- local
    integer(I4B) :: ipos
    logical(LGP) check_opt
    ! -- code
    !
    ! -- initialize
    mt => null()
    found = .false.
    !
    ! -- iterate over the memory list
    do ipos = 1, memorylist%count()
      mt => memorylist%Get(ipos)
      if (mt%name == name .and. mt%path == mem_path) then
        found = .true.
        exit
      end if
    end do
    check_opt = .true.
    if (present(check)) then
      check_opt = check
    end if
    if (check_opt) then
      if (.not. found) then
        errmsg = "Programming error in memory manager. Variable '"// &
                 trim(name)//"' in '"//trim(mem_path)//"' cannot be "// &
                 "assigned because it does not exist in memory manager."
        call store_error(errmsg, terminate=.true.)
      end if
    end if
    !
    ! -- return
    return

Here is the call graph for this function:

get_isize()

subroutine, public memorymanagermodule::get_isize	(	character(len=*), intent(in)	name,
		character(len=*), intent(in)	mem_path,
		integer(i4b), intent(out)	isize
	)

Returns with isize = -1 when not found. Return 1 for scalars.

Parameters

[in]	name	variable name
[in]	mem_path	path where the variable is stored
[out]	isize	number of elements (flattened)

Definition at line 275 of file MemoryManager.f90.

    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    integer(I4B), intent(out) :: isize !< number of elements (flattened)
    ! -- local
    type(MemoryType), pointer :: mt => null()
    logical(LGP) :: found
    logical(LGP) :: terminate
    ! -- code
    !
    ! -- initialize isize to a value to communicate failure
    isize = -1
    !
    ! -- don't exit program if variable not found
    terminate = .false.
    !
    ! -- get the entry from the memory manager
    call get_from_memorylist(name, mem_path, mt, found, terminate)
    !
    ! -- set isize
    if (found) then
      isize = mt%isize
    end if
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

get_mem_elem_size()

subroutine, public memorymanagermodule::get_mem_elem_size	(	character(len=*), intent(in)	name,
		character(len=*), intent(in)	mem_path,
		integer(i4b), intent(out)	size
	)

Memory size in bytes, returns size = -1 when not found. This is

Parameters

[in]	name	variable name
[in]	mem_path	path where the variable is stored
[out]	size	size of the variable in bytes

Definition at line 206 of file MemoryManager.f90.

    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    integer(I4B), intent(out) :: size !< size of the variable in bytes
    ! -- local
    type(MemoryType), pointer :: mt => null()
    logical(LGP) :: found
    ! -- code
    !
    ! -- initialize size to a value to communicate failure
    size = -1
    !
    ! -- get the entry from the memory manager
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- set memory size
    if (found) then
      size = mt%element_size
    end if
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

get_mem_rank()

subroutine, public memorymanagermodule::get_mem_rank	(	character(len=*), intent(in)	name,
		character(len=*), intent(in)	mem_path,
		integer(i4b), intent(out)	rank
	)

Returns rank = -1 when not found.

Parameters

[in]

name

variable name

Definition at line 167 of file MemoryManager.f90.

    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< mem_path
    integer(I4B), intent(out) :: rank !< rank
    ! -- local
    type(MemoryType), pointer :: mt => null()
    logical(LGP) :: found
    ! -- code
    !
    ! -- initialize rank to a value to communicate failure
    rank = -1
    !
    ! -- get the entry from the memory manager
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- set rank
    if (found) then
      if (associated(mt%logicalsclr)) rank = 0
      if (associated(mt%intsclr)) rank = 0
      if (associated(mt%dblsclr)) rank = 0
      if (associated(mt%aint1d)) rank = 1
      if (associated(mt%aint2d)) rank = 2
      if (associated(mt%aint3d)) rank = 3
      if (associated(mt%adbl1d)) rank = 1
      if (associated(mt%adbl2d)) rank = 2
      if (associated(mt%adbl3d)) rank = 3
      if (associated(mt%strsclr)) rank = 0
      if (associated(mt%astr1d)) rank = 1
      if (associated(mt%acharstr1d)) rank = 1
    end if
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

get_mem_shape()

subroutine, public memorymanagermodule::get_mem_shape	(	character(len=*), intent(in)	name,
		character(len=*), intent(in)	mem_path,
		integer(i4b), dimension(:), intent(out)	mem_shape
	)

Returns an integer array with the shape (Fortran ordering), and set shape(1) = -1 when not found.

Parameters

[in]	name	variable name
[in]	mem_path	path where the variable is stored
[out]	mem_shape	shape of the variable

Definition at line 235 of file MemoryManager.f90.

    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    integer(I4B), dimension(:), intent(out) :: mem_shape !< shape of the variable
    ! -- local
    type(MemoryType), pointer :: mt => null()
    logical(LGP) :: found
    ! -- code
    !
    ! -- get the entry from the memory manager
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- set shape
    if (found) then
      if (associated(mt%logicalsclr)) mem_shape = shape(mt%logicalsclr)
      if (associated(mt%intsclr)) mem_shape = shape(mt%logicalsclr)
      if (associated(mt%dblsclr)) mem_shape = shape(mt%dblsclr)
      if (associated(mt%aint1d)) mem_shape = shape(mt%aint1d)
      if (associated(mt%aint2d)) mem_shape = shape(mt%aint2d)
      if (associated(mt%aint3d)) mem_shape = shape(mt%aint3d)
      if (associated(mt%adbl1d)) mem_shape = shape(mt%adbl1d)
      if (associated(mt%adbl2d)) mem_shape = shape(mt%adbl2d)
      if (associated(mt%adbl3d)) mem_shape = shape(mt%adbl3d)
      if (associated(mt%strsclr)) mem_shape = shape(mt%strsclr)
      if (associated(mt%astr1d)) mem_shape = shape(mt%astr1d)
      if (associated(mt%acharstr1d)) mem_shape = shape(mt%acharstr1d)
      ! -- to communicate failure
    else
      mem_shape(1) = -1
    end if
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

get_mem_type()

subroutine, public memorymanagermodule::get_mem_type	(	character(len=*), intent(in)	name,
		character(len=*), intent(in)	mem_path,
		character(len=lenmemtype), intent(out)	var_type
	)

Returns any of 'LOGICAL', 'INTEGER', 'DOUBLE', 'STRING'. returns 'UNKNOWN' when the variable is not found.

Parameters

[in]	name	variable name
[in]	mem_path	path where the variable is stored
[out]	var_type	memory type

Definition at line 144 of file MemoryManager.f90.

    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where the variable is stored
    character(len=LENMEMTYPE), intent(out) :: var_type !< memory type
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    mt => null()
    var_type = 'UNKNOWN'
    call get_from_memorylist(name, mem_path, mt, found)
    if (found) then
      var_type = mt%memtype
    end if
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

mem_cleanup_table()

subroutine memorymanagermodule::mem_cleanup_table

private

Definition at line 2811 of file MemoryManager.f90.

    ! -- local
    ! -- formats
    ! -- code
    call memtab%table_da()
    deallocate (memtab)
    nullify (memtab)
    !
    ! -- return
    return

Here is the caller graph for this function:

mem_da()

subroutine, public memorymanagermodule::mem_da

Definition at line 2960 of file MemoryManager.f90.

    ! -- modules
    use versionmodule, only: idevelopmode
    use inputoutputmodule, only: upcase
    ! -- local
    class(MemoryType), pointer :: mt
    character(len=LINELENGTH) :: error_msg
    character(len=LENVARNAME) :: ucname
    integer(I4B) :: ipos
    ! -- code
    do ipos = 1, memorylist%count()
      mt => memorylist%Get(ipos)
      if (idevelopmode == 1) then
        !
        ! -- check if memory has been deallocated
        if (mt%mt_associated() .and. mt%element_size == -1) then
          error_msg = trim(adjustl(mt%path))//' '// &
                      trim(adjustl(mt%name))//' has invalid element size'
          call store_error(trim(error_msg))
        end if
        !
        ! -- check if memory has been deallocated
        if (mt%mt_associated() .and. mt%isize > 0) then
          error_msg = trim(adjustl(mt%path))//' '// &
                      trim(adjustl(mt%name))//' not deallocated'
          call store_error(trim(error_msg))
        end if
        !
        ! -- check case of varname
        ucname = mt%name
        call upcase(ucname)
        if (mt%name /= ucname) then
          error_msg = trim(adjustl(mt%path))//' '// &
                      trim(adjustl(mt%name))//' not upper case'
          call store_error(trim(error_msg))
        end if
      end if
      !
      ! -- deallocate instance of memory type
      deallocate (mt)
    end do
    call memorylist%clear()
    if (count_errors() > 0) then
      call store_error('Could not clear memory list.', terminate=.true.)
    end if
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

mem_detailed_table()

subroutine memorymanagermodule::mem_detailed_table ( integer(i4b), intent(in)  iout, integer(i4b), intent(in)  nrows  )

private

Parameters

[in]	iout	unit number for mfsim.lst
[in]	nrows	number of table rows

Definition at line 2631 of file MemoryManager.f90.

    integer(I4B), intent(in) :: iout !< unit number for mfsim.lst
    integer(I4B), intent(in) :: nrows !< number of table rows
    ! -- local
    character(len=LINELENGTH) :: title
    character(len=LINELENGTH) :: text
    integer(I4B) :: nterms
    ! -- formats
    ! -- code
    nterms = 5
    !
    ! -- set up table title
    title = 'DETAILED INFORMATION ON VARIABLES STORED IN THE MEMORY MANAGER'
    !
    ! -- set up stage tableobj
    call table_cr(memtab, 'MEM DET', title)
    call memtab%table_df(nrows, nterms, iout)
    !
    ! -- origin
    text = 'ORIGIN'
    call memtab%initialize_column(text, lenmempath, alignment=tableft)
    !
    ! -- variable
    text = 'VARIABLE NAME'
    call memtab%initialize_column(text, lenvarname, alignment=tableft)
    !
    ! -- data type
    text = 'DATA TYPE'
    call memtab%initialize_column(text, 16, alignment=tableft)
    !
    ! -- size
    text = 'NUMBER OF ITEMS'
    call memtab%initialize_column(text, 20, alignment=tabright)
    !
    ! -- is it a pointer
    text = 'ASSOCIATED VARIABLE'
    call memtab%initialize_column(text, lenmemaddress, alignment=tableft)
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

mem_print_detailed()

subroutine, public memorymanagermodule::mem_print_detailed

(

integer(i4b)

iout

)

Definition at line 2925 of file MemoryManager.f90.

    integer(I4B) :: iout
    ! local
    class(MemoryType), pointer :: mt
    integer(I4B) :: ipos
 
    call mem_detailed_table(iout, memorylist%count())
    do ipos = 1, memorylist%count()
      mt => memorylist%Get(ipos)
      call mt%table_entry(memtab)
    end do
    call mem_cleanup_table()
 

Here is the call graph for this function:

Here is the caller graph for this function:

mem_set_print_option()

subroutine, public memorymanagermodule::mem_set_print_option	(	integer(i4b), intent(in)	iout,
		character(len=*), intent(in)	keyword,
		character(len=*), intent(inout)	error_msg
	)

Parameters

[in]	iout	unit number for mfsim.lst
[in]	keyword	memory print option
[in,out]	error_msg	returned error message if keyword is not valid option

Definition at line 2553 of file MemoryManager.f90.

    integer(I4B), intent(in) :: iout !< unit number for mfsim.lst
    character(len=*), intent(in) :: keyword !< memory print option
    character(len=*), intent(inout) :: error_msg !< returned error message if keyword is not valid option
    ! -- local
    ! -- format
    ! -- code
    select case (keyword)
    case ('NONE')
      iprmem = 0
      write (iout, '(4x, a)') &
        'LIMITED MEMORY INFORMATION WILL BE WRITTEN.'
    case ('SUMMARY')
      iprmem = 1
      write (iout, '(4x, a)') &
        'A SUMMARY OF SIMULATION MEMORY INFORMATION WILL BE WRITTEN.'
    case ('ALL')
      iprmem = 2
      write (iout, '(4x, a)') &
        'ALL SIMULATION MEMORY INFORMATION WILL BE WRITTEN.'
    case default
      error_msg = "Unknown memory print option '"//trim(keyword)//"."
    end select
    return

Here is the caller graph for this function:

mem_summary_line()

subroutine memorymanagermodule::mem_summary_line ( character(len=*), intent(in)  component, real(dp), intent(in)  rchars, real(dp), intent(in)  rlog, real(dp), intent(in)  rint, real(dp), intent(in)  rreal, real(dp), intent(in)  bytes  )

private

Parameters

[in]	component	character defining the program component (e.g. solution)
[in]	rchars	allocated size of characters (in common units)
[in]	rlog	allocated size of logical (in common units)
[in]	rint	allocated size of integer variables (in common units)
[in]	rreal	allocated size of real variables (in common units)
[in]	bytes	total allocated memory in memory manager (in common units)

Definition at line 2675 of file MemoryManager.f90.

    character(len=*), intent(in) :: component !< character defining the program component (e.g. solution)
    real(DP), intent(in) :: rchars !< allocated size of characters (in common units)
    real(DP), intent(in) :: rlog !< allocated size of logical (in common units)
    real(DP), intent(in) :: rint !< allocated size of integer variables (in common units)
    real(DP), intent(in) :: rreal !< allocated size of real variables (in common units)
    real(DP), intent(in) :: bytes !< total allocated memory in memory manager (in common units)
    ! -- formats
    ! -- code
    !
    ! -- write line
    call memtab%add_term(component)
    call memtab%add_term(rchars)
    call memtab%add_term(rlog)
    call memtab%add_term(rint)
    call memtab%add_term(rreal)
    call memtab%add_term(bytes)
    !
    ! -- return
    return

Here is the caller graph for this function:

mem_summary_table()

subroutine memorymanagermodule::mem_summary_table ( integer(i4b), intent(in)  iout, integer(i4b), intent(in)  nrows, character(len=*), intent(in)  cunits  )

private

Parameters

[in]	iout	unit number for mfsim.lst
[in]	nrows	number of table rows
[in]	cunits	memory units (bytes, kilobytes, megabytes, or gigabytes)

Definition at line 2581 of file MemoryManager.f90.

    integer(I4B), intent(in) :: iout !< unit number for mfsim.lst
    integer(I4B), intent(in) :: nrows !< number of table rows
    character(len=*), intent(in) :: cunits !< memory units (bytes, kilobytes, megabytes, or gigabytes)
    ! -- local
    character(len=LINELENGTH) :: title
    character(len=LINELENGTH) :: text
    integer(I4B) :: nterms
    ! -- formats
    ! -- code
    nterms = 6
    !
    ! -- set up table title
    title = 'SUMMARY INFORMATION ON VARIABLES STORED IN THE MEMORY MANAGER, '// &
            'IN '//trim(cunits)
    !
    ! -- set up stage tableobj
    call table_cr(memtab, 'MEM SUM', title)
    call memtab%table_df(nrows, nterms, iout)
    !
    ! -- data type
    text = 'COMPONENT'
    call memtab%initialize_column(text, 20, alignment=tableft)
    !
    ! -- memory allocated for characters
    text = 'CHARACTER'
    call memtab%initialize_column(text, 15, alignment=tabcenter)
    !
    ! -- memory allocated for logical
    text = 'LOGICAL'
    call memtab%initialize_column(text, 15, alignment=tabcenter)
    !
    ! -- memory allocated for integers
    text = 'INTEGER'
    call memtab%initialize_column(text, 15, alignment=tabcenter)
    !
    ! -- memory allocated for reals
    text = 'REAL'
    call memtab%initialize_column(text, 15, alignment=tabcenter)
    !
    ! -- total memory allocated
    text = 'TOTAL'
    call memtab%initialize_column(text, 15, alignment=tabcenter)
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

mem_summary_total()

subroutine memorymanagermodule::mem_summary_total ( integer(i4b), intent(in)  iout, real(dp), intent(in)  bytes  )

private

Parameters

[in]	iout	unit number for mfsim.lst
[in]	bytes	total number of bytes allocated in the memory manager

Definition at line 2733 of file MemoryManager.f90.

    integer(I4B), intent(in) :: iout !< unit number for mfsim.lst
    real(DP), intent(in) :: bytes !< total number of bytes allocated in the memory manager
    ! -- local
    character(len=LINELENGTH) :: title
    character(len=LINELENGTH) :: text
    character(LEN=10) :: cunits
    integer(I4B) :: nterms
    integer(I4B) :: nrows
    real(DP) :: fact
    real(DP) :: smb
    ! -- formats
    ! -- code
    !
    ! -- calculate factor and memory units
    call mem_units(bytes, fact, cunits)
    !
    ! -- set table terms
    nterms = 2
    nrows = 6
    !
    ! -- set up table title
    title = 'MEMORY MANAGER TOTAL STORAGE BY DATA TYPE, IN '//trim(cunits)
    !
    ! -- set up stage tableobj
    call table_cr(memtab, 'MEM TOT', title)
    call memtab%table_df(nrows, nterms, iout)
    !
    ! -- data type
    text = 'DATA TYPE'
    call memtab%initialize_column(text, 15, alignment=tableft)
    !
    ! -- number of values
    text = 'ALLOCATED MEMORY'
    call memtab%initialize_column(text, 15, alignment=tabcenter)
    !
    ! -- write data
    !
    ! -- characters
    smb = real(nvalues_astr, dp) * fact
    call memtab%add_term('Character')
    call memtab%add_term(smb)
    !
    ! -- logicals
    smb = real(nvalues_alogical * lgp, dp) * fact
    call memtab%add_term('Logical')
    call memtab%add_term(smb)
    !
    ! -- integers
    smb = real(nvalues_aint * i4b, dp) * fact
    call memtab%add_term('Integer')
    call memtab%add_term(smb)
    !
    ! -- reals
    smb = real(nvalues_adbl * dp, dp) * fact
    call memtab%add_term('Real')
    call memtab%add_term(smb)
    !
    ! -- total memory usage
    call memtab%print_separator()
    smb = bytes * fact
    call memtab%add_term('Total')
    call memtab%add_term(smb)
    !
    ! -- Virtual memory
    smb = calc_virtual_mem() * fact
    call memtab%add_term('Virtual')
    call memtab%add_term(smb)
    !
    ! -- deallocate table
    call mem_cleanup_table()
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

mem_unique_origins()

subroutine memorymanagermodule::mem_unique_origins

(

character(len=lenmemaddress), dimension(:), intent(inout), allocatable

cunique

)

Parameters

[in,out]

cunique

array with unique first components

Definition at line 3013 of file MemoryManager.f90.

    ! -- modules
    use arrayhandlersmodule, only: expandarray, ifind
    ! -- dummy
    character(len=LENMEMADDRESS), allocatable, dimension(:), intent(inout) :: &
      cunique !< array with unique first components
    ! -- local
    class(MemoryType), pointer :: mt
    character(len=LENMEMPATH) :: context
    character(len=LENCOMPONENTNAME) :: component
    character(len=LENCOMPONENTNAME) :: subcomponent
    character(len=LENMEMADDRESS) :: context_component
    integer(I4B) :: ipos
    integer(I4B) :: ipa
    ! -- code
    !
    ! -- initialize cunique
    allocate (cunique(0))
    !
    ! -- find unique origins
    do ipos = 1, memorylist%count()
      mt => memorylist%Get(ipos)
      call split_mem_path(mt%path, component, subcomponent)
      context = get_mem_path_context(mt%path)
      context_component = trim(context)//component
      ipa = ifind(cunique, context_component)
      if (ipa < 1) then
        call expandarray(cunique, 1)
        cunique(size(cunique)) = context_component
      end if
    end do
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

mem_units()

subroutine memorymanagermodule::mem_units ( real(dp), intent(in)  bytes, real(dp), intent(inout)  fact, character(len=*), intent(inout)  cunits  )

private

Parameters

[in]	bytes	total nr. of bytes
[in,out]	fact	conversion factor
[in,out]	cunits	string with memory unit

Definition at line 2699 of file MemoryManager.f90.

    ! -- dummy
    real(DP), intent(in) :: bytes !< total nr. of bytes
    real(DP), intent(inout) :: fact !< conversion factor
    character(len=*), intent(inout) :: cunits !< string with memory unit
    ! -- local
    ! -- formats
    ! -- code
    !
    ! -- initialize factor and unit string
    cunits = 'UNKNOWN'
    fact = done
    !
    ! -- set factor
    if (bytes < dep3) then
      fact = done
      cunits = 'BYTES'
    else if (bytes < dep6) then
      fact = dem3
      cunits = 'KILOBYTES'
    else if (bytes < dep9) then
      fact = dem6
      cunits = 'MEGABYTES'
    else
      fact = dem9
      cunits = 'GIGABYTES'
    end if
    !
    ! -- return
    return

Here is the caller graph for this function:

mem_write_usage()

subroutine, public memorymanagermodule::mem_write_usage

(

integer(i4b), intent(in)

iout

)

The total memory usage by data types (int, real, etc.) is written for every simulation.

Parameters

[in]

iout

unit number for mfsim.lst

Definition at line 2829 of file MemoryManager.f90.

    integer(I4B), intent(in) :: iout !< unit number for mfsim.lst
    ! -- local
    class(MemoryType), pointer :: mt
    character(len=LENMEMADDRESS), allocatable, dimension(:) :: cunique
    ! character(len=LENMEMPATH) :: mem_path
    character(len=LENMEMPATH) :: context
    character(len=LENCOMPONENTNAME) :: component
    character(len=LENCOMPONENTNAME) :: subcomponent
    character(len=LENMEMADDRESS) :: context_component
    character(LEN=10) :: cunits
    integer(I4B) :: ipos
    integer(I4B) :: icomp
    integer(I4B) :: ilen
    integer(I8B) :: nchars
    integer(I8B) :: nlog
    integer(I8B) :: nint
    integer(I8B) :: nreal
    real(DP) :: simbytes
    real(DP) :: fact
    real(DP) :: rchars
    real(DP) :: rlog
    real(DP) :: rint
    real(DP) :: rreal
    real(DP) :: bytes
    ! -- formats
    ! -- code
    !
    ! -- Calculate simulation memory allocation
    simbytes = (nvalues_astr + &
                nvalues_alogical * lgp + &
                nvalues_aint * i4b + &
                nvalues_adbl * dp)
    simbytes = real(simbytes, dp)
    !
    ! -- calculate factor and memory units
    call mem_units(simbytes, fact, cunits)
    !
    ! -- Write summary table for simulation components
    if (iprmem == 1) then
      !
      ! -- Find unique names of simulation components
      call mem_unique_origins(cunique)
      call mem_summary_table(iout, size(cunique), cunits)
      do icomp = 1, size(cunique)
        nchars = 0
        nlog = 0
        nint = 0
        nreal = 0
        bytes = dzero
        ilen = len_trim(cunique(icomp))
        do ipos = 1, memorylist%count()
          mt => memorylist%Get(ipos)
          call split_mem_path(mt%path, component, subcomponent)
          context = get_mem_path_context(mt%path)
          context_component = trim(context)//component
          if (cunique(icomp) /= context_component(1:ilen)) cycle
          if (.not. mt%master) cycle
          if (mt%memtype(1:6) == 'STRING') then
            nchars = nchars + mt%isize * mt%element_size
          else if (mt%memtype(1:7) == 'LOGICAL') then
            nlog = nlog + mt%isize
          else if (mt%memtype(1:7) == 'INTEGER') then
            nint = nint + mt%isize
          else if (mt%memtype(1:6) == 'DOUBLE') then
            nreal = nreal + mt%isize
          end if
        end do
        !
        ! -- calculate size of each data type in bytes
        rchars = real(nchars, dp) * fact
        rlog = real(nlog * lgp, dp) * fact
        rint = real(nint * i4b, dp) * fact
        rreal = real(nreal * dp, dp) * fact
        !
        ! -- calculate total storage in bytes
        bytes = rchars + rlog + rint + rreal
        !
        ! -- write data
        call mem_summary_line(cunique(icomp), rchars, rlog, rint, rreal, bytes)
      end do
      call mem_cleanup_table()
    end if
    !
    ! -- Write table with all variables for iprmem == 2
    if (iprmem == 2) then
      call mem_print_detailed(iout)
    end if
    !
    ! -- Write total memory allocation
    call mem_summary_total(iout, simbytes)
    !
    ! -- return
    return

Here is the call graph for this function:

Here is the caller graph for this function:

reallocate_charstr1d()

subroutine memorymanagermodule::reallocate_charstr1d ( type(characterstringtype), dimension(:), intent(inout), pointer, contiguous  acharstr1d, integer(i4b), intent(in)  ilen, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	acharstr1d	the reallocated charstring array
[in]	ilen	string length
[in]	nrow	number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1262 of file MemoryManager.f90.

    type(CharacterStringType), dimension(:), pointer, contiguous, &
      intent(inout) :: acharstr1d !< the reallocated charstring array
    integer(I4B), intent(in) :: ilen !< string length
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    type(CharacterStringType), dimension(:), allocatable :: astrtemp
    character(len=ilen) :: string
    integer(I4B) :: istat
    integer(I4B) :: isize
    integer(I4B) :: isize_old
    integer(I4B) :: nrow_old
    integer(I4B) :: n
    !
    ! -- Initialize string
    string = ''
    !
    ! -- Find and assign mt
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- reallocate astr1d
    if (found) then
      isize_old = mt%isize
      if (isize_old > 0) then
        nrow_old = size(acharstr1d)
      else
        nrow_old = 0
      end if
      !
      ! -- calculate isize
      isize = nrow
      !
      ! -- allocate astrtemp
      allocate (astrtemp(nrow), stat=istat, errmsg=errmsg)
      if (istat /= 0) then
        call allocate_error(name, mem_path, istat, isize)
      end if
      !
      ! -- copy existing values
      do n = 1, nrow_old
        astrtemp(n) = acharstr1d(n)
      end do
      !
      ! -- fill new values with missing values
      do n = nrow_old + 1, nrow
        astrtemp(n) = string
      end do
      !
      ! -- deallocate mt pointer, repoint, recalculate isize
      deallocate (acharstr1d)
      !
      ! -- allocate astr1d
      allocate (acharstr1d(nrow), stat=istat, errmsg=errmsg)
      if (istat /= 0) then
        call allocate_error(name, mem_path, istat, isize)
      end if
      !
      ! -- fill the reallocated character array
      do n = 1, nrow
        acharstr1d(n) = astrtemp(n)
      end do
      !
      ! -- deallocate temporary storage
      deallocate (astrtemp)
      !
      ! -- reset memory manager values
      mt%acharstr1d => acharstr1d
      mt%element_size = ilen
      mt%isize = isize
      mt%nrealloc = mt%nrealloc + 1
      mt%master = .true.
      nvalues_astr = nvalues_astr + isize - isize_old
      write (mt%memtype, "(a,' LEN=',i0,' (',i0,')')") 'STRING', ilen, nrow
    else
      errmsg = "Programming error, variable '"//trim(name)//"' from '"// &
               trim(mem_path)//"' is not defined in the memory manager. Use "// &
               "mem_allocate instead."
      call store_error(errmsg, terminate=.true.)
    end if
    !
    ! -- return
    return

reallocate_dbl1d()

subroutine memorymanagermodule::reallocate_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous  adbl, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	adbl	the reallocated 1d real array
[in]	nrow	number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1447 of file MemoryManager.f90.

    real(DP), dimension(:), pointer, contiguous, intent(inout) :: adbl !< the reallocated 1d real array
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    integer(I4B) :: istat
    integer(I4B) :: isize
    integer(I4B) :: i
    integer(I4B) :: isizeold
    integer(I4B) :: ifill
    logical(LGP) :: found
    ! -- code
    !
    ! -- Find and assign mt
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- Allocate adbl and then refill
    isize = nrow
    isizeold = size(mt%adbl1d)
    ifill = min(isizeold, isize)
    allocate (adbl(nrow), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    do i = 1, ifill
      adbl(i) = mt%adbl1d(i)
    end do
    !
    ! -- deallocate mt pointer, repoint, recalculate isize
    deallocate (mt%adbl1d)
    mt%adbl1d => adbl
    mt%element_size = dp
    mt%isize = isize
    mt%nrealloc = mt%nrealloc + 1
    mt%master = .true.
    nvalues_adbl = nvalues_adbl + isize - isizeold
    write (mt%memtype, "(a,' (',i0,')')") 'DOUBLE', isize
    !
    ! -- return
    return

reallocate_dbl2d()

subroutine memorymanagermodule::reallocate_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous  adbl, integer(i4b), intent(in)  ncol, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	adbl	the reallocated 2d real array
[in]	ncol	number of columns
[in]	nrow	number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1493 of file MemoryManager.f90.

    real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: adbl !< the reallocated 2d real array
    integer(I4B), intent(in) :: ncol !< number of columns
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: istat
    integer(I4B), dimension(2) :: ishape
    integer(I4B) :: i
    integer(I4B) :: j
    integer(I4B) :: isize
    integer(I4B) :: isizeold
    ! -- code
    !
    ! -- Find and assign mt
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- Allocate adbl and then refill
    ishape = shape(mt%adbl2d)
    isize = nrow * ncol
    isizeold = ishape(1) * ishape(2)
    allocate (adbl(ncol, nrow), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    do i = 1, ishape(2)
      do j = 1, ishape(1)
        adbl(j, i) = mt%adbl2d(j, i)
      end do
    end do
    !
    ! -- deallocate mt pointer, repoint, recalculate isize
    deallocate (mt%adbl2d)
    mt%adbl2d => adbl
    mt%element_size = dp
    mt%isize = isize
    mt%nrealloc = mt%nrealloc + 1
    mt%master = .true.
    nvalues_adbl = nvalues_adbl + isize - isizeold
    write (mt%memtype, "(a,' (',i0,',',i0,')')") 'DOUBLE', ncol, nrow
    !
    ! -- return
    return

reallocate_int1d()

subroutine memorymanagermodule::reallocate_int1d ( integer(i4b), dimension(:), intent(inout), pointer, contiguous  aint, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	aint	the reallocated integer array
[in]	nrow	number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1352 of file MemoryManager.f90.

    integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: aint !< the reallocated integer array
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: istat
    integer(I4B) :: isize
    integer(I4B) :: i
    integer(I4B) :: isizeold
    integer(I4B) :: ifill
    ! -- code
    !
    ! -- Find and assign mt
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- Allocate aint and then refill
    isize = nrow
    isizeold = size(mt%aint1d)
    ifill = min(isizeold, isize)
    allocate (aint(nrow), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    do i = 1, ifill
      aint(i) = mt%aint1d(i)
    end do
    !
    ! -- deallocate mt pointer, repoint, recalculate isize
    deallocate (mt%aint1d)
    mt%aint1d => aint
    mt%element_size = i4b
    mt%isize = isize
    mt%nrealloc = mt%nrealloc + 1
    mt%master = .true.
    nvalues_aint = nvalues_aint + isize - isizeold
    !
    ! -- return
    return

reallocate_int2d()

subroutine memorymanagermodule::reallocate_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous  aint, integer(i4b), intent(in)  ncol, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	aint	the reallocated 2d integer array
[in]	ncol	number of columns
[in]	nrow	number of rows
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1397 of file MemoryManager.f90.

    integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: aint !< the reallocated 2d integer array
    integer(I4B), intent(in) :: ncol !< number of columns
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    integer(I4B) :: istat
    integer(I4B), dimension(2) :: ishape
    integer(I4B) :: i
    integer(I4B) :: j
    integer(I4B) :: isize
    integer(I4B) :: isizeold
    ! -- code
    !
    ! -- Find and assign mt
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- Allocate aint and then refill
    ishape = shape(mt%aint2d)
    isize = nrow * ncol
    isizeold = ishape(1) * ishape(2)
    allocate (aint(ncol, nrow), stat=istat, errmsg=errmsg)
    if (istat /= 0) then
      call allocate_error(name, mem_path, istat, isize)
    end if
    do i = 1, ishape(2)
      do j = 1, ishape(1)
        aint(j, i) = mt%aint2d(j, i)
      end do
    end do
    !
    ! -- deallocate mt pointer, repoint, recalculate isize
    deallocate (mt%aint2d)
    mt%aint2d => aint
    mt%element_size = i4b
    mt%isize = isize
    mt%nrealloc = mt%nrealloc + 1
    mt%master = .true.
    nvalues_aint = nvalues_aint + isize - isizeold
    write (mt%memtype, "(a,' (',i0,',',i0,')')") 'INTEGER', ncol, nrow
    !
    ! -- return
    return

reallocate_str1d()

subroutine memorymanagermodule::reallocate_str1d ( character(len=ilen), dimension(:), intent(inout), pointer, contiguous  astr, integer(i4b), intent(in)  ilen, integer(i4b), intent(in)  nrow, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in]	ilen	string length
[in]	nrow	number of rows
[in,out]	astr	the reallocated string array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1178 of file MemoryManager.f90.

    integer(I4B), intent(in) :: ilen !< string length
    integer(I4B), intent(in) :: nrow !< number of rows
    character(len=ilen), dimension(:), pointer, contiguous, intent(inout) :: astr !< the reallocated string array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    character(len=ilen), dimension(:), allocatable :: astrtemp
    integer(I4B) :: istat
    integer(I4B) :: isize
    integer(I4B) :: isize_old
    integer(I4B) :: nrow_old
    integer(I4B) :: n
    !
    ! -- Find and assign mt
    call get_from_memorylist(name, mem_path, mt, found)
    !
    ! -- reallocate astr1d
    if (found) then
      isize_old = mt%isize
      if (isize_old > 0) then
        nrow_old = size(astr)
      else
        nrow_old = 0
      end if
      !
      ! -- calculate isize
      isize = nrow
      !
      ! -- allocate astrtemp
      allocate (astrtemp(nrow), stat=istat, errmsg=errmsg)
      if (istat /= 0) then
        call allocate_error(name, mem_path, istat, isize)
      end if
      !
      ! -- copy existing values
      do n = 1, nrow_old
        astrtemp(n) = astr(n)
      end do
      !
      ! -- fill new values with missing values
      do n = nrow_old + 1, nrow
        astrtemp(n) = ''
      end do
      !
      ! -- deallocate mt pointer, repoint, recalculate isize
      deallocate (astr)
      !
      ! -- allocate astr1d
      allocate (astr(nrow), stat=istat, errmsg=errmsg)
      if (istat /= 0) then
        call allocate_error(name, mem_path, istat, isize)
      end if
      !
      ! -- fill the reallocate character array
      do n = 1, nrow
        astr(n) = astrtemp(n)
      end do
      !
      ! -- deallocate temporary storage
      deallocate (astrtemp)
      !
      ! -- reset memory manager values
      mt%element_size = ilen
      mt%isize = isize
      mt%nrealloc = mt%nrealloc + 1
      mt%master = .true.
      nvalues_astr = nvalues_astr + isize - isize_old
      write (mt%memtype, "(a,' LEN=',i0,' (',i0,')')") 'STRING', ilen, nrow
    else
      errmsg = "Programming error, variable '"//trim(name)//"' from '"// &
               trim(mem_path)//"' is not defined in the memory manager. Use "// &
               "mem_allocate instead."
      call store_error(errmsg, terminate=.true.)
    end if
    !
    ! -- return
    return

reassignptr_dbl1d()

subroutine memorymanagermodule::reassignptr_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous  adbl, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name_target, character(len=*), intent(in)  mem_path_target  )

private

Parameters

[in,out]	adbl	pointer to 1d real array
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	name_target	name of target variable
[in]	mem_path_target	path where target variable is stored

Definition at line 2013 of file MemoryManager.f90.

    real(DP), dimension(:), pointer, contiguous, intent(inout) :: adbl !< pointer to 1d real array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in) :: name_target !< name of target variable
    character(len=*), intent(in) :: mem_path_target !< path where target variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    type(MemoryType), pointer :: mt2
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    call get_from_memorylist(name_target, mem_path_target, mt2, found)
    if (size(adbl) > 0) then
      nvalues_adbl = nvalues_adbl - size(adbl)
      deallocate (adbl)
    end if
    adbl => mt2%adbl1d
    mt%adbl1d => adbl
    mt%element_size = dp
    mt%isize = size(adbl)
    write (mt%memtype, "(a,' (',i0,')')") 'DOUBLE', mt%isize
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name_target
    mt%masterPath = mem_path_target
    !
    ! -- return
    return

reassignptr_dbl2d()

subroutine memorymanagermodule::reassignptr_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous  adbl, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name_target, character(len=*), intent(in)  mem_path_target  )

private

Parameters

[in,out]	adbl	pointer to 2d real array
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	name_target	name of target variable
[in]	mem_path_target	path where target variable is stored

Definition at line 2047 of file MemoryManager.f90.

    real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: adbl !< pointer to 2d real array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in) :: name_target !< name of target variable
    character(len=*), intent(in) :: mem_path_target !< path where target variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    type(MemoryType), pointer :: mt2
    logical(LGP) :: found
    integer(I4B) :: ncol
    integer(I4b) :: nrow
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    call get_from_memorylist(name_target, mem_path_target, mt2, found)
    if (size(adbl) > 0) then
      nvalues_adbl = nvalues_adbl - size(adbl)
      deallocate (adbl)
    end if
    adbl => mt2%adbl2d
    mt%adbl2d => adbl
    mt%element_size = dp
    mt%isize = size(adbl)
    ncol = size(adbl, dim=1)
    nrow = size(adbl, dim=2)
    write (mt%memtype, "(a,' (',i0,',',i0,')')") 'DOUBLE', ncol, nrow
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name_target
    mt%masterPath = mem_path_target
    !
    ! -- return
    return

reassignptr_int()

subroutine memorymanagermodule::reassignptr_int ( integer(i4b), intent(inout), pointer  sclr, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name_target, character(len=*), intent(in)  mem_path_target  )

private

Parameters

[in,out]	sclr	pointer to integer scalar
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	name_target	name of target variable
[in]	mem_path_target	path where target variable is stored

Definition at line 1907 of file MemoryManager.f90.

    integer(I4B), pointer, intent(inout) :: sclr !< pointer to integer scalar
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in) :: name_target !< name of target variable
    character(len=*), intent(in) :: mem_path_target !< path where target variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    type(MemoryType), pointer :: mt2
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    call get_from_memorylist(name_target, mem_path_target, mt2, found)
    if (associated(sclr)) then
      nvalues_aint = nvalues_aint - 1
      deallocate (sclr)
    end if
    sclr => mt2%intsclr
    mt%intsclr => sclr
    mt%element_size = i4b
    mt%isize = 1
    write (mt%memtype, "(a,' (',i0,')')") 'INTEGER', mt%isize
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name_target
    mt%masterPath = mem_path_target
    !
    ! -- return
    return

reassignptr_int1d()

subroutine memorymanagermodule::reassignptr_int1d ( integer(i4b), dimension(:), intent(inout), pointer, contiguous  aint, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name_target, character(len=*), intent(in)  mem_path_target  )

private

Parameters

[in,out]	aint	pointer to 1d integer array
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	name_target	name of target variable
[in]	mem_path_target	path where target variable is stored

Definition at line 1941 of file MemoryManager.f90.

    integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: aint !< pointer to 1d integer array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in) :: name_target !< name of target variable
    character(len=*), intent(in) :: mem_path_target !< path where target variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    type(MemoryType), pointer :: mt2
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    call get_from_memorylist(name_target, mem_path_target, mt2, found)
    if (size(aint) > 0) then
      nvalues_aint = nvalues_aint - size(aint)
      deallocate (aint)
    end if
    aint => mt2%aint1d
    mt%aint1d => aint
    mt%element_size = i4b
    mt%isize = size(aint)
    write (mt%memtype, "(a,' (',i0,')')") 'INTEGER', mt%isize
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name_target
    mt%masterPath = mem_path_target
    !
    ! -- return
    return

reassignptr_int2d()

subroutine memorymanagermodule::reassignptr_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous  aint, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path, character(len=*), intent(in)  name_target, character(len=*), intent(in)  mem_path_target  )

private

Parameters

[in,out]	aint	pointer to 2d integer array
[in]	name	variable name
[in]	mem_path	path where variable is stored
[in]	name_target	name of target variable
[in]	mem_path_target	path where target variable is stored

Definition at line 1975 of file MemoryManager.f90.

    integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: aint !< pointer to 2d integer array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    character(len=*), intent(in) :: name_target !< name of target variable
    character(len=*), intent(in) :: mem_path_target !< path where target variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    type(MemoryType), pointer :: mt2
    logical(LGP) :: found
    integer(I4B) :: ncol
    integer(I4B) :: nrow
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    call get_from_memorylist(name_target, mem_path_target, mt2, found)
    if (size(aint) > 0) then
      nvalues_aint = nvalues_aint - size(aint)
      deallocate (aint)
    end if
    aint => mt2%aint2d
    mt%aint2d => aint
    mt%element_size = i4b
    mt%isize = size(aint)
    ncol = size(aint, dim=1)
    nrow = size(aint, dim=2)
    write (mt%memtype, "(a,' (',i0,',',i0,')')") 'INTEGER', ncol, nrow
    !
    ! -- set master information
    mt%master = .false.
    mt%mastername = name_target
    mt%masterPath = mem_path_target
    !
    ! -- return
    return

setptr_charstr1d()

subroutine memorymanagermodule::setptr_charstr1d ( type(characterstringtype), dimension(:), intent(inout), pointer, contiguous  acharstr1d, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	acharstr1d	the reallocated charstring array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1731 of file MemoryManager.f90.

    type(CharacterStringType), dimension(:), pointer, contiguous, &
      intent(inout) :: acharstr1d !< the reallocated charstring array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    acharstr1d => mt%acharstr1d
    !
    ! -- return
    return

setptr_dbl()

subroutine memorymanagermodule::setptr_dbl ( real(dp), intent(inout), pointer  sclr, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	sclr	pointer to a real scalar
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1628 of file MemoryManager.f90.

    real(DP), pointer, intent(inout) :: sclr !< pointer to a real scalar
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    sclr => mt%dblsclr
    !
    ! -- return
    return

setptr_dbl1d()

subroutine memorymanagermodule::setptr_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous  adbl, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	adbl	pointer to 1d real array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1645 of file MemoryManager.f90.

    real(DP), dimension(:), pointer, contiguous, intent(inout) :: adbl !< pointer to 1d real array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    adbl => mt%adbl1d
    !
    ! -- return
    return

setptr_dbl2d()

subroutine memorymanagermodule::setptr_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous  adbl, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	adbl	pointer to 2d real array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1662 of file MemoryManager.f90.

    real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: adbl !< pointer to 2d real array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    adbl => mt%adbl2d
    !
    ! -- return
    return

setptr_dbl3d()

subroutine memorymanagermodule::setptr_dbl3d ( real(dp), dimension(:, :, :), intent(inout), pointer, contiguous  adbl, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	adbl	pointer to 3d real array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1679 of file MemoryManager.f90.

    real(DP), dimension(:, :, :), pointer, contiguous, intent(inout) :: adbl !< pointer to 3d real array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    adbl => mt%adbl3d
    !
    ! -- return
    return

setptr_int()

subroutine memorymanagermodule::setptr_int ( integer(i4b), intent(inout), pointer  sclr, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	sclr	pointer to integer scalar
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1560 of file MemoryManager.f90.

    integer(I4B), pointer, intent(inout) :: sclr !< pointer to integer scalar
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    sclr => mt%intsclr
    !
    ! -- return
    return

setptr_int1d()

subroutine memorymanagermodule::setptr_int1d ( integer(i4b), dimension(:), intent(inout), pointer, contiguous  aint, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	aint	pointer to 1d integer array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1577 of file MemoryManager.f90.

    integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: aint !< pointer to 1d integer array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    aint => mt%aint1d
    !
    ! -- return
    return

setptr_int2d()

subroutine memorymanagermodule::setptr_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous  aint, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	aint	pointer to 2d integer array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1594 of file MemoryManager.f90.

    integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: aint !< pointer to 2d integer array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    aint => mt%aint2d
    !
    ! -- return
    return

setptr_int3d()

subroutine memorymanagermodule::setptr_int3d ( integer(i4b), dimension(:, :, :), intent(inout), pointer, contiguous  aint, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	aint	pointer to 3d integer array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1611 of file MemoryManager.f90.

    integer(I4B), dimension(:, :, :), pointer, contiguous, intent(inout) :: aint !< pointer to 3d integer array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    aint => mt%aint3d
    !
    ! -- return
    return

setptr_logical()

subroutine memorymanagermodule::setptr_logical ( logical(lgp), intent(inout), pointer  sclr, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	sclr	pointer to logical scalar
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1543 of file MemoryManager.f90.

    logical(LGP), pointer, intent(inout) :: sclr !< pointer to logical scalar
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    sclr => mt%logicalsclr
    !
    ! -- return
    return

setptr_str()

subroutine memorymanagermodule::setptr_str ( character(len=:), pointer  asrt, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

	asrt	pointer to the character string
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1696 of file MemoryManager.f90.

    character(len=:), pointer :: asrt !< pointer to the character string
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    asrt => mt%strsclr
    !
    ! -- return
    return

setptr_str1d()

subroutine memorymanagermodule::setptr_str1d ( character(len=:), dimension(:), intent(inout), pointer, contiguous  astr1d, character(len=*), intent(in)  name, character(len=*), intent(in)  mem_path  )

private

Parameters

[in,out]	astr1d	pointer to the string array
[in]	name	variable name
[in]	mem_path	path where variable is stored

Definition at line 1713 of file MemoryManager.f90.

    character(len=:), dimension(:), &
      pointer, contiguous, intent(inout) :: astr1d !< pointer to the string array
    character(len=*), intent(in) :: name !< variable name
    character(len=*), intent(in) :: mem_path !< path where variable is stored
    ! -- local
    type(MemoryType), pointer :: mt
    logical(LGP) :: found
    ! -- code
    call get_from_memorylist(name, mem_path, mt, found)
    astr1d => mt%astr1d
    !
    ! -- return
    return

Variable Documentation

iprmem

integer(i4b) memorymanagermodule::iprmem = 0

private

Definition at line 51 of file MemoryManager.f90.

  integer(I4B) :: iprmem = 0

memorylist

type(memorylisttype), public memorymanagermodule::memorylist

Definition at line 45 of file MemoryManager.f90.

  type(MemoryListType) :: memorylist

memtab

type(tabletype), pointer memorymanagermodule::memtab => null()

private

Definition at line 46 of file MemoryManager.f90.

  type(TableType), pointer :: memtab => null()

nvalues_adbl

integer(i8b) memorymanagermodule::nvalues_adbl = 0

private

Definition at line 50 of file MemoryManager.f90.

  integer(I8B) :: nvalues_adbl = 0

nvalues_aint

integer(i8b) memorymanagermodule::nvalues_aint = 0

private

Definition at line 49 of file MemoryManager.f90.

  integer(I8B) :: nvalues_aint = 0

nvalues_alogical

integer(i8b) memorymanagermodule::nvalues_alogical = 0

private

Definition at line 47 of file MemoryManager.f90.

  integer(I8B) :: nvalues_alogical = 0

nvalues_astr

integer(i8b) memorymanagermodule::nvalues_astr = 0

private

Definition at line 48 of file MemoryManager.f90.

  integer(I8B) :: nvalues_astr = 0