MODFLOW 6  version 6.8.0.dev0
USGS Modular Hydrologic Model
Data Types | Functions/Subroutines
memorymanagerextmodule Module Reference

Data Types

interface  mem_set_value
 

Functions/Subroutines

subroutine, public memorystore_remove (component, subcomponent, context)
 
subroutine, public memorystore_release (varname, memory_path)
 Release a single variable from the memory store. More...
 
subroutine mem_set_value_logical (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list logical variable. More...
 
subroutine mem_set_value_int (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list int variable. More...
 
subroutine mem_set_value_int_setval (p_mem, varname, memory_path, setval, found, release)
 
subroutine mem_set_value_str_mapped_int (p_mem, varname, memory_path, str_list, found, release)
 
subroutine mem_set_value_logical1d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 1d logical array variable. More...
 
subroutine mem_set_value_logical1d_mapped (p_mem, varname, memory_path, map, found, release)
 Set pointer to value of memory list 1d logical array variable with mapping. More...
 
subroutine mem_set_value_int1d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 1d int array variable. More...
 
subroutine mem_set_value_int1d_mapped (p_mem, varname, memory_path, map, found, release)
 Set pointer to value of memory list 1d int array variable with mapping. More...
 
subroutine mem_set_value_int2d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 2d int array variable. More...
 
subroutine mem_set_value_int3d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 3d int array variable. More...
 
subroutine mem_set_value_dbl (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list double variable. More...
 
subroutine mem_set_value_dbl1d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 1d dbl array variable. More...
 
subroutine mem_set_value_dbl1d_mapped (p_mem, varname, memory_path, map, found, release)
 Set pointer to value of memory list 1d dbl array variable with mapping. More...
 
subroutine mem_set_value_dbl2d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 2d dbl array variable. More...
 
subroutine mem_set_value_dbl3d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 3d dbl array variable. More...
 
subroutine mem_set_value_str (p_mem, varname, memory_path, found, release)
 
subroutine mem_set_value_charstr1d (p_mem, varname, memory_path, found, release)
 

Function/Subroutine Documentation

◆ mem_set_value_charstr1d()

subroutine memorymanagerextmodule::mem_set_value_charstr1d ( type(characterstringtype), dimension(:), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to charstr 1d array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 583 of file MemoryManagerExt.f90.

585  use characterstringmodule, only: characterstringtype
586  type(CharacterStringType), dimension(:), &
587  pointer, contiguous, intent(inout) :: p_mem !< pointer to charstr 1d array
588  character(len=*), intent(in) :: varname !< variable name
589  character(len=*), intent(in) :: memory_path !< path where variable is stored
590  logical(LGP), intent(inout) :: found
591  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
592  type(MemoryType), pointer :: mt
593  logical(LGP) :: checkfail = .false.
594  logical(LGP) :: do_release
595  integer(I4B) :: n
596 
597  do_release = (isim_mode /= mvalidate)
598  if (present(release)) do_release = release
599 
600  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
601  if (.not. found) return
602  if (.not. mt%mt_associated()) return ! guard: entry was previously released
603  if (mt%memtype(1:index(mt%memtype, ' ')) == 'STRING') then
604  do n = 1, size(mt%acharstr1d)
605  p_mem(n) = mt%acharstr1d(n)
606  end do
607  if (do_release) call mem_release(mt)
608  end if
characterstringmodule::characterstringtype
This class is used to store a single deferred-length character string. It was designed to work in an ...
Definition: CharString.f90:23

◆ mem_set_value_dbl()

subroutine memorymanagerextmodule::mem_set_value_dbl ( real(dp), intent(inout), pointer  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to dbl scalar
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 398 of file MemoryManagerExt.f90.

399  real(DP), pointer, intent(inout) :: p_mem !< pointer to dbl scalar
400  character(len=*), intent(in) :: varname !< variable name
401  character(len=*), intent(in) :: memory_path !< path where variable is stored
402  logical(LGP), intent(inout) :: found
403  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
404  type(MemoryType), pointer :: mt
405  logical(LGP) :: checkfail = .false.
406  logical(LGP) :: do_release
407 
408  do_release = (isim_mode /= mvalidate)
409  if (present(release)) do_release = release
410 
411  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
412  if (.not. found) return
413  if (.not. mt%mt_associated()) return ! guard: entry was previously released
414  if (mt%memtype(1:index(mt%memtype, ' ')) == 'DOUBLE') then
415  p_mem = mt%dblsclr
416  if (do_release) call mem_release(mt)
417  end if

◆ mem_set_value_dbl1d()

subroutine memorymanagerextmodule::mem_set_value_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 1d dbl array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 422 of file MemoryManagerExt.f90.

423  real(DP), dimension(:), pointer, contiguous, intent(inout) :: p_mem !< pointer to 1d dbl array
424  character(len=*), intent(in) :: varname !< variable name
425  character(len=*), intent(in) :: memory_path !< path where variable is stored
426  logical(LGP), intent(inout) :: found
427  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
428  type(MemoryType), pointer :: mt
429  logical(LGP) :: checkfail = .false.
430  logical(LGP) :: do_release
431  integer(I4B) :: n
432 
433  do_release = (isim_mode /= mvalidate)
434  if (present(release)) do_release = release
435 
436  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
437  if (.not. found) return
438  if (.not. mt%mt_associated()) return ! guard: entry was previously released
439  if (mt%memtype(1:index(mt%memtype, ' ')) == 'DOUBLE') then
440  if (size(mt%adbl1d) /= size(p_mem)) then
441  call store_error('mem_set_value() size mismatch dbl1d, varname='//&
442  &trim(varname), terminate=.true.)
443  end if
444  do n = 1, size(mt%adbl1d)
445  p_mem(n) = mt%adbl1d(n)
446  end do
447  if (do_release) call mem_release(mt)
448  end if

◆ mem_set_value_dbl1d_mapped()

subroutine memorymanagerextmodule::mem_set_value_dbl1d_mapped ( real(dp), dimension(:), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
integer(i4b), dimension(:), intent(in), pointer, contiguous  map,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 1d dbl array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]mappointer to 1d int mapping array
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 453 of file MemoryManagerExt.f90.

455  real(DP), dimension(:), pointer, contiguous, intent(inout) :: p_mem !< pointer to 1d dbl array
456  character(len=*), intent(in) :: varname !< variable name
457  character(len=*), intent(in) :: memory_path !< path where variable is stored
458  integer(I4B), dimension(:), pointer, contiguous, intent(in) :: map !< pointer to 1d int mapping array
459  logical(LGP), intent(inout) :: found
460  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
461  type(MemoryType), pointer :: mt
462  logical(LGP) :: checkfail = .false.
463  logical(LGP) :: do_release
464  integer(I4B) :: n
465 
466  do_release = (isim_mode /= mvalidate)
467  if (present(release)) do_release = release
468 
469  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
470  if (.not. found) return
471  if (.not. mt%mt_associated()) return ! guard: entry was previously released
472  if (mt%memtype(1:index(mt%memtype, ' ')) == 'DOUBLE') then
473  if (associated(map)) then
474  do n = 1, size(p_mem)
475  p_mem(n) = mt%adbl1d(map(n))
476  end do
477  else
478  if (size(mt%adbl1d) /= size(p_mem)) then
479  call store_error('mem_set_value() size mismatch dbl1d, varname='//&
480  &trim(varname), terminate=.true.)
481  end if
482  do n = 1, size(mt%adbl1d)
483  p_mem(n) = mt%adbl1d(n)
484  end do
485  end if
486  if (do_release) call mem_release(mt)
487  end if

◆ mem_set_value_dbl2d()

subroutine memorymanagerextmodule::mem_set_value_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 2d dbl array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 492 of file MemoryManagerExt.f90.

493  real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: p_mem !< pointer to 2d dbl array
494  character(len=*), intent(in) :: varname !< variable name
495  character(len=*), intent(in) :: memory_path !< path where variable is stored
496  logical(LGP), intent(inout) :: found
497  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
498  type(MemoryType), pointer :: mt
499  logical(LGP) :: checkfail = .false.
500  logical(LGP) :: do_release
501  integer(I4B) :: i, j
502 
503  do_release = (isim_mode /= mvalidate)
504  if (present(release)) do_release = release
505 
506  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
507  if (.not. found) return
508  if (.not. mt%mt_associated()) return ! guard: entry was previously released
509  if (mt%memtype(1:index(mt%memtype, ' ')) == 'DOUBLE') then
510  if (size(mt%adbl2d, dim=1) /= size(p_mem, dim=1) .or. &
511  size(mt%adbl2d, dim=2) /= size(p_mem, dim=2)) then
512  call store_error('mem_set_value() size mismatch dbl2d, varname='//&
513  &trim(varname), terminate=.true.)
514  end if
515  do j = 1, size(mt%adbl2d, dim=2)
516  do i = 1, size(mt%adbl2d, dim=1)
517  p_mem(i, j) = mt%adbl2d(i, j)
518  end do
519  end do
520  if (do_release) call mem_release(mt)
521  end if

◆ mem_set_value_dbl3d()

subroutine memorymanagerextmodule::mem_set_value_dbl3d ( real(dp), dimension(:, :, :), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 3d dbl array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 526 of file MemoryManagerExt.f90.

527  real(DP), dimension(:, :, :), pointer, contiguous, intent(inout) :: p_mem !< pointer to 3d dbl array
528  character(len=*), intent(in) :: varname !< variable name
529  character(len=*), intent(in) :: memory_path !< path where variable is stored
530  logical(LGP), intent(inout) :: found
531  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
532  type(MemoryType), pointer :: mt
533  logical(LGP) :: checkfail = .false.
534  logical(LGP) :: do_release
535  integer(I4B) :: i, j, k
536 
537  do_release = (isim_mode /= mvalidate)
538  if (present(release)) do_release = release
539 
540  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
541  if (.not. found) return
542  if (.not. mt%mt_associated()) return ! guard: entry was previously released
543  if (mt%memtype(1:index(mt%memtype, ' ')) == 'DOUBLE') then
544  if (size(mt%adbl3d, dim=1) /= size(p_mem, dim=1) .or. &
545  size(mt%adbl3d, dim=2) /= size(p_mem, dim=2) .or. &
546  size(mt%adbl3d, dim=3) /= size(p_mem, dim=3)) then
547  call store_error('mem_set_value() size mismatch dbl3d, varname='//&
548  &trim(varname), terminate=.true.)
549  end if
550  do k = 1, size(mt%adbl3d, dim=3)
551  do j = 1, size(mt%adbl3d, dim=2)
552  do i = 1, size(mt%adbl3d, dim=1)
553  p_mem(i, j, k) = mt%adbl3d(i, j, k)
554  end do
555  end do
556  end do
557  if (do_release) call mem_release(mt)
558  end if

◆ mem_set_value_int()

subroutine memorymanagerextmodule::mem_set_value_int ( integer(i4b), intent(inout), pointer  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to int scalar
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 110 of file MemoryManagerExt.f90.

111  integer(I4B), pointer, intent(inout) :: p_mem !< pointer to int scalar
112  character(len=*), intent(in) :: varname !< variable name
113  character(len=*), intent(in) :: memory_path !< path where variable is stored
114  logical(LGP), intent(inout) :: found
115  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
116  type(MemoryType), pointer :: mt
117  logical(LGP) :: checkfail = .false.
118  logical(LGP) :: do_release
119 
120  do_release = (isim_mode /= mvalidate)
121  if (present(release)) do_release = release
122 
123  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
124  if (.not. found) return
125  if (.not. mt%mt_associated()) return ! guard: entry was previously released
126  if (mt%memtype(1:index(mt%memtype, ' ')) == 'INTEGER') then
127  p_mem = mt%intsclr
128  if (do_release) call mem_release(mt)
129  end if

◆ mem_set_value_int1d()

subroutine memorymanagerextmodule::mem_set_value_int1d ( integer(i4b), dimension(:), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 1d int array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 257 of file MemoryManagerExt.f90.

258  integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: p_mem !< pointer to 1d int array
259  character(len=*), intent(in) :: varname !< variable name
260  character(len=*), intent(in) :: memory_path !< path where variable is stored
261  logical(LGP), intent(inout) :: found
262  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
263  type(MemoryType), pointer :: mt
264  logical(LGP) :: checkfail = .false.
265  logical(LGP) :: do_release
266  integer(I4B) :: n
267 
268  do_release = (isim_mode /= mvalidate)
269  if (present(release)) do_release = release
270 
271  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
272  if (.not. found) return
273  if (.not. mt%mt_associated()) return ! guard: entry was previously released
274  if (mt%memtype(1:index(mt%memtype, ' ')) == 'INTEGER') then
275  if (size(mt%aint1d) /= size(p_mem)) then
276  call store_error('mem_set_value() size mismatch int1d, varname='//&
277  &trim(varname), terminate=.true.)
278  end if
279  do n = 1, size(mt%aint1d)
280  p_mem(n) = mt%aint1d(n)
281  end do
282  if (do_release) call mem_release(mt)
283  end if

◆ mem_set_value_int1d_mapped()

subroutine memorymanagerextmodule::mem_set_value_int1d_mapped ( integer(i4b), dimension(:), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
integer(i4b), dimension(:), intent(in), pointer, contiguous  map,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 1d int array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]mappointer to 1d int mapping array
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 288 of file MemoryManagerExt.f90.

290  integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: p_mem !< pointer to 1d int array
291  character(len=*), intent(in) :: varname !< variable name
292  character(len=*), intent(in) :: memory_path !< path where variable is stored
293  integer(I4B), dimension(:), pointer, contiguous, intent(in) :: map !< pointer to 1d int mapping array
294  logical(LGP), intent(inout) :: found
295  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
296  type(MemoryType), pointer :: mt
297  logical(LGP) :: checkfail = .false.
298  logical(LGP) :: do_release
299  integer(I4B) :: n
300 
301  do_release = (isim_mode /= mvalidate)
302  if (present(release)) do_release = release
303 
304  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
305  if (.not. found) return
306  if (.not. mt%mt_associated()) return ! guard: entry was previously released
307  if (mt%memtype(1:index(mt%memtype, ' ')) == 'INTEGER') then
308  if (associated(map)) then
309  do n = 1, size(p_mem)
310  p_mem(n) = mt%aint1d(map(n))
311  end do
312  else
313  if (size(mt%aint1d) /= size(p_mem)) then
314  call store_error('mem_set_value() size mismatch int1d, varname='//&
315  &trim(varname), terminate=.true.)
316  end if
317  do n = 1, size(mt%aint1d)
318  p_mem(n) = mt%aint1d(n)
319  end do
320  end if
321  if (do_release) call mem_release(mt)
322  end if

◆ mem_set_value_int2d()

subroutine memorymanagerextmodule::mem_set_value_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 2d int array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 327 of file MemoryManagerExt.f90.

328  integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: p_mem !< pointer to 2d int array
329  character(len=*), intent(in) :: varname !< variable name
330  character(len=*), intent(in) :: memory_path !< path where variable is stored
331  logical(LGP), intent(inout) :: found
332  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
333  type(MemoryType), pointer :: mt
334  logical(LGP) :: checkfail = .false.
335  logical(LGP) :: do_release
336  integer(I4B) :: i, j
337 
338  do_release = (isim_mode /= mvalidate)
339  if (present(release)) do_release = release
340 
341  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
342  if (.not. found) return
343  if (.not. mt%mt_associated()) return ! guard: entry was previously released
344  if (mt%memtype(1:index(mt%memtype, ' ')) == 'INTEGER') then
345  if (size(mt%aint2d, dim=1) /= size(p_mem, dim=1) .or. &
346  size(mt%aint2d, dim=2) /= size(p_mem, dim=2)) then
347  call store_error('mem_set_value() size mismatch int2d, varname='//&
348  &trim(varname), terminate=.true.)
349  end if
350  do j = 1, size(mt%aint2d, dim=2)
351  do i = 1, size(mt%aint2d, dim=1)
352  p_mem(i, j) = mt%aint2d(i, j)
353  end do
354  end do
355  if (do_release) call mem_release(mt)
356  end if

◆ mem_set_value_int3d()

subroutine memorymanagerextmodule::mem_set_value_int3d ( integer(i4b), dimension(:, :, :), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 3d int array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 361 of file MemoryManagerExt.f90.

362  integer(I4B), dimension(:, :, :), pointer, contiguous, intent(inout) :: p_mem !< pointer to 3d int array
363  character(len=*), intent(in) :: varname !< variable name
364  character(len=*), intent(in) :: memory_path !< path where variable is stored
365  logical(LGP), intent(inout) :: found
366  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
367  type(MemoryType), pointer :: mt
368  logical(LGP) :: checkfail = .false.
369  logical(LGP) :: do_release
370  integer(I4B) :: i, j, k
371 
372  do_release = (isim_mode /= mvalidate)
373  if (present(release)) do_release = release
374 
375  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
376  if (.not. found) return
377  if (.not. mt%mt_associated()) return ! guard: entry was previously released
378  if (mt%memtype(1:index(mt%memtype, ' ')) == 'INTEGER') then
379  if (size(mt%aint3d, dim=1) /= size(p_mem, dim=1) .or. &
380  size(mt%aint3d, dim=2) /= size(p_mem, dim=2) .or. &
381  size(mt%aint3d, dim=3) /= size(p_mem, dim=3)) then
382  call store_error('mem_set_value() size mismatch int3d, varname='//&
383  &trim(varname), terminate=.true.)
384  end if
385  do k = 1, size(mt%aint3d, dim=3)
386  do j = 1, size(mt%aint3d, dim=2)
387  do i = 1, size(mt%aint3d, dim=1)
388  p_mem(i, j, k) = mt%aint3d(i, j, k)
389  end do
390  end do
391  end do
392  if (do_release) call mem_release(mt)
393  end if

◆ mem_set_value_int_setval()

subroutine memorymanagerextmodule::mem_set_value_int_setval ( integer(i4b), intent(inout), pointer  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
integer(i4b), intent(in)  setval,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to int scalar
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]setvalset p_mem to setval if varname found
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 132 of file MemoryManagerExt.f90.

134  integer(I4B), pointer, intent(inout) :: p_mem !< pointer to int scalar
135  character(len=*), intent(in) :: varname !< variable name
136  character(len=*), intent(in) :: memory_path !< path where variable is stored
137  integer(I4B), intent(in) :: setval !< set p_mem to setval if varname found
138  logical(LGP), intent(inout) :: found
139  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
140  type(MemoryType), pointer :: mt
141  logical(LGP) :: checkfail = .false.
142  logical(LGP) :: do_release
143 
144  do_release = (isim_mode /= mvalidate)
145  if (present(release)) do_release = release
146 
147  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
148  if (.not. found) return
149  if (.not. mt%mt_associated()) return ! guard: entry was previously released
150 
151  p_mem = setval
152  if (do_release) call mem_release(mt)

◆ mem_set_value_logical()

subroutine memorymanagerextmodule::mem_set_value_logical ( logical(lgp), intent(inout), pointer  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to logical scalar
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 82 of file MemoryManagerExt.f90.

83  logical(LGP), pointer, intent(inout) :: p_mem !< pointer to logical scalar
84  character(len=*), intent(in) :: varname !< variable name
85  character(len=*), intent(in) :: memory_path !< path where variable is stored
86  logical(LGP), intent(inout) :: found
87  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
88  type(MemoryType), pointer :: mt
89  logical(LGP) :: checkfail = .false.
90  logical(LGP) :: do_release
91 
92  do_release = (isim_mode /= mvalidate)
93  if (present(release)) do_release = release
94 
95  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
96  if (.not. found) return
97  if (.not. mt%mt_associated()) return ! guard: entry was previously released
98  if (mt%memtype(1:index(mt%memtype, ' ')) == 'INTEGER') then
99  if (mt%intsclr == 0) then
100  p_mem = .false.
101  else
102  p_mem = .true.
103  end if
104  if (do_release) call mem_release(mt)
105  end if

◆ mem_set_value_logical1d()

subroutine memorymanagerextmodule::mem_set_value_logical1d ( logical(lgp), dimension(:), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 1d logical array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 186 of file MemoryManagerExt.f90.

188  logical(LGP), dimension(:), pointer, contiguous, intent(inout) :: p_mem !< pointer to 1d logical array
189  character(len=*), intent(in) :: varname !< variable name
190  character(len=*), intent(in) :: memory_path !< path where variable is stored
191  logical(LGP), intent(inout) :: found
192  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
193  type(MemoryType), pointer :: mt
194  logical(LGP) :: checkfail = .false.
195  logical(LGP) :: do_release
196  integer(I4B) :: n
197 
198  do_release = (isim_mode /= mvalidate)
199  if (present(release)) do_release = release
200 
201  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
202  if (.not. found) return
203  if (.not. mt%mt_associated()) return ! guard: entry was previously released
204  if (mt%memtype(1:index(mt%memtype, ' ')) == 'LOGICAL') then
205  if (size(mt%alogical1d) /= size(p_mem)) then
206  call store_error('mem_set_value() size mismatch logical1d, varname='//&
207  &trim(varname), terminate=.true.)
208  end if
209  do n = 1, size(mt%alogical1d)
210  p_mem(n) = mt%alogical1d(n)
211  end do
212  if (do_release) call mem_release(mt)
213  end if

◆ mem_set_value_logical1d_mapped()

subroutine memorymanagerextmodule::mem_set_value_logical1d_mapped ( logical(lgp), dimension(:), intent(inout), pointer, contiguous  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
integer(i4b), dimension(:), intent(in), pointer, contiguous  map,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to 1d logical array
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]mappointer to 1d int mapping array
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 218 of file MemoryManagerExt.f90.

220  logical(LGP), dimension(:), pointer, contiguous, intent(inout) :: p_mem !< pointer to 1d logical array
221  character(len=*), intent(in) :: varname !< variable name
222  character(len=*), intent(in) :: memory_path !< path where variable is stored
223  integer(I4B), dimension(:), pointer, contiguous, intent(in) :: map !< pointer to 1d int mapping array
224  logical(LGP), intent(inout) :: found
225  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
226  type(MemoryType), pointer :: mt
227  logical(LGP) :: checkfail = .false.
228  logical(LGP) :: do_release
229  integer(I4B) :: n
230 
231  do_release = (isim_mode /= mvalidate)
232  if (present(release)) do_release = release
233 
234  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
235  if (.not. found) return
236  if (.not. mt%mt_associated()) return ! guard: entry was previously released
237  if (mt%memtype(1:index(mt%memtype, ' ')) == 'LOGICAL') then
238  if (associated(map)) then
239  do n = 1, size(p_mem)
240  p_mem(n) = mt%alogical1d(map(n))
241  end do
242  else
243  if (size(mt%alogical1d) /= size(p_mem)) then
244  call store_error('mem_set_value() size mismatch logical1d, varname='//&
245  &trim(varname), terminate=.true.)
246  end if
247  do n = 1, size(mt%alogical1d)
248  p_mem(n) = mt%alogical1d(n)
249  end do
250  end if
251  if (do_release) call mem_release(mt)
252  end if

◆ mem_set_value_str()

subroutine memorymanagerextmodule::mem_set_value_str ( character(len=*), intent(inout)  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to str scalar
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 561 of file MemoryManagerExt.f90.

562  character(len=*), intent(inout) :: p_mem !< pointer to str scalar
563  character(len=*), intent(in) :: varname !< variable name
564  character(len=*), intent(in) :: memory_path !< path where variable is stored
565  logical(LGP), intent(inout) :: found
566  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
567  type(MemoryType), pointer :: mt
568  logical(LGP) :: checkfail = .false.
569  logical(LGP) :: do_release
570 
571  do_release = (isim_mode /= mvalidate)
572  if (present(release)) do_release = release
573 
574  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
575  if (.not. found) return
576  if (.not. mt%mt_associated()) return ! guard: entry was previously released
577  if (mt%memtype(1:index(mt%memtype, ' ')) == 'STRING') then
578  p_mem = mt%strsclr
579  if (do_release) call mem_release(mt)
580  end if

◆ mem_set_value_str_mapped_int()

subroutine memorymanagerextmodule::mem_set_value_str_mapped_int ( integer(i4b), intent(inout), pointer  p_mem,
character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path,
character(len=*), dimension(:), intent(in)  str_list,
logical(lgp), intent(inout)  found,
logical(lgp), intent(in), optional  release 
)
private
Parameters
[in,out]p_mempointer to int scalar
[in]varnamevariable name
[in]memory_pathpath where variable is stored
[in]releaseif true (default), deallocate input context memory after copy

Definition at line 155 of file MemoryManagerExt.f90.

157  integer(I4B), pointer, intent(inout) :: p_mem !< pointer to int scalar
158  character(len=*), intent(in) :: varname !< variable name
159  character(len=*), intent(in) :: memory_path !< path where variable is stored
160  character(len=*), dimension(:), intent(in) :: str_list
161  logical(LGP), intent(inout) :: found
162  logical(LGP), intent(in), optional :: release !< if true (default), deallocate input context memory after copy
163  type(MemoryType), pointer :: mt
164  logical(LGP) :: checkfail = .false.
165  logical(LGP) :: do_release
166  integer(I4B) :: i
167 
168  do_release = (isim_mode /= mvalidate)
169  if (present(release)) do_release = release
170 
171  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
172  if (.not. found) return
173  if (.not. mt%mt_associated()) return ! guard: entry was previously released
174  if (mt%memtype(1:index(mt%memtype, ' ')) == 'STRING') then
175  do i = 1, size(str_list)
176  if (mt%strsclr == str_list(i)) then
177  p_mem = i
178  end if
179  end do
180  if (do_release) call mem_release(mt)
181  end if

◆ memorystore_release()

subroutine, public memorymanagerextmodule::memorystore_release ( character(len=*), intent(in)  varname,
character(len=*), intent(in)  memory_path 
)

Looks up the variable by name and path and deallocates its data. Safe to call when the variable is not found or was already released.

Parameters
[in]varnamevariable name
[in]memory_pathpath where variable is stored

Definition at line 67 of file MemoryManagerExt.f90.

68  character(len=*), intent(in) :: varname !< variable name
69  character(len=*), intent(in) :: memory_path !< path where variable is stored
70  type(MemoryType), pointer :: mt
71  logical(LGP) :: found
72  logical(LGP) :: checkfail = .false.
73 
74  call get_from_memorystore(varname, memory_path, mt, found, checkfail)
75  if (.not. found) return
76  if (.not. mt%mt_associated()) return ! guard: already released
77  if (isim_mode /= mvalidate) call mem_release(mt)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ memorystore_remove()

subroutine, public memorymanagerextmodule::memorystore_remove ( character(len=*), intent(in)  component,
character(len=*), intent(in), optional  subcomponent,
character(len=*), intent(in), optional  context 
)
Parameters
[in]componentname of the solution, model, or exchange
[in]subcomponentname of the package (optional)
[in]contextname of the context (optional)

Definition at line 30 of file MemoryManagerExt.f90.

31  use memoryhelpermodule, only: create_mem_path
32  use constantsmodule, only: lenmempath
33  character(len=*), intent(in) :: component !< name of the solution, model, or exchange
34  character(len=*), intent(in), optional :: subcomponent !< name of the package (optional)
35  character(len=*), intent(in), optional :: context !< name of the context (optional)
36  character(len=LENMEMPATH) :: memory_path !< the memory path
37  type(MemoryType), pointer :: mt
38  type(MemoryContainerIteratorType), allocatable :: itr
39  logical(LGP) :: removed
40 
41  memory_path = create_mem_path(component, subcomponent, context)
42  removed = .true. !< initialize the loop
43 
44  do while (removed)
45  removed = .false.
46  itr = memorystore%iterator()
47  do while (itr%has_next())
48  call itr%next()
49  mt => itr%value()
50  ! guard: mt_associated() is false for entries already released via
51  ! mem_set_value(..., release=.true.) prior to this call
52  if (mt%path == memory_path .and. mt%mt_associated()) then
53  call mt%mt_deallocate()
54  removed = .true.
55  deallocate (itr)
56  exit
57  end if
58  end do
59  end do
constantsmodule
This module contains simulation constants.
Definition: Constants.f90:9
constantsmodule::lenmempath
integer(i4b), parameter lenmempath
maximum length of the memory path
Definition: Constants.f90:27
memoryhelpermodule::create_mem_path
character(len=lenmempath) function create_mem_path(component, subcomponent, context)
returns the path to the memory object
Definition: MemoryHelper.f90:22
Here is the call graph for this function:
Here is the caller graph for this function: