memorymanagermodule::mem_allocate Interface Reference

Collaboration diagram for memorymanagermodule::mem_allocate:

Private Member Functions
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_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	allocate_charstr1d (acharstr1d, ilen, nrow, name, mem_path)
	Allocate a 1-dimensional array of deferred-length CharacterStringType. More...

Detailed Description

Definition at line 54 of file MemoryManager.f90.

Member Function/Subroutine Documentation

allocate_charstr1d()

subroutine memorymanagermodule::mem_allocate::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 502 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_dbl()

subroutine memorymanagermodule::mem_allocate::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 730 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_dbl1d()

subroutine memorymanagermodule::mem_allocate::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 768 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_dbl2d()

subroutine memorymanagermodule::mem_allocate::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 811 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_dbl3d()

subroutine memorymanagermodule::mem_allocate::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 855 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_int()

subroutine memorymanagermodule::mem_allocate::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 559 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_int1d()

subroutine memorymanagermodule::mem_allocate::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 597 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_int2d()

subroutine memorymanagermodule::mem_allocate::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 640 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_int3d()

subroutine memorymanagermodule::mem_allocate::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 684 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_logical()

subroutine memorymanagermodule::mem_allocate::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 349 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_str()

subroutine memorymanagermodule::mem_allocate::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 387 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 memorystore%add(mt)

Here is the call graph for this function:

allocate_str1d()

subroutine memorymanagermodule::mem_allocate::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 436 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 memorystore%add(mt)

Here is the call graph for this function:

---

The documentation for this interface was generated from the following file:

• /home/runner/work/modflow6/modflow6/src/Utilities/Memory/MemoryManager.f90