145 character(len=*),
intent(in) :: name
146 character(len=*),
intent(in) :: mem_path
147 character(len=LENMEMTYPE),
intent(out) :: var_type
150 logical(LGP) :: found
156 var_type = mt%memtype
168 character(len=*),
intent(in) :: name
169 character(len=*),
intent(in) :: mem_path
170 integer(I4B),
intent(out) :: rank
173 logical(LGP) :: found
184 if (
associated(mt%logicalsclr)) rank = 0
185 if (
associated(mt%intsclr)) rank = 0
186 if (
associated(mt%dblsclr)) rank = 0
187 if (
associated(mt%aint1d)) rank = 1
188 if (
associated(mt%aint2d)) rank = 2
189 if (
associated(mt%aint3d)) rank = 3
190 if (
associated(mt%adbl1d)) rank = 1
191 if (
associated(mt%adbl2d)) rank = 2
192 if (
associated(mt%adbl3d)) rank = 3
193 if (
associated(mt%strsclr)) rank = 0
194 if (
associated(mt%astr1d)) rank = 1
195 if (
associated(mt%acharstr1d)) rank = 1
207 character(len=*),
intent(in) :: name
208 character(len=*),
intent(in) :: mem_path
209 integer(I4B),
intent(out) :: size
212 logical(LGP) :: found
223 size = mt%element_size
236 character(len=*),
intent(in) :: name
237 character(len=*),
intent(in) :: mem_path
238 integer(I4B),
dimension(:),
intent(out) :: mem_shape
241 logical(LGP) :: found
249 if (
associated(mt%logicalsclr)) mem_shape = shape(mt%logicalsclr)
250 if (
associated(mt%intsclr)) mem_shape = shape(mt%logicalsclr)
251 if (
associated(mt%dblsclr)) mem_shape = shape(mt%dblsclr)
252 if (
associated(mt%aint1d)) mem_shape = shape(mt%aint1d)
253 if (
associated(mt%aint2d)) mem_shape = shape(mt%aint2d)
254 if (
associated(mt%aint3d)) mem_shape = shape(mt%aint3d)
255 if (
associated(mt%adbl1d)) mem_shape = shape(mt%adbl1d)
256 if (
associated(mt%adbl2d)) mem_shape = shape(mt%adbl2d)
257 if (
associated(mt%adbl3d)) mem_shape = shape(mt%adbl3d)
258 if (
associated(mt%strsclr)) mem_shape = shape(mt%strsclr)
259 if (
associated(mt%astr1d)) mem_shape = shape(mt%astr1d)
260 if (
associated(mt%acharstr1d)) mem_shape = shape(mt%acharstr1d)
276 character(len=*),
intent(in) :: name
277 character(len=*),
intent(in) :: mem_path
278 integer(I4B),
intent(out) :: isize
281 logical(LGP) :: found
282 logical(LGP) :: terminate
309 character(len=*),
intent(in) :: name
310 character(len=*),
intent(in) :: mem_path
311 type(
memorytype),
pointer,
intent(inout) :: mt
312 logical(LGP),
intent(out) :: found
313 logical(LGP),
intent(in),
optional :: check
317 logical(LGP) check_opt
327 if (mt%name == name .and. mt%path == mem_path)
then
333 if (
present(check))
then
337 if (.not. found)
then
338 errmsg =
"Programming error in memory manager. Variable '"// &
339 trim(name)//
"' in '"//trim(mem_path)//
"' cannot be "// &
340 "assigned because it does not exist in memory manager."
352 character(len=*),
intent(in) :: varname
353 character(len=*),
intent(in) :: mem_path
354 integer(I4B),
intent(in) :: istat
355 integer(I4B),
intent(in) :: isize
357 character(len=20) :: csize
358 character(len=20) :: cstat
362 write (csize,
'(i0)') isize
363 write (cstat,
'(i0)') istat
366 errmsg =
"Error trying to allocate memory. Path '"//trim(mem_path)// &
367 "' variable name '"//trim(varname)//
"' size '"//trim(csize)// &
368 "'. Error message is '"//trim(adjustl(
errmsg))// &
369 "'. Status code is "//trim(cstat)//
'.'
378 logical(LGP),
pointer,
intent(inout) :: sclr
379 character(len=*),
intent(in) :: name
380 character(len=*),
intent(in) :: mem_path
382 integer(I4B) :: istat
402 mt%logicalsclr => sclr
403 mt%element_size = lgp
407 write (mt%memtype,
"(a)")
'LOGICAL'
419 integer(I4B),
intent(in) :: ilen
420 character(len=ilen),
pointer,
intent(inout) :: sclr
421 character(len=*),
intent(in) :: name
422 character(len=*),
intent(in) :: mem_path
424 integer(I4B) :: istat
431 errmsg =
'Programming error in allocate_str. ILEN must be greater than 0.'
439 allocate (
character(len=ilen) :: sclr, stat=istat,
errmsg=
errmsg)
455 mt%element_size = ilen
459 write (mt%memtype,
"(a,' LEN=',i0)")
'STRING', ilen
471 integer(I4B),
intent(in) :: ilen
472 character(len=ilen),
dimension(:), &
473 pointer,
contiguous,
intent(inout) :: astr1d
474 integer(I4B),
intent(in) :: nrow
475 character(len=*),
intent(in) :: name
476 character(len=*),
intent(in) :: mem_path
479 character(len=ilen) :: string
481 integer(I4B) :: istat
482 integer(I4B) :: isize
490 errmsg =
'Programming error in allocate_str1d. '// &
491 'ILEN must be greater than 0.'
502 allocate (
character(len=ilen) :: astr1d(nrow), stat=istat,
errmsg=
errmsg)
524 mt%element_size = ilen
528 write (mt%memtype,
"(a,' LEN=',i0,' (',i0,')')")
'STRING', ilen, nrow
541 pointer,
contiguous,
intent(inout) :: acharstr1d
542 integer(I4B),
intent(in) :: ilen
543 integer(I4B),
intent(in) :: nrow
544 character(len=*),
intent(in) :: name
545 character(len=*),
intent(in) :: mem_path
547 character(len=ilen) :: string
550 integer(I4B) :: istat
551 integer(I4B) :: isize
573 acharstr1d(n) = string
583 mt%acharstr1d => acharstr1d
584 mt%element_size = ilen
588 write (mt%memtype,
"(a,' LEN=',i0,' (',i0,')')")
'STRING', ilen, nrow
600 integer(I4B),
pointer,
intent(inout) :: sclr
601 character(len=*),
intent(in) :: name
602 character(len=*),
intent(in) :: mem_path
605 integer(I4B) :: istat
625 mt%element_size = i4b
629 write (mt%memtype,
"(a)")
'INTEGER'
641 integer(I4B),
dimension(:),
pointer,
contiguous,
intent(inout) :: aint
642 integer(I4B),
intent(in) :: nrow
643 character(len=*),
intent(in) :: name
644 character(len=*),
intent(in) :: mem_path
647 integer(I4B) :: istat
648 integer(I4B) :: isize
671 mt%element_size = i4b
675 write (mt%memtype,
"(a,' (',i0,')')")
'INTEGER', isize
687 integer(I4B),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: aint
688 integer(I4B),
intent(in) :: ncol
689 integer(I4B),
intent(in) :: nrow
690 character(len=*),
intent(in) :: name
691 character(len=*),
intent(in) :: mem_path
694 integer(I4B) :: istat
695 integer(I4B) :: isize
718 mt%element_size = i4b
722 write (mt%memtype,
"(a,' (',i0,',',i0,')')")
'INTEGER', ncol, nrow
733 integer(I4B),
dimension(:, :, :),
pointer,
contiguous,
intent(inout) :: aint
734 integer(I4B),
intent(in) :: ncol
735 integer(I4B),
intent(in) :: nrow
736 integer(I4B),
intent(in) :: nlay
737 character(len=*),
intent(in) :: name
738 character(len=*),
intent(in) :: mem_path
741 integer(I4B) :: istat
742 integer(I4B) :: isize
749 isize = ncol * nrow * nlay
752 allocate (aint(ncol, nrow, nlay), stat=istat,
errmsg=
errmsg)
765 mt%element_size = i4b
769 write (mt%memtype,
"(a,' (',i0,',',i0,',',i0,')')")
'INTEGER', ncol, &
782 real(DP),
pointer,
intent(inout) :: sclr
783 character(len=*),
intent(in) :: name
784 character(len=*),
intent(in) :: mem_path
787 integer(I4B) :: istat
811 write (mt%memtype,
"(a)")
'DOUBLE'
823 real(DP),
dimension(:),
pointer,
contiguous,
intent(inout) :: adbl
824 integer(I4B),
intent(in) :: nrow
825 character(len=*),
intent(in) :: name
826 character(len=*),
intent(in) :: mem_path
829 integer(I4B) :: istat
830 integer(I4B) :: isize
857 write (mt%memtype,
"(a,' (',i0,')')")
'DOUBLE', isize
869 real(DP),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: adbl
870 integer(I4B),
intent(in) :: ncol
871 integer(I4B),
intent(in) :: nrow
872 character(len=*),
intent(in) :: name
873 character(len=*),
intent(in) :: mem_path
876 integer(I4B) :: istat
877 integer(I4B) :: isize
904 write (mt%memtype,
"(a,' (',i0,',',i0,')')")
'DOUBLE', ncol, nrow
916 real(DP),
dimension(:, :, :),
pointer,
contiguous,
intent(inout) :: adbl
917 integer(I4B),
intent(in) :: ncol
918 integer(I4B),
intent(in) :: nrow
919 integer(I4B),
intent(in) :: nlay
920 character(len=*),
intent(in) :: name
921 character(len=*),
intent(in) :: mem_path
924 integer(I4B) :: istat
925 integer(I4B) :: isize
932 isize = ncol * nrow * nlay
935 allocate (adbl(ncol, nrow, nlay), stat=istat,
errmsg=
errmsg)
952 write (mt%memtype,
"(a,' (',i0,',',i0,',',i0,')')")
'DOUBLE', ncol, &
965 integer(I4B),
dimension(:),
pointer,
contiguous,
intent(in) :: aint
966 character(len=*),
intent(in) :: name
967 character(len=*),
intent(in) :: mem_path
968 character(len=*),
intent(in) :: name2
969 character(len=*),
intent(in) :: mem_path2
972 integer(I4B) :: isize
986 mt%element_size = i4b
990 write (mt%memtype,
"(a,' (',i0,')')")
'INTEGER', isize
994 mt%mastername = name2
995 mt%masterPath = mem_path2
1007 integer(I4B),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: aint2d
1008 character(len=*),
intent(in) :: name
1009 character(len=*),
intent(in) :: mem_path
1010 character(len=*),
intent(in) :: name2
1011 character(len=*),
intent(in) :: mem_path2
1014 integer(I4B) :: ncol, nrow, isize
1021 ncol =
size(aint2d, dim=1)
1022 nrow =
size(aint2d, dim=2)
1033 write (mt%memtype,
"(a,' (',i0,',',i0,')')")
'INTEGER', ncol, nrow
1037 mt%mastername = name2
1038 mt%masterPath = mem_path2
1050 real(DP),
dimension(:),
pointer,
contiguous,
intent(inout) :: adbl
1051 character(len=*),
intent(in) :: name
1052 character(len=*),
intent(in) :: mem_path
1053 character(len=*),
intent(in) :: name2
1054 character(len=*),
intent(in) :: mem_path2
1057 integer(I4B) :: isize
1071 mt%element_size = dp
1075 write (mt%memtype,
"(a,' (',i0,')')")
'DOUBLE', isize
1079 mt%mastername = name2
1080 mt%masterPath = mem_path2
1092 real(DP),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: adbl2d
1093 character(len=*),
intent(in) :: name
1094 character(len=*),
intent(in) :: mem_path
1095 character(len=*),
intent(in) :: name2
1096 character(len=*),
intent(in) :: mem_path2
1099 integer(I4B) :: ncol, nrow, isize
1106 ncol =
size(adbl2d, dim=1)
1107 nrow =
size(adbl2d, dim=2)
1118 write (mt%memtype,
"(a,' (',i0,',',i0,')')")
'DOUBLE', ncol, nrow
1122 mt%mastername = name2
1123 mt%masterPath = mem_path2
1136 pointer,
contiguous,
intent(inout) :: acharstr1d
1137 integer(I4B),
intent(in) :: ilen
1138 character(len=*),
intent(in) :: name
1139 character(len=*),
intent(in) :: mem_path
1140 character(len=*),
intent(in) :: name2
1141 character(len=*),
intent(in) :: mem_path2
1144 integer(I4B) :: isize
1151 isize =
size(acharstr1d)
1157 mt%acharstr1d => acharstr1d
1158 mt%element_size = ilen
1162 write (mt%memtype,
"(a,' LEN=',i0,' (',i0,')')")
'STRING', ilen, isize
1166 mt%mastername = name2
1167 mt%masterPath = mem_path2
1179 integer(I4B),
intent(in) :: ilen
1180 integer(I4B),
intent(in) :: nrow
1181 character(len=ilen),
dimension(:),
pointer,
contiguous,
intent(inout) :: astr
1182 character(len=*),
intent(in) :: name
1183 character(len=*),
intent(in) :: mem_path
1186 logical(LGP) :: found
1187 character(len=ilen),
dimension(:),
allocatable :: astrtemp
1188 integer(I4B) :: istat
1189 integer(I4B) :: isize
1190 integer(I4B) :: isize_old
1191 integer(I4B) :: nrow_old
1199 isize_old = mt%isize
1200 if (isize_old > 0)
then
1201 nrow_old =
size(astr)
1211 if (istat /= 0)
then
1217 astrtemp(n) = astr(n)
1221 do n = nrow_old + 1, nrow
1230 if (istat /= 0)
then
1236 astr(n) = astrtemp(n)
1240 deallocate (astrtemp)
1243 mt%element_size = ilen
1245 mt%nrealloc = mt%nrealloc + 1
1248 write (mt%memtype,
"(a,' LEN=',i0,' (',i0,')')")
'STRING', ilen, nrow
1250 errmsg =
"Programming error, variable '"//trim(name)//
"' from '"// &
1251 trim(mem_path)//
"' is not defined in the memory manager. Use "// &
1252 "mem_allocate instead."
1264 intent(inout) :: acharstr1d
1265 integer(I4B),
intent(in) :: ilen
1266 integer(I4B),
intent(in) :: nrow
1267 character(len=*),
intent(in) :: name
1268 character(len=*),
intent(in) :: mem_path
1271 logical(LGP) :: found
1273 character(len=ilen) :: string
1274 integer(I4B) :: istat
1275 integer(I4B) :: isize
1276 integer(I4B) :: isize_old
1277 integer(I4B) :: nrow_old
1288 isize_old = mt%isize
1289 if (isize_old > 0)
then
1290 nrow_old =
size(acharstr1d)
1300 if (istat /= 0)
then
1306 astrtemp(n) = acharstr1d(n)
1310 do n = nrow_old + 1, nrow
1311 astrtemp(n) = string
1315 deallocate (acharstr1d)
1319 if (istat /= 0)
then
1325 acharstr1d(n) = astrtemp(n)
1329 deallocate (astrtemp)
1332 mt%acharstr1d => acharstr1d
1333 mt%element_size = ilen
1335 mt%nrealloc = mt%nrealloc + 1
1338 write (mt%memtype,
"(a,' LEN=',i0,' (',i0,')')")
'STRING', ilen, nrow
1340 errmsg =
"Programming error, variable '"//trim(name)//
"' from '"// &
1341 trim(mem_path)//
"' is not defined in the memory manager. Use "// &
1342 "mem_allocate instead."
1353 integer(I4B),
dimension(:),
pointer,
contiguous,
intent(inout) :: aint
1354 integer(I4B),
intent(in) :: nrow
1355 character(len=*),
intent(in) :: name
1356 character(len=*),
intent(in) :: mem_path
1359 logical(LGP) :: found
1360 integer(I4B) :: istat
1361 integer(I4B) :: isize
1363 integer(I4B) :: isizeold
1364 integer(I4B) :: ifill
1372 isizeold =
size(mt%aint1d)
1373 ifill = min(isizeold, isize)
1375 if (istat /= 0)
then
1379 aint(i) = mt%aint1d(i)
1383 deallocate (mt%aint1d)
1385 mt%element_size = i4b
1387 mt%nrealloc = mt%nrealloc + 1
1398 integer(I4B),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: aint
1399 integer(I4B),
intent(in) :: ncol
1400 integer(I4B),
intent(in) :: nrow
1401 character(len=*),
intent(in) :: name
1402 character(len=*),
intent(in) :: mem_path
1405 logical(LGP) :: found
1406 integer(I4B) :: istat
1407 integer(I4B),
dimension(2) :: ishape
1410 integer(I4B) :: isize
1411 integer(I4B) :: isizeold
1418 ishape = shape(mt%aint2d)
1420 isizeold = ishape(1) * ishape(2)
1422 if (istat /= 0)
then
1427 aint(j, i) = mt%aint2d(j, i)
1432 deallocate (mt%aint2d)
1434 mt%element_size = i4b
1436 mt%nrealloc = mt%nrealloc + 1
1439 write (mt%memtype,
"(a,' (',i0,',',i0,')')")
'INTEGER', ncol, nrow
1448 real(DP),
dimension(:),
pointer,
contiguous,
intent(inout) :: adbl
1449 integer(I4B),
intent(in) :: nrow
1450 character(len=*),
intent(in) :: name
1451 character(len=*),
intent(in) :: mem_path
1454 integer(I4B) :: istat
1455 integer(I4B) :: isize
1457 integer(I4B) :: isizeold
1458 integer(I4B) :: ifill
1459 logical(LGP) :: found
1467 isizeold =
size(mt%adbl1d)
1468 ifill = min(isizeold, isize)
1470 if (istat /= 0)
then
1474 adbl(i) = mt%adbl1d(i)
1478 deallocate (mt%adbl1d)
1480 mt%element_size = dp
1482 mt%nrealloc = mt%nrealloc + 1
1485 write (mt%memtype,
"(a,' (',i0,')')")
'DOUBLE', isize
1494 real(DP),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: adbl
1495 integer(I4B),
intent(in) :: ncol
1496 integer(I4B),
intent(in) :: nrow
1497 character(len=*),
intent(in) :: name
1498 character(len=*),
intent(in) :: mem_path
1501 logical(LGP) :: found
1502 integer(I4B) :: istat
1503 integer(I4B),
dimension(2) :: ishape
1506 integer(I4B) :: isize
1507 integer(I4B) :: isizeold
1514 ishape = shape(mt%adbl2d)
1516 isizeold = ishape(1) * ishape(2)
1518 if (istat /= 0)
then
1523 adbl(j, i) = mt%adbl2d(j, i)
1528 deallocate (mt%adbl2d)
1530 mt%element_size = dp
1532 mt%nrealloc = mt%nrealloc + 1
1535 write (mt%memtype,
"(a,' (',i0,',',i0,')')")
'DOUBLE', ncol, nrow
1544 logical(LGP),
pointer,
intent(inout) :: sclr
1545 character(len=*),
intent(in) :: name
1546 character(len=*),
intent(in) :: mem_path
1549 logical(LGP) :: found
1552 sclr => mt%logicalsclr
1561 integer(I4B),
pointer,
intent(inout) :: sclr
1562 character(len=*),
intent(in) :: name
1563 character(len=*),
intent(in) :: mem_path
1566 logical(LGP) :: found
1578 integer(I4B),
dimension(:),
pointer,
contiguous,
intent(inout) :: aint
1579 character(len=*),
intent(in) :: name
1580 character(len=*),
intent(in) :: mem_path
1583 logical(LGP) :: found
1595 integer(I4B),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: aint
1596 character(len=*),
intent(in) :: name
1597 character(len=*),
intent(in) :: mem_path
1600 logical(LGP) :: found
1612 integer(I4B),
dimension(:, :, :),
pointer,
contiguous,
intent(inout) :: aint
1613 character(len=*),
intent(in) :: name
1614 character(len=*),
intent(in) :: mem_path
1617 logical(LGP) :: found
1629 real(DP),
pointer,
intent(inout) :: sclr
1630 character(len=*),
intent(in) :: name
1631 character(len=*),
intent(in) :: mem_path
1634 logical(LGP) :: found
1646 real(DP),
dimension(:),
pointer,
contiguous,
intent(inout) :: adbl
1647 character(len=*),
intent(in) :: name
1648 character(len=*),
intent(in) :: mem_path
1651 logical(LGP) :: found
1663 real(DP),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: adbl
1664 character(len=*),
intent(in) :: name
1665 character(len=*),
intent(in) :: mem_path
1668 logical(LGP) :: found
1680 real(DP),
dimension(:, :, :),
pointer,
contiguous,
intent(inout) :: adbl
1681 character(len=*),
intent(in) :: name
1682 character(len=*),
intent(in) :: mem_path
1685 logical(LGP) :: found
1697 character(len=:),
pointer :: asrt
1698 character(len=*),
intent(in) :: name
1699 character(len=*),
intent(in) :: mem_path
1702 logical(LGP) :: found
1714 character(len=:),
dimension(:), &
1715 pointer,
contiguous,
intent(inout) :: astr1d
1716 character(len=*),
intent(in) :: name
1717 character(len=*),
intent(in) :: mem_path
1720 logical(LGP) :: found
1733 intent(inout) :: acharstr1d
1734 character(len=*),
intent(in) :: name
1735 character(len=*),
intent(in) :: mem_path
1738 logical(LGP) :: found
1741 acharstr1d => mt%acharstr1d
1750 integer(I4B),
dimension(:),
pointer,
contiguous,
intent(inout) :: aint
1751 character(len=*),
intent(in) :: name
1752 character(len=*),
intent(in) :: mem_path
1753 character(len=*),
intent(in),
optional :: mem_path_copy
1758 logical(LGP) :: found
1764 if (
present(mem_path_copy))
then
1765 call allocate_int1d(aint,
size(mt%aint1d), mt%name, mem_path_copy)
1768 allocate (aint(
size(mt%aint1d)))
1770 do n = 1,
size(mt%aint1d)
1771 aint(n) = mt%aint1d(n)
1781 integer(I4B),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: aint
1782 character(len=*),
intent(in) :: name
1783 character(len=*),
intent(in) :: mem_path
1784 character(len=*),
intent(in),
optional :: mem_path_copy
1789 logical(LGP) :: found
1792 integer(I4B) :: ncol
1793 integer(I4B) :: nrow
1797 ncol =
size(mt%aint2d, dim=1)
1798 nrow =
size(mt%aint2d, dim=2)
1800 if (
present(mem_path_copy))
then
1804 allocate (aint(ncol, nrow))
1808 aint(j, i) = mt%aint2d(j, i)
1819 real(DP),
dimension(:),
pointer,
contiguous,
intent(inout) :: adbl
1820 character(len=*),
intent(in) :: name
1821 character(len=*),
intent(in) :: mem_path
1822 character(len=*),
intent(in),
optional :: mem_path_copy
1827 logical(LGP) :: found
1833 if (
present(mem_path_copy))
then
1834 call allocate_dbl1d(adbl,
size(mt%adbl1d), mt%name, mem_path_copy)
1837 allocate (adbl(
size(mt%adbl1d)))
1839 do n = 1,
size(mt%adbl1d)
1840 adbl(n) = mt%adbl1d(n)
1850 real(DP),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: adbl
1851 character(len=*),
intent(in) :: name
1852 character(len=*),
intent(in) :: mem_path
1853 character(len=*),
intent(in),
optional :: mem_path_copy
1858 logical(LGP) :: found
1861 integer(I4B) :: ncol
1862 integer(I4B) :: nrow
1866 ncol =
size(mt%adbl2d, dim=1)
1867 nrow =
size(mt%adbl2d, dim=2)
1869 if (
present(mem_path_copy))
then
1873 allocate (adbl(ncol, nrow))
1877 adbl(j, i) = mt%adbl2d(j, i)
1888 real(dp),
dimension(:),
intent(inout) :: adbl
1889 character(len=*),
intent(in) :: name
1890 character(len=*),
intent(in) :: mem_path
1893 logical(LGP) :: found
1897 do n = 1,
size(mt%adbl1d)
1898 adbl(n) = mt%adbl1d(n)
1908 integer(I4B),
pointer,
intent(inout) :: sclr
1909 character(len=*),
intent(in) :: name
1910 character(len=*),
intent(in) :: mem_path
1911 character(len=*),
intent(in) :: name_target
1912 character(len=*),
intent(in) :: mem_path_target
1916 logical(LGP) :: found
1920 if (
associated(sclr))
then
1926 mt%element_size = i4b
1928 write (mt%memtype,
"(a,' (',i0,')')")
'INTEGER', mt%isize
1932 mt%mastername = name_target
1933 mt%masterPath = mem_path_target
1942 integer(I4B),
dimension(:),
pointer,
contiguous,
intent(inout) :: aint
1943 character(len=*),
intent(in) :: name
1944 character(len=*),
intent(in) :: mem_path
1945 character(len=*),
intent(in) :: name_target
1946 character(len=*),
intent(in) :: mem_path_target
1950 logical(LGP) :: found
1954 if (
size(aint) > 0)
then
1960 mt%element_size = i4b
1961 mt%isize =
size(aint)
1962 write (mt%memtype,
"(a,' (',i0,')')")
'INTEGER', mt%isize
1966 mt%mastername = name_target
1967 mt%masterPath = mem_path_target
1976 integer(I4B),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: aint
1977 character(len=*),
intent(in) :: name
1978 character(len=*),
intent(in) :: mem_path
1979 character(len=*),
intent(in) :: name_target
1980 character(len=*),
intent(in) :: mem_path_target
1984 logical(LGP) :: found
1985 integer(I4B) :: ncol
1986 integer(I4B) :: nrow
1990 if (
size(aint) > 0)
then
1996 mt%element_size = i4b
1997 mt%isize =
size(aint)
1998 ncol =
size(aint, dim=1)
1999 nrow =
size(aint, dim=2)
2000 write (mt%memtype,
"(a,' (',i0,',',i0,')')")
'INTEGER', ncol, nrow
2004 mt%mastername = name_target
2005 mt%masterPath = mem_path_target
2014 real(DP),
dimension(:),
pointer,
contiguous,
intent(inout) :: adbl
2015 character(len=*),
intent(in) :: name
2016 character(len=*),
intent(in) :: mem_path
2017 character(len=*),
intent(in) :: name_target
2018 character(len=*),
intent(in) :: mem_path_target
2022 logical(LGP) :: found
2026 if (
size(adbl) > 0)
then
2032 mt%element_size = dp
2033 mt%isize =
size(adbl)
2034 write (mt%memtype,
"(a,' (',i0,')')")
'DOUBLE', mt%isize
2038 mt%mastername = name_target
2039 mt%masterPath = mem_path_target
2048 real(DP),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: adbl
2049 character(len=*),
intent(in) :: name
2050 character(len=*),
intent(in) :: mem_path
2051 character(len=*),
intent(in) :: name_target
2052 character(len=*),
intent(in) :: mem_path_target
2056 logical(LGP) :: found
2057 integer(I4B) :: ncol
2058 integer(I4b) :: nrow
2062 if (
size(adbl) > 0)
then
2068 mt%element_size = dp
2069 mt%isize =
size(adbl)
2070 ncol =
size(adbl, dim=1)
2071 nrow =
size(adbl, dim=2)
2072 write (mt%memtype,
"(a,' (',i0,',',i0,')')")
'DOUBLE', ncol, nrow
2076 mt%mastername = name_target
2077 mt%masterPath = mem_path_target
2086 character(len=*),
pointer,
intent(inout) :: sclr
2087 character(len=*),
intent(in),
optional :: name
2088 character(len=*),
intent(in),
optional :: mem_path
2091 logical(LGP) :: found
2092 integer(I4B) :: ipos
2095 if (
present(name) .and.
present(mem_path))
then
2097 nullify (mt%strsclr)
2101 if (
associated(mt%strsclr, sclr))
then
2102 nullify (mt%strsclr)
2108 if (.not. found)
then
2109 call store_error(
'Programming error in deallocate_str.', terminate=.true.)
2126 character(len=*),
dimension(:),
pointer,
contiguous,
intent(inout) :: astr1d
2127 character(len=*),
optional,
intent(in) :: name
2128 character(len=*),
optional,
intent(in) :: mem_path
2131 logical(LGP) :: found
2132 integer(I4B) :: ipos
2137 if (
present(name) .and.
present(mem_path))
then
2143 if (
associated(mt%astr1d, astr1d))
then
2150 if (.not. found .and.
size(astr1d) > 0)
then
2151 call store_error(
'programming error in deallocate_str1d', terminate=.true.)
2169 intent(inout) :: astr1d
2170 character(len=*),
optional,
intent(in) :: name
2171 character(len=*),
optional,
intent(in) :: mem_path
2174 logical(LGP) :: found
2175 integer(I4B) :: ipos
2180 if (
present(name) .and.
present(mem_path))
then
2182 nullify (mt%acharstr1d)
2186 if (
associated(mt%acharstr1d, astr1d))
then
2187 nullify (mt%acharstr1d)
2193 if (.not. found .and.
size(astr1d) > 0)
then
2194 call store_error(
'programming error in deallocate_charstr1d', &
2211 logical(LGP),
pointer,
intent(inout) :: sclr
2214 logical(LGP) :: found
2215 integer(I4B) :: ipos
2220 if (
associated(mt%logicalsclr, sclr))
then
2221 nullify (mt%logicalsclr)
2226 if (.not. found)
then
2227 call store_error(
'programming error in deallocate_logical', &
2244 integer(I4B),
pointer,
intent(inout) :: sclr
2247 logical(LGP) :: found
2248 integer(I4B) :: ipos
2253 if (
associated(mt%intsclr, sclr))
then
2254 nullify (mt%intsclr)
2259 if (.not. found)
then
2260 call store_error(
'Programming error in deallocate_int.', terminate=.true.)
2276 real(DP),
pointer,
intent(inout) :: sclr
2279 logical(LGP) :: found
2280 integer(I4B) :: ipos
2285 if (
associated(mt%dblsclr, sclr))
then
2286 nullify (mt%dblsclr)
2291 if (.not. found)
then
2292 call store_error(
'Programming error in deallocate_dbl.', terminate=.true.)
2308 integer(I4B),
dimension(:),
pointer,
contiguous,
intent(inout) :: aint
2309 character(len=*),
optional :: name
2310 character(len=*),
optional :: mem_path
2313 logical(LGP) :: found
2314 integer(I4B) :: ipos
2319 if (
present(name) .and.
present(mem_path))
then
2325 if (
associated(mt%aint1d, aint))
then
2332 if (.not. found .and.
size(aint) > 0)
then
2333 call store_error(
'programming error in deallocate_int1d', terminate=.true.)
2349 integer(I4B),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: aint
2350 character(len=*),
optional :: name
2351 character(len=*),
optional :: mem_path
2354 logical(LGP) :: found
2355 integer(I4B) :: ipos
2360 if (
present(name) .and.
present(mem_path))
then
2366 if (
associated(mt%aint2d, aint))
then
2373 if (.not. found .and.
size(aint) > 0)
then
2374 call store_error(
'programming error in deallocate_int2d', terminate=.true.)
2390 integer(I4B),
dimension(:, :, :),
pointer,
contiguous,
intent(inout) :: aint
2391 character(len=*),
optional :: name
2392 character(len=*),
optional :: mem_path
2395 logical(LGP) :: found
2396 integer(I4B) :: ipos
2401 if (
present(name) .and.
present(mem_path))
then
2407 if (
associated(mt%aint3d, aint))
then
2414 if (.not. found .and.
size(aint) > 0)
then
2415 call store_error(
'programming error in deallocate_int3d', terminate=.true.)
2431 real(DP),
dimension(:),
pointer,
contiguous,
intent(inout) :: adbl
2432 character(len=*),
optional :: name
2433 character(len=*),
optional :: mem_path
2436 logical(LGP) :: found
2437 integer(I4B) :: ipos
2442 if (
present(name) .and.
present(mem_path))
then
2448 if (
associated(mt%adbl1d, adbl))
then
2455 if (.not. found .and.
size(adbl) > 0)
then
2456 call store_error(
'programming error in deallocate_dbl1d', terminate=.true.)
2472 real(DP),
dimension(:, :),
pointer,
contiguous,
intent(inout) :: adbl
2473 character(len=*),
optional :: name
2474 character(len=*),
optional :: mem_path
2477 logical(LGP) :: found
2478 integer(I4B) :: ipos
2483 if (
present(name) .and.
present(mem_path))
then
2489 if (
associated(mt%adbl2d, adbl))
then
2496 if (.not. found .and.
size(adbl) > 0)
then
2497 call store_error(
'programming error in deallocate_dbl2d', terminate=.true.)
2513 real(DP),
dimension(:, :, :),
pointer,
contiguous,
intent(inout) :: adbl
2514 character(len=*),
optional :: name
2515 character(len=*),
optional :: mem_path
2518 logical(LGP) :: found
2519 integer(I4B) :: ipos
2524 if (
present(name) .and.
present(mem_path))
then
2530 if (
associated(mt%adbl3d, adbl))
then
2537 if (.not. found .and.
size(adbl) > 0)
then
2538 call store_error(
'programming error in deallocate_dbl3d', terminate=.true.)
2554 integer(I4B),
intent(in) :: iout
2555 character(len=*),
intent(in) :: keyword
2556 character(len=*),
intent(inout) :: error_msg
2560 select case (keyword)
2563 write (iout,
'(4x, a)') &
2564 'LIMITED MEMORY INFORMATION WILL BE WRITTEN.'
2567 write (iout,
'(4x, a)') &
2568 'A SUMMARY OF SIMULATION MEMORY INFORMATION WILL BE WRITTEN.'
2571 write (iout,
'(4x, a)') &
2572 'ALL SIMULATION MEMORY INFORMATION WILL BE WRITTEN.'
2574 error_msg =
"Unknown memory print option '"//trim(keyword)//
"."
2582 integer(I4B),
intent(in) :: iout
2583 integer(I4B),
intent(in) :: nrows
2584 character(len=*),
intent(in) :: cunits
2586 character(len=LINELENGTH) :: title
2587 character(len=LINELENGTH) :: text
2588 integer(I4B) :: nterms
2594 title =
'SUMMARY INFORMATION ON VARIABLES STORED IN THE MEMORY MANAGER, '// &
2599 call memtab%table_df(nrows, nterms, iout)
2632 integer(I4B),
intent(in) :: iout
2633 integer(I4B),
intent(in) :: nrows
2635 character(len=LINELENGTH) :: title
2636 character(len=LINELENGTH) :: text
2637 integer(I4B) :: nterms
2643 title =
'DETAILED INFORMATION ON VARIABLES STORED IN THE MEMORY MANAGER'
2647 call memtab%table_df(nrows, nterms, iout)
2654 text =
'VARIABLE NAME'
2662 text =
'NUMBER OF ITEMS'
2666 text =
'ASSOCIATED VARIABLE'
2676 character(len=*),
intent(in) :: component
2677 real(DP),
intent(in) :: rchars
2678 real(DP),
intent(in) :: rlog
2679 real(DP),
intent(in) :: rint
2680 real(DP),
intent(in) :: rreal
2681 real(DP),
intent(in) :: bytes
2686 call memtab%add_term(component)
2687 call memtab%add_term(rchars)
2688 call memtab%add_term(rlog)
2689 call memtab%add_term(rint)
2690 call memtab%add_term(rreal)
2691 call memtab%add_term(bytes)
2701 real(DP),
intent(in) :: bytes
2702 real(DP),
intent(inout) :: fact
2703 character(len=*),
intent(inout) :: cunits
2713 if (bytes <
dep3)
then
2716 else if (bytes <
dep6)
then
2718 cunits =
'KILOBYTES'
2719 else if (bytes <
dep9)
then
2721 cunits =
'MEGABYTES'
2724 cunits =
'GIGABYTES'
2734 integer(I4B),
intent(in) :: iout
2735 real(DP),
intent(in) :: bytes
2737 character(len=LINELENGTH) :: title
2738 character(len=LINELENGTH) :: text
2739 character(LEN=10) :: cunits
2740 integer(I4B) :: nterms
2741 integer(I4B) :: nrows
2755 title =
'MEMORY MANAGER TOTAL STORAGE BY DATA TYPE, IN '//trim(cunits)
2759 call memtab%table_df(nrows, nterms, iout)
2766 text =
'ALLOCATED MEMORY'
2773 call memtab%add_term(
'Character')
2774 call memtab%add_term(smb)
2778 call memtab%add_term(
'Logical')
2779 call memtab%add_term(smb)
2783 call memtab%add_term(
'Integer')
2784 call memtab%add_term(smb)
2788 call memtab%add_term(
'Real')
2789 call memtab%add_term(smb)
2792 call memtab%print_separator()
2794 call memtab%add_term(
'Total')
2795 call memtab%add_term(smb)
2799 call memtab%add_term(
'Virtual')
2800 call memtab%add_term(smb)
2830 integer(I4B),
intent(in) :: iout
2833 character(len=LENMEMADDRESS),
allocatable,
dimension(:) :: cunique
2835 character(len=LENMEMPATH) :: context
2836 character(len=LENCOMPONENTNAME) :: component
2837 character(len=LENCOMPONENTNAME) :: subcomponent
2838 character(len=LENMEMADDRESS) :: context_component
2839 character(LEN=10) :: cunits
2840 integer(I4B) :: ipos
2841 integer(I4B) :: icomp
2842 integer(I4B) :: ilen
2843 integer(I8B) :: nchars
2844 integer(I8B) :: nlog
2845 integer(I8B) :: nint
2846 integer(I8B) :: nreal
2847 real(dp) :: simbytes
2862 simbytes = real(simbytes, dp)
2873 do icomp = 1,
size(cunique)
2879 ilen = len_trim(cunique(icomp))
2884 context_component = trim(context)//component
2885 if (cunique(icomp) /= context_component(1:ilen)) cycle
2886 if (.not. mt%master) cycle
2887 if (mt%memtype(1:6) ==
'STRING')
then
2888 nchars = nchars + mt%isize * mt%element_size
2889 else if (mt%memtype(1:7) ==
'LOGICAL')
then
2890 nlog = nlog + mt%isize
2891 else if (mt%memtype(1:7) ==
'INTEGER')
then
2892 nint = nint + mt%isize
2893 else if (mt%memtype(1:6) ==
'DOUBLE')
then
2894 nreal = nreal + mt%isize
2899 rchars = real(nchars, dp) * fact
2900 rlog = real(nlog * lgp, dp) * fact
2901 rint = real(nint * i4b, dp) * fact
2902 rreal = real(nreal * dp, dp) * fact
2905 bytes = rchars + rlog + rint + rreal
2926 integer(I4B) :: iout
2929 integer(I4B) :: ipos
2934 call mt%table_entry(
memtab)
2943 real(dp) :: vmem_size
2951 if (index(mt%path,
"__P") == 1)
then
2952 vmem_size = mt%element_size * mt%isize + vmem_size
2966 character(len=LINELENGTH) :: error_msg
2967 character(len=LENVARNAME) :: ucname
2968 integer(I4B) :: ipos
2975 if (mt%mt_associated() .and. mt%element_size == -1)
then
2976 error_msg = trim(adjustl(mt%path))//
' '// &
2977 trim(adjustl(mt%name))//
' has invalid element size'
2982 if (mt%mt_associated() .and. mt%isize > 0)
then
2983 error_msg = trim(adjustl(mt%path))//
' '// &
2984 trim(adjustl(mt%name))//
' not deallocated'
2991 if (mt%name /= ucname)
then
2992 error_msg = trim(adjustl(mt%path))//
' '// &
2993 trim(adjustl(mt%name))//
' not upper case'
3003 call store_error(
'Could not clear memory list.', terminate=.true.)
3017 character(len=LENMEMADDRESS),
allocatable,
dimension(:),
intent(inout) :: &
3021 character(len=LENMEMPATH) :: context
3022 character(len=LENCOMPONENTNAME) :: component
3023 character(len=LENCOMPONENTNAME) :: subcomponent
3024 character(len=LENMEMADDRESS) :: context_component
3025 integer(I4B) :: ipos
3030 allocate (cunique(0))
3037 context_component = trim(context)//component
3038 ipa =
ifind(cunique, context_component)
3041 cunique(
size(cunique)) = context_component
This module contains simulation constants.
integer(i4b), parameter linelength
maximum length of a standard line
integer(i4b), parameter lencomponentname
maximum length of a component name
@ tabcenter
centered table column
@ tabright
right justified table column
@ tableft
left justified table column
integer(i4b), parameter lenmemaddress
maximum length of the full memory address, including variable name
real(dp), parameter dep3
real constant 1000
@ tabucstring
upper case string table data
@ tabstring
string table data
@ tabinteger
integer table data
real(dp), parameter dep6
real constant 1000000
integer(i4b), parameter lenmemseparator
maximum length of the memory path separator used, currently a '/'
real(dp), parameter dep9
real constant 1e9
integer(i4b), parameter lenvarname
maximum length of a variable name
integer(i4b), parameter, public lenmemtype
maximum length of a memory manager type
real(dp), parameter dem3
real constant 1e-3
real(dp), parameter dem6
real constant 1e-6
real(dp), parameter dzero
real constant zero
real(dp), parameter dem9
real constant 1e-9
integer(i4b), parameter lenmempath
maximum length of the memory path
real(dp), parameter done
real constant 1
This module defines variable data types.
character(len=lenmempath) function get_mem_path_context(mem_path)
Return the context from the memory path.
subroutine mem_check_length(name, max_length, description)
Generic routine to check the length of (parts of) the memory address.
subroutine strip_context_mem_path(mem_path, mem_path_no_context)
Remove the context from the memory path.
subroutine split_mem_path(mem_path, component, subcomponent)
Split the memory path into component(s)
subroutine reallocate_int2d(aint, ncol, nrow, name, mem_path)
Reallocate a 2-dimensional integer array.
subroutine allocate_logical(sclr, name, mem_path)
Allocate a logical scalar.
subroutine allocate_int2d(aint, ncol, nrow, name, mem_path)
Allocate a 2-dimensional integer array.
subroutine mem_summary_line(component, rchars, rlog, rint, rreal, bytes)
Write a row for the memory_print_option 'SUMMARY' table.
subroutine allocate_dbl3d(adbl, ncol, nrow, nlay, name, mem_path)
Allocate a 3-dimensional real array.
integer(i8b) nvalues_adbl
subroutine deallocate_str1d(astr1d, name, mem_path)
Deallocate an array of defined-length character strings.
subroutine deallocate_int(sclr)
Deallocate a integer scalar.
type(tabletype), pointer memtab
subroutine setptr_int3d(aint, name, mem_path)
Set pointer to 3d integer array.
subroutine mem_detailed_table(iout, nrows)
Create a table if memory_print_option is 'ALL'.
subroutine deallocate_charstr1d(astr1d, name, mem_path)
Deallocate an array of deferred-length character strings.
subroutine allocate_charstr1d(acharstr1d, ilen, nrow, name, mem_path)
Allocate a 1-dimensional array of deferred-length CharacterStringType.
subroutine reallocate_charstr1d(acharstr1d, ilen, nrow, name, mem_path)
Reallocate a 1-dimensional deferred length string array.
subroutine, public mem_write_usage(iout)
Write memory manager memory usage based on the user-specified memory_print_option.
subroutine reallocate_dbl2d(adbl, ncol, nrow, name, mem_path)
Reallocate a 2-dimensional real array.
integer(i8b) nvalues_aint
subroutine setptr_int(sclr, name, mem_path)
Set pointer to integer scalar.
subroutine checkin_charstr1d(acharstr1d, ilen, name, mem_path, name2, mem_path2)
Check in an existing 1d CharacterStringType array with a new address (name + path)
subroutine mem_cleanup_table()
Generic function to clean a memory manager table.
subroutine copyptr_int1d(aint, name, mem_path, mem_path_copy)
Make a copy of a 1-dimensional integer array.
subroutine deallocate_dbl1d(adbl, name, mem_path)
Deallocate a 1-dimensional real array.
subroutine allocate_str1d(astr1d, ilen, nrow, name, mem_path)
Allocate a 1-dimensional defined length string array.
subroutine allocate_str(sclr, ilen, name, mem_path)
Allocate a character string.
subroutine, public get_mem_type(name, mem_path, var_type)
@ brief Get the variable memory type
subroutine setptr_int2d(aint, name, mem_path)
Set pointer to 2d integer array.
subroutine, public mem_da()
Deallocate memory in the memory manager.
subroutine deallocate_int1d(aint, name, mem_path)
Deallocate a 1-dimensional integer array.
integer(i8b) nvalues_astr
subroutine deallocate_dbl(sclr)
Deallocate a real scalar.
subroutine copyptr_int2d(aint, name, mem_path, mem_path_copy)
Make a copy of a 2-dimensional integer array.
subroutine allocate_dbl(sclr, name, mem_path)
Allocate a real scalar.
real(dp) function calc_virtual_mem()
Sum up virtual memory, i.e. memory.
subroutine copyptr_dbl2d(adbl, name, mem_path, mem_path_copy)
Make a copy of a 2-dimensional real array.
subroutine reassignptr_int2d(aint, name, mem_path, name_target, mem_path_target)
Set the pointer for a 2-dimensional integer array to.
subroutine setptr_dbl(sclr, name, mem_path)
Set pointer to a real scalar.
subroutine deallocate_int3d(aint, name, mem_path)
Deallocate a 3-dimensional integer array.
subroutine deallocate_int2d(aint, name, mem_path)
Deallocate a 2-dimensional integer array.
subroutine reassignptr_dbl1d(adbl, name, mem_path, name_target, mem_path_target)
Set the pointer for a 1-dimensional real array to.
subroutine allocate_int3d(aint, ncol, nrow, nlay, name, mem_path)
Allocate a 3-dimensional integer array.
subroutine, public get_mem_shape(name, mem_path, mem_shape)
@ brief Get the variable memory shape
subroutine deallocate_dbl2d(adbl, name, mem_path)
Deallocate a 2-dimensional real array.
subroutine mem_units(bytes, fact, cunits)
Determine appropriate memory unit and conversion factor.
subroutine setptr_int1d(aint, name, mem_path)
Set pointer to 1d integer array.
subroutine, public get_from_memorylist(name, mem_path, mt, found, check)
@ brief Get a memory type entry from the memory list
subroutine setptr_str1d(astr1d, name, mem_path)
Set pointer to a fixed-length string array.
subroutine checkin_int2d(aint2d, name, mem_path, name2, mem_path2)
Check in an existing 2d integer array with a new address (name + path)
subroutine reallocate_dbl1d(adbl, nrow, name, mem_path)
Reallocate a 1-dimensional real array.
subroutine setptr_dbl2d(adbl, name, mem_path)
Set pointer to a 2d real array.
subroutine deallocate_logical(sclr)
Deallocate a logical scalar.
subroutine checkin_dbl2d(adbl2d, name, mem_path, name2, mem_path2)
Check in an existing 2d double precision array with a new address (name + path)
subroutine deallocate_dbl3d(adbl, name, mem_path)
Deallocate a 3-dimensional real array.
type(memorylisttype), public memorylist
subroutine reallocate_int1d(aint, nrow, name, mem_path)
Reallocate a 1-dimensional integer array.
subroutine, public mem_print_detailed(iout)
subroutine reallocate_str1d(astr, ilen, nrow, name, mem_path)
Reallocate a 1-dimensional defined length string array.
subroutine copyptr_dbl1d(adbl, name, mem_path, mem_path_copy)
Make a copy of a 1-dimensional real array.
subroutine reassignptr_dbl2d(adbl, name, mem_path, name_target, mem_path_target)
Set the pointer for a 2-dimensional real array to.
subroutine allocate_int1d(aint, nrow, name, mem_path)
Allocate a 1-dimensional integer array.
subroutine allocate_int(sclr, name, mem_path)
Allocate a integer scalar.
subroutine reassignptr_int1d(aint, name, mem_path, name_target, mem_path_target)
Set the pointer for a 1-dimensional integer array to.
subroutine mem_summary_total(iout, bytes)
Create and fill a table with the total allocated memory.
subroutine, public get_isize(name, mem_path, isize)
@ brief Get the number of elements for this variable
subroutine allocate_dbl2d(adbl, ncol, nrow, name, mem_path)
Allocate a 2-dimensional real array.
subroutine deallocate_str(sclr, name, mem_path)
Deallocate a variable-length character string.
subroutine, public get_mem_rank(name, mem_path, rank)
@ brief Get the variable rank
subroutine checkin_dbl1d(adbl, name, mem_path, name2, mem_path2)
Check in an existing 1d double precision array with a new address (name + path)
subroutine checkin_int1d(aint, name, mem_path, name2, mem_path2)
Check in an existing 1d integer array with a new address (name + path)
subroutine reassignptr_int(sclr, name, mem_path, name_target, mem_path_target)
Set the pointer for an integer scalar to.
subroutine, public copy_dbl1d(adbl, name, mem_path)
Copy values from a 1-dimensional real array in the memory.
subroutine setptr_dbl3d(adbl, name, mem_path)
Set pointer to a 3d real array.
subroutine, public get_mem_elem_size(name, mem_path, size)
@ brief Get the memory size of a single element of the stored variable
subroutine setptr_dbl1d(adbl, name, mem_path)
Set pointer to a 1d real array.
subroutine setptr_str(asrt, name, mem_path)
Set pointer to a string (scalar)
integer(i8b) nvalues_alogical
subroutine setptr_charstr1d(acharstr1d, name, mem_path)
Set pointer to an array of CharacterStringType.
subroutine mem_unique_origins(cunique)
Create a array with unique first components from all memory paths. Only the first component of the me...
subroutine mem_summary_table(iout, nrows, cunits)
Create a table if memory_print_option is 'SUMMARY'.
subroutine setptr_logical(sclr, name, mem_path)
Set pointer to a logical scalar.
subroutine, public mem_set_print_option(iout, keyword, error_msg)
Set the memory print option.
subroutine allocate_dbl1d(adbl, nrow, name, mem_path)
Allocate a 1-dimensional real array.
subroutine allocate_error(varname, mem_path, istat, isize)
Issue allocation error message and stop program execution.
This module contains simulation methods.
subroutine, public store_error(msg, terminate)
Store an error message.
integer(i4b) function, public count_errors()
Return number of errors.
This module contains simulation variables.
character(len=maxcharlen) errmsg
error message string
subroutine, public table_cr(this, name, title)
This module contains version information.
integer(i4b), parameter idevelopmode
This class is used to store a single deferred-length character string. It was designed to work in an ...