MODFLOW 6 version 6.9.0.dev0
USGS Modular Hydrologic Model
Loading...
Searching...
No Matches
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.
subroutine mem_set_value_logical (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list logical variable.
subroutine mem_set_value_int (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list int variable.
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.
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.
subroutine mem_set_value_int1d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 1d int array variable.
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.
subroutine mem_set_value_int2d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 2d int array variable.
subroutine mem_set_value_int3d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 3d int array variable.
subroutine mem_set_value_dbl (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list double variable.
subroutine mem_set_value_dbl1d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 1d dbl array variable.
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.
subroutine mem_set_value_dbl2d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 2d dbl array variable.
subroutine mem_set_value_dbl3d (p_mem, varname, memory_path, found, release)
 Set pointer to value of memory list 3d dbl array variable.
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.

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
This class is used to store a single deferred-length character string. It was designed to work in an ...

◆ 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.

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
This module contains simulation constants.
Definition Constants.f90:9
integer(i4b), parameter lenmempath
maximum length of the memory path
Definition Constants.f90:27
character(len=lenmempath) function create_mem_path(component, subcomponent, context)
returns the path to the memory object
Here is the call graph for this function:
Here is the caller graph for this function: