My Project
Public Member Functions | List of all members
mod_nctools::nc_make_avar Interface Reference

Public Member Functions

type(ncvar) function, pointer nc_make_avar_scl_chr (NAME, VALUES, DIM1, DIM2)
 
type(ncvar) function, pointer nc_make_avar_vec_chr (NAME, VALUES, DIM1, DIM2, DIM3)
 
type(ncvar) function, pointer nc_make_avar_scl_dbl (NAME, VALUES, DIM1)
 
type(ncvar) function, pointer nc_make_avar_vec_dbl (NAME, VALUES, DIM1, DIM2)
 
type(ncvar) function, pointer nc_make_avar_arr_dbl (NAME, VALUES, DIM1, DIM2, DIM3)
 
type(ncvar) function, pointer nc_make_avar_cub_dbl (NAME, VALUES, DIM1, DIM2, DIM3, DIM4)
 
type(ncvar) function, pointer nc_make_avar_fda_dbl (NAME, VALUES, DIM1, DIM2, DIM3, DIM4, DIM5)
 
type(ncvar) function, pointer nc_make_avar_scl_flt (NAME, VALUES, DIM1)
 
type(ncvar) function, pointer nc_make_avar_vec_flt (NAME, VALUES, DIM1, DIM2)
 
type(ncvar) function, pointer nc_make_avar_arr_flt (NAME, VALUES, DIM1, DIM2, DIM3)
 
type(ncvar) function, pointer nc_make_avar_cub_flt (NAME, VALUES, DIM1, DIM2, DIM3, DIM4)
 
type(ncvar) function, pointer nc_make_avar_fda_flt (NAME, VALUES, DIM1, DIM2, DIM3, DIM4, DIM5)
 
type(ncvar) function, pointer nc_make_avar_scl_int (NAME, VALUES, DIM1)
 
type(ncvar) function, pointer nc_make_avar_vec_int (NAME, VALUES, DIM1, DIM2)
 
type(ncvar) function, pointer nc_make_avar_arr_int (NAME, VALUES, DIM1, DIM2, DIM3)
 
type(ncvar) function, pointer nc_make_avar_cub_int (NAME, VALUES, DIM1, DIM2, DIM3, DIM4)
 
type(ncvar) function, pointer nc_make_avar_fda_int (NAME, VALUES, DIM1, DIM2, DIM3, DIM4, DIM5)
 

Detailed Description

Definition at line 80 of file mod_nctools.f90.

Member Function/Subroutine Documentation

◆ nc_make_avar_arr_dbl()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_arr_dbl ( character(len=*), intent(in)  NAME,
real(dp), dimension(:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), optional, pointer  DIM3 
)

Definition at line 1297 of file mod_nctools.f90.

1297  IMPLICIT NONE
1298  TYPE(NCVAR), POINTER :: VAR
1299  TYPE(NCDIM), POINTER :: DIM1
1300  TYPE(NCDIM), POINTER :: DIM2
1301  TYPE(NCDIM), OPTIONAL, POINTER :: DIM3
1302  character(len=*), intent(in) :: name
1303  REAL(DP), allocatable, target, intent(in) :: values(:,:)
1304  if(dbg_set(dbg_sbr)) &
1305  & write(ipt,*) "START NC_MAKE_AVAR_ARR_DBL"
1306 
1307  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1308  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1309  & "ERROR MAKING VARIABLE: "//trim(name))
1310  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1311  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1312  &"ERROR MAKING VARIABLE: "//trim(name))
1313  if(dim1%UNLIMITED) CALL fatal_error &
1314  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1315  &"ERROR MAKING VARIABLE: "//trim(name))
1316  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1317  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1318  &"ERROR MAKING VARIABLE: "//trim(name))
1319 ! if(DIM2%UNLIMITED) CALL FATAL_ERROR &
1320 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1321 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1322  var => new_var()
1323 
1324  var%VARID = -1
1325  var%VARNAME = trim(name)
1326  var%xtype = nf90_double
1327  var%arr_dbl => values
1328  var => add(var,copy_dim(dim1))
1329  var => add(var,copy_dim(dim2))
1330  if(present(dim3)) then
1331  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1332  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1333  &"ERROR MAKING VARIABLE: "//trim(name))
1334  if(.NOT. dim3%UNLIMITED) CALL fatal_error &
1335  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1336  &"ERROR MAKING VARIABLE: "//trim(name))
1337  var => add(var,copy_dim(dim3))
1338  end if
1339 
1340  if(dbg_set(dbg_sbr)) &
1341  & write(ipt,*) "END NC_MAKE_AVAR_ARR_DBL"

◆ nc_make_avar_arr_flt()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_arr_flt ( character(len=*), intent(in)  NAME,
real(spa), dimension(:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), optional, pointer  DIM3 
)

Definition at line 1539 of file mod_nctools.f90.

1539  IMPLICIT NONE
1540  TYPE(NCVAR), POINTER :: VAR
1541  TYPE(NCDIM), POINTER :: DIM1
1542  TYPE(NCDIM), POINTER :: DIM2
1543  TYPE(NCDIM), OPTIONAL, POINTER :: DIM3
1544  character(len=*), intent(in) :: name
1545  REAL(SPA), allocatable, target, intent(in) :: values(:,:)
1546  if(dbg_set(dbg_sbr)) &
1547  & write(ipt,*) "START NC_MAKE_AVAR_ARR_FLT"
1548 
1549  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1550  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1551  & "ERROR MAKING VARIABLE: "//trim(name))
1552  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1553  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1554  &"ERROR MAKING VARIABLE: "//trim(name))
1555  if(dim1%UNLIMITED) CALL fatal_error &
1556  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1557  &"ERROR MAKING VARIABLE: "//trim(name))
1558  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1559  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1560  &"ERROR MAKING VARIABLE: "//trim(name))
1561 ! if(DIM2%UNLIMITED) CALL FATAL_ERROR &
1562 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1563 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1564  var => new_var()
1565 
1566  var%VARID = -1
1567  var%VARNAME = trim(name)
1568  var%xtype = nf90_float
1569  var%arr_flt => values
1570  var => add(var,copy_dim(dim1))
1571  var => add(var,copy_dim(dim2))
1572  if(present(dim3)) then
1573  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1574  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1575  &"ERROR MAKING VARIABLE: "//trim(name))
1576  if(.NOT. dim3%UNLIMITED) CALL fatal_error &
1577  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1578  &"ERROR MAKING VARIABLE: "//trim(name))
1579  var => add(var,copy_dim(dim3))
1580  end if
1581 
1582  if(dbg_set(dbg_sbr)) &
1583  & write(ipt,*) "END NC_MAKE_AVAR_ARR_FLT"

◆ nc_make_avar_arr_int()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_arr_int ( character(len=*), intent(in)  NAME,
integer, dimension(:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), optional, pointer  DIM3 
)

Definition at line 1781 of file mod_nctools.f90.

1781  IMPLICIT NONE
1782  TYPE(NCVAR), POINTER :: VAR
1783  TYPE(NCDIM), POINTER :: DIM1
1784  TYPE(NCDIM), POINTER :: DIM2
1785  TYPE(NCDIM), OPTIONAL, POINTER :: DIM3
1786  character(len=*), intent(in) :: name
1787  INTEGER, allocatable, target, intent(in) :: values(:,:)
1788  if(dbg_set(dbg_sbr)) &
1789  & write(ipt,*) "START NC_MAKE_AVAR_ARR_INT"
1790 
1791  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1792  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1793  & "ERROR MAKING VARIABLE: "//trim(name))
1794  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1795  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1796  &"ERROR MAKING VARIABLE: "//trim(name))
1797  if(dim1%UNLIMITED) CALL fatal_error &
1798  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1799  &"ERROR MAKING VARIABLE: "//trim(name))
1800  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1801  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1802  &"ERROR MAKING VARIABLE: "//trim(name))
1803 ! if(DIM2%UNLIMITED) CALL FATAL_ERROR &
1804 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1805 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1806  var => new_var()
1807 
1808  var%VARID = -1
1809  var%VARNAME = trim(name)
1810  var%xtype = nf90_int
1811  var%arr_int => values
1812  var => add(var,copy_dim(dim1))
1813  var => add(var,copy_dim(dim2))
1814  if(present(dim3)) then
1815  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1816  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1817  &"ERROR MAKING VARIABLE: "//trim(name))
1818  if(.NOT. dim3%UNLIMITED) CALL fatal_error &
1819  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1820  &"ERROR MAKING VARIABLE: "//trim(name))
1821  var => add(var,copy_dim(dim3))
1822  end if
1823 
1824  if(dbg_set(dbg_sbr)) &
1825  & write(ipt,*) "END NC_MAKE_AVAR_ARR_INT"

◆ nc_make_avar_cub_dbl()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_cub_dbl ( character(len=*), intent(in)  NAME,
real(dp), dimension(:,:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), pointer  DIM3,
type(ncdim), optional, pointer  DIM4 
)

Definition at line 1346 of file mod_nctools.f90.

1346  IMPLICIT NONE
1347  TYPE(NCVAR), POINTER :: VAR
1348  TYPE(NCDIM), POINTER :: DIM1
1349  TYPE(NCDIM), POINTER :: DIM2
1350  TYPE(NCDIM), POINTER :: DIM3
1351  TYPE(NCDIM), OPTIONAL, POINTER :: DIM4
1352  character(len=*), intent(in) :: name
1353  REAL(DP), allocatable, target, intent(in) :: values(:,:,:)
1354  if(dbg_set(dbg_sbr)) &
1355  & write(ipt,*) "START NC_MAKE_AVAR_CUB_DBL"
1356 
1357  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1358  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1359  & "ERROR MAKING VARIABLE: "//trim(name))
1360  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1361  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1362  &"ERROR MAKING VARIABLE: "//trim(name))
1363  if(dim1%UNLIMITED) CALL fatal_error &
1364  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1365  &"ERROR MAKING VARIABLE: "//trim(name))
1366  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1367  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1368  &"ERROR MAKING VARIABLE: "//trim(name))
1369  if(dim2%UNLIMITED) CALL fatal_error &
1370  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1371  &"ERROR MAKING VARIABLE: "//trim(name))
1372  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1373  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1374  &"ERROR MAKING VARIABLE: "//trim(name))
1375 ! if(DIM3%UNLIMITED) CALL FATAL_ERROR &
1376 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1377 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1378  var => new_var()
1379 
1380  var%VARID = -1
1381  var%VARNAME = trim(name)
1382  var%xtype = nf90_double
1383  var%cub_dbl => values
1384  var => add(var,copy_dim(dim1))
1385  var => add(var,copy_dim(dim2))
1386  var => add(var,copy_dim(dim3))
1387  if(present(dim4)) then
1388  if(.NOT. ASSOCIATED(dim4)) CALL fatal_error &
1389  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1390  &"ERROR MAKING VARIABLE: "//trim(name))
1391  if(.NOT. dim4%UNLIMITED) CALL fatal_error &
1392  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1393  &"ERROR MAKING VARIABLE: "//trim(name))
1394  var => add(var,copy_dim(dim4))
1395  end if
1396 
1397  if(dbg_set(dbg_sbr)) &
1398  & write(ipt,*) "END NC_MAKE_AVAR_CUB_DBL"

◆ nc_make_avar_cub_flt()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_cub_flt ( character(len=*), intent(in)  NAME,
real(spa), dimension(:,:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), pointer  DIM3,
type(ncdim), optional, pointer  DIM4 
)

Definition at line 1588 of file mod_nctools.f90.

1588  IMPLICIT NONE
1589  TYPE(NCVAR), POINTER :: VAR
1590  TYPE(NCDIM), POINTER :: DIM1
1591  TYPE(NCDIM), POINTER :: DIM2
1592  TYPE(NCDIM), POINTER :: DIM3
1593  TYPE(NCDIM), OPTIONAL, POINTER :: DIM4
1594  character(len=*), intent(in) :: name
1595  REAL(SPA), allocatable, target, intent(in) :: values(:,:,:)
1596  if(dbg_set(dbg_sbr)) &
1597  & write(ipt,*) "START NC_MAKE_AVAR_CUB_FLT"
1598 
1599  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1600  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1601  & "ERROR MAKING VARIABLE: "//trim(name))
1602  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1603  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1604  &"ERROR MAKING VARIABLE: "//trim(name))
1605  if(dim1%UNLIMITED) CALL fatal_error &
1606  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1607  &"ERROR MAKING VARIABLE: "//trim(name))
1608  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1609  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1610  &"ERROR MAKING VARIABLE: "//trim(name))
1611  if(dim2%UNLIMITED) CALL fatal_error &
1612  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1613  &"ERROR MAKING VARIABLE: "//trim(name))
1614  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1615  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1616  &"ERROR MAKING VARIABLE: "//trim(name))
1617 ! if(DIM3%UNLIMITED) CALL FATAL_ERROR &
1618 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1619 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1620  var => new_var()
1621 
1622  var%VARID = -1
1623  var%VARNAME = trim(name)
1624  var%xtype = nf90_float
1625  var%cub_flt => values
1626  var => add(var,copy_dim(dim1))
1627  var => add(var,copy_dim(dim2))
1628  var => add(var,copy_dim(dim3))
1629  if(present(dim4)) then
1630  if(.NOT. ASSOCIATED(dim4)) CALL fatal_error &
1631  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1632  &"ERROR MAKING VARIABLE: "//trim(name))
1633  if(.NOT. dim4%UNLIMITED) CALL fatal_error &
1634  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1635  &"ERROR MAKING VARIABLE: "//trim(name))
1636  var => add(var,copy_dim(dim4))
1637  end if
1638 
1639  if(dbg_set(dbg_sbr)) &
1640  & write(ipt,*) "END NC_MAKE_AVAR_CUB_FLT"

◆ nc_make_avar_cub_int()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_cub_int ( character(len=*), intent(in)  NAME,
integer, dimension(:,:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), pointer  DIM3,
type(ncdim), optional, pointer  DIM4 
)

Definition at line 1830 of file mod_nctools.f90.

1830  IMPLICIT NONE
1831  TYPE(NCVAR), POINTER :: VAR
1832  TYPE(NCDIM), POINTER :: DIM1
1833  TYPE(NCDIM), POINTER :: DIM2
1834  TYPE(NCDIM), POINTER :: DIM3
1835  TYPE(NCDIM), OPTIONAL, POINTER :: DIM4
1836  character(len=*), intent(in) :: name
1837  INTEGER, allocatable, target, intent(in) :: values(:,:,:)
1838  if(dbg_set(dbg_sbr)) &
1839  & write(ipt,*) "START NC_MAKE_AVAR_CUB_INT"
1840 
1841  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1842  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1843  & "ERROR MAKING VARIABLE: "//trim(name))
1844  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1845  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1846  &"ERROR MAKING VARIABLE: "//trim(name))
1847  if(dim1%UNLIMITED) CALL fatal_error &
1848  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1849  &"ERROR MAKING VARIABLE: "//trim(name))
1850  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1851  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1852  &"ERROR MAKING VARIABLE: "//trim(name))
1853  if(dim2%UNLIMITED) CALL fatal_error &
1854  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1855  &"ERROR MAKING VARIABLE: "//trim(name))
1856  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1857  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1858  &"ERROR MAKING VARIABLE: "//trim(name))
1859 ! if(DIM3%UNLIMITED) CALL FATAL_ERROR &
1860 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1861 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1862  var => new_var()
1863 
1864  var%VARID = -1
1865  var%VARNAME = trim(name)
1866  var%xtype = nf90_int
1867  var%cub_int => values
1868  var => add(var,copy_dim(dim1))
1869  var => add(var,copy_dim(dim2))
1870  var => add(var,copy_dim(dim3))
1871  if(present(dim4)) then
1872  if(.NOT. ASSOCIATED(dim4)) CALL fatal_error &
1873  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1874  &"ERROR MAKING VARIABLE: "//trim(name))
1875  if(.NOT. dim4%UNLIMITED) CALL fatal_error &
1876  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1877  &"ERROR MAKING VARIABLE: "//trim(name))
1878  var => add(var,copy_dim(dim4))
1879  end if
1880 
1881  if(dbg_set(dbg_sbr)) &
1882  & write(ipt,*) "END NC_MAKE_AVAR_CUB_INT"

◆ nc_make_avar_fda_dbl()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_fda_dbl ( character(len=*), intent(in)  NAME,
real(dp), dimension(:,:,:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), pointer  DIM3,
type(ncdim), pointer  DIM4,
type(ncdim), optional, pointer  DIM5 
)

Definition at line 1403 of file mod_nctools.f90.

1403  IMPLICIT NONE
1404  TYPE(NCVAR), POINTER :: VAR
1405  TYPE(NCDIM), POINTER :: DIM1
1406  TYPE(NCDIM), POINTER :: DIM2
1407  TYPE(NCDIM), POINTER :: DIM3
1408  TYPE(NCDIM), POINTER :: DIM4
1409  TYPE(NCDIM), OPTIONAL, POINTER :: DIM5
1410  character(len=*), intent(in) :: name
1411  REAL(DP), allocatable, target, intent(in) :: values(:,:,:,:)
1412  if(dbg_set(dbg_sbr)) &
1413  & write(ipt,*) "START NC_MAKE_AVAR_FDA_DBL"
1414 
1415  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1416  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1417  & "ERROR MAKING VARIABLE: "//trim(name))
1418  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1419  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1420  &"ERROR MAKING VARIABLE: "//trim(name))
1421  if(dim1%UNLIMITED) CALL fatal_error &
1422  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1423  &"ERROR MAKING VARIABLE: "//trim(name))
1424  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1425  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1426  &"ERROR MAKING VARIABLE: "//trim(name))
1427  if(dim2%UNLIMITED) CALL fatal_error &
1428  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1429  &"ERROR MAKING VARIABLE: "//trim(name))
1430  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1431  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1432  &"ERROR MAKING VARIABLE: "//trim(name))
1433  if(dim3%UNLIMITED) CALL fatal_error &
1434  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1435  &"ERROR MAKING VARIABLE: "//trim(name))
1436  if(.NOT. ASSOCIATED(dim4)) CALL fatal_error &
1437  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1438  &"ERROR MAKING VARIABLE: "//trim(name))
1439 ! if(DIM4%UNLIMITED) CALL FATAL_ERROR &
1440 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1441 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1442  var => new_var()
1443 
1444  var%VARID = -1
1445  var%VARNAME = trim(name)
1446  var%xtype = nf90_double
1447  var%fda_dbl => values
1448  var => add(var,copy_dim(dim1))
1449  var => add(var,copy_dim(dim2))
1450  var => add(var,copy_dim(dim3))
1451  var => add(var,copy_dim(dim4))
1452  if(present(dim5)) then
1453  if(.NOT. ASSOCIATED(dim5)) CALL fatal_error &
1454  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1455  &"ERROR MAKING VARIABLE: "//trim(name))
1456  if(.NOT. dim5%UNLIMITED) CALL fatal_error &
1457  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1458  &"ERROR MAKING VARIABLE: "//trim(name))
1459  var => add(var,copy_dim(dim5))
1460  end if
1461 
1462  if(dbg_set(dbg_sbr)) &
1463  & write(ipt,*) "END NC_MAKE_AVAR_FDA_DBL"

◆ nc_make_avar_fda_flt()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_fda_flt ( character(len=*), intent(in)  NAME,
real(spa), dimension(:,:,:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), pointer  DIM3,
type(ncdim), pointer  DIM4,
type(ncdim), optional, pointer  DIM5 
)

Definition at line 1645 of file mod_nctools.f90.

1645  IMPLICIT NONE
1646  TYPE(NCVAR), POINTER :: VAR
1647  TYPE(NCDIM), POINTER :: DIM1
1648  TYPE(NCDIM), POINTER :: DIM2
1649  TYPE(NCDIM), POINTER :: DIM3
1650  TYPE(NCDIM), POINTER :: DIM4
1651  TYPE(NCDIM), OPTIONAL, POINTER :: DIM5
1652  character(len=*), intent(in) :: name
1653  REAL(SPA), allocatable, target, intent(in) :: values(:,:,:,:)
1654  if(dbg_set(dbg_sbr)) &
1655  & write(ipt,*) "START NC_MAKE_AVAR_FDA_FLT"
1656 
1657  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1658  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1659  & "ERROR MAKING VARIABLE: "//trim(name))
1660  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1661  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1662  &"ERROR MAKING VARIABLE: "//trim(name))
1663  if(dim1%UNLIMITED) CALL fatal_error &
1664  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1665  &"ERROR MAKING VARIABLE: "//trim(name))
1666  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1667  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1668  &"ERROR MAKING VARIABLE: "//trim(name))
1669  if(dim2%UNLIMITED) CALL fatal_error &
1670  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1671  &"ERROR MAKING VARIABLE: "//trim(name))
1672  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1673  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1674  &"ERROR MAKING VARIABLE: "//trim(name))
1675  if(dim3%UNLIMITED) CALL fatal_error &
1676  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1677  &"ERROR MAKING VARIABLE: "//trim(name))
1678  if(.NOT. ASSOCIATED(dim4)) CALL fatal_error &
1679  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1680  &"ERROR MAKING VARIABLE: "//trim(name))
1681 ! if(DIM4%UNLIMITED) CALL FATAL_ERROR &
1682 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1683 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1684  var => new_var()
1685 
1686  var%VARID = -1
1687  var%VARNAME = trim(name)
1688  var%xtype = nf90_float
1689  var%fda_flt => values
1690  var => add(var,copy_dim(dim1))
1691  var => add(var,copy_dim(dim2))
1692  var => add(var,copy_dim(dim3))
1693  var => add(var,copy_dim(dim4))
1694  if(present(dim5)) then
1695  if(.NOT. ASSOCIATED(dim5)) CALL fatal_error &
1696  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1697  &"ERROR MAKING VARIABLE: "//trim(name))
1698  if(.NOT. dim5%UNLIMITED) CALL fatal_error &
1699  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1700  &"ERROR MAKING VARIABLE: "//trim(name))
1701  var => add(var,copy_dim(dim5))
1702  end if
1703 
1704  if(dbg_set(dbg_sbr)) &
1705  & write(ipt,*) "END NC_MAKE_AVAR_FDA_FLT"

◆ nc_make_avar_fda_int()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_fda_int ( character(len=*), intent(in)  NAME,
integer, dimension(:,:,:,:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), pointer  DIM3,
type(ncdim), pointer  DIM4,
type(ncdim), optional, pointer  DIM5 
)

Definition at line 1887 of file mod_nctools.f90.

1887  IMPLICIT NONE
1888  TYPE(NCVAR), POINTER :: VAR
1889  TYPE(NCDIM), POINTER :: DIM1
1890  TYPE(NCDIM), POINTER :: DIM2
1891  TYPE(NCDIM), POINTER :: DIM3
1892  TYPE(NCDIM), POINTER :: DIM4
1893  TYPE(NCDIM), OPTIONAL, POINTER :: DIM5
1894  character(len=*), intent(in) :: name
1895  INTEGER, allocatable, target, intent(in) :: values(:,:,:,:)
1896  if(dbg_set(dbg_sbr)) &
1897  & write(ipt,*) "START NC_MAKE_AVAR_FDA_INT"
1898 
1899  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1900  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1901  & "ERROR MAKING VARIABLE: "//trim(name))
1902  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1903  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1904  &"ERROR MAKING VARIABLE: "//trim(name))
1905  if(dim1%UNLIMITED) CALL fatal_error &
1906  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1907  &"ERROR MAKING VARIABLE: "//trim(name))
1908  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1909  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1910  &"ERROR MAKING VARIABLE: "//trim(name))
1911  if(dim2%UNLIMITED) CALL fatal_error &
1912  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1913  &"ERROR MAKING VARIABLE: "//trim(name))
1914  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1915  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1916  &"ERROR MAKING VARIABLE: "//trim(name))
1917  if(dim3%UNLIMITED) CALL fatal_error &
1918  & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1919  &"ERROR MAKING VARIABLE: "//trim(name))
1920  if(.NOT. ASSOCIATED(dim4)) CALL fatal_error &
1921  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1922  &"ERROR MAKING VARIABLE: "//trim(name))
1923 ! if(DIM4%UNLIMITED) CALL FATAL_ERROR &
1924 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1925 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1926  var => new_var()
1927 
1928  var%VARID = -1
1929  var%VARNAME = trim(name)
1930  var%xtype = nf90_int
1931  var%fda_int => values
1932  var => add(var,copy_dim(dim1))
1933  var => add(var,copy_dim(dim2))
1934  var => add(var,copy_dim(dim3))
1935  var => add(var,copy_dim(dim4))
1936  if(present(dim5)) then
1937  if(.NOT. ASSOCIATED(dim5)) CALL fatal_error &
1938  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1939  &"ERROR MAKING VARIABLE: "//trim(name))
1940  if(.NOT. dim5%UNLIMITED) CALL fatal_error &
1941  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1942  &"ERROR MAKING VARIABLE: "//trim(name))
1943  var => add(var,copy_dim(dim5))
1944  end if
1945 
1946  if(dbg_set(dbg_sbr)) &
1947  & write(ipt,*) "END NC_MAKE_AVAR_FDA_INT"

◆ nc_make_avar_scl_chr()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_scl_chr ( character(len=*), intent(in)  NAME,
character(len=80), intent(in), target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), optional, pointer  DIM2 
)

Definition at line 1121 of file mod_nctools.f90.

1121  IMPLICIT NONE
1122  TYPE(NCVAR), POINTER :: VAR
1123  TYPE(NCDIM), POINTER :: DIM1 ! MUST BE STR LENGTH
1124  TYPE(NCDIM), OPTIONAL, POINTER :: DIM2 ! IF PRESENT THIS MUST BE UNLIMITED
1125  character(len=*), intent(in) :: name
1126  character(len=80), target, intent(in) :: values
1127  if(dbg_set(dbg_sbr)) &
1128  & write(ipt,*) "START NC_MAKE_AVAR_SCL_CHR"
1129 
1130  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1131  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1132  &"ERROR MAKING VARIABLE: "//trim(name))
1133 
1134 
1135  if(dim1%UNLIMITED) CALL fatal_error &
1136  & ("NC_MAKE_AVAR: WHEN MAKING CHARACTER DATA, THE FIRST DIMENSION",&
1137  & "MUST BE THE STING LENGTH. THE LAST DIMENSION (IF PRESENT) MUST BE UNLIMITED",&
1138  &"VARIABLE NAME: "//trim(name))
1139 
1140  var => new_var()
1141 
1142  var%VARID = -1
1143  var%VARNAME = trim(name)
1144  var%xtype = nf90_char
1145  var%scl_chr => values
1146  var => add(var,copy_dim(dim1))
1147  IF(present(dim2)) THEN
1148  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1149  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1150  &"ERROR MAKING VARIABLE: "//trim(name))
1151 
1152  IF(.NOT. dim2%UNLIMITED) CALL fatal_error &
1153  & ("NC_MAKE_AVAR: WHEN MAKING CHARACTER DATA, THE LAST DIMENSION",&
1154  & "MUST BE THE UNLIMITED DIMENSION",&
1155  & "VARIABLE NAME: "//trim(name))
1156 
1157  var => add(var,copy_dim(dim2))
1158  END IF
1159 
1160  if(dbg_set(dbg_sbr)) &
1161  & write(ipt,*) "END NC_MAKE_AVAR_SCL_CHR"

◆ nc_make_avar_scl_dbl()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_scl_dbl ( character(len=*), intent(in)  NAME,
real(dp), intent(in), target  VALUES,
type(ncdim), optional, pointer  DIM1 
)

Definition at line 1226 of file mod_nctools.f90.

1226  IMPLICIT NONE
1227  TYPE(NCVAR), POINTER :: VAR
1228  TYPE(NCDIM), OPTIONAL, POINTER :: DIM1
1229  character(len=*), intent(in) :: name
1230  REAL(DP), target, intent(in) :: values
1231  if(dbg_set(dbg_sbr)) &
1232  & write(ipt,*) "START NC_MAKE_AVAR_SCL_DBL"
1233 
1234  var => new_var()
1235 
1236  var%VARID = -1
1237  var%VARNAME = trim(name)
1238  var%xtype = nf90_double
1239  var%scl_dbl => values
1240  IF(present(dim1)) THEN
1241  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1242  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1243  &"ERROR MAKING VARIABLE: "//trim(name))
1244  if(.NOT. dim1%UNLIMITED) CALL fatal_error &
1245  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1246  &"ERROR MAKING VARIABLE: "//trim(name))
1247  var => add(var,copy_dim(dim1))
1248  END IF
1249 
1250  if(dbg_set(dbg_sbr)) &
1251  & write(ipt,*) "END NC_MAKE_AVAR_SCL_DBL"

◆ nc_make_avar_scl_flt()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_scl_flt ( character(len=*), intent(in)  NAME,
real(spa), intent(in), target  VALUES,
type(ncdim), optional, pointer  DIM1 
)

Definition at line 1468 of file mod_nctools.f90.

1468  IMPLICIT NONE
1469  TYPE(NCVAR), POINTER :: VAR
1470  TYPE(NCDIM), OPTIONAL, POINTER :: DIM1
1471  character(len=*), intent(in) :: name
1472  REAL(SPA), target, intent(in) :: values
1473  if(dbg_set(dbg_sbr)) &
1474  & write(ipt,*) "START NC_MAKE_AVAR_SCL_FLT"
1475 
1476  var => new_var()
1477 
1478  var%VARID = -1
1479  var%VARNAME = trim(name)
1480  var%xtype = nf90_float
1481  var%scl_flt => values
1482  IF(present(dim1)) THEN
1483  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1484  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1485  &"ERROR MAKING VARIABLE: "//trim(name))
1486  if(.NOT. dim1%UNLIMITED) CALL fatal_error &
1487  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1488  &"ERROR MAKING VARIABLE: "//trim(name))
1489  var => add(var,copy_dim(dim1))
1490  END IF
1491 
1492  if(dbg_set(dbg_sbr)) &
1493  & write(ipt,*) "END NC_MAKE_AVAR_SCL_FLT"

◆ nc_make_avar_scl_int()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_scl_int ( character(len=*), intent(in)  NAME,
integer, intent(in), target  VALUES,
type(ncdim), optional, pointer  DIM1 
)

Definition at line 1710 of file mod_nctools.f90.

1710  IMPLICIT NONE
1711  TYPE(NCVAR), POINTER :: VAR
1712  TYPE(NCDIM), OPTIONAL, POINTER :: DIM1
1713  character(len=*), intent(in) :: name
1714  INTEGER, target, intent(in) :: values
1715  if(dbg_set(dbg_sbr)) &
1716  & write(ipt,*) "START NC_MAKE_AVAR_SCL_INT"
1717 
1718  var => new_var()
1719 
1720  var%VARID = -1
1721  var%VARNAME = trim(name)
1722  var%xtype = nf90_int
1723  var%scl_int => values
1724  IF(present(dim1)) THEN
1725  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1726  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1727  &"ERROR MAKING VARIABLE: "//trim(name))
1728  if(.NOT. dim1%UNLIMITED) CALL fatal_error &
1729  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1730  &"ERROR MAKING VARIABLE: "//trim(name))
1731  var => add(var,copy_dim(dim1))
1732  END IF
1733 
1734  if(dbg_set(dbg_sbr)) &
1735  & write(ipt,*) "END NC_MAKE_AVAR_SCL_INT"

◆ nc_make_avar_vec_chr()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_vec_chr ( character(len=*), intent(in)  NAME,
character(len=80), dimension(:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), pointer  DIM2,
type(ncdim), optional, pointer  DIM3 
)

Definition at line 1166 of file mod_nctools.f90.

1166  IMPLICIT NONE
1167  TYPE(NCVAR), POINTER :: VAR
1168  TYPE(NCDIM), POINTER :: DIM1 ! MUST BE STR LENGTH
1169  TYPE(NCDIM), POINTER :: DIM2 ! Number of strings
1170  TYPE(NCDIM), OPTIONAL, POINTER :: DIM3 ! IF PRESENT THIS MUST BE UNLIMITED
1171  character(len=*), intent(in) :: name
1172  character(len=80), target,allocatable, intent(in) :: values(:)
1173  if(dbg_set(dbg_sbr)) &
1174  & write(ipt,*) "START NC_MAKE_AVAR_VEC_CHR"
1175 
1176  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1177  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1178  & "ERROR MAKING VARIABLE: "//trim(name))
1179 
1180  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1181  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1182  &"ERROR MAKING VARIABLE: "//trim(name))
1183 
1184  if(dim1%UNLIMITED) CALL fatal_error &
1185  & ("NC_MAKE_AVAR: WHEN MAKING CHARACTER DATA, THE FIRST DIMENSION",&
1186  & "MUST BE THE STRING LENGTH. THE LAST DIMENSION (IF PRESENT) MUST BE UNLIMITED",&
1187  &"VARIABLE NAME: "//trim(name))
1188 
1189 
1190  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1191  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1192  &"ERROR MAKING VARIABLE: "//trim(name))
1193 
1194 ! if(DIM2%UNLIMITED) CALL FATAL_ERROR &
1195 ! & ("NC_MAKE_AVAR: WHEN MAKING CHARACTER DATA, THE FIRST DIMENSION",&
1196 ! & "MUST BE THE STRING LENGTH. THE LAST DIMENSION (IF PRESENT) MUST BE UNLIMITED",&
1197 ! &"VARIABLE NAME: "//TRIM(NAME))
1198 
1199  var => new_var()
1200 
1201  var%VARID = -1
1202  var%VARNAME = trim(name)
1203  var%xtype = nf90_char
1204  var%vec_chr => values
1205  var => add(var,copy_dim(dim1))
1206  var => add(var,copy_dim(dim2))
1207  IF(present(dim3)) THEN
1208  if(.NOT. ASSOCIATED(dim3)) CALL fatal_error &
1209  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1210  &"ERROR MAKING VARIABLE: "//trim(name))
1211 
1212  IF(.NOT. dim3%UNLIMITED) CALL fatal_error &
1213  & ("NC_MAKE_AVAR: WHEN MAKING CHARACTER DATA, THE LAST DIMENSION",&
1214  & "MUST BE THE UNLIMITED DIMENSION",&
1215  & "VARIABLE NAME: "//trim(name))
1216 
1217  var => add(var,copy_dim(dim3))
1218  END IF
1219 
1220  if(dbg_set(dbg_sbr)) &
1221  & write(ipt,*) "END NC_MAKE_AVAR_VEC_CHR"

◆ nc_make_avar_vec_dbl()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_vec_dbl ( character(len=*), intent(in)  NAME,
real(dp), dimension(:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), optional, pointer  DIM2 
)

Definition at line 1256 of file mod_nctools.f90.

1256  IMPLICIT NONE
1257  TYPE(NCVAR), POINTER :: VAR
1258  TYPE(NCDIM), POINTER :: DIM1
1259  TYPE(NCDIM), OPTIONAL, POINTER :: DIM2
1260  character(len=*), intent(in) :: name
1261  REAL(DP), allocatable, target, intent(in) :: values(:)
1262  if(dbg_set(dbg_sbr)) &
1263  & write(ipt,*) "START NC_MAKE_AVAR_VEC_DBL"
1264 
1265  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1266  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1267  & "ERROR MAKING VARIABLE: "//trim(name))
1268  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1269  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1270  &"ERROR MAKING VARIABLE: "//trim(name))
1271 ! if(DIM1%UNLIMITED) CALL FATAL_ERROR &
1272 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1273 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1274  var => new_var()
1275 
1276  var%VARID = -1
1277  var%VARNAME = trim(name)
1278  var%xtype = nf90_double
1279  var%vec_dbl => values
1280  var => add(var,copy_dim(dim1))
1281  if(present(dim2)) then
1282  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1283  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1284  &"ERROR MAKING VARIABLE: "//trim(name))
1285  if(.NOT. dim2%UNLIMITED) CALL fatal_error &
1286  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1287  &"ERROR MAKING VARIABLE: "//trim(name))
1288  var => add(var,copy_dim(dim2))
1289  end if
1290 
1291  if(dbg_set(dbg_sbr)) &
1292  & write(ipt,*) "END NC_MAKE_AVAR_VEC_DBL"

◆ nc_make_avar_vec_flt()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_vec_flt ( character(len=*), intent(in)  NAME,
real(spa), dimension(:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), optional, pointer  DIM2 
)

Definition at line 1498 of file mod_nctools.f90.

1498  IMPLICIT NONE
1499  TYPE(NCVAR), POINTER :: VAR
1500  TYPE(NCDIM), POINTER :: DIM1
1501  TYPE(NCDIM), OPTIONAL, POINTER :: DIM2
1502  character(len=*), intent(in) :: name
1503  REAL(SPA), allocatable, target, intent(in) :: values(:)
1504  if(dbg_set(dbg_sbr)) &
1505  & write(ipt,*) "START NC_MAKE_AVAR_VEC_FLT"
1506 
1507  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1508  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1509  & "ERROR MAKING VARIABLE: "//trim(name))
1510  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1511  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1512  &"ERROR MAKING VARIABLE: "//trim(name))
1513 ! if(DIM1%UNLIMITED) CALL FATAL_ERROR &
1514 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1515 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1516  var => new_var()
1517 
1518  var%VARID = -1
1519  var%VARNAME = trim(name)
1520  var%xtype = nf90_float
1521  var%vec_flt => values(1:)
1522  var => add(var,copy_dim(dim1))
1523  if(present(dim2)) then
1524  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1525  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1526  &"ERROR MAKING VARIABLE: "//trim(name))
1527  if(.NOT. dim2%UNLIMITED) CALL fatal_error &
1528  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1529  &"ERROR MAKING VARIABLE: "//trim(name))
1530  var => add(var,copy_dim(dim2))
1531  end if
1532 
1533  if(dbg_set(dbg_sbr)) &
1534  & write(ipt,*) "END NC_MAKE_AVAR_VEC_FLT"

◆ nc_make_avar_vec_int()

type(ncvar) function, pointer mod_nctools::nc_make_avar::nc_make_avar_vec_int ( character(len=*), intent(in)  NAME,
integer, dimension(:), intent(in), allocatable, target  VALUES,
type(ncdim), pointer  DIM1,
type(ncdim), optional, pointer  DIM2 
)

Definition at line 1740 of file mod_nctools.f90.

1740  IMPLICIT NONE
1741  TYPE(NCVAR), POINTER :: VAR
1742  TYPE(NCDIM), POINTER :: DIM1
1743  TYPE(NCDIM), OPTIONAL, POINTER :: DIM2
1744  character(len=*), intent(in) :: name
1745  INTEGER, allocatable, target, intent(in) :: values(:)
1746  if(dbg_set(dbg_sbr)) &
1747  & write(ipt,*) "START NC_MAKE_AVAR_VEC_INT"
1748 
1749  IF(.NOT. ALLOCATED(values)) CALL fatal_error &
1750  & ("NC_MAKE_AVAR: VALUES ARGUMENT MUST ALREADY BE ALLOCATED!",&
1751  & "ERROR MAKING VARIABLE: "//trim(name))
1752  if(.NOT. ASSOCIATED(dim1)) CALL fatal_error &
1753  & ("NC_MAKE_AVAR: THE DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1754  &"ERROR MAKING VARIABLE: "//trim(name))
1755 ! if(DIM1%UNLIMITED) CALL FATAL_ERROR &
1756 ! & ("NC_MAKE_AVAR: NON-OPTIONAL DIMENSION ARGUMENT MUST BE NOT BE UNLIMITED (TIME)",&
1757 ! &"ERROR MAKING VARIABLE: "//TRIM(NAME))
1758  var => new_var()
1759 
1760  var%VARID = -1
1761  var%VARNAME = trim(name)
1762  var%xtype = nf90_int
1763  var%vec_int => values
1764  var => add(var,copy_dim(dim1))
1765  if(present(dim2)) then
1766  if(.NOT. ASSOCIATED(dim2)) CALL fatal_error &
1767  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE ASSOCIATED",&
1768  &"ERROR MAKING VARIABLE: "//trim(name))
1769  if(.NOT. dim2%UNLIMITED) CALL fatal_error &
1770  & ("NC_MAKE_AVAR: OPTIONAL DIMENSION ARGUMENT MUST BE UNLIMITED (TIME)",&
1771  &"ERROR MAKING VARIABLE: "//trim(name))
1772  var => add(var,copy_dim(dim2))
1773  end if
1774 
1775  if(dbg_set(dbg_sbr)) &
1776  & write(ipt,*) "END NC_MAKE_AVAR_VEC_INT"
The documentation for this interface was generated from the following file:
Generated by   doxygen 1.8.15