MODFLOW 6 version 6.9.0.dev0
USGS Modular Hydrologic Model
Loading...
Searching...
No Matches
memorymanagermodule::mem_copyptr Interface Reference
Collaboration diagram for memorymanagermodule::mem_copyptr:
Collaboration graph

Public Member Functions

subroutine copyptr_logical1d (alog, name, mem_path, mem_path_copy)
 Make a copy of a 1-dimensional logical array.
subroutine copyptr_int1d (aint, name, mem_path, mem_path_copy)
 Make a copy of a 1-dimensional integer array.
subroutine copyptr_int2d (aint, name, mem_path, mem_path_copy)
 Make a copy of a 2-dimensional integer array.
subroutine copyptr_dbl1d (adbl, name, mem_path, mem_path_copy)
 Make a copy of a 1-dimensional real array.
subroutine copyptr_dbl2d (adbl, name, mem_path, mem_path_copy)
 Make a copy of a 2-dimensional real array.

Detailed Description

Definition at line 110 of file MemoryManager.f90.

Member Function/Subroutine Documentation

◆ copyptr_dbl1d()

subroutine memorymanagermodule::mem_copyptr::copyptr_dbl1d ( real(dp), dimension(:), intent(inout), pointer, contiguous adbl,
character(len=*), intent(in) name,
character(len=*), intent(in) mem_path,
character(len=*), intent(in), optional mem_path_copy )
Parameters
[in,out]adblreturned copy of 1d real array
[in]namevariable name
[in]mem_pathpath where variable is stored
[in]mem_path_copyoptional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1872 of file MemoryManager.f90.

1873 real(DP), dimension(:), pointer, contiguous, intent(inout) :: adbl !< returned copy of 1d real array
1874 character(len=*), intent(in) :: name !< variable name
1875 character(len=*), intent(in) :: mem_path !< path where variable is stored
1876 character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
1877 !! if passed then the copy is added to the
1878 !! memory manager
1879 ! -- local
1880 type(MemoryType), pointer :: mt
1881 logical(LGP) :: found
1882 integer(I4B) :: n
1883 ! -- code
1884 call get_from_memorystore(name, mem_path, mt, found)
1885 adbl => null()
1886 ! -- check the copy into the memory manager
1887 if (present(mem_path_copy)) then
1888 call allocate_dbl1d(adbl, size(mt%adbl1d), mt%name, mem_path_copy)
1889 ! -- create a local copy
1890 else
1891 allocate (adbl(size(mt%adbl1d)))
1892 end if
1893 do n = 1, size(mt%adbl1d)
1894 adbl(n) = mt%adbl1d(n)
1895 end do
Here is the call graph for this function:

◆ copyptr_dbl2d()

subroutine memorymanagermodule::mem_copyptr::copyptr_dbl2d ( real(dp), dimension(:, :), intent(inout), pointer, contiguous adbl,
character(len=*), intent(in) name,
character(len=*), intent(in) mem_path,
character(len=*), intent(in), optional mem_path_copy )
Parameters
[in,out]adblreturned copy of 2d real array
[in]namevariable name
[in]mem_pathpath where variable is stored
[in]mem_path_copyoptional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1900 of file MemoryManager.f90.

1901 real(DP), dimension(:, :), pointer, contiguous, intent(inout) :: adbl !< returned copy of 2d real array
1902 character(len=*), intent(in) :: name !< variable name
1903 character(len=*), intent(in) :: mem_path !< path where variable is stored
1904 character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
1905 !! if passed then the copy is added to the
1906 !! memory manager
1907 ! -- local
1908 type(MemoryType), pointer :: mt
1909 logical(LGP) :: found
1910 integer(I4B) :: i
1911 integer(I4B) :: j
1912 integer(I4B) :: ncol
1913 integer(I4B) :: nrow
1914 ! -- code
1915 call get_from_memorystore(name, mem_path, mt, found)
1916 adbl => null()
1917 ncol = size(mt%adbl2d, dim=1)
1918 nrow = size(mt%adbl2d, dim=2)
1919 ! -- check the copy into the memory manager
1920 if (present(mem_path_copy)) then
1921 call allocate_dbl2d(adbl, ncol, nrow, mt%name, mem_path_copy)
1922 ! -- create a local copy
1923 else
1924 allocate (adbl(ncol, nrow))
1925 end if
1926 do i = 1, nrow
1927 do j = 1, ncol
1928 adbl(j, i) = mt%adbl2d(j, i)
1929 end do
1930 end do
Here is the call graph for this function:

◆ copyptr_int1d()

subroutine memorymanagermodule::mem_copyptr::copyptr_int1d ( integer(i4b), dimension(:), intent(inout), pointer, contiguous aint,
character(len=*), intent(in) name,
character(len=*), intent(in) mem_path,
character(len=*), intent(in), optional mem_path_copy )
Parameters
[in,out]aintreturned copy of 1d integer array
[in]namevariable name
[in]mem_pathpath where variable is stored
[in]mem_path_copyoptional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1809 of file MemoryManager.f90.

1810 integer(I4B), dimension(:), pointer, contiguous, intent(inout) :: aint !< returned copy of 1d integer array
1811 character(len=*), intent(in) :: name !< variable name
1812 character(len=*), intent(in) :: mem_path !< path where variable is stored
1813 character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
1814 !! if passed then the copy is added to the
1815 !! memory manager
1816 ! -- local
1817 type(MemoryType), pointer :: mt
1818 logical(LGP) :: found
1819 integer(I4B) :: n
1820 ! -- code
1821 call get_from_memorystore(name, mem_path, mt, found)
1822 aint => null()
1823 ! -- check the copy into the memory manager
1824 if (present(mem_path_copy)) then
1825 call allocate_int1d(aint, size(mt%aint1d), mt%name, mem_path_copy)
1826 ! -- create a local copy
1827 else
1828 allocate (aint(size(mt%aint1d)))
1829 end if
1830 do n = 1, size(mt%aint1d)
1831 aint(n) = mt%aint1d(n)
1832 end do
Here is the call graph for this function:

◆ copyptr_int2d()

subroutine memorymanagermodule::mem_copyptr::copyptr_int2d ( integer(i4b), dimension(:, :), intent(inout), pointer, contiguous aint,
character(len=*), intent(in) name,
character(len=*), intent(in) mem_path,
character(len=*), intent(in), optional mem_path_copy )
Parameters
[in,out]aintreturned copy of 2d integer array
[in]namevariable name
[in]mem_pathpath where variable is stored
[in]mem_path_copyoptional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1837 of file MemoryManager.f90.

1838 integer(I4B), dimension(:, :), pointer, contiguous, intent(inout) :: aint !< returned copy of 2d integer array
1839 character(len=*), intent(in) :: name !< variable name
1840 character(len=*), intent(in) :: mem_path !< path where variable is stored
1841 character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
1842 !! if passed then the copy is added to the
1843 !! memory manager
1844 ! -- local
1845 type(MemoryType), pointer :: mt
1846 logical(LGP) :: found
1847 integer(I4B) :: i
1848 integer(I4B) :: j
1849 integer(I4B) :: ncol
1850 integer(I4B) :: nrow
1851 ! -- code
1852 call get_from_memorystore(name, mem_path, mt, found)
1853 aint => null()
1854 ncol = size(mt%aint2d, dim=1)
1855 nrow = size(mt%aint2d, dim=2)
1856 ! -- check the copy into the memory manager
1857 if (present(mem_path_copy)) then
1858 call allocate_int2d(aint, ncol, nrow, mt%name, mem_path_copy)
1859 ! -- create a local copy
1860 else
1861 allocate (aint(ncol, nrow))
1862 end if
1863 do i = 1, nrow
1864 do j = 1, ncol
1865 aint(j, i) = mt%aint2d(j, i)
1866 end do
1867 end do
Here is the call graph for this function:

◆ copyptr_logical1d()

subroutine memorymanagermodule::mem_copyptr::copyptr_logical1d ( logical(lgp), dimension(:), intent(inout), pointer, contiguous alog,
character(len=*), intent(in) name,
character(len=*), intent(in) mem_path,
character(len=*), intent(in), optional mem_path_copy )
Parameters
[in,out]alogreturned copy of 1d logical array
[in]namevariable name
[in]mem_pathpath where variable is stored
[in]mem_path_copyoptional path where the copy will be stored, if passed then the copy is added to the memory manager

Definition at line 1781 of file MemoryManager.f90.

1782 logical(LGP), dimension(:), pointer, contiguous, intent(inout) :: alog !< returned copy of 1d logical array
1783 character(len=*), intent(in) :: name !< variable name
1784 character(len=*), intent(in) :: mem_path !< path where variable is stored
1785 character(len=*), intent(in), optional :: mem_path_copy !< optional path where the copy will be stored,
1786 !! if passed then the copy is added to the
1787 !! memory manager
1788 ! -- local
1789 type(MemoryType), pointer :: mt
1790 logical(LGP) :: found
1791 integer(I4B) :: n
1792 ! -- code
1793 call get_from_memorystore(name, mem_path, mt, found)
1794 alog => null()
1795 ! -- check the copy into the memory manager
1796 if (present(mem_path_copy)) then
1797 call allocate_logical1d(alog, size(mt%alogical1d), mt%name, mem_path_copy)
1798 ! -- create a local copy
1799 else
1800 allocate (alog(size(mt%alogical1d)))
1801 end if
1802 do n = 1, size(mt%alogical1d)
1803 alog(n) = mt%alogical1d(n)
1804 end do
Here is the call graph for this function:

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