My Project
Data Types | Functions/Subroutines | Variables
mod_ncll Module Reference

Data Types

interface  add
 
interface  assignment(=)
 
interface  count_att_list
 
interface  count_dim_list
 
interface  count_nonsingleton_dim_list
 
interface  delete_att_link
 
interface  delete_att_list
 
interface  delete_dim_link
 
interface  delete_dim_list
 
interface  delete_file_link
 
interface  delete_var_link
 
interface  find_att
 
interface  find_dim
 
interface  find_file
 
interface  find_unlimited
 
interface  find_var
 
interface  has_unlimited
 
interface  insert_att_link
 
interface  insert_dim_link
 
interface  insert_file_link
 
interface  insert_var_link
 
type  ncatt
 
type  ncattp
 
type  ncdim
 
type  ncdimp
 
type  ncfile
 
type  ncfilelist
 
type  ncfilep
 
type  ncftime
 
type  ncvar
 
type  ncvarp
 
interface  print_att_list
 
interface  print_dim_list
 

Functions/Subroutines

type(ncfile) function, pointer new_file (fname)
 
type(ncfile) function, pointer copy_file (NCFIN)
 
type(ncftime) function, pointer new_ftime ()
 
subroutine copy_ftime (FTIME_OUT, FTIME_IN)
 
type(ncfilep) function, pointer new_filep ()
 
type(ncfilelist) function, pointer new_filehead ()
 
subroutine kill_filehead (FILEHEAD)
 
subroutine delete_filep_byname (LIST, NAME, FOUND)
 
subroutine delete_filep_byncid (LIST, NCID, FOUND)
 
subroutine delete_file_list (LIST)
 
subroutine kill_file (NCF)
 
subroutine insert_filep_byncf (LIST, NCF, FOUND)
 
type(ncfile) function, pointer find_file_byname (LIST, NAME, FOUND)
 
type(ncfile) function, pointer find_file_byncid (LIST, NCID, FOUND)
 
integer function count_file_list (LIST)
 
subroutine print_file_list (LIST)
 
subroutine print_file (NCF)
 
subroutine print_ftime (FTIME)
 
type(ncvar) function, pointer new_var ()
 
type(ncvarp) function, pointer new_varp ()
 
type(ncvar) function, pointer copy_var (VARIN)
 
type(ncvar) function, pointer reference_var (VARIN)
 
subroutine delete_varp_byname (LIST, NAME, FOUND)
 
subroutine delete_varp_byvarid (LIST, VARID, FOUND)
 
subroutine delete_var_list (LIST)
 
subroutine kill_var (VAR)
 
subroutine insert_varp_byvar (LIST, VAR, FOUND)
 
type(ncvar) function, pointer find_var_byname (LIST, NAME, FOUND)
 
type(ncvar) function, pointer find_var_byvarid (LIST, VARID, FOUND)
 
integer function count_var_list (LIST)
 
integer function count_unlimited_vars (LIST)
 
subroutine print_var_list (LIST)
 
subroutine print_var (VAR)
 
type(ncatt) function, pointer new_att ()
 
type(ncattp) function, pointer new_attp ()
 
type(ncatt) function, pointer copy_att (ATTIN)
 
subroutine copy_att_list (ATTPOUT, ATTPIN)
 
subroutine delete_ncf_attp_byname (LIST, NAME, FOUND)
 
subroutine delete_ncf_attp_byattid (LIST, ATTID, FOUND)
 
subroutine delete_ncf_attp_list (LIST)
 
subroutine delete_var_attp_byname (LIST, NAME, FOUND)
 
subroutine delete_var_attp_byattid (LIST, ATTID, FOUND)
 
subroutine delete_var_attp_list (LIST)
 
subroutine kill_att (ATT)
 
subroutine insert_ncf_attp_byatt (LIST, ATT, FOUND)
 
subroutine insert_var_attp_byatt (LIST, ATT, FOUND)
 
type(ncatt) function, pointer find_ncf_att_byname (LIST, NAME, FOUND)
 
type(ncatt) function, pointer find_ncf_att_byattid (LIST, ATTID, FOUND)
 
type(ncatt) function, pointer find_var_att_byname (LIST, NAME, FOUND)
 
type(ncatt) function, pointer find_var_att_byattid (LIST, ATTID, FOUND)
 
integer function count_ncf_att_list (LIST)
 
integer function count_var_att_list (LIST)
 
subroutine print_ncf_att_list (LIST)
 
subroutine print_var_att_list (LIST)
 
subroutine print_att (ATT)
 
type(ncdim) function, pointer new_dim ()
 
subroutine copy_dim_list (DIMPOUT, DIMPIN)
 
type(ncdim) function, pointer copy_dim (DIMIN)
 
type(ncdimp) function, pointer new_dimp ()
 
subroutine delete_ncf_dimp_byname (LIST, NAME, FOUND)
 
subroutine delete_ncf_dimp_bydimid (LIST, DIMID, FOUND)
 
subroutine delete_ncf_dimp_list (LIST)
 
subroutine delete_var_dimp_byname (LIST, NAME, FOUND)
 
subroutine delete_var_dimp_bydimid (LIST, DIMID, FOUND)
 
subroutine delete_var_dimp_list (LIST)
 
subroutine kill_dim (DIM)
 
subroutine insert_ncf_dimp_bydim (LIST, DIM, FOUND)
 
subroutine insert_var_dimp_bydim (LIST, DIM, FOUND)
 
type(ncdim) function, pointer find_ncf_dim_byname (LIST, NAME, FOUND)
 
type(ncdim) function, pointer find_ncf_dim_bydimid (LIST, DIMID, FOUND)
 
type(ncdim) function, pointer find_ncf_dim_unlimited (LIST, FOUND)
 
logical function has_unlimited_ncf (LIST)
 
type(ncdim) function, pointer find_var_dim_byname (LIST, NAME, FOUND)
 
type(ncdim) function, pointer find_var_dim_bydimid (LIST, DIMID, FOUND)
 
type(ncdim) function, pointer find_var_dim_unlimited (LIST, FOUND)
 
logical function has_unlimited_var (LIST)
 
integer function, dimension(:), pointer var_dimids (LIST)
 
integer function, dimension(:), pointer var_dims (LIST)
 
integer function, dimension(:), pointer mem_dims (LIST)
 
integer function count_ncf_ns_dim_list (LIST)
 
integer function count_var_ns_dim_list (LIST)
 
subroutine alloc_var (VAR, MYDIMS)
 
subroutine allocate_associated_vars (LIST)
 
integer function count_ncf_dim_list (LIST)
 
integer function count_var_dim_list (LIST)
 
subroutine print_ncf_dim_list (LIST)
 
subroutine print_var_dim_list (LIST)
 
subroutine print_dim (DIM)
 
type(ncvar) function, pointer var_plus_dim (VAR, DIM)
 
type(ncvar) function, pointer var_plus_att (VAR, ATT)
 
type(ncfile) function, pointer ncf_plus_var (NCF, VAR)
 
type(ncfile) function, pointer ncf_plus_att (NCF, ATT)
 
type(ncfile) function, pointer ncf_plus_dim (NCF, DIM)
 
type(ncfile) function, pointer ncf_plus_ncf (NCF1, NCF2)
 
type(ncfilelist) function, pointer ncflist_plus_ncf (NCFLIST, NCF)
 

Variables

integer, parameter tmtype_unknown = 0
 
integer, parameter tmtype_char_date = 1
 
integer, parameter tmtype_int2_mjd = 2
 
integer, parameter tmtype_float_days = 3
 
integer, parameter tmtype_float_seconds = 4
 
integer, parameter char_max_attlen = 160
 

Function/Subroutine Documentation

◆ alloc_var()

subroutine mod_ncll::alloc_var ( type(ncvar), intent(inout), pointer  VAR,
integer, intent(out), optional  MYDIMS 
)

Definition at line 3095 of file mod_ncll.f90.

3095  IMPLICIT NONE
3096  TYPE(NCVAR),INTENT(INOUT), POINTER :: VAR
3097  INTEGER,OPTIONAL,INTENT(OUT) :: MYDIMS
3098  TYPE(NCDIM), POINTER :: DIM
3099  TYPE(NCVAR), POINTER :: VAR_TMP
3100 
3101  INTEGER :: Ndims
3102  INTEGER, POINTER :: DIMS(:)
3103  LOGICAL :: FOUND
3104  INTEGER :: STATUS
3105 
3106  NULLIFY(dim,dims)
3107 
3108  IF(dbg_set(dbg_sbr)) WRITE(ipt,*) "START: ALLOC_VAR"
3109 
3110  IF(.not. ASSOCIATED(var))CALL fatal_error&
3111  & ("ALLOC_VAR: Unassociated Var!")
3112 
3113  ! GET RID OF TIME AND SINGLETON DIMENSIONS WHEN ALLOCATING SPACE
3114  var_tmp => copy_var(var)
3115 
3116  dim => find_unlimited(var_tmp,found)
3117  IF (found) THEN
3118  CALL delete_dim_link(var_tmp,dim%DIMID,found)
3119  END IF
3120 
3121  dims => mem_dims(var_tmp)
3122 
3123  IF(.not. Associated(dims)) CALL fatal_error("ALLOC_VAR: Could not allocate Dims?")
3124  ndims=size(dims)
3125  IF(PRESENT(mydims)) mydims = ndims
3126 
3127  CALL kill_var(var_tmp)
3128 
3129 
3130  IF(dbg_set(dbg_sbrio)) WRITE(ipt,*) "ALLOCATING SPACE FOR:"
3131 
3132  select case(var%XTYPE)
3133  case(nf90_char)
3134  IF(dbg_set(dbg_sbrio)) THEN
3135  WRITE(ipt,*) "XYTPE :: CHAR"
3136  WRITE(ipt,*) "DIMS ::",dims
3137  END IF
3138 
3139  SELECT CASE(ndims)
3140  CASE(2)
3141  ALLOCATE(var%VEC_CHR(dims(2)),stat=status)
3142  if(status /= 0) CALL fatal_error("VAR_DIMS: Can not allocate VEC_CHR")
3143  var%VEC_CHR=""
3144  CASE(1)
3145  ALLOCATE(var%SCL_CHR,stat=status)
3146  if(status /= 0) CALL fatal_error("VAR_DIMS: Can not allocate SCL_CHR")
3147  var%SCL_CHR=""
3148  CASE(0)
3149  CALL fatal_error("Unsupported Character data dimension: 0")
3150  CASE DEFAULT
3151  CALL fatal_error("Unsupported Character data dimension")
3152  END SELECT
3153 
3154  case(nf90_byte)
3155  WRITE(ipt,*) "XYTPE :: BYTE"
3156  CALL fatal_error("No Byte Type Available")
3157 
3158  case(nf90_short)
3159  WRITE(ipt,*) "XYTPE :: SHORT"
3160  CALL fatal_error("No Short Type Available")
3161 
3162  case(nf90_int)
3163  IF(dbg_set(dbg_sbrio)) THEN
3164  WRITE(ipt,*) "XYTPE :: INT"
3165  WRITE(ipt,*) "dims ::",dims
3166  END IF
3167 
3168 
3169  SELECT CASE(ndims)
3170  CASE(4)
3171  ALLOCATE(var%FDA_INT(0:dims(1),dims(2),dims(3),dims(4)),stat=status)
3172  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_FDA")
3173  var%FDA_INT=0
3174  CASE(3)
3175  ALLOCATE(var%CUB_INT(0:dims(1),dims(2),dims(3)),stat=status)
3176  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_CUB")
3177  var%CUB_INT=0
3178  CASE(2)
3179  ALLOCATE(var%ARR_INT(0:dims(1),dims(2)),stat=status)
3180  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_ARR")
3181  var%ARR_INT=0
3182  CASE(1)
3183  ALLOCATE(var%VEC_INT(0:dims(1)),stat=status)
3184  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_VEC")
3185  var%VEC_INT=0
3186  CASE(0)
3187  ALLOCATE(var%SCL_INT,stat=status)
3188  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_SCL")
3189  var%SCL_INT=0
3190  CASE DEFAULT
3191  CALL fatal_error("Unsupported Integer data dimension")
3192  END SELECT
3193 
3194 
3195  case(nf90_float)
3196  IF(dbg_set(dbg_sbrio)) THEN
3197  WRITE(ipt,*) "XYTPE :: FLOAT"
3198  WRITE(ipt,*) "dims ::",dims
3199  END IF
3200 
3201  SELECT CASE(ndims)
3202  CASE(4)
3203  ALLOCATE(var%FDA_FLT(0:dims(1),dims(2),dims(3),dims(4)),stat=status)
3204  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_FDA")
3205  var%FDA_FLT=0.0_spa
3206  CASE(3)
3207  ALLOCATE(var%CUB_FLT(0:dims(1),dims(2),dims(3)),stat=status)
3208  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_CUB")
3209  var%CUB_FLT=0.0_spa
3210  CASE(2)
3211  ALLOCATE(var%ARR_FLT(0:dims(1),dims(2)),stat=status)
3212  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_ARR")
3213  var%ARR_FLT=0.0_spa
3214  CASE(1)
3215  ALLOCATE(var%VEC_FLT(0:dims(1)),stat=status)
3216  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_VEC")
3217  var%VEC_FLT=0.0_spa
3218  CASE(0)
3219  ALLOCATE(var%SCL_FLT,stat=status)
3220  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_SCL")
3221  var%SCL_FLT=0.0_spa
3222  CASE DEFAULT
3223  CALL fatal_error("Unsupported Integer data dimension")
3224  END SELECT
3225 
3226  case(nf90_double)
3227  IF(dbg_set(dbg_sbrio)) THEN
3228  WRITE(ipt,*) "XYTPE :: DOUBLE"
3229  WRITE(ipt,*) "dims ::",dims
3230  END IF
3231 
3232  SELECT CASE(ndims)
3233  CASE(4)
3234  ALLOCATE(var%FDA_DBL(0:dims(1),dims(2),dims(3),dims(4)),stat=status)
3235  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_FDA")
3236  var%FDA_DBL=0.0_dp
3237  CASE(3)
3238  ALLOCATE(var%CUB_DBL(0:dims(1),dims(2),dims(3)),stat=status)
3239  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_CUB")
3240  var%CUB_DBL=0.0_dp
3241  CASE(2)
3242  ALLOCATE(var%ARR_DBL(0:dims(1),dims(2)),stat=status)
3243  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_ARR")
3244  var%ARR_DBL=0.0_dp
3245  CASE(1)
3246  ALLOCATE(var%VEC_DBL(0:dims(1)),stat=status)
3247  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_VEC")
3248  var%VEC_DBL=0.0_dp
3249  CASE(0)
3250  ALLOCATE(var%SCL_DBL,stat=status)
3251  if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_SCL")
3252  var%SCL_DBL=0.0_dp
3253  CASE DEFAULT
3254  CALL fatal_error("Unsupported Integer data dimension")
3255  END SELECT
3256 
3257  END select
3258 
3259 
3260  DEALLOCATE(dims)
3261 
3262  IF(dbg_set(dbg_sbr)) WRITE(ipt,*) "END: ALLOC_VAR"
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:

◆ allocate_associated_vars()

subroutine mod_ncll::allocate_associated_vars ( type(ncfile), intent(in)  LIST)

Definition at line 3267 of file mod_ncll.f90.

3267  ! THIS IS A SHADY THING TO DO - I AM INTENTIONALLY ALLOCATING AN
3268  ! ASSOCIATED VARIABLE ASSUMING THAT IT WAS ASSOCIATED NOT
3269  ! ALLOCATED TO BEGIN WITH, THUS NOT CAUSING A MEMORY LEAK
3270 
3271  IMPLICIT NONE
3272  TYPE(NCFILE), INTENT(IN) :: LIST
3273  TYPE(NCVARP),POINTER :: CURRENT
3274  TYPE(NCVAR),POINTER :: VAR
3275 
3276  current => list%VARS%NEXT
3277  DO
3278  IF(.NOT. ASSOCIATED(current)) THEN
3279  EXIT ! END OF VAR LIST
3280  END IF
3281 
3282  IF(.NOT. ASSOCIATED(current%VAR)) THEN
3283  CALL fatal_error("ALLOCATE_ASSOCIATED_VARS: FOUND NULL VAR POINTER IN THE LIST")
3284  END IF
3285 
3286  var => current%VAR
3287 
3288  ! INTEGERS
3289  IF(Associated(var%SCL_INT)) THEN
3290  ALLOCATE(var%SCL_INT)
3291  var%SCL_INT=0
3292  END IF
3293 
3294  IF(Associated(var%VEC_INT))THEN
3295  ALLOCATE(var%VEC_INT(lbound(var%VEC_INT,1):ubound(var%VEC_INT,1)))
3296  var%VEC_INT=0
3297  END IF
3298 
3299  IF(Associated(var%ARR_INT))THEN
3300  ALLOCATE(var%ARR_INT(lbound(var%ARR_INT,1):ubound(var%ARR_INT,1),&
3301  & lbound(var%ARR_INT,2):ubound(var%ARR_INT,2)) )
3302  var%ARR_INT=0
3303  END IF
3304 
3305  IF(Associated(var%CUB_INT))THEN
3306  ALLOCATE(var%CUB_INT(lbound(var%CUB_INT,1):ubound(var%CUB_INT,1),&
3307  & lbound(var%CUB_INT,2):ubound(var%CUB_INT,2),&
3308  & lbound(var%CUB_INT,3):ubound(var%CUB_INT,3)))
3309  var%CUB_INT=0
3310  END IF
3311 
3312  IF(Associated(var%FDA_INT))THEN
3313  ALLOCATE(var%FDA_INT(lbound(var%FDA_INT,1):ubound(var%FDA_INT,1),&
3314  & lbound(var%FDA_INT,2):ubound(var%FDA_INT,2),&
3315  & lbound(var%FDA_INT,3):ubound(var%FDA_INT,3),&
3316  & lbound(var%FDA_INT,4):ubound(var%FDA_INT,4)))
3317  var%FDA_INT=0
3318  END IF
3319 
3320 
3321  !FLOATING POINT VALUES
3322  IF(Associated(var%SCL_FLT)) THEN
3323  ALLOCATE(var%SCL_FLT)
3324  var%SCL_FLT=0.0_spa
3325  END IF
3326  IF(Associated(var%VEC_FLT))THEN
3327  ALLOCATE(var%VEC_FLT(lbound(var%VEC_FLT,1):ubound(var%VEC_FLT,1)))
3328  var%VEC_FLT=0.0_spa
3329  END IF
3330 
3331  IF(Associated(var%ARR_FLT))THEN
3332  ALLOCATE(var%ARR_FLT(lbound(var%ARR_FLT,1):ubound(var%ARR_FLT,1),&
3333  & lbound(var%ARR_FLT,2):ubound(var%ARR_FLT,2)) )
3334  var%ARR_FLT=0.0_spa
3335  END IF
3336 
3337  IF(Associated(var%CUB_FLT))THEN
3338  ALLOCATE(var%CUB_FLT(lbound(var%CUB_FLT,1):ubound(var%CUB_FLT,1),&
3339  & lbound(var%CUB_FLT,2):ubound(var%CUB_FLT,2),&
3340  & lbound(var%CUB_FLT,3):ubound(var%CUB_FLT,3)))
3341  var%CUB_FLT=0.0_spa
3342  END IF
3343 
3344  IF(Associated(var%FDA_FLT))THEN
3345  ALLOCATE(var%FDA_FLT(lbound(var%FDA_FLT,1):ubound(var%FDA_FLT,1),&
3346  & lbound(var%FDA_FLT,2):ubound(var%FDA_FLT,2),&
3347  & lbound(var%FDA_FLT,3):ubound(var%FDA_FLT,3),&
3348  & lbound(var%FDA_FLT,4):ubound(var%FDA_FLT,4)))
3349  var%FDA_FLT=0.0_spa
3350  END IF
3351 
3352  !DOUBLE PRECISION
3353  IF(Associated(var%SCL_DBL)) THEN
3354  ALLOCATE(var%SCL_DBL)
3355  var%SCL_DBL=0.0_dp
3356  END IF
3357  IF(Associated(var%VEC_DBL))THEN
3358  ALLOCATE(var%VEC_DBL(lbound(var%VEC_DBL,1):ubound(var%VEC_DBL,1)))
3359  var%VEC_DBL=0.0_dp
3360  END IF
3361  IF(Associated(var%ARR_DBL))THEN
3362  ALLOCATE(var%ARR_DBL(lbound(var%ARR_DBL,1):ubound(var%ARR_DBL,1),&
3363  & lbound(var%ARR_DBL,2):ubound(var%ARR_DBL,2)) )
3364  var%ARR_DBL=0.0_dp
3365  END IF
3366 
3367  IF(Associated(var%CUB_DBL))THEN
3368  ALLOCATE(var%CUB_DBL(lbound(var%CUB_DBL,1):ubound(var%CUB_DBL,1),&
3369  & lbound(var%CUB_DBL,2):ubound(var%CUB_DBL,2),&
3370  & lbound(var%CUB_DBL,3):ubound(var%CUB_DBL,3)))
3371  var%CUB_DBL=0.0_dp
3372  END IF
3373 
3374  IF(Associated(var%FDA_DBL))THEN
3375  ALLOCATE(var%FDA_DBL(lbound(var%FDA_DBL,1):ubound(var%FDA_DBL,1),&
3376  & lbound(var%FDA_DBL,2):ubound(var%FDA_DBL,2),&
3377  & lbound(var%FDA_DBL,3):ubound(var%FDA_DBL,3),&
3378  & lbound(var%FDA_DBL,4):ubound(var%FDA_DBL,4)))
3379  var%FDA_DBL=0.0_dp
3380  END IF
3381 
3382  ! CHARACTER ARRAY DATA
3383  IF(Associated(var%SCL_CHR)) THEN
3384  ALLOCATE(var%SCL_CHR)
3385  var%SCL_CHR=""
3386  END IF
3387  IF(Associated(var%VEC_CHR))THEN
3388  ALLOCATE(var%VEC_CHR(lbound(var%VEC_CHR,1):ubound(var%VEC_CHR,1)))
3389  var%VEC_CHR=""
3390  END IF
3391 
3392  current => current%NEXT
3393 
3394  END DO
3395 
3396 
3397 
Here is the call graph for this function:

◆ copy_att()

type(ncatt) function, pointer mod_ncll::copy_att ( type(ncatt), intent(in), pointer  ATTIN)

Definition at line 1485 of file mod_ncll.f90.

1485  IMPLICIT NONE
1486  TYPE(NCATT), POINTER, INTENT(IN) :: ATTIN
1487  TYPE(NCATT), POINTER :: ATTOUT
1488  integer status
1489 
1490  IF(.not. Associated(attin)) CALL fatal_error("THE ARGUMENT MUST BE&
1491  & ASSOCIAED FOR COPY_ATT")
1492 
1493 
1494  attout=>new_att()
1495 
1496  attout%ATTNAME = attin%ATTNAME
1497  attout%LEN = attin%LEN
1498  attout%ATTID = attin%ATTID
1499  attout%XTYPE = attin%XTYPE
1500 
1501  IF (Allocated(attin%int)) THEN
1502  ALLOCATE(attout%int(attin%LEN),stat=status)
1503  if(status/=0) CALL fatal_error("COPY_ATT COULD NOT ALLOCATE INT!")
1504  attout%int = attin%int
1505  END IF
1506 
1507  IF (Allocated(attin%flt)) THEN
1508  ALLOCATE(attout%flt(attin%LEN),stat=status)
1509  if(status/=0) CALL fatal_error("COPY_ATT COULD NOT ALLOCATE FLT!")
1510  attout%flt = attin%flt
1511  END IF
1512 
1513  IF (Allocated(attin%dbl)) THEN
1514  ALLOCATE(attout%dbl(attin%LEN),stat=status)
1515  if(status/=0) CALL fatal_error("COPY_ATT COULD NOT ALLOCATE DBL!")
1516  attout%dbl = attin%dbl
1517  END IF
1518 
1519  IF (Allocated(attin%chr)) THEN
1520  ALLOCATE(attout%chr(size(attin%chr)),stat=status)
1521  if(status/=0) CALL fatal_error("COPY_ATT COULD NOT ALLOCATE CHR!")
1522  attout%chr = attin%chr
1523  END IF
1524 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ copy_att_list()

subroutine mod_ncll::copy_att_list ( type(ncattp), intent(out), target  ATTPOUT,
type(ncattp), intent(in), target  ATTPIN 
)

Definition at line 1529 of file mod_ncll.f90.

1529  IMPLICIT NONE
1530 ! TYPE(NCATTP), POINTER, INTENT(IN) :: ATTPIN
1531 ! TYPE(NCATTP), POINTER, INTENT(INOUT) :: ATTPOUT
1532  TYPE(NCATTP), TARGET, INTENT(IN) :: ATTPIN
1533  TYPE(NCATTP), TARGET, INTENT(OUT) :: ATTPOUT
1534  TYPE(NCATT), POINTER :: ATT
1535  TYPE(NCATTP),POINTER :: CURRENT_IN, PREVIOUS_IN
1536  TYPE(NCATTP),POINTER :: CURRENT_OUT, PREVIOUS_OUT
1537 
1538  integer status
1539 
1540 !!$ IF(.not. Associated(ATTPIN)) CALL FATAL_ERROR("THE INPUT ARGUMENT MUST BE&
1541 !!$ & ASSOCIAED FOR COPY_ATT_LIST?")
1542 !!$
1543 !!$ IF(.not. Associated(ATTPOUT)) CALL FATAL_ERROR("THE OUTPUT ARGUMENT MUST BE&
1544 !!$ & ASSOCIAED FOR COPY_ATT_LIST?")
1545 
1546  previous_in => attpin
1547  current_in => previous_in%NEXT
1548 
1549  previous_out => attpout
1550  current_out => previous_out%NEXT
1551 
1552  ! I DON'T THINK THAT CURRENT_OUT SERVES ANY PURPOSE HERE?
1553  ! I DON'T THINK THAT PREVIOUS_IN SERVES ANY PURPOSE HERE?
1554 
1555 
1556  DO
1557  IF(.NOT. ASSOCIATED(current_in)) THEN
1558  RETURN ! END OF ATT IN LIST
1559  END IF
1560 
1561  IF(.NOT. ASSOCIATED(current_in%ATT)) THEN
1562  CALL fatal_error("COPY_ATT_LIST: FOUND NULL DIM POINTER IN THE LIST")
1563  END IF
1564 
1565  previous_out%NEXT => new_attp()
1566  previous_out%NEXT%ATT => copy_att(current_in%ATT)
1567  previous_out%NEXT%NEXT => current_out
1568 
1569  ! INCRIMENT THROUGH THE LIST
1570  previous_out => previous_out%NEXT
1571  ! DO NOT INCRIMENT CURRENT_OUT
1572 
1573  previous_in => previous_in%NEXT
1574  current_in => current_in%NEXT
1575 
1576  END DO
1577 
1578 
1579 
Here is the call graph for this function:

◆ copy_dim()

type(ncdim) function, pointer mod_ncll::copy_dim ( type(ncdim), intent(in), pointer  DIMIN)

Definition at line 2269 of file mod_ncll.f90.

2269  IMPLICIT NONE
2270  TYPE(NCDIM), POINTER, INTENT(IN) :: DIMIN
2271  TYPE(NCDIM), POINTER :: DIMOUT
2272  integer status
2273 
2274  IF(.not. Associated(dimin)) CALL fatal_error("THE ARGUMENT MUST BE&
2275  & ASSOCIAED FOR COPY_DIM?")
2276 
2277  dimout => new_dim()
2278 
2279  dimout%DIMID = dimin%DIMID
2280  dimout%DIMNAME = dimin%DIMNAME
2281  dimout%DIM = dimin%DIM
2282  dimout%UNLIMITED = dimin%UNLIMITED
Here is the call graph for this function:
Here is the caller graph for this function:

◆ copy_dim_list()

subroutine mod_ncll::copy_dim_list ( type(ncdimp), intent(out), target  DIMPOUT,
type(ncdimp), intent(in), target  DIMPIN 
)

Definition at line 2213 of file mod_ncll.f90.

2213  IMPLICIT NONE
2214 ! TYPE(NCDIMP),POINTER,INTENT(INOUT):: DIMPOUT
2215 ! TYPE(NCDIMP), POINTER, INTENT(IN) :: DIMPIN
2216  TYPE(NCDIMP),TARGET, INTENT(OUT):: DIMPOUT
2217  TYPE(NCDIMP), TARGET, INTENT(IN) :: DIMPIN
2218  TYPE(NCDIM), POINTER :: DIM
2219  TYPE(NCDIMP),POINTER :: CURRENT_IN, PREVIOUS_IN
2220  TYPE(NCDIMP),POINTER :: CURRENT_OUT, PREVIOUS_OUT
2221 
2222  integer status
2223 
2224 !!$ IF(.not. Associated(DIMPIN)) CALL FATAL_ERROR("THE INPUT ARGUMENT MUST BE&
2225 !!$ & ASSOCIAED FOR COPY_DIM_LIST?")
2226 !!$
2227 !!$ IF(.not. Associated(DIMPOUT)) CALL FATAL_ERROR("THE OUTPUT ARGUMENT MUST BE&
2228 !!$ & ASSOCIAED FOR COPY_DIM_LIST?")
2229 
2230  previous_in => dimpin
2231  current_in => previous_in%NEXT
2232 
2233 ! DIMPOUT => NEW_DIMP()
2234  previous_out => dimpout
2235  current_out => previous_out%NEXT
2236 
2237  ! I DON'T THINK THAT CURRENT_OUT SERVES ANY PURPOSE HERE?
2238  ! I DON'T THINK THAT PREVIOUS_IN SERVES ANY PURPOSE HERE?
2239 
2240 
2241  DO
2242  IF(.NOT. ASSOCIATED(current_in)) THEN
2243  RETURN ! END OF DIM IN LIST
2244  END IF
2245 
2246  IF(.NOT. ASSOCIATED(current_in%DIM)) THEN
2247  CALL fatal_error("COPY_DIM_LIST: FOUND NULL DIM POINTER IN THE LIST")
2248  END IF
2249 
2250  previous_out%NEXT => new_dimp()
2251  previous_out%NEXT%DIM => copy_dim(current_in%DIM)
2252  previous_out%NEXT%NEXT => current_out
2253 
2254  ! INCRIMENT THROUGH THE LIST
2255  previous_out => previous_out%NEXT
2256  ! DO NOT INCRIMENT CURRENT_OUT
2257 
2258  previous_in => previous_in%NEXT
2259  current_in => current_in%NEXT
2260 
2261  END DO
2262 
2263 
2264 
Here is the call graph for this function:

◆ copy_file()

type(ncfile) function, pointer mod_ncll::copy_file ( type(ncfile), intent(in), pointer  NCFIN)

Definition at line 398 of file mod_ncll.f90.

398  IMPLICIT NONE
399 ! CHARACTER(LEN=160), INTENT(IN) :: NAME
400  TYPE(NCFILE), POINTER,INTENT(IN) :: NCFIN
401  TYPE(NCFILE), POINTER :: NCFOUT
402  TYPE(NCVAR), POINTER :: NCFOUT1
403  TYPE(NCVARP), POINTER :: CURRENT
404  integer status
405 
406  IF(.not. Associated(ncfin)) Call fatal_error &
407  ("COPY_NCF: INPUT FILE IS NOT ASSOCIATED!")
408 
409  ncfout => new_file()
410 
411  ncfout%NCID = -1
412  ncfout%FNAME = ncfin%FNAME
413  ncfout%WRITABLE = .false.
414  ncfout%OPEN = .false.
415  ncfout%CONNECTED = .false.
416  ncfout%UNLIMDIMID = ncfin%UNLIMDIMID
417 
418 !!$
419 !!$ IF(Associated(NCFIN%INTERP_N)) NCFOUT%INTERP_N => COPY_INTERP(NCFIN%INTERP_N)
420 !!$
421 !!$ IF(Associated(NCFIN%INTERP_C)) NCFOUT%INTERP_C => COPY_INTERP(NCFIN%INTERP_C)
422 !!$
423 
424  ! TIME VARIABLES ARE ALL INTEGER => AUTOMATICALLY INITIALIZED TO ZERO
425 
426  ! MAKE NEW LISTS FOR THE NCFILE
427  IF(.not. Associated(ncfin%DIMS)) Call fatal_error &
428  ("COPY_NCF: INPUT FILE DIMS LIST IS NOT ASSOCIATED!")
429 
430  IF(.not. Associated(ncfin%ATTS)) Call fatal_error &
431  ("COPY_NCF: INPUT FILE ATTS LIST IS NOT ASSOCIATED!")
432 
433  IF(.not. Associated(ncfin%VARS)) Call fatal_error &
434  ("COPY_NCF: INPUT FILE VARS LIST IS NOT ASSOCIATED!")
435 
436  ! USE OVERLOADED ASSIGNMENT OPERATOR
437  ncfout%DIMS = ncfin%DIMS
438  ncfout%ATTS = ncfin%ATTS
439 
440  current => ncfin%VARS%NEXT
441  DO
442  IF(.NOT. ASSOCIATED(current)) THEN
443  EXIT ! END OF VAR LIST
444  END IF
445 
446  IF(.NOT. ASSOCIATED(current%VAR)) THEN
447  CALL fatal_error("COPY_FILE: FOUND NULL VAR POINTER IN THE LIST")
448  END IF
449 
450  ncfout1 => copy_var(current%VAR)
451  ncfout => add(ncfout,ncfout1)
452 !!$ NCFOUT => ADD(NCFOUT,COPY_VAR(CURRENT%VAR))
453 
454  current => current%NEXT
455 
456  END DO
457 
458 
459  ! NOTE - THIS ONLY SETS THE INTEGER VALUES THE TIME VARIABLE
460  ! POINTERS ARE NOT SET HERE!
461  IF(Associated(ncfin%FTIME)) THEN
462  ncfout%FTIME => new_ftime()
463  ncfout%FTIME = ncfin%FTIME
464  END IF
465 
466 
Here is the call graph for this function:

◆ copy_ftime()

subroutine mod_ncll::copy_ftime ( type(ncftime), intent(out)  FTIME_OUT,
type(ncftime), intent(in)  FTIME_IN 
)

Definition at line 487 of file mod_ncll.f90.

487  IMPLICIT NONE
488  TYPE(NCFTIME),INTENT(OUT):: FTIME_OUT
489  TYPE(NCFTIME),INTENT(IN) :: FTIME_IN
490 
491  ftime_out%TMTYPE = ftime_in%TMTYPE
492  ftime_out%STK_LEN = ftime_in%STK_LEN
493  ftime_out%PREV_STKCNT = ftime_in%PREV_STKCNT
494  ftime_out%NEXT_STKCNT = ftime_in%NEXT_STKCNT
495  ftime_out%MAX_STKCNT = ftime_in%MAX_STKCNT
496  ftime_out%PREV_IO = ftime_in%PREV_IO
497  ftime_out%NEXT_IO = ftime_in%NEXT_IO
498  ftime_out%PREV_WGHT = ftime_in%PREV_WGHT
499  ftime_out%NEXT_WGHT = ftime_in%NEXT_WGHT
500  ftime_out%INTERVAL = ftime_in%INTERVAL
501  ftime_out%TIMEZONE = ftime_in%TIMEZONE
502 

◆ copy_var()

type(ncvar) function, pointer mod_ncll::copy_var ( type(ncvar), pointer  VARIN)

Definition at line 1003 of file mod_ncll.f90.

1003  IMPLICIT NONE
1004  TYPE(NCVAR), POINTER :: VARIN, VAROUT
1005  integer status
1006 
1007  varout => new_var()
1008 
1009  ! DO NOT TAKE VALUES THAT BELONG TO THIS FILE
1010 ! VAROUT%NCID => VARIN%NCID
1011 ! VAROUT%CONNECTED = VARIN%CONNECTED
1012 ! VAROUT%VARID = VARIN%VARID
1013  varout%VARNAME = varin%VARNAME
1014  varout%XTYPE = varin%XTYPE
1015 
1016  IF(Associated(varin%SCL_INT)) varout%SCL_INT=>varin%SCL_INT
1017  IF(Associated(varin%VEC_INT)) varout%VEC_INT=>varin%VEC_INT
1018  IF(Associated(varin%ARR_INT)) varout%ARR_INT=>varin%ARR_INT
1019  IF(Associated(varin%CUB_INT)) varout%CUB_INT=>varin%CUB_INT
1020  IF(Associated(varin%FDA_INT)) varout%FDA_INT=>varin%FDA_INT
1021 
1022  IF(Associated(varin%SCL_FLT)) varout%SCL_FLT=>varin%SCL_FLT
1023  IF(Associated(varin%VEC_FLT)) varout%VEC_FLT=>varin%VEC_FLT
1024  IF(Associated(varin%ARR_FLT)) varout%ARR_FLT=>varin%ARR_FLT
1025  IF(Associated(varin%CUB_FLT)) varout%CUB_FLT=>varin%CUB_FLT
1026  IF(Associated(varin%FDA_FLT)) varout%FDA_FLT=>varin%FDA_FLT
1027 
1028  IF(Associated(varin%SCL_DBL)) varout%SCL_DBL=>varin%SCL_DBL
1029  IF(Associated(varin%VEC_DBL)) varout%VEC_DBL=>varin%VEC_DBL
1030  IF(Associated(varin%ARR_DBL)) varout%ARR_DBL=>varin%ARR_DBL
1031  IF(Associated(varin%CUB_DBL)) varout%CUB_DBL=>varin%CUB_DBL
1032  IF(Associated(varin%FDA_DBL)) varout%FDA_DBL=>varin%FDA_DBL
1033 
1034  IF(Associated(varin%SCL_CHR)) varout%SCL_CHR=>varin%SCL_CHR
1035  IF(Associated(varin%VEC_CHR)) varout%VEC_CHR=>varin%VEC_CHR
1036 
1037 
1038 
1039  IF(.not. Associated(varin%DIMS)) Call fatal_error &
1040  ("COPY_VAR: INPUT VARIABLE DIMS LIST IS NOT ASSOCIATED!")
1041 
1042  IF(.not. Associated(varin%ATTS)) Call fatal_error &
1043  ("COPY_VAR: INPUT VARIABLE ATTS LIST IS NOT ASSOCIATED!")
1044 
1045  ! USING OVERLOADED ASSIGNMENT OPERATOR
1046 ! call copy_dim_list(VAROUT%DIMS, VARIN%DIMS)
1047 ! call copy_att_list(VAROUT%ATTS, VARIN%ATTS)
1048 
1049  varout%DIMS = varin%DIMS
1050  varout%ATTS = varin%ATTS
1051 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ count_file_list()

integer function mod_ncll::count_file_list ( type(ncfilelist), intent(in)  LIST)

Definition at line 802 of file mod_ncll.f90.

802  IMPLICIT NONE
803  INTEGER :: CNT
804  TYPE(NCFILELIST), INTENT(IN) :: LIST
805  TYPE(NCFILEP), pointer :: CURRENT, PREVIOUS
806 
807  previous => list%FIRST
808  current => previous%NEXT
809  cnt = 0
810  DO
811  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
812  previous => previous%NEXT
813  current => current%NEXT
814  cnt = cnt + 1
815  END DO
816 

◆ count_ncf_att_list()

integer function mod_ncll::count_ncf_att_list ( type(ncfile), intent(in)  LIST)

Definition at line 2028 of file mod_ncll.f90.

2028  IMPLICIT NONE
2029  INTEGER :: CNT
2030  TYPE(NCFILE), INTENT(IN) :: LIST
2031  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
2032 
2033  previous => list%ATTS
2034  current => previous%NEXT
2035  cnt = 0
2036  DO
2037  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2038  previous => previous%NEXT
2039  current => current%NEXT
2040  cnt = cnt + 1
2041  END DO
2042 

◆ count_ncf_dim_list()

integer function mod_ncll::count_ncf_dim_list ( type(ncfile), intent(in)  LIST)

Definition at line 3402 of file mod_ncll.f90.

3402  IMPLICIT NONE
3403  INTEGER :: CNT
3404  TYPE(NCFILE), INTENT(IN) :: LIST
3405  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
3406 
3407  previous => list%DIMS
3408  current => previous%NEXT
3409  cnt = 0
3410  DO
3411  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
3412  previous => previous%NEXT
3413  current => current%NEXT
3414  cnt = cnt + 1
3415  END DO
3416 

◆ count_ncf_ns_dim_list()

integer function mod_ncll::count_ncf_ns_dim_list ( type(ncfile), intent(in)  LIST)

Definition at line 3049 of file mod_ncll.f90.

3049  IMPLICIT NONE
3050  INTEGER :: CNT
3051  TYPE(NCFILE), INTENT(IN) :: LIST
3052  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
3053 
3054  previous => list%DIMS
3055  current => previous%NEXT
3056  cnt = 0
3057  DO
3058  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
3059 
3060  ! DO NOT COUNT SINGLETON DIMENSIONS
3061  IF(current%DIM%DIM .GT. 1) cnt = cnt + 1
3062 
3063  previous => previous%NEXT
3064  current => current%NEXT
3065 
3066  END DO
3067 

◆ count_unlimited_vars()

integer function mod_ncll::count_unlimited_vars ( type(ncfile), intent(in)  LIST)

Definition at line 1326 of file mod_ncll.f90.

1326  IMPLICIT NONE
1327  INTEGER :: CNT
1328  TYPE(NCFILE), INTENT(IN) :: LIST
1329  TYPE(NCVARP) ,POINTER :: CURRENT, PREVIOUS
1330 
1331  previous => list%VARS
1332  current => previous%NEXT
1333  cnt = 0
1334  DO
1335  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1336 
1337  IF(has_unlimited(current%VAR)) cnt = cnt + 1
1338 
1339  previous => previous%NEXT
1340  current => current%NEXT
1341  END DO
1342 

◆ count_var_att_list()

integer function mod_ncll::count_var_att_list ( type(ncvar), intent(in)  LIST)

Definition at line 2047 of file mod_ncll.f90.

2047  IMPLICIT NONE
2048  INTEGER :: CNT
2049  TYPE(NCVAR), INTENT(IN) :: LIST
2050  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
2051 
2052  previous => list%ATTS
2053  current => previous%NEXT
2054  cnt = 0
2055  DO
2056  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2057  previous => previous%NEXT
2058  current => current%NEXT
2059  cnt = cnt + 1
2060  END DO
2061 

◆ count_var_dim_list()

integer function mod_ncll::count_var_dim_list ( type(ncvar), intent(in)  LIST)

Definition at line 3421 of file mod_ncll.f90.

3421  IMPLICIT NONE
3422  INTEGER :: CNT
3423  TYPE(NCVAR), INTENT(IN) :: LIST
3424  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
3425 
3426  previous => list%DIMS
3427  current => previous%NEXT
3428  cnt = 0
3429  DO
3430  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
3431  previous => previous%NEXT
3432  current => current%NEXT
3433  cnt = cnt + 1
3434  END DO
3435 

◆ count_var_list()

integer function mod_ncll::count_var_list ( type(ncfile), intent(in)  LIST)

Definition at line 1307 of file mod_ncll.f90.

1307  IMPLICIT NONE
1308  INTEGER :: CNT
1309  TYPE(NCFILE), INTENT(IN) :: LIST
1310  TYPE(NCVARP) ,POINTER :: CURRENT, PREVIOUS
1311 
1312  previous => list%VARS
1313  current => previous%NEXT
1314  cnt = 0
1315  DO
1316  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1317  previous => previous%NEXT
1318  current => current%NEXT
1319  cnt = cnt + 1
1320  END DO
1321 
Here is the caller graph for this function:

◆ count_var_ns_dim_list()

integer function mod_ncll::count_var_ns_dim_list ( type(ncvar), intent(in)  LIST)

Definition at line 3072 of file mod_ncll.f90.

3072  IMPLICIT NONE
3073  INTEGER :: CNT
3074  TYPE(NCVAR), INTENT(IN) :: LIST
3075  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
3076 
3077  previous => list%DIMS
3078  current => previous%NEXT
3079  cnt = 0
3080  DO
3081  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
3082 
3083  ! DO NOT COUNT SINGLETON DIMENSIONS
3084  IF(current%DIM%DIM .GT. 1) cnt = cnt + 1
3085 
3086  previous => previous%NEXT
3087  current => current%NEXT
3088 
3089  END DO
3090 

◆ delete_file_list()

subroutine mod_ncll::delete_file_list ( type(ncfilelist), intent(inout)  LIST)

Definition at line 606 of file mod_ncll.f90.

606  IMPLICIT NONE
607  TYPE(NCFILELIST), INTENT(INOUT) :: LIST
608  TYPE(NCFILEP),pointer :: CURRENT, PREVIOUS
609 
610  previous => list%FIRST
611  current => previous%NEXT
612 
613  DO
614  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
615 
616  previous%NEXT => current%NEXT
617  CALL kill_file(current%NCF)
618  DEALLOCATE(current)
619 
620  current => previous%NEXT
621 
622  END DO
623 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ delete_filep_byname()

subroutine mod_ncll::delete_filep_byname ( type(ncfilelist), intent(inout)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 544 of file mod_ncll.f90.

544  IMPLICIT NONE
545  TYPE(NCFILELIST), INTENT(INOUT) :: LIST
546  CHARACTER(LEN=*), INTENT(IN) :: NAME
547  LOGICAL, INTENT(OUT) :: FOUND
548  TYPE(NCFILEP), pointer :: CURRENT, PREVIOUS
549 
550  previous => list%FIRST
551  current => previous%NEXT
552  found = .false.
553 
554  DO
555  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
556 
557  IF( name == current%NCF%FNAME ) THEN ! FOUND THE FILE LINK
558  found = .true.
559  EXIT
560  ELSE
561  previous => previous%NEXT
562  current => current%NEXT
563  END IF
564  END DO
565 
566  ! IF FOUND DELETE IT
567  previous%NEXT => current%NEXT
568  CALL kill_file(current%NCF)
569  DEALLOCATE(current)
570 
Here is the call graph for this function:

◆ delete_filep_byncid()

subroutine mod_ncll::delete_filep_byncid ( type(ncfilelist), intent(inout)  LIST,
integer, intent(in)  NCID,
logical, intent(out)  FOUND 
)

Definition at line 575 of file mod_ncll.f90.

575  IMPLICIT NONE
576  TYPE(NCFILELIST), INTENT(INOUT) :: LIST
577  INTEGER, INTENT(IN) :: NCID
578  LOGICAL, INTENT(OUT) :: FOUND
579  TYPE(NCFILEP),pointer :: CURRENT, PREVIOUS
580 
581  previous => list%FIRST
582  current => previous%NEXT
583  found = .false.
584 
585  DO
586  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
587 
588  IF( ncid == current%NCF%NCID ) THEN ! FOUND THE FILE LINK
589  found = .true.
590  EXIT
591  ELSE
592  previous => previous%NEXT
593  current => current%NEXT
594  END IF
595  END DO
596 
597  ! IF FOUND DELETE IT
598  previous%NEXT => current%NEXT
599  CALL kill_file(current%NCF)
600  DEALLOCATE(current)
601 
Here is the call graph for this function:

◆ delete_ncf_attp_byattid()

subroutine mod_ncll::delete_ncf_attp_byattid ( type(ncfile), intent(inout)  LIST,
integer, intent(in)  ATTID,
logical, intent(out)  FOUND 
)

Definition at line 1615 of file mod_ncll.f90.

1615  IMPLICIT NONE
1616  TYPE(NCFILE), INTENT(INOUT):: LIST
1617  INTEGER, INTENT(IN) :: ATTID
1618  LOGICAL, INTENT(OUT) :: FOUND
1619  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
1620 
1621  previous => list%ATTS
1622  current => previous%NEXT
1623  found = .false.
1624 
1625  DO
1626  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1627 
1628  IF( attid == current%ATT%ATTID ) THEN ! FOUND THE FILE LINK
1629  found = .true.
1630  EXIT
1631  ELSE
1632  previous => previous%NEXT
1633  current => current%NEXT
1634  END IF
1635  END DO
1636 
1637  ! IF FOUND DELETE IT
1638  previous%NEXT => current%NEXT
1639  CALL kill_att(current%ATT)
1640  DEALLOCATE(current)
1641 
Here is the call graph for this function:

◆ delete_ncf_attp_byname()

subroutine mod_ncll::delete_ncf_attp_byname ( type(ncfile), intent(inout)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 1584 of file mod_ncll.f90.

1584  IMPLICIT NONE
1585  TYPE(NCFILE), INTENT(INOUT):: LIST
1586  CHARACTER(LEN=*),INTENT(IN) :: NAME
1587  LOGICAL, INTENT(OUT) :: FOUND
1588  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
1589 
1590  previous => list%ATTS
1591  current => previous%NEXT
1592  found = .false.
1593 
1594  DO
1595  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1596 
1597  IF( name == current%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
1598  found = .true.
1599  EXIT
1600  ELSE
1601  previous => previous%NEXT
1602  current => current%NEXT
1603  END IF
1604  END DO
1605 
1606  ! IF FOUND DELETE IT
1607  previous%NEXT => current%NEXT
1608  CALL kill_att(current%ATT)
1609  DEALLOCATE(current)
1610 
Here is the call graph for this function:

◆ delete_ncf_attp_list()

subroutine mod_ncll::delete_ncf_attp_list ( type(ncfile), intent(inout)  LIST)

Definition at line 1646 of file mod_ncll.f90.

1646  IMPLICIT NONE
1647  TYPE(NCFILE), INTENT(INOUT):: LIST
1648  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
1649 
1650  previous => list%ATTS
1651  current => previous%NEXT
1652  DO
1653  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1654 
1655  ! IF FOUND DELETE IT
1656  previous%NEXT => current%NEXT
1657  CALL kill_att(current%ATT)
1658  DEALLOCATE(current)
1659  current => previous%NEXT
1660 
1661  END DO
1662 
Here is the call graph for this function:

◆ delete_ncf_dimp_bydimid()

subroutine mod_ncll::delete_ncf_dimp_bydimid ( type(ncfile), intent(inout)  LIST,
integer, intent(in)  DIMID,
logical, intent(out)  FOUND 
)

Definition at line 2348 of file mod_ncll.f90.

2348  IMPLICIT NONE
2349  TYPE(NCFILE), INTENT(INOUT):: LIST
2350  INTEGER, INTENT(IN) :: DIMID
2351  LOGICAL, INTENT(OUT) :: FOUND
2352  LOGICAL :: F1
2353  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2354  TYPE(NCVARP) ,POINTER :: CURRENT_VAR
2355 
2356  current_var => list%VARS%NEXT
2357  DO
2358  IF(.NOT. ASSOCIATED(current_var)) RETURN !END OF LIST
2359 
2360  IF(.NOT. ASSOCIATED(current_var%VAR)) THEN
2361  CALL fatal_error("DELETE_NCF_DIMP_BYDIMID: NULL VAR POINTER IN FILE LIST?")
2362  END IF
2363 
2364  CALL delete_dim_link(current_var%VAR,dimid,f1)
2365 
2366  current_var => current_var%NEXT
2367  END DO
2368 
2369 
2370 
2371  previous => list%DIMS
2372  current => previous%NEXT
2373  found = .false.
2374 
2375  DO
2376  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2377 
2378  IF( dimid == current%DIM%DIMID ) THEN ! FOUND THE FILE LINK
2379  found = .true.
2380  EXIT
2381  ELSE
2382  previous => previous%NEXT
2383  current => current%NEXT
2384  END IF
2385  END DO
2386 
2387  ! IF FOUND DELETE IT
2388  previous%NEXT => current%NEXT
2389  CALL kill_dim(current%DIM)
2390  DEALLOCATE(current)
2391 
Here is the call graph for this function:

◆ delete_ncf_dimp_byname()

subroutine mod_ncll::delete_ncf_dimp_byname ( type(ncfile), intent(inout)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 2301 of file mod_ncll.f90.

2301  IMPLICIT NONE
2302  TYPE(NCFILE), INTENT(INOUT):: LIST
2303  CHARACTER(LEN=*),INTENT(IN) :: NAME
2304  LOGICAL, INTENT(OUT) :: FOUND
2305  LOGICAL :: F1
2306  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2307  TYPE(NCVARP) ,POINTER :: CURRENT_VAR
2308 
2309  current_var => list%VARS%NEXT
2310  DO
2311  IF(.NOT. ASSOCIATED(current_var)) RETURN !END OF LIST
2312 
2313  IF(.NOT. ASSOCIATED(current_var%VAR)) THEN
2314  CALL fatal_error("DELETE_NCF_DIMP_BYNAME: NULL VAR POINTER IN FILE LIST?")
2315  END IF
2316 
2317  CALL delete_dim_link(current_var%VAR,name,f1)
2318 
2319  current_var => current_var%NEXT
2320  END DO
2321 
2322 
2323  previous => list%DIMS
2324  current => previous%NEXT
2325  found = .false.
2326 
2327  DO
2328  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2329 
2330  IF( name == current%DIM%DIMNAME ) THEN ! FOUND THE FILE LINK
2331  found = .true.
2332  EXIT
2333  ELSE
2334  previous => previous%NEXT
2335  current => current%NEXT
2336  END IF
2337  END DO
2338 
2339  ! IF FOUND DELETE IT
2340  previous%NEXT => current%NEXT
2341  CALL kill_dim(current%DIM)
2342  DEALLOCATE(current)
2343 
Here is the call graph for this function:

◆ delete_ncf_dimp_list()

subroutine mod_ncll::delete_ncf_dimp_list ( type(ncfile), intent(inout)  LIST)

Definition at line 2396 of file mod_ncll.f90.

2396  IMPLICIT NONE
2397  TYPE(NCFILE), INTENT(INOUT):: LIST
2398  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2399 
2400  previous => list%DIMS
2401  current => previous%NEXT
2402  DO
2403  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2404 
2405  ! IF FOUND DELETE IT
2406  previous%NEXT => current%NEXT
2407  CALL kill_dim(current%DIM)
2408  DEALLOCATE(current)
2409  current => previous%NEXT
2410 
2411  END DO
2412 
Here is the call graph for this function:

◆ delete_var_attp_byattid()

subroutine mod_ncll::delete_var_attp_byattid ( type(ncvar), intent(inout)  LIST,
integer, intent(in)  ATTID,
logical, intent(out)  FOUND 
)

Definition at line 1699 of file mod_ncll.f90.

1699  IMPLICIT NONE
1700  TYPE(NCVAR), INTENT(INOUT):: LIST
1701  INTEGER, INTENT(IN) :: ATTID
1702  LOGICAL, INTENT(OUT) :: FOUND
1703  TYPE(NCATTP), POINTER :: CURRENT, PREVIOUS
1704 
1705  previous => list%ATTS
1706  current => previous%NEXT
1707  found = .false.
1708 
1709  DO
1710  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1711 
1712  IF( attid == current%ATT%ATTID ) THEN ! FOUND THE FILE LINK
1713  found = .true.
1714  EXIT
1715  ELSE
1716  previous => previous%NEXT
1717  current => current%NEXT
1718  END IF
1719  END DO
1720 
1721  ! IF FOUND DELETE IT
1722  previous%NEXT => current%NEXT
1723  CALL kill_att(current%ATT)
1724  DEALLOCATE(current)
1725 
Here is the call graph for this function:

◆ delete_var_attp_byname()

subroutine mod_ncll::delete_var_attp_byname ( type(ncvar), intent(inout)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 1667 of file mod_ncll.f90.

1667  IMPLICIT NONE
1668  TYPE(NCVAR), INTENT(INOUT):: LIST
1669 ! CHARACTER(LEN=NF90_MAX_NAME+1),INTENT(IN) :: NAME
1670  CHARACTER(LEN=*),INTENT(IN) :: NAME
1671  LOGICAL, INTENT(OUT) :: FOUND
1672  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
1673 
1674  previous => list%ATTS
1675  current => previous%NEXT
1676  found = .false.
1677 
1678  DO
1679  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1680 
1681  IF( name == current%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
1682  found = .true.
1683  EXIT
1684  ELSE
1685  previous => previous%NEXT
1686  current => current%NEXT
1687  END IF
1688  END DO
1689 
1690  ! IF FOUND DELETE IT
1691  previous%NEXT => current%NEXT
1692  CALL kill_att(current%ATT)
1693  DEALLOCATE(current)
1694 
Here is the call graph for this function:

◆ delete_var_attp_list()

subroutine mod_ncll::delete_var_attp_list ( type(ncvar), intent(inout)  LIST)

Definition at line 1730 of file mod_ncll.f90.

1730  IMPLICIT NONE
1731  TYPE(NCVAR), INTENT(INOUT):: LIST
1732  TYPE(NCATTP),POINTER :: CURRENT, PREVIOUS
1733 
1734  previous => list%ATTS
1735  current => previous%NEXT
1736 
1737  DO
1738  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1739 
1740  previous%NEXT => current%NEXT
1741  CALL kill_att(current%ATT)
1742  DEALLOCATE(current)
1743  current => previous%NEXT
1744 
1745  END DO
1746 
Here is the call graph for this function:

◆ delete_var_dimp_bydimid()

subroutine mod_ncll::delete_var_dimp_bydimid ( type(ncvar), intent(inout)  LIST,
integer, intent(in)  DIMID,
logical, intent(out)  FOUND 
)

Definition at line 2464 of file mod_ncll.f90.

2464  IMPLICIT NONE
2465  TYPE(NCVAR), INTENT(INOUT):: LIST
2466  INTEGER, INTENT(IN) :: DIMID
2467  LOGICAL, INTENT(OUT) :: FOUND
2468  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2469 
2470  previous => list%DIMS
2471  current => previous%NEXT
2472  found = .false.
2473 
2474  DO
2475  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2476 
2477  IF(.NOT. ASSOCIATED(current%DIM))THEN
2478  ! CALL PRINT_VAR(LIST)
2479  CALL fatal_error("DELETE_VAR_DIMP_BYDIMID: VARIABLE HAS UNASSOCIATED DIMENSION IN LIST?")
2480  END IF
2481 
2482  IF( dimid == current%DIM%DIMID ) THEN ! FOUND THE FILE LINK
2483  found = .true.
2484  EXIT
2485  ELSE
2486  previous => previous%NEXT
2487  current => current%NEXT
2488  END IF
2489  END DO
2490 
2491  ! IF FOUND DELETE IT
2492  previous%NEXT => current%NEXT
2493 
2494  IF(current%DIM%DIMID==-1) THEN
2495  call kill_dim(current%DIM) ! IT BELONGS TO THE VAR ONLY, NOT PART
2496  ! OF A FILE
2497  ELSE
2498  NULLIFY(current%DIM) ! DO NOT DEALLOCATE POINTER TO ACTUAL
2499  ! DIMENSION, IT BELONGS TO A FILE
2500  END IF
2501  DEALLOCATE(current)
Here is the call graph for this function:

◆ delete_var_dimp_byname()

subroutine mod_ncll::delete_var_dimp_byname ( type(ncvar), intent(inout)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 2417 of file mod_ncll.f90.

2417  IMPLICIT NONE
2418  TYPE(NCVAR), INTENT(INOUT):: LIST
2419  CHARACTER(LEN=*),INTENT(IN) :: NAME
2420  LOGICAL, INTENT(OUT) :: FOUND
2421  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2422 
2423  previous => list%DIMS
2424  current => previous%NEXT
2425  found = .false.
2426 
2427  DO
2428  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2429 
2430  IF(.NOT. ASSOCIATED(current%DIM))THEN
2431  ! CALL PRINT_VAR(LIST)
2432  CALL fatal_error("DELETE_VAR_DIMP_BYNAME: VARIABLE HAS UNASSOCIATED DIMENSION IN LIST?")
2433  END IF
2434 
2435  IF( name == current%DIM%DIMNAME ) THEN ! FOUND THE FILE LINK
2436  found = .true.
2437  EXIT
2438  ELSE
2439  previous => previous%NEXT
2440  current => current%NEXT
2441  END IF
2442  END DO
2443 
2444  ! IF FOUND DELETE IT
2445  previous%NEXT => current%NEXT
2446 
2447  IF(current%DIM%DIMID==-1) THEN
2448  call kill_dim(current%DIM) ! IT BELONGS TO THE VAR ONLY, NOT PART
2449  ! OF A FILE
2450  ELSE
2451  NULLIFY(current%DIM) ! DO NOT DEALLOCATE POINTER TO ACTUAL
2452  ! DIMENSION, IT BELONGS TO A FILE
2453  END IF
2454 
2455  DEALLOCATE(current)
2456 
Here is the call graph for this function:

◆ delete_var_dimp_list()

subroutine mod_ncll::delete_var_dimp_list ( type(ncvar), intent(inout)  LIST)

Definition at line 2506 of file mod_ncll.f90.

2506  IMPLICIT NONE
2507  TYPE(NCVAR), INTENT(INOUT):: LIST
2508  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2509 
2510  previous => list%DIMS
2511  current => previous%NEXT
2512 
2513  DO
2514  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2515 
2516  previous%NEXT => current%NEXT
2517  IF(.NOT. ASSOCIATED(current%DIM))THEN
2518 ! CALL PRINT_VAR(LIST)
2519  CALL fatal_error("VARIABLE HAS UNASSOCIATED DIMENSION IN LIST?")
2520  END IF
2521 
2522  IF(current%DIM%DIMID==-1) THEN
2523  call kill_dim(current%DIM) ! IT BELONGS TO THE VAR ONLY, NOT PART
2524  ! OF A FILE
2525  ELSE
2526  NULLIFY(current%DIM) ! DO NOT DEALLOCATE POINTER, IT
2527  ! BELONGS TO A FILE
2528  END IF
2529 
2530  DEALLOCATE(current)
2531  current => previous%NEXT
2532 
2533  END DO
2534 
Here is the call graph for this function:

◆ delete_var_list()

subroutine mod_ncll::delete_var_list ( type(ncfile), pointer  LIST)

Definition at line 1138 of file mod_ncll.f90.

1138  IMPLICIT NONE
1139  ! NCFILE IS ALWAYS THE HEAD FOR A VAR LINK LIST
1140  TYPE(NCFILE), POINTER :: LIST
1141  TYPE(NCVARP), pointer :: CURRENT, PREVIOUS
1142 
1143  IF(.not.ASSOCIATED(list)) RETURN
1144 
1145  previous => list%VARS
1146  current => previous%NEXT
1147 
1148  DO
1149  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1150 
1151  previous%NEXT => current%NEXT
1152  CALL kill_var(current%VAR)
1153  DEALLOCATE(current)
1154  current => previous%NEXT
1155 
1156  END DO
1157 
1158 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ delete_varp_byname()

subroutine mod_ncll::delete_varp_byname ( type(ncfile), intent(inout)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 1074 of file mod_ncll.f90.

1074  IMPLICIT NONE
1075  ! NCFILE IS ALWAYS THE HEAD FOR A VAR LINK LIST
1076  TYPE(NCFILE), INTENT(INOUT):: LIST
1077  CHARACTER(LEN=*),INTENT(IN) :: NAME
1078  LOGICAL, INTENT(OUT) :: FOUND
1079  TYPE(NCVARP), pointer :: CURRENT, PREVIOUS
1080 
1081  previous => list%VARS
1082  current => previous%NEXT
1083  found = .false.
1084 
1085  DO
1086  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1087 
1088  IF( name == current%VAR%VARNAME ) THEN ! FOUND THE FILE LINK
1089  found = .true.
1090  EXIT
1091  ELSE
1092  previous => previous%NEXT
1093  current => current%NEXT
1094  END IF
1095  END DO
1096 
1097  ! IF FOUND DELETE IT
1098  previous%NEXT => current%NEXT
1099  CALL kill_var(current%VAR)
1100  DEALLOCATE(current)
1101 
Here is the call graph for this function:

◆ delete_varp_byvarid()

subroutine mod_ncll::delete_varp_byvarid ( type(ncfile), intent(inout)  LIST,
integer, intent(in)  VARID,
logical, intent(out)  FOUND 
)

Definition at line 1106 of file mod_ncll.f90.

1106  IMPLICIT NONE
1107  ! NCFILE IS ALWAYS THE HEAD FOR A VAR LINK LIST
1108  TYPE(NCFILE), INTENT(INOUT):: LIST
1109  INTEGER, INTENT(IN) :: VARID
1110  LOGICAL, INTENT(OUT) :: FOUND
1111  TYPE(NCVARP), pointer :: CURRENT, PREVIOUS
1112 
1113  previous => list%VARS
1114  current => previous%NEXT
1115  found = .false.
1116 
1117  DO
1118  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1119 
1120  IF( varid == current%VAR%VARID ) THEN ! FOUND THE FILE LINK
1121  found = .true.
1122  EXIT
1123  ELSE
1124  previous => previous%NEXT
1125  current => current%NEXT
1126  END IF
1127  END DO
1128 
1129  ! IF FOUND DELETE IT
1130  previous%NEXT => current%NEXT
1131  CALL kill_var(current%VAR)
1132  DEALLOCATE(current)
1133 
Here is the call graph for this function:

◆ find_file_byname()

type(ncfile) function, pointer mod_ncll::find_file_byname ( type(ncfilelist), intent(in)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 737 of file mod_ncll.f90.

737  IMPLICIT NONE
738  TYPE(NCFILE),POINTER :: NCF
739  TYPE(NCFILELIST), INTENT(IN) :: LIST
740  CHARACTER(LEN=*), INTENT(IN) :: NAME
741  LOGICAL, INTENT(OUT) :: FOUND
742  TYPE(NCFILEP), pointer :: CURRENT, PREVIOUS
743  integer :: idx
744 
745  previous => list%FIRST
746  current => previous%NEXT
747  NULLIFY(ncf)
748  found = .false.
749 
750  DO
751  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
752 
753  if(.not. associated(current%ncf)) Call fatal_error&
754  & ("FIND_FILE: Link in file list has file pointer that is &
755  &not associated!")
756 
757  idx = index(current%NCF%FNAME,name)
758 
759  IF( idx /= 0 ) THEN ! FOUND THE FILE LINK
760  ncf => current%NCF
761  found = .true.
762  EXIT
763  ELSE
764  previous => previous%NEXT
765  current => current%NEXT
766  END IF
767  END DO
768 
Here is the call graph for this function:

◆ find_file_byncid()

type(ncfile) function, pointer mod_ncll::find_file_byncid ( type(ncfilelist), intent(in)  LIST,
integer, intent(in)  NCID,
logical, intent(out)  FOUND 
)

Definition at line 773 of file mod_ncll.f90.

773  IMPLICIT NONE
774  TYPE(NCFILE),POINTER :: NCF
775  TYPE(NCFILELIST), INTENT(IN) :: LIST
776  INTEGER, INTENT(IN) :: NCID
777  LOGICAL, INTENT(OUT) :: FOUND
778  TYPE(NCFILEP), pointer :: CURRENT, PREVIOUS
779 
780  NULLIFY(ncf)
781  previous => list%FIRST
782  current => previous%NEXT
783  found = .false.
784 
785  DO
786  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
787 
788  IF( ncid == current%NCF%NCID ) THEN ! FOUND THE FILE LINK
789  ncf => current%NCF
790  found = .true.
791  EXIT
792  ELSE
793  previous => previous%NEXT
794  current => current%NEXT
795  END IF
796  END DO
797 

◆ find_ncf_att_byattid()

type(ncatt) function, pointer mod_ncll::find_ncf_att_byattid ( type(ncfile), intent(in)  LIST,
integer, intent(in)  ATTID,
logical, intent(out)  FOUND 
)

Definition at line 1941 of file mod_ncll.f90.

1941  IMPLICIT NONE
1942  TYPE(NCATT), POINTER :: ATT
1943  INTEGER, INTENT(IN) :: ATTID
1944  TYPE(NCFILE), INTENT(IN):: LIST
1945  LOGICAL, INTENT(OUT) :: FOUND
1946  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
1947 
1948  NULLIFY(att)
1949  previous => list%ATTS
1950  current => previous%NEXT
1951  found = .false.
1952 
1953  DO
1954  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1955 
1956  IF( attid == current%ATT%ATTID ) THEN ! FOUND THE FILE LINK
1957  att => current%ATT
1958  found = .true.
1959  EXIT
1960  ELSE
1961  previous => previous%NEXT
1962  current => current%NEXT
1963  END IF
1964  END DO
1965 

◆ find_ncf_att_byname()

type(ncatt) function, pointer mod_ncll::find_ncf_att_byname ( type(ncfile), intent(in)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 1912 of file mod_ncll.f90.

1912  IMPLICIT NONE
1913  TYPE(NCATT), POINTER :: ATT
1914  TYPE(NCFILE), INTENT(IN):: LIST
1915  CHARACTER(LEN=*),INTENT(IN) :: NAME
1916  LOGICAL, INTENT(OUT) :: FOUND
1917  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
1918 
1919  NULLIFY(att)
1920  previous => list%ATTS
1921  current => previous%NEXT
1922  found = .false.
1923 
1924  DO
1925  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1926 
1927  IF( trim(name) == trim(current%ATT%ATTNAME) ) THEN ! FOUND THE FILE LINK
1928  att => current%ATT
1929  found = .true.
1930  EXIT
1931  ELSE
1932  previous => previous%NEXT
1933  current => current%NEXT
1934  END IF
1935  END DO
1936 

◆ find_ncf_dim_bydimid()

type(ncdim) function, pointer mod_ncll::find_ncf_dim_bydimid ( type(ncfile), intent(in)  LIST,
integer, intent(in)  DIMID,
logical, intent(out)  FOUND 
)

Definition at line 2749 of file mod_ncll.f90.

2749  IMPLICIT NONE
2750  TYPE(NCDIM), POINTER :: DIM
2751  INTEGER, INTENT(IN) :: DIMID
2752  TYPE(NCFILE), INTENT(IN):: LIST
2753  LOGICAL, INTENT(OUT) :: FOUND
2754  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2755 
2756  NULLIFY(dim)
2757  previous => list%DIMS
2758  current => previous%NEXT
2759  found = .false.
2760 
2761  DO
2762  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2763 
2764  IF( dimid == current%DIM%DIMID ) THEN ! FOUND THE DIM LINK
2765  dim => current%DIM
2766  found = .true.
2767  EXIT
2768  ELSE
2769  previous => previous%NEXT
2770  current => current%NEXT
2771  END IF
2772  END DO
2773 

◆ find_ncf_dim_byname()

type(ncdim) function, pointer mod_ncll::find_ncf_dim_byname ( type(ncfile), intent(in)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 2720 of file mod_ncll.f90.

2720  IMPLICIT NONE
2721  TYPE(NCDIM), POINTER :: DIM
2722  TYPE(NCFILE), INTENT(IN) :: LIST
2723  CHARACTER(LEN=*),INTENT(IN) :: NAME
2724  LOGICAL, INTENT(OUT) :: FOUND
2725  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2726 
2727  NULLIFY(dim)
2728  previous => list%DIMS
2729  current => previous%NEXT
2730  found = .false.
2731 
2732  DO
2733  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2734 
2735  IF( trim(name) == trim(current%DIM%DIMNAME) ) THEN ! FOUND THE FILE LINK
2736  dim => current%DIM
2737  found = .true.
2738  EXIT
2739  ELSE
2740  previous => previous%NEXT
2741  current => current%NEXT
2742  END IF
2743  END DO
2744 

◆ find_ncf_dim_unlimited()

type(ncdim) function, pointer mod_ncll::find_ncf_dim_unlimited ( type(ncfile), intent(in)  LIST,
logical, intent(out)  FOUND 
)

Definition at line 2778 of file mod_ncll.f90.

2778  IMPLICIT NONE
2779  TYPE(NCDIM), POINTER :: DIM
2780  TYPE(NCFILE), INTENT(IN):: LIST
2781  LOGICAL, INTENT(OUT) :: FOUND
2782  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2783 
2784  NULLIFY(dim)
2785  previous => list%DIMS
2786  current => previous%NEXT
2787  found = .false.
2788 
2789  DO
2790  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2791 
2792  IF(current%DIM%UNLIMITED ) THEN ! FOUND THE DIM LINK
2793  dim => current%DIM
2794  found = .true.
2795  EXIT
2796  ELSE
2797  previous => previous%NEXT
2798  current => current%NEXT
2799  END IF
2800  END DO
2801 

◆ find_var_att_byattid()

type(ncatt) function, pointer mod_ncll::find_var_att_byattid ( type(ncvar), intent(in)  LIST,
integer, intent(in)  ATTID,
logical, intent(out)  FOUND 
)

Definition at line 1999 of file mod_ncll.f90.

1999  IMPLICIT NONE
2000  TYPE(NCATT), POINTER :: ATT
2001  INTEGER, INTENT(IN) :: ATTID
2002  TYPE(NCVAR), INTENT(IN):: LIST
2003  LOGICAL, INTENT(OUT) :: FOUND
2004  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
2005 
2006  NULLIFY(att)
2007  previous => list%ATTS
2008  current => previous%NEXT
2009  found = .false.
2010 
2011  DO
2012  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2013 
2014  IF( attid == current%ATT%ATTID ) THEN ! FOUND THE FILE LINK
2015  att => current%ATT
2016  found = .true.
2017  EXIT
2018  ELSE
2019  previous => previous%NEXT
2020  current => current%NEXT
2021  END IF
2022  END DO
2023 

◆ find_var_att_byname()

type(ncatt) function, pointer mod_ncll::find_var_att_byname ( type(ncvar), intent(in)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 1970 of file mod_ncll.f90.

1970  IMPLICIT NONE
1971  TYPE(NCATT), POINTER :: ATT
1972  TYPE(NCVAR), INTENT(IN) :: LIST
1973  CHARACTER(LEN=*),INTENT(IN) :: NAME
1974  LOGICAL, INTENT(OUT) :: FOUND
1975  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
1976 
1977  NULLIFY(att)
1978  previous => list%ATTS
1979  current => previous%NEXT
1980  found = .false.
1981 
1982  DO
1983  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1984 
1985  IF( trim(name) == trim(current%ATT%ATTNAME) ) THEN ! FOUND THE FILE LINK
1986  att => current%ATT
1987  found = .true.
1988  EXIT
1989  ELSE
1990  previous => previous%NEXT
1991  current => current%NEXT
1992  END IF
1993  END DO
1994 

◆ find_var_byname()

type(ncvar) function, pointer mod_ncll::find_var_byname ( type(ncfile), intent(in)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 1249 of file mod_ncll.f90.

1249  IMPLICIT NONE
1250  TYPE(NCVAR), POINTER :: VAR
1251  TYPE(NCFILE), INTENT(IN) :: LIST
1252  CHARACTER(LEN=*),INTENT(IN) :: NAME
1253  LOGICAL, INTENT(OUT) :: FOUND
1254  TYPE(NCVARP) ,POINTER :: CURRENT, PREVIOUS
1255 
1256  NULLIFY(var)
1257  previous => list%VARS
1258  current => previous%NEXT
1259  found = .false.
1260 
1261  DO
1262  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1263 
1264  IF( name == current%VAR%VARNAME ) THEN ! FOUND THE FILE LINK
1265  var => current%VAR
1266  found = .true.
1267  EXIT
1268  ELSE
1269  previous => previous%NEXT
1270  current => current%NEXT
1271  END IF
1272  END DO
1273 

◆ find_var_byvarid()

type(ncvar) function, pointer mod_ncll::find_var_byvarid ( type(ncfile), intent(in)  LIST,
integer, intent(in)  VARID,
logical, intent(out)  FOUND 
)

Definition at line 1278 of file mod_ncll.f90.

1278  IMPLICIT NONE
1279  TYPE(NCVAR), POINTER :: VAR
1280  TYPE(NCFILE), INTENT(IN) :: LIST
1281  INTEGER, INTENT(IN) :: VARID
1282  LOGICAL, INTENT(OUT) :: FOUND
1283  TYPE(NCVARP) ,POINTER :: CURRENT, PREVIOUS
1284 
1285  NULLIFY(var)
1286  previous => list%VARS
1287  current => previous%NEXT
1288  found = .false.
1289 
1290  DO
1291  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
1292 
1293  IF( varid == current%VAR%VARID ) THEN ! FOUND THE FILE LINK
1294  var => current%VAR
1295  found = .true.
1296  EXIT
1297  ELSE
1298  previous => previous%NEXT
1299  current => current%NEXT
1300  END IF
1301  END DO
1302 

◆ find_var_dim_bydimid()

type(ncdim) function, pointer mod_ncll::find_var_dim_bydimid ( type(ncvar), intent(in)  LIST,
integer, intent(in)  DIMID,
logical, intent(out)  FOUND 
)

Definition at line 2860 of file mod_ncll.f90.

2860  IMPLICIT NONE
2861  TYPE(NCDIM), POINTER :: DIM
2862  INTEGER, INTENT(IN) :: DIMID
2863  TYPE(NCVAR), INTENT(IN) :: LIST
2864  LOGICAL, INTENT(OUT) :: FOUND
2865  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2866 
2867  NULLIFY(dim)
2868  previous => list%DIMS
2869  current => previous%NEXT
2870  found = .false.
2871 
2872  DO
2873  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2874 
2875  IF( dimid == current%DIM%DIMID ) THEN ! FOUND THE DIM LINK
2876  dim => current%DIM
2877  found = .true.
2878  EXIT
2879  ELSE
2880  previous => previous%NEXT
2881  current => current%NEXT
2882  END IF
2883  END DO
2884 

◆ find_var_dim_byname()

type(ncdim) function, pointer mod_ncll::find_var_dim_byname ( type(ncvar), intent(in)  LIST,
character(len=*), intent(in)  NAME,
logical, intent(out)  FOUND 
)

Definition at line 2831 of file mod_ncll.f90.

2831  IMPLICIT NONE
2832  TYPE(NCDIM), POINTER :: DIM
2833  TYPE(NCVAR), INTENT(IN) :: LIST
2834  CHARACTER(LEN=*),INTENT(IN) :: NAME
2835  LOGICAL, INTENT(OUT) :: FOUND
2836  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2837 
2838  NULLIFY(dim)
2839  previous => list%DIMS
2840  current => previous%NEXT
2841  found = .false.
2842 
2843  DO
2844  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2845 
2846  IF( trim(name) == trim(current%DIM%DIMNAME) ) THEN ! FOUND THE FILE LINK
2847  dim => current%DIM
2848  found = .true.
2849  EXIT
2850  ELSE
2851  previous => previous%NEXT
2852  current => current%NEXT
2853  END IF
2854  END DO
2855 

◆ find_var_dim_unlimited()

type(ncdim) function, pointer mod_ncll::find_var_dim_unlimited ( type(ncvar), intent(in)  LIST,
logical, intent(out)  FOUND 
)

Definition at line 2889 of file mod_ncll.f90.

2889  IMPLICIT NONE
2890  TYPE(NCDIM), POINTER :: DIM
2891  TYPE(NCVAR), INTENT(IN) :: LIST
2892  LOGICAL, INTENT(OUT) :: FOUND
2893  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2894 
2895  NULLIFY(dim)
2896  previous => list%DIMS
2897  current => previous%NEXT
2898  found = .false.
2899 
2900  DO
2901  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2902 
2903  IF(current%DIM%UNLIMITED ) THEN ! FOUND THE DIM LINK
2904  dim => current%DIM
2905  found = .true.
2906  EXIT
2907  ELSE
2908  previous => previous%NEXT
2909  current => current%NEXT
2910  END IF
2911  END DO
2912 

◆ has_unlimited_ncf()

logical function mod_ncll::has_unlimited_ncf ( type(ncfile), intent(in)  LIST)

Definition at line 2806 of file mod_ncll.f90.

2806  IMPLICIT NONE
2807  TYPE(NCFILE), INTENT(IN):: LIST
2808  LOGICAL :: FOUND
2809  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2810 
2811  previous => list%DIMS
2812  current => previous%NEXT
2813  found = .false.
2814 
2815  DO
2816  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2817 
2818  IF(current%DIM%UNLIMITED ) THEN ! FOUND THE DIM LINK
2819  found = .true.
2820  EXIT
2821  ELSE
2822  previous => previous%NEXT
2823  current => current%NEXT
2824  END IF
2825  END DO
2826 

◆ has_unlimited_var()

logical function mod_ncll::has_unlimited_var ( type(ncvar), intent(in)  LIST)

Definition at line 2917 of file mod_ncll.f90.

2917  IMPLICIT NONE
2918  TYPE(NCVAR), INTENT(IN) :: LIST
2919  LOGICAL :: FOUND
2920  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
2921 
2922  previous => list%DIMS
2923  current => previous%NEXT
2924  found = .false.
2925 
2926  DO
2927  IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
2928 
2929  IF(current%DIM%UNLIMITED ) THEN ! FOUND THE DIM LINK
2930  found = .true.
2931  EXIT
2932  ELSE
2933  previous => previous%NEXT
2934  current => current%NEXT
2935  END IF
2936  END DO
2937 

◆ insert_filep_byncf()

subroutine mod_ncll::insert_filep_byncf ( type(ncfilelist), intent(inout)  LIST,
type(ncfile), pointer  NCF,
logical, intent(out)  FOUND 
)

Definition at line 703 of file mod_ncll.f90.

703  ! ONLY INSERT NEW FILE IF NOT FOUND
704  ! ALWAYS INSERT NCFILEP AT THE END OF THE LIST
705  IMPLICIT NONE
706  TYPE(NCFILE),POINTER :: NCF
707  LOGICAL, INTENT(OUT) :: FOUND
708  TYPE(NCFILELIST), INTENT(INOUT) :: LIST
709  TYPE(NCFILEP), pointer :: CURRENT, PREVIOUS
710 
711  IF(.NOT.ASSOCIATED(ncf))&
712  & CALL fatal_error("INSERT_FILEP_BYNCF: NCF NOT ASSOCIATED!")
713 
714  previous => list%FIRST
715  current => previous%NEXT
716  found = .false.
717  ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
718  DO
719  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
720  IF( ncf%FNAME == current%NCF%FNAME ) THEN ! FOUND THE FILE LINK
721  found = .true.
722  RETURN
723  ELSE
724  previous => previous%NEXT
725  current => current%NEXT
726  END IF
727  END DO
728  ! NOT FOUND - ADD NEW FILE TO END OF LIST
729 
730  previous%NEXT => new_filep()
731  previous%NEXT%NCF => ncf
732 
Here is the call graph for this function:

◆ insert_ncf_attp_byatt()

subroutine mod_ncll::insert_ncf_attp_byatt ( type(ncfile), intent(inout)  LIST,
type(ncatt), pointer  ATT,
logical, intent(out)  FOUND 
)

Definition at line 1802 of file mod_ncll.f90.

1802  ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
1803  ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
1804  IMPLICIT NONE
1805  TYPE(NCATT), POINTER :: ATT
1806  LOGICAL, INTENT(OUT) :: FOUND
1807  TYPE(NCFILE), INTENT(INOUT):: LIST
1808  TYPE(NCATTP),POINTER :: CURRENT, PREVIOUS
1809  INTEGER CNT
1810  IF(.NOT.ASSOCIATED(att))&
1811  & CALL fatal_error("INSERT_NCF_ATTP_BYATT: ATT NOT ASSOCIATED!")
1812 
1813  previous => list%ATTS
1814  current => previous%NEXT
1815  found = .false.
1816  cnt= 1
1817 
1818  ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
1819  DO
1820  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
1821  IF( att%ATTNAME == current%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
1822  found = .true.
1823  RETURN
1824  ELSE
1825  previous => previous%NEXT
1826  current => current%NEXT
1827  cnt = cnt + 1
1828  END IF
1829  END DO
1830  ! NOT FOUND - ADD NEW FILE TO END OF LIST
1831 
1832  previous%NEXT => new_attp()
1833  previous%NEXT%ATT => att
1834  att%ATTID = cnt ! SET THE ATTID
1835 
1836  previous%NEXT%NEXT => current
1837 
1838 
Here is the call graph for this function:

◆ insert_ncf_dimp_bydim()

subroutine mod_ncll::insert_ncf_dimp_bydim ( type(ncfile), intent(inout)  LIST,
type(ncdim), pointer  DIM,
logical, intent(out)  FOUND 
)

Definition at line 2554 of file mod_ncll.f90.

2554  ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
2555  ! INSERT UNLIMDIM AT THE END OF THE LIST
2556  ! INSERT NONE UNLIMDIM IN THE ORDER ADDED
2557  IMPLICIT NONE
2558  TYPE(NCDIM), POINTER :: DIM
2559  LOGICAL, INTENT(OUT) :: FOUND
2560  TYPE(NCFILE), INTENT(INOUT):: LIST
2561  TYPE(NCDIMP),POINTER :: CURRENT, PREVIOUS
2562  INTEGER CNT
2563  IF(.NOT.ASSOCIATED(dim))&
2564  & CALL fatal_error("INSERT_NCF_DIMP_BYDIM: DIM NOT ASSOCIATED!")
2565 
2566  previous => list%DIMS
2567  current => previous%NEXT
2568  found = .false.
2569  cnt = 1
2570 
2571 !!$ IF (DIM%UNLIMITED) THEN ! ADD AT END OF LIST!
2572  ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
2573  DO
2574  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST, ADD DIM
2575 
2576  IF( dim%DIMNAME == current%DIM%DIMNAME) THEN
2577  ! PROTECT AGAINST USER ERROR - MISMATCHED DIMENSIONS!
2578  IF(dim%DIM .NE. current%DIM%DIM) &
2579  & CALL fatal_error("ATEMPTED TO ADD DIMENSION NAMED:"//trim(dim%DIMNAME),&
2580  & "BUT THAT DIMENSION NAME ALREADY EXISTS WITH A DIFFERENT SIZE")
2581 
2582  ! PROTECT AGAINST USER ERROR - MISMATCHED UNLIMITED DIMENSIONS!
2583  IF(dim%UNLIMITED .AND. .NOT. current%DIM%UNLIMITED)&
2584  & CALL fatal_error("ATEMPTED TO ADD DIMENSION NAMED:&
2585  &"//trim(dim%DIMNAME)//"; AS UNLIMITED",&
2586  & "BUT THAT DIMENSION NAME ALREADY EXISTS AS NOT UNLIMITED")
2587 
2588  IF(.NOT. dim%UNLIMITED .AND. current%DIM%UNLIMITED)&
2589  & CALL fatal_error("ATEMPTED TO ADD DIMENSION NAMED:&
2590  &"//trim(dim%DIMNAME)//"; AS NOT UNLIMITED",&
2591  & "BUT THAT DIMENSION NAME ALREADY EXISTS AS UNLIMITED")
2592 
2593  found = .true.
2594  RETURN ! DIMENSION ALREADY EXISTS
2595  ELSE IF(dim%UNLIMITED .AND. current%DIM%UNLIMITED) THEN
2596  CALL fatal_error("ATTEMPT TO PUT A SECOND UNLIMITED DIMENSIO&
2597  &N IN THE FILE OBJECT","DIMENSION NAME: "//trim(dim%DIMNAME))
2598  ELSE
2599  previous => previous%NEXT
2600  current => current%NEXT
2601  cnt = cnt +1
2602  END IF
2603  END DO
2604  ! NOT FOUND - ADD NEW DIM TO END OF LIST
2605 
2606  previous%NEXT => new_dimp()
2607  previous%NEXT%DIM => dim
2608  previous%NEXT%NEXT => current
2609 
2610  dim%DIMID = cnt ! SET THE DIMID OF THE NEW DIMENSION
2611 
2612  IF(dim%UNLIMITED) list%UNLIMDIMID = dim%DIMID
2613 
2614 !!$ ELSE ! NOT AN UNLIMITED DIMENSION - ADD BEFORE ANY UNLIMITED DIMENSION
2615 !!$ ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
2616 !!$ DO
2617 !!$ IF(.NOT. ASSOCIATED(CURRENT)) EXIT !END OF LIST, ADD DIM TO END OF LIST
2618 !!$
2619 !!$ IF( DIM%DIMNAME == CURRENT%DIM%DIMNAME) THEN
2620 !!$ ! PROTECT AGAINST USER ERROR - MISMATCHED DIMENSIONS!
2621 !!$ IF(DIM%DIM .NE. CURRENT%DIM%DIM) &
2622 !!$ & CALL FATAL_ERROR("ATEMPTED TO ADD DIMENSION NAMED:"//TRIM(DIM%DIMNAME),&
2623 !!$ & "BUT THAT DIMENSION NAME ALREADY EXISTS WITH A DIFFERENT SIZE")
2624 !!$
2625 !!$ ! PROTECT AGAINST USER ERROR - MISMATCHED UNLIMITED DIMENSIONS!
2626 !!$ IF(CURRENT%DIM%UNLIMITED)&
2627 !!$ & CALL FATAL_ERROR("ATEMPTED TO ADD DIMENSION NAMED:&
2628 !!$ &"//TRIM(DIM%DIMNAME)//"; AS NOT UNLIMITED",&
2629 !!$ & "BUT THAT DIMENSION NAME ALREADY EXISTS AS UNLIMITED")
2630 !!$
2631 !!$ FOUND = .TRUE.
2632 !!$ RETURN ! DIMENSION ALREADY EXISTS
2633 !!$ ELSE IF(CURRENT%DIM%UNLIMITED) THEN ! FOUND THE UNLIMITED DIMENSION
2634 !!$ IF(ASSOCIATED(CURRENT%NEXT)) &
2635 !!$ & CALL FATAL_ERROR("FOUND EXTRA DIMENSION LINK AFTER&
2636 !!$ & THE UNLIMITED DIMENSION", "WHILE ADDING NEW DIMENSION: "&
2637 !!$ &//TRIM(DIM%DIMNAME) )
2638 !!$
2639 !!$ CURRENT%DIM%DIMID = CNT+1 ! INCRIMENT THE UNLIMITED DIMENSIONS DIMID
2640 !!$ EXIT ! Add the new dimension
2641 !!$
2642 !!$ ELSE
2643 !!$ PREVIOUS => PREVIOUS%NEXT
2644 !!$ CURRENT => CURRENT%NEXT
2645 !!$ CNT = CNT+1
2646 !!$ END IF
2647 !!$ END DO
2648 !!$ ! NOT FOUND - INSERT DIM INTO LIST
2649 !!$
2650 !!$ PREVIOUS%NEXT => NEW_DIMP()
2651 !!$ PREVIOUS%NEXT%DIM => DIM
2652 !!$ DIM%DIMID = CNT ! SET THE DIMID OF THE NEW DIMENSION
2653 !!$
2654 !!$ PREVIOUS%NEXT%NEXT => CURRENT
2655 !!$ END IF
2656 
Here is the call graph for this function:

◆ insert_var_attp_byatt()

subroutine mod_ncll::insert_var_attp_byatt ( type(ncvar), intent(inout)  LIST,
type(ncatt), pointer  ATT,
logical, intent(out)  FOUND 
)

Definition at line 1875 of file mod_ncll.f90.

1875  ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
1876  ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
1877  IMPLICIT NONE
1878  TYPE(NCATT),POINTER :: ATT
1879  LOGICAL, INTENT(OUT) :: FOUND
1880  TYPE(NCVAR), INTENT(INOUT):: LIST
1881  TYPE(NCATTP),POINTER :: CURRENT, PREVIOUS
1882  INTEGER CNT
1883  IF(.NOT.ASSOCIATED(att))&
1884  & CALL fatal_error("INSERT_VAR_ATTP_BYATT: ATT NOT ASSOCIATED!")
1885 
1886  previous => list%ATTS
1887  current => previous%NEXT
1888  found = .false.
1889  cnt = 1
1890  ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
1891  DO
1892  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
1893  IF( att%ATTNAME == current%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
1894  found = .true.
1895  RETURN
1896  ELSE
1897  previous => previous%NEXT
1898  current => current%NEXT
1899  cnt = cnt + 1
1900  END IF
1901  END DO
1902  ! NOT FOUND - ADD NEW FILE TO END OF LIST
1903  previous%NEXT => new_attp()
1904  previous%NEXT%ATT => att
1905 
1906  att%ATTID = cnt ! SET THE ATTID
1907 
Here is the call graph for this function:

◆ insert_var_dimp_bydim()

subroutine mod_ncll::insert_var_dimp_bydim ( type(ncvar), intent(inout)  LIST,
type(ncdim), pointer  DIM,
logical, intent(out)  FOUND 
)

Definition at line 2666 of file mod_ncll.f90.

2666  ! ALLOW NETCDF TO HAVE DUPLICATE DIMENSIONS IN A VARIABLE
2667  ! INSERT DIMS IN THE ORDER THEY ARE ADDED
2668  !
2669  ! DO NOT TOUCH DIMID - IT IS ONLY SET WHEN THE VARIABLE'S
2670  ! DIMENSIONS ARE POINTED TO THE FILES DIMENSIONS
2671 
2672  IMPLICIT NONE
2673  TYPE(NCDIM), POINTER :: DIM
2674  LOGICAL, INTENT(OUT) :: FOUND
2675  TYPE(NCVAR), INTENT(INOUT):: LIST
2676  TYPE(NCDIMP),POINTER :: CURRENT, PREVIOUS
2677 
2678  IF(.NOT.ASSOCIATED(dim))&
2679  & CALL fatal_error("INSERT_NCF_DIMP_BYDIM: DIM NOT ASSOCIATED!")
2680 
2681  previous => list%DIMS
2682  current => previous%NEXT
2683  found = .false.
2684 
2685  DO
2686  IF(.NOT. ASSOCIATED(current)) THEN
2687  EXIT !END OF LIST, ADD DIM
2688  ELSE
2689 
2690  IF( dim%DIMNAME == current%DIM%DIMNAME) found = .true.
2691 
2692  IF(dim%UNLIMITED .AND. current%DIM%UNLIMITED) &
2693  & CALL fatal_error("ATTEMPT TO PUT A SECOND UNLIMITED DIMENSIO&
2694  &N IN THE VARIALBE NAME:"//trim(list%VARNAME),&
2695  & "DIMENSION NAME: "//trim(dim%DIMNAME))
2696 
2697  ! MAKE AN EXCEPTION FOR CHARACTER DATA?!?!
2698  IF(current%DIM%UNLIMITED .AND. list%XTYPE .NE. nf90_char) &
2699  & CALL fatal_error("ATTEMPT TO PUT A DIMENSION AFTER THE UNLIMITED DIMENSIO&
2700  &N IN THE VARIALBE NAME:"//trim(list%VARNAME),&
2701  & "DIMENSION NAME: "//trim(dim%DIMNAME),"THE USER MUST &
2702  &ADD DIMENSION IN THE CORRECT ORDER! (UNLIMITEDS GO LAS&
2703  &T IN FORTRAN ORDER)")
2704 
2705 
2706  previous => previous%NEXT
2707  current => current%NEXT
2708  END IF
2709  END DO
2710  ! NOT FOUND - ADD NEW DIM TO END OF LIST, EVEN IF IT ALREADY
2711  ! EXISTS!
2712  previous%NEXT => new_dimp()
2713  previous%NEXT%DIM => dim
2714  previous%NEXT%NEXT => current
2715 
Here is the call graph for this function:

◆ insert_varp_byvar()

subroutine mod_ncll::insert_varp_byvar ( type(ncfile), intent(inout)  LIST,
type(ncvar), pointer  VAR,
logical, intent(out)  FOUND 
)

Definition at line 1212 of file mod_ncll.f90.

1212  ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
1213  ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
1214  IMPLICIT NONE
1215  TYPE(NCVAR),POINTER :: VAR
1216  LOGICAL, INTENT(OUT) :: FOUND
1217  TYPE(NCFILE), INTENT(INOUT):: LIST
1218  TYPE(NCVARP),POINTER :: CURRENT, PREVIOUS
1219  INTEGER CNT
1220 
1221  IF(.NOT.ASSOCIATED(var))&
1222  & CALL fatal_error("INSERT_VARP_BYVAR: VAR NOT ASSOCIATED!")
1223 
1224  previous => list%VARS
1225  current => previous%NEXT
1226  found = .false.
1227  cnt = 1
1228  ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
1229  DO
1230  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
1231  IF( var%VARNAME == current%VAR%VARNAME ) THEN ! FOUND THE FILE LINK
1232  found = .true.
1233  RETURN
1234  ELSE
1235  previous => previous%NEXT
1236  current => current%NEXT
1237  cnt = cnt + 1
1238  END IF
1239  END DO
1240  ! NOT FOUND - ADD NEW FILE TO END OF LIST
1241  previous%NEXT => new_varp()
1242  previous%NEXT%VAR => var
1243  var%VARID = cnt
1244 
Here is the call graph for this function:

◆ kill_att()

subroutine mod_ncll::kill_att ( type(ncatt), pointer  ATT)

Definition at line 1751 of file mod_ncll.f90.

1751  TYPE(NCATT),POINTER :: ATT
1752  INTEGER STATUS
1753  IF(ASSOCIATED(att)) THEN
1754  IF(ALLOCATED(att%INT)) DEALLOCATE(att%INT)
1755  IF(ALLOCATED(att%FLT)) DEALLOCATE(att%FLT)
1756  IF(ALLOCATED(att%DBL)) DEALLOCATE(att%DBL)
1757  IF(ALLOCATED(att%CHR)) DEALLOCATE(att%CHR)
1758 
1759  DEALLOCATE(att,stat=status)
1760  IF(status /= 0) CALL fatal_error("KILL_ATT: COULD NOT DEALLOCATE")
1761  NULLIFY(att)
1762  END IF
1763 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kill_dim()

subroutine mod_ncll::kill_dim ( type(ncdim), pointer  DIM)

Definition at line 2539 of file mod_ncll.f90.

2539  TYPE(NCDIM),POINTER :: DIM
2540  INTEGER STATUS
2541  DEALLOCATE(dim,stat=status)
2542  IF(status /= 0) CALL fatal_error("KILL_DIM: COULD NOT DEALLOCATE")
2543  NULLIFY(dim)
2544 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kill_file()

subroutine mod_ncll::kill_file ( type(ncfile), pointer  NCF)

Definition at line 628 of file mod_ncll.f90.

628  TYPE(NCFILE),POINTER :: NCF
629  INTEGER STATUS
630 
631  IF(.not. ASSOCIATED(ncf))THEN
632 
633  IF(dbg_set(dbg_log)) CALL warning &
634  & ("CALLED KILL FILL BUT FILE OBJECT IS NOT ASSOCIATED?")
635  RETURN
636  END IF
637 
638  IF (ncf%OPEN) THEN
639  status = nf90_close(ncf%ncid)
640  END IF
641 
642  CALL delete_var_list(ncf)
643  DEALLOCATE(ncf%VARS)
644 
645  CALL delete_dim_list(ncf)
646  DEALLOCATE(ncf%DIMS)
647 
648  CALL delete_att_list(ncf)
649  DEALLOCATE(ncf%ATTS)
650 
651  IF(ASSOCIATED(ncf%FTIME)) THEN
652  NULLIFY(ncf%FTIME%TM1)
653  NULLIFY(ncf%FTIME%TM2)
654  DEALLOCATE(ncf%FTIME)
655  NULLIFY (ncf%FTIME)
656  END IF
657 
658  ! INTERP MEMORY IS NEVER BELLONGS TO THE FILE POINTER
659  IF(ASSOCIATED(ncf%INTERP_N)) Nullify(ncf%INTERP_N)
660  IF(ASSOCIATED(ncf%INTERP_C)) Nullify(ncf%INTERP_C)
661 
662  DEALLOCATE(ncf%NCID)
663  NULLIFY(ncf%NCID)
664 
665  DEALLOCATE(ncf,stat=status)
666  IF(status /= 0) CALL fatal_error("KILL_FILE: COULD NOT DEALLOCATE")
667  NULLIFY(ncf)
668 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kill_filehead()

subroutine mod_ncll::kill_filehead ( type(ncfilelist), pointer  FILEHEAD)

Definition at line 533 of file mod_ncll.f90.

533  IMPLICIT NONE
534  TYPE(NCFILELIST), POINTER :: FILEHEAD
535 
536  call delete_file_list(filehead)
537  DEALLOCATE(filehead)
538  NULLIFY(filehead)
539 
Here is the call graph for this function:

◆ kill_var()

subroutine mod_ncll::kill_var ( type(ncvar), pointer  VAR)

Definition at line 1163 of file mod_ncll.f90.

1163  TYPE(NCVAR),POINTER :: VAR
1164  INTEGER STATUS
1165 
1166  IF(.not.ASSOCIATED(var)) RETURN
1167 
1168  CALL delete_dim_list(var)
1169  DEALLOCATE(var%DIMS)
1170 
1171  CALL delete_att_list(var)
1172  DEALLOCATE(var%ATTS)
1173 
1174  DEALLOCATE(var,stat=status)
1175  IF(status /= 0) CALL fatal_error("KILL_VAR: COULD NOT DEALLOCATE")
1176  NULLIFY(var)
1177 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mem_dims()

integer function, dimension(:), pointer mod_ncll::mem_dims ( type(ncvar), intent(in)  LIST)

Definition at line 3012 of file mod_ncll.f90.

3012  TYPE(NCVAR), INTENT(IN) :: LIST
3013  INTEGER, POINTER :: DIMS(:)
3014  TYPE(NCDIMP),POINTER :: CURRENT, PREVIOUS
3015  INTEGER :: CNT, status
3016 
3017  previous => list%DIMS
3018  current => previous%NEXT
3019  cnt = 0
3020 ! ALLOCATE(DIMS(COUNT_DIM_LIST(LIST)),stat=status)
3021 
3022  ALLOCATE(dims(count_nonsingleton_dim_list(list)),stat=status)
3023  if(status /= 0) CALL fatal_error("VAR_DIMS: Can not allocate DIMS")
3024 
3025  IF(SIZE(dims)==0) RETURN
3026 
3027  dims=0
3028 
3029  DO
3030  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
3031  cnt= cnt+1
3032 
3033  dims(cnt) = current%DIM%DIM
3034 
3035  previous => previous%NEXT
3036  current => current%NEXT
3037 
3038  END DO
3039 
3040  if(cnt .NE. count_dim_list(list)) CALL fatal_error&
3041  &("VAR_DIMS: THE NUMBER OF DIMENSION OBJECTS IN THE VARIABL&
3042  &ES LIST EXCEEDS THE VARIABLES NDIMS PROPERTY")
3043 
3044 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ncf_plus_att()

type(ncfile) function, pointer mod_ncll::ncf_plus_att ( type(ncfile), pointer  NCF,
type(ncatt), pointer  ATT 
)

Definition at line 3732 of file mod_ncll.f90.

3732  IMPLICIT NONE
3733  type(NCATT), POINTER :: ATT
3734  type(NCFILE), POINTER :: RET
3735  type(NCFILE), POINTER :: NCF
3736  LOGICAL FOUND
3737  if(dbg_set(dbg_sbr)) &
3738  & write(ipt,*) "START NCF_PLUS_ATT"
3739 
3740  IF(.NOT. ASSOCIATED(ncf)) CALL fatal_error &
3741  & ("NCF_PLUS_ATT: THE FILE OBJECT ARGUMENT IS NOT ASSOC&
3742  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3743 
3744  IF(.NOT. ASSOCIATED(att)) CALL fatal_error &
3745  & ("NCF_PLUS_ATT: THE ATT OBJECT ARGUMENT IS NOT ASSOC&
3746  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3747 
3748  IF(ncf%CONNECTED) CALL fatal_error&
3749  ("CAN NOT ADD ATTRIBUTE TO FILE OBJECTS ALREADY CONNECTED TO A NETCDF FILE")
3750 
3751  CALL insert_att_link(ncf,att,found)
3752  ! ADD ERROR HANDLING LATER FOR MERGING ATTS
3753  IF(found) CALL fatal_error("ERROR ADDIND ATTRIBUTE TO FILE",&
3754  & "THE ATTRIBUTE: "//trim(att%ATTNAME)//"; ALREADY EXISTS",&
3755  & "IN THE FILE: "//trim(ncf%FNAME))
3756 
3757 
3758  !ALL MEMORY NOW BELONGS TO RET
3759  ret => ncf
3760  NULLIFY(ncf)
3761  NULLIFY(att)
3762  if(dbg_set(dbg_sbr)) &
3763  & write(ipt,*) "END NCF_PLUS_ATT"
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ncf_plus_dim()

type(ncfile) function, pointer mod_ncll::ncf_plus_dim ( type(ncfile), pointer  NCF,
type(ncdim), pointer  DIM 
)

Definition at line 3768 of file mod_ncll.f90.

3768  IMPLICIT NONE
3769  type(NCDIM), POINTER :: DIM
3770  type(NCFILE), POINTER :: RET
3771  type(NCFILE), POINTER :: NCF
3772  LOGICAL FOUND
3773  if(dbg_set(dbg_sbr)) &
3774  & write(ipt,*) "START NCF_PLUS_DIM"
3775 
3776  IF(.NOT. ASSOCIATED(ncf)) CALL fatal_error &
3777  & ("NCF_PLUS_DIM: THE FILE OBJECT ARGUMENT IS NOT ASSOC&
3778  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3779 
3780  IF(.NOT. ASSOCIATED(dim)) CALL fatal_error &
3781  & ("NCF_PLUS_DIM: THE DIM OBJECT ARGUMENT IS NOT ASSOC&
3782  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3783 
3784 
3785  IF(ncf%CONNECTED) CALL fatal_error&
3786  ("CAN NOT ADD DIMENSION TO FILE OBJECTS ALREADY CONNECTED TO A NETCDF FILE")
3787 
3788  CALL insert_dim_link(ncf,dim,found)
3789 
3790  ! ADDING DUPLICATE DIMENSIONS TO A FILE IS NOT IS OKAY
3791  IF(found) CALL fatal_error("ERROR ADDIND DIMENSION TO FILE",&
3792  & "THE DIMENSION: "//trim(dim%DIMNAME)//"; ALREADY EXISTS",&
3793  & "IN THE FILE: "//trim(ncf%FNAME))
3794 
3795 
3796  !ALL MEMORY NOW BELONGS TO RET
3797  ret => ncf
3798  NULLIFY(ncf)
3799  NULLIFY(dim)
3800 
3801  if(dbg_set(dbg_sbr)) &
3802  & write(ipt,*) "END NCF_PLUS_DIM"
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:

◆ ncf_plus_ncf()

type(ncfile) function, pointer mod_ncll::ncf_plus_ncf ( type(ncfile), pointer  NCF1,
type(ncfile), pointer  NCF2 
)

Definition at line 3807 of file mod_ncll.f90.

3807  ! ADD EACH VARIABLE FROM NCF2 TO NCF1
3808  ! THE VARIABLES WILL TAKE THEIR DIMENSIONS WITH THEM AS NEEDED
3809  !
3810  ! ADD ANY ATTRIBUTES THAT DO NOT ALREADY EXIST IN NCF1
3811 
3812  IMPLICIT NONE
3813  type(NCFILE), POINTER :: NCF1
3814  type(NCFILE), POINTER :: NCF2
3815  type(NCFILE), POINTER :: RET
3816 
3817  type(NCVARP), POINTER :: CURRENT_VAR
3818  type(NCVAR), POINTER :: VAR
3819 
3820  type(NCDIMP), POINTER :: CURRENT_DIM
3821  type(NCDIM), POINTER :: DIM1
3822  type(NCDIM), POINTER :: DIM2
3823 
3824  TYPE(NCATTP), POINTER :: CURRENT_ATT
3825 !!$
3826  TYPE(NCATT), POINTER :: ATTT
3827 !!$
3828 
3829  CHARACTER(LEN=NF90_MAX_NAME+1):: NAME
3830  LOGICAL FOUND1, FOUND2
3831 
3832  if(dbg_set(dbg_sbr)) &
3833  & write(ipt,*) "START NCF_PLUS_NCF"
3834 
3835 
3836  IF(.NOT. ASSOCIATED(ncf1)) CALL fatal_error &
3837  & ("NCF_PLUS_NCF: THE FIRST FILE OBJECT ARGUMENT IS NOT ASSOC&
3838  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3839 
3840  IF(.NOT. ASSOCIATED(ncf2)) CALL fatal_error &
3841  & ("NCF_PLUS_NCF: THE SECOND FILE OBJECT ARGUMENT IS NOT ASSOC&
3842  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3843 
3844  IF(ncf1%CONNECTED .OR. ncf2%CONNECTED) CALL fatal_error&
3845  ("CAN NOT COMBINE FILE OBJECTS ALREADY CONNECTED TO A NETCDF FILE")
3846 
3847  current_var => ncf2%VARS%NEXT
3848 
3849  DO
3850  IF(.NOT. ASSOCIATED(current_var)) EXIT
3851 
3852  IF (.NOT. ASSOCIATED(current_var%VAR)) &
3853  & CALL fatal_error("NCF_PLUS_NCF: ATTEMPT TO ADD A FILE &
3854  &THAT HAS UNASSOCIATED VAR POINTER IN ITS LINK LIST!")
3855 
3856  ! Variable from the second file
3857  var =>copy_var(current_var%VAR)
3858  !DISCONECT THE VARIABLE MOMENTARILY
3859  var%CONNECTED=.false.
3860 
3861 
3862  current_dim=>var%DIMS%NEXT
3863  DO
3864  IF(.NOT. ASSOCIATED(current_dim)) EXIT
3865 
3866  IF (.NOT. ASSOCIATED(current_dim%DIM)) &
3867  & CALL fatal_error("NCF_PLUS_NCF: ATTEMPT TO ADD VARIABLE &
3868  &THAT HAS UNASSOCIATED DIM POINTERS IN ITS LINK LIST!")
3869 
3870  !DIM from the variable of the second file
3871  dim2 => current_dim%DIM
3872 
3873  CALL insert_dim_link(ncf1,dim2,found1)
3874  ! THIS WILL ADD THE VARIABLES DIMENSION IF IT IS NOT THERE ALREADY
3875  ! IN THE FILE. THERE IS SOME BASIC CONSISTANCY CHECKING.
3876 
3877  ! IF WE JUST ADDED IT, GREAT! NOW THE FILE'S DIM LINK LIST AND
3878  ! THE VARIABLE'S DIM LINK LIST ALREADY POINT TO THE SAME MEMORY
3879 
3880  ! IF WE FOUND IT IN THE FILE TO WHICH THE VARIABLE IS BEING
3881  ! ADDED MOVE THE POINTER OVER
3882  IF (found1) THEN
3883  current_dim%DIM => find_dim(ncf1,dim2%DIMNAME,found2)
3884  IF (.NOT. found2) CALL fatal_error("NCF_PLUS_NCF: CAN'T FIN&
3885  &D DIMENSION IN FILE BUT IT WAS HERE A SECOND AGO?")
3886  CALL kill_dim(dim2)
3887 
3888  END IF
3889 
3890  current_dim => current_dim%NEXT
3891  END DO
3892 
3893  ! NOW ADD THE VARIABLE TO THE FILE
3894 
3895  CALL insert_var_link(ncf1,var,found1)
3896  IF(found1) CALL fatal_error("NCF_PLUS_VAR: THIS VARIABLE ALREADY EX&
3897  &ISTS IN THE FILE. YOU CAN'T ADD IT AGAIN!", &
3898  & "VARIABLE NAME: "//trim(var%VARNAME))
3899 
3900 
3901  var%NCID => ncf1%NCID
3902  var%CONNECTED=.true.
3903 
3904  current_var => current_var%NEXT
3905  END DO
3906 
3907 
3908 !!$ ! NOW GO THROUGH DIMENSION LIST IN BOTH FILES AND DELETE DUPLICATES!
3909 !!$ CURRENT_DIM=>NCF2%DIMS%NEXT
3910 !!$ DO
3911 !!$ IF(.NOT. ASSOCIATED(CURRENT_DIM)) EXIT
3912 !!$
3913 !!$ IF (.NOT. ASSOCIATED(CURRENT_DIM%DIM)) &
3914 !!$ & CALL FATAL_ERROR("NCF_PLUS_NCF: ATTEMPT TO ADD VARIABLE &
3915 !!$ &THAT HAS UNASSOCIATED DIM POINTERS IN ITS LINK LIST!")
3916 !!$
3917 !!$ !DIM from the second file
3918 !!$ DIM2 => CURRENT_DIM%DIM
3919 !!$
3920 !!$ DIM1 => FIND_DIM(NCF1,DIM2%DIMNAME,FOUND1)
3921 !!$ IF (.NOT. FOUND1) THEN
3922 !!$ CALL FATAL_ERROR("NCF_PLUS_NCF: ALL DIMENSIO&
3923 !!$ &NS FROM FILE TWO SHOULD ALREADY BE ADDED TO FILE ONE:",&
3924 !!$ &"FOUND DIMNAME: "//DIM2%DIMNAME//" IN FILE 2 BUT NOT IN 1&
3925 !!$ & ?")
3926 !!$ ELSE
3927 !!$ IF(.not. associated(DIM1,target = DIM2)) CALL KILL_DIM(DIM2)
3928 !!$ END IF
3929 !!$
3930 !!$ CURRENT_DIM => CURRENT_DIM%NEXT
3931 !!$
3932 !!$ END DO
3933 
3934 
3935  current_att => ncf2%ATTS%NEXT
3936  DO
3937  IF(.NOT. ASSOCIATED(current_att)) EXIT
3938 
3939  IF (.NOT. ASSOCIATED(current_att%ATT)) &
3940  & CALL fatal_error("NCF_PLUS_NCF: ATTEMPT TO ADD A FILE &
3941  &THAT HAS UNASSOCIATED ATT POINTER IN ITS LINK LIST!")
3942 
3943  attt => copy_att(current_att%ATT)
3944  ncf1 => ncf_plus_att(ncf1,attt)
3945 !!$ NCF1 => NCF_PLUS_ATT(NCF1,Copy_Att(CURRENT_ATT%ATT))
3946  !ALREADY INCRIMENTED NATTS
3947 
3948  current_att => current_att%NEXT
3949  END DO
3950 
3951 
3952 
3953  ret => ncf1
3954  NULLIFY(ncf1)
3955  CALL kill_file(ncf2)
3956  NULLIFY(ncf2)
3957 
3958  if(dbg_set(dbg_sbr)) &
3959  & write(ipt,*) "END NCF_PLUS_NCF"
3960 
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:

◆ ncf_plus_var()

type(ncfile) function, pointer mod_ncll::ncf_plus_var ( type(ncfile), pointer  NCF,
type(ncvar), pointer  VAR 
)

Definition at line 3626 of file mod_ncll.f90.

3626  ! ADD THE VARIABLE TO THE FILE LIST IF IT DOES NOT ALREADY EXIST
3627  !
3628  ! ADD THE VARIABLES DIMENSIONS IF THEY DO NOT EXIST IN THE FILE LIST
3629  ! OR POINT TO THE FILES DIMENSIONS AND USE THE FILES DIMIDS IF THE
3630  ! DIMENSION ALREADY EXISTS IN THE FILE'S LIST
3631  !
3632  ! ATTRIBUTES BELONG TO THE VARIABLE, JUST ADD THEM WITH THE VARIABLE
3633  IMPLICIT NONE
3634  type(NCVAR), POINTER :: VAR
3635  type(NCFILE), POINTER :: RET
3636  type(NCFILE), POINTER :: NCF
3637  type(NCDIM), POINTER :: VDIM, GDIM
3638  type(NCDIMP), POINTER :: CURRENT
3639 
3640  LOGICAL :: FOUND, F
3641  CHARACTER(LEN=NF90_MAX_NAME+1):: NAME
3642  if(dbg_set(dbg_sbr)) &
3643  & write(ipt,*) "START NCF_PLUS_VAR"
3644 
3645  IF(.NOT. ASSOCIATED(ncf)) CALL fatal_error &
3646  & ("NCF_PLUS_VAR: THE FILE OBJECT ARGUMENT IS NOT ASSOC&
3647  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3648 
3649  IF(.NOT. ASSOCIATED(var)) CALL fatal_error &
3650  & ("NCF_PLUS_VAR: THE VAR OBJECT ARGUMENT IS NOT ASSOC&
3651  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3652 
3653 
3654  IF(ncf%CONNECTED) CALL fatal_error&
3655  ("CAN NOT ADD VARIABLE TO FILE OBJECTS ALREADY CONNECTED TO A NETCDF FILE")
3656 
3657  IF(var%CONNECTED) CALL fatal_error&
3658  ("CAN NOT ADD VARIABLE TO A FILE OBJECT WHEN IT IS ALREADY CONNECTED")
3659 
3660 
3661  ! LOOK TO SEE IF WE NEED TO ADD ANY NEW DIMENSIONS TO THE FILE
3662  current=>var%DIMS%NEXT
3663  DO
3664  IF(.NOT. ASSOCIATED(current)) EXIT
3665 
3666  IF (.NOT. ASSOCIATED(current%DIM)) &
3667  & CALL fatal_error("NCF_PLUS_VAR: ATTEMPT TO ADD VARIABLE &
3668  &THAT HAS UNASSOCIATED DIM POINTERS IN ITS LINK LIST!")
3669 
3670  vdim => current%DIM
3671 
3672  CALL insert_dim_link(ncf,vdim,found)
3673  ! THIS WILL ADD THE VARIABLES DIMENSION IF IT IS NOT THERE ALREADY
3674  ! IN THE FILE. THERE IS SOME BASIC CONSISTANCY CHECKING.
3675 
3676  ! IF WE JUST ADDED IT, GREAT! NOW THE FILE'S DIM LINK LIST AND
3677  ! THE VARIABLE'S DIM LINK LIST ALREADY POINT TO THE SAME MEMORY
3678 
3679  IF(found) THEN ! THE DIMENSION IS ALREADY THERE.
3680 
3681  name = vdim%DIMNAME
3682  gdim => find_dim(ncf,name,f)
3683  IF(.NOT. f) CALL fatal_error("NCF_PLUS_VAR: CAN'T FIND D&
3684  &IMENSION BUT IT WAS THERE A MINUTE AGO?")
3685 
3686  IF (.not. associated(vdim,target = gdim)) THEN ! CHECKS TO SEE IF IT IS
3687  ! POINTING TO THE SAME MEMORY OR TRUELY A DUPLICATE
3688 
3689  ! DELETE THE DUPLICATE AND POINT TO THE FILES DIM LINK LIST
3690 
3691  ! THIS ALLOWS THE FILE TO SET THE DIMIDS. DIMIDS SET IN THE
3692  ! VARIABLES DIM LIST ARE IGNORED
3693  CALL kill_dim(vdim)
3694 
3695  ! MOVE NOW EMPTY VARIABLE'S DIM LINK LIST POINTER TO FILE'S DIM LINK LIST
3696  current%DIM => gdim
3697  END IF
3698  END IF
3699  current => current%NEXT
3700  END DO
3701 
3702  ! NOW ADD THE VARIABLE TO THE FILE
3703 
3704  CALL insert_var_link(ncf,var,found)
3705  IF(found) CALL fatal_error("NCF_PLUS_VAR: THIS VARIABLE ALREADY EX&
3706  &ISTS IN THE FILE. YOU CAN'T ADD IT AGAIN!", &
3707  & "VARIABLE NAME: "//trim(var%VARNAME))
3708 
3709 
3710 ! IF(ASSOCIATED(VAR%NCID)) THEN
3711  ! IF(VAR%NCID /= NCF%NCID) &
3712 ! CALL FATAL_ERROR&
3713 ! &("CAN'T ADD VARIABLE TO A FILE WITH A DIFFERENT NCID")
3714 ! ELSE
3715 
3716 ! END IF
3717 
3718  var%NCID => ncf%NCID
3719  var%CONNECTED=.true.
3720 
3721  !ALL MEMORY NOW BELONGS TO RET
3722  ret => ncf
3723  NULLIFY(ncf)
3724  NULLIFY(var)
3725  if(dbg_set(dbg_sbr)) &
3726  & write(ipt,*) "END NCF_PLUS_VAR"
3727 
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:

◆ ncflist_plus_ncf()

type(ncfilelist) function, pointer mod_ncll::ncflist_plus_ncf ( type(ncfilelist), pointer  NCFLIST,
type(ncfile), pointer  NCF 
)

Definition at line 3965 of file mod_ncll.f90.

3965  IMPLICIT NONE
3966  type(NCFILELIST), POINTER :: NCFLIST
3967  type(NCFILELIST), POINTER :: RET
3968  type(NCFILE), POINTER :: NCF
3969  LOGICAL FOUND
3970 
3971  IF (.NOT. ASSOCIATED(ncflist))THEN
3972  ALLOCATE(ncflist)
3973  ncflist%FIRST => new_filep()
3974  END IF
3975 
3976  CALL insert_file_link(ncflist,ncf,found)
3977  IF(found) CALL fatal_error("NCFLIST_PLUS_NCF: THIS FILE ALREADY EX&
3978  &ISTS IN THE FILELIST. YOU CAN'T ADD IT AGAIN!", &
3979  & "FILE NAME: "//trim(ncf%FNAME))
3980 
3981  !ALL MEMORY IN NCFLIST NOW BELONGS TO RET
3982  ret => ncflist
3983  NULLIFY(ncflist)
3984  NULLIFY(ncf)
Here is the call graph for this function:

◆ new_att()

type(ncatt) function, pointer mod_ncll::new_att ( )

Definition at line 1455 of file mod_ncll.f90.

1455  IMPLICIT NONE
1456 ! CHARACTER(LEN=*),INTENT(IN) :: NAME
1457  TYPE(NCATT), POINTER :: ATT
1458  integer status
1459 
1460  ALLOCATE(att,stat=status)
1461  if(status/=0) CALL fatal_error("NEW_ATT: COULD NOT ALLOCATE!")
1462 
1463 ! ATT%ATTNAME = NAME
1464  att%ATTNAME = ' '
1465  att%LEN = -1
1466  att%ATTID = 0
1467  att%XTYPE = -1
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_attp()

type(ncattp) function, pointer mod_ncll::new_attp ( )

Definition at line 1472 of file mod_ncll.f90.

1472  IMPLICIT NONE
1473  TYPE(NCATTP), POINTER :: ATTP
1474  integer status
1475 
1476  ALLOCATE(attp,stat=status)
1477  if(status/=0) CALL fatal_error("NEW_ATTP COULD NOT ALLOCATE!")
1478  NULLIFY(attp%NEXT)
1479  NULLIFY(attp%ATT)
1480 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_dim()

type(ncdim) function, pointer mod_ncll::new_dim ( )

Definition at line 2198 of file mod_ncll.f90.

2198  IMPLICIT NONE
2199  TYPE(NCDIM), POINTER :: DIM
2200  integer status
2201 
2202  ALLOCATE(dim,stat=status)
2203  if(status/=0) CALL fatal_error("ALLOC_DIM: COULD NOT ALLOCATE!")
2204 
2205  dim%DIMID = -1
2206  dim%DIMNAME =" "
2207  dim%DIM = -1
2208  dim%UNLIMITED = .false.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_dimp()

type(ncdimp) function, pointer mod_ncll::new_dimp ( )

Definition at line 2287 of file mod_ncll.f90.

2287  IMPLICIT NONE
2288  TYPE(NCDIMP), POINTER :: DIMP
2289  integer status
2290 
2291  NULLIFY(dimp)
2292  ALLOCATE(dimp,stat=status)
2293  if(status/=0) CALL fatal_error("ALLOC_NCDIMP COULD NOT ALLOCATE!")
2294  NULLIFY(dimp%NEXT)
2295  NULLIFY(dimp%DIM)
2296 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_file()

type(ncfile) function, pointer mod_ncll::new_file ( character(len=*), intent(in), optional  fname)

Definition at line 364 of file mod_ncll.f90.

364  IMPLICIT NONE
365 ! CHARACTER(LEN=160), INTENT(IN) :: NAME
366  TYPE(NCFILE), POINTER :: NCF
367  CHARACTER(len=*), OPTIONAL, INTENT(IN) :: FNAME
368  integer status
369 
370  nullify(ncf)
371  ALLOCATE(ncf,stat=status)
372  if(status/=0) CALL fatal_error("NEW_FILE: COULD NOT ALLOCATE!")
373 
374  Nullify(ncf%NCID)
375  ALLOCATE(ncf%NCID)
376  ncf%NCID = -1
377  ncf%FNAME = ' '
378  IF (PRESENT(fname)) ncf%FNAME=fname
379  ncf%WRITABLE = .false.
380  ncf%OPEN = .false.
381  ncf%CONNECTED = .false.
382  ncf%UNLIMDIMID = -1
383 
384  NULLIFY(ncf%FTIME)
385  NULLIFY(ncf%INTERP_N)
386  NULLIFY(ncf%INTERP_C)
387 
388  ! TIME VARIABLES ARE ALL INTEGER => AUTOMATICALLY INITIALIZED TO ZERO
389 
390  ! MAKE NEW LISTS FOR THE NCFILE
391  ncf%DIMS => new_dimp()
392  ncf%ATTS => new_attp()
393  ncf%VARS => new_varp()
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_filehead()

type(ncfilelist) function, pointer mod_ncll::new_filehead ( )

Definition at line 521 of file mod_ncll.f90.

521  IMPLICIT NONE
522  TYPE(NCFILELIST), POINTER :: FILEHEAD
523  integer status
524 
525  ALLOCATE(filehead,stat=status)
526  if(status/=0) CALL fatal_error("ALLOC_FILEHEAD: COULD NOT ALLOCATE!")
527  filehead%FIRST => new_filep()
528 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_filep()

type(ncfilep) function, pointer mod_ncll::new_filep ( )

Definition at line 507 of file mod_ncll.f90.

507  IMPLICIT NONE
508  TYPE(NCFILEP), POINTER :: NCFP
509  integer status
510 
511  ALLOCATE(ncfp,stat=status)
512  if(status/=0) CALL fatal_error("ALLOC_FILEP: COULD NOT ALLOCATE!")
513  NULLIFY(ncfp%NEXT)
514  NULLIFY(ncfp%NCF)
515 
516 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_ftime()

type(ncftime) function, pointer mod_ncll::new_ftime ( )

Definition at line 471 of file mod_ncll.f90.

471  IMPLICIT NONE
472  TYPE(NCFTIME), POINTER :: FTM
473  integer status
474 
475  ALLOCATE(ftm,stat=status)
476  if(status/=0) CALL fatal_error("NEW_FTM: COULD NOT ALLOCATE FTM!")
477 
478  nullify(ftm%tm1)
479  nullify(ftm%tm2)
480 
481  ftm%TIMEZONE="none"
482 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_var()

type(ncvar) function, pointer mod_ncll::new_var ( )

Definition at line 945 of file mod_ncll.f90.

945  IMPLICIT NONE
946 ! CHARACTER(Len=*), INTENT(IN) :: NAME
947  TYPE(NCVAR), POINTER :: VAR
948  integer status
949 
950  ALLOCATE(var,stat=status)
951  if(status/=0) CALL fatal_error("NEW_VAR: COULD NOT ALLOCATE!")
952 
953  NULLIFY(var%NCID)
954  var%CONNECTED = .false.
955  var%VARID = -1
956 ! VAR%VARNAME = NAME
957  var%VARNAME = ' '
958  var%XTYPE = -1
959  nullify(var%DIMS)
960  nullify(var%ATTS)
961 
962  var%DIMS => new_dimp()
963  var%ATTS => new_attp()
964 
965  nullify(var%scl_int)
966  nullify(var%vec_int)
967  nullify(var%arr_int)
968  nullify(var%cub_int)
969  nullify(var%fda_int)
970 
971  nullify(var%scl_flt)
972  nullify(var%vec_flt)
973  nullify(var%arr_flt)
974  nullify(var%cub_flt)
975  nullify(var%fda_flt)
976 
977  nullify(var%scl_dbl)
978  nullify(var%vec_dbl)
979  nullify(var%arr_dbl)
980  nullify(var%cub_dbl)
981  nullify(var%fda_dbl)
982 
983  nullify(var%scl_chr)
984  nullify(var%vec_chr)
985 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_varp()

type(ncvarp) function, pointer mod_ncll::new_varp ( )

Definition at line 990 of file mod_ncll.f90.

990  IMPLICIT NONE
991  TYPE(NCVARP), POINTER :: VARP
992  integer status
993 
994  ALLOCATE(varp,stat=status)
995  if(status/=0) CALL fatal_error("NEW_VARP: COULD NOT ALLOCATE!")
996  NULLIFY(varp%NEXT)
997  NULLIFY(varp%VAR)
998 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_att()

subroutine mod_ncll::print_att ( type(ncatt), intent(in), pointer  ATT)

Definition at line 2139 of file mod_ncll.f90.

2139  implicit none
2140  type(NCATT), pointer, intent(IN) :: ATT
2141  integer I
2142 
2143  if(dbg_set(dbg_log)) then
2144  WRITE(ipt,*) "======== PRINT NCATT TYPE ======="
2145  if(.not. associated(att)) then
2146  WRITE(ipt,*) "THIS NCATT HAS NOT BEEN ASSOCIATED"
2147  WRITE(ipt,*) "======= PRINTED NCATT TYPE ======"
2148  return
2149  end if
2150  WRITE(ipt,*) "ATTNAME::"//trim(att%ATTNAME)
2151  WRITE(ipt,*) "LEN ::",att%LEN
2152  WRITE(ipt,*) "ATTID ::",att%ATTID
2153  select case(att%XTYPE)
2154  case(nf90_char)
2155  WRITE(ipt,*) "XYTPE ::CHAR"
2156  IF (.not. Allocated(att%chr)) then
2157  WRITE(ipt,*) "CHAR :: Not allocated!"
2158  ELSE
2159  DO i = 1,size(att%chr)
2160  WRITE(ipt,*) "CHAR ::"//trim(att%chr(i))
2161  END DO
2162  END IF
2163  case(nf90_byte)
2164  WRITE(ipt,*) "XYTPE ::BYTE - TYPE NOT DEFINED"
2165  case(nf90_short)
2166  WRITE(ipt,*) "XYTPE ::SHORT - TYPE NOT DEFINED"
2167  case(nf90_int)
2168  WRITE(ipt,*) "XYTPE ::INT"
2169  IF (.not. Allocated(att%int)) then
2170  WRITE(ipt,*) "INT :: Not allocated!"
2171  ELSE
2172  write(ipt,'(I8)') att%int
2173  END IF
2174  case(nf90_float)
2175  WRITE(ipt,*) "XYTPE ::FLOAT"
2176  IF (.not. Allocated(att%flt)) then
2177  WRITE(ipt,*) "FLOAT :: Not allocated!"
2178  ELSE
2179  write(ipt,'(ES14.3)') att%flt
2180  END IF
2181  case(nf90_double)
2182  WRITE(ipt,*) "XYTPE ::DOUBLE"
2183  IF (.not. Allocated(att%DBL)) then
2184  WRITE(ipt,*) "DOUBLE :: Not allocated!"
2185  ELSE
2186  write(ipt,'(ES14.3)') att%dbl
2187  END IF
2188  END select
2189  WRITE(ipt,*) "======= PRINTED NCATT TYPE ======"
2190  end if
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_dim()

subroutine mod_ncll::print_dim ( type(ncdim), intent(in), pointer  DIM)

Definition at line 3515 of file mod_ncll.f90.

3515  implicit none
3516  type(NCDIM),pointer, intent(IN) :: DIM
3517 
3518  if(dbg_set(dbg_log)) then
3519  WRITE(ipt,*) "======== PRINT NCDIM TYPE ======="
3520  if(.not. associated(dim)) then
3521  WRITE(ipt,*) "THIS NCDIM HAS NOT BEEN ASSOCIATED"
3522  WRITE(ipt,*) "======= PRINTED NCDIM TYPE ======"
3523  return
3524  end if
3525  WRITE(ipt,*) "DIMNAME ::"//trim(dim%DIMNAME)
3526  WRITE(ipt,*) "DIMID ::",dim%DIMID
3527  WRITE(ipt,*) "DIMLEN ::",dim%DIM
3528  WRITE(ipt,*) "UNLIMITED::",dim%UNLIMITED
3529  WRITE(ipt,*) "======= PRINTED NCDIM TYPE ======"
3530  end if
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_file()

subroutine mod_ncll::print_file ( type(ncfile), pointer  NCF)

Definition at line 857 of file mod_ncll.f90.

857  implicit none
858  type(NCFILE), pointer :: NCF
859  type(NCFTIME), pointer :: TM
860 
861  if(dbg_set(dbg_log)) then
862  WRITE(ipt,*) "======== PRINT NCFILE TYPE ======="
863  if(.not. associated(ncf)) then
864  WRITE(ipt,*) "THIS NCFILE HAS NOT BEEN ASSOCIATED"
865  WRITE(ipt,*) "======= PRINTED NCFILE TYPE ======"
866  return
867  end if
868  WRITE(ipt,*) "=FILENAME ::"//trim(ncf%FNAME)
869  WRITE(ipt,*) "=NCID ::",ncf%NCID
870  WRITE(ipt,*) "=WRITABLE ::",ncf%WRITABLE
871  WRITE(ipt,*) "=OPEN ::",ncf%OPEN
872  WRITE(ipt,*) "=CONNECTED ::",ncf%CONNECTED
873  WRITE(ipt,*) "=INDEFMODE ::",ncf%INDEFMODE
874  WRITE(ipt,*) "=UNLIMDIMID ::",ncf%UNLIMDIMID
875  WRITE(ipt,*) "= "
876  tm => ncf%FTIME
877  CALL print_ftime(tm)
878  WRITE(ipt,*) "= "
879  WRITE(ipt,*) "= FILE OBJECT COUNTS"
880  WRITE(ipt,*) "=nDIMS ::",count_dim_list(ncf)
881  WRITE(ipt,*) "=nATTS ::",count_att_list(ncf)
882  WRITE(ipt,*) "=nVARS ::",count_var_list(ncf)
883  IF(ASSOCIATED(ncf%INTERP_N))WRITE(ipt,*) "= HAS INTERP COEF'S TO NODES"
884  IF(ASSOCIATED(ncf%INTERP_C))WRITE(ipt,*) "= HAS INTERP COEF'S TO CELLS"
885  WRITE(ipt,*) "====== PRINTED NCFILE TYPE ======"
886 
887  end if
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_file_list()

subroutine mod_ncll::print_file_list ( type(ncfilelist), intent(in)  LIST)

Definition at line 821 of file mod_ncll.f90.

821  IMPLICIT NONE
822  type(NCFILELIST), intent(IN) :: LIST
823  TYPE(NCFILEP), pointer :: CURRENT, PREVIOUS
824  INTEGER :: CNT
825  Character(len=4) :: chr
826 
827  previous => list%FIRST
828  current => previous%NEXT
829 
830  IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
831  if(dbg_set(dbg_log)) &
832  & write(ipt,*)"%%%%%%%%%%% FILE LIST IS EMPTY %%%%%%%%%%%%%"
833  RETURN
834  ELSE
835  if(dbg_set(dbg_log)) &
836  & write(ipt,*)"%%%%%%%%%%% PRINTING FILE LIST %%%%%%%%%%%%%"
837  END IF
838 
839  cnt = 0
840  DO
841  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
842  cnt = cnt + 1
843  write(chr,'(I4.4)')cnt
844  if(dbg_set(dbg_log)) &
845  & write(ipt,*)"! PRINTING FILE LIST ENTRY #"//chr
846  CALL print_file(current%NCF)
847 
848  previous => previous%NEXT
849  current => current%NEXT
850  END DO
851  if(dbg_set(dbg_log)) &
852  & write(ipt,*)"%%%%%%%%%%% END OF FILE LIST %%%%%%%%%%%%%"
control::ipt
integer ipt
Definition: mod_main.f90:922
Here is the call graph for this function:

◆ print_ftime()

subroutine mod_ncll::print_ftime ( type(ncftime), pointer  FTIME)

Definition at line 892 of file mod_ncll.f90.

892  USE control, only : use_real_world_time
893  IMPLICIT NONE
894  TYPE(NCFTIME), POINTER :: FTIME
895 
896 
897  WRITE(ipt,*) "===== FILE IO TIME INFO ===="
898 
899  IF (ASSOCIATED(ftime)) THEN
900  select case(ftime%TMtype)
901  CASE(tmtype_unknown)
902  WRITE(ipt,*) "= TMTYPE :: UNKNOWN"
903  CASE(tmtype_char_date)
904  WRITE(ipt,*) "= TMTYPE :: CHARACTER STRING DATE"
905  CASE(tmtype_int2_mjd)
906  WRITE(ipt,*) "= TMTYPE :: TWO INTEGER MJD"
907  CASE(tmtype_float_seconds)
908  WRITE(ipt,*) "= TMTYPE :: FLOATING POINT SECONDS"
909  CASE(tmtype_float_days)
910  WRITE(ipt,*) "= TMTYPE :: FLOATING POINT DAYS"
911  END select
912  CALL print_var(ftime%TM1)
913  CALL print_var(ftime%TM2)
914 
915  IF(use_real_world_time) THEN
916  CALL print_real_time(ftime%PREV_IO,ipt,"PREV IO")
917  CALL print_real_time(ftime%NEXT_IO,ipt,"NEXT IO")
918  ELSE
919  CALL print_time(ftime%PREV_IO,ipt,"PREV IO")
920  CALL print_time(ftime%NEXT_IO,ipt,"NEXT IO")
921  END IF
922  CALL print_time(ftime%INTERVAL,ipt,"IO INTERVAL")
923 
924  WRITE(ipt,*) "=STK_LEN ::",ftime%STK_LEN
925 
926  WRITE(ipt,*) "=PREV_STKCNT ::",ftime%PREV_STKCNT
927  WRITE(ipt,*) "=NEXT_STKCNT ::",ftime%NEXT_STKCNT
928  WRITE(ipt,*) "=MAX_STKCNT ::",ftime%MAX_STKCNT
929  WRITE(ipt,*) "=PREV_WGHT ::",ftime%PREV_WGHT
930  WRITE(ipt,*) "=NEXT_WGHT ::",ftime%NEXT_WGHT
931  WRITE(ipt,*) "=TIMEZONE ::"//trim(ftime%TIMEZONE)
932 
933  ELSE
934  WRITE(ipt,*) "= FTIME NOT ALLOCATED: THE FILE HAS NO RECOGNIZED TIME VARIABLE"
935  END IF
936  WRITE(ipt,*) "=END FILE IO TIME TYPE ===="
937 
mod_time::print_real_time
subroutine print_real_time(mjd, IPT, char, TZONE)
Definition: mod_time.f90:1201
control::use_real_world_time
logical use_real_world_time
Definition: mod_main.f90:131
mod_time::print_time
subroutine print_time(mjd, IPT, char)
Definition: mod_time.f90:1166
Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_ncf_att_list()

subroutine mod_ncll::print_ncf_att_list ( type(ncfile), intent(in)  LIST)

Definition at line 2066 of file mod_ncll.f90.

2066  IMPLICIT NONE
2067  type(NCFILE), intent(IN) :: LIST
2068  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
2069  INTEGER :: CNT
2070  Character(len=4) :: chr
2071 
2072  previous => list%ATTS
2073  current => previous%NEXT
2074 
2075  IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
2076  if(dbg_set(dbg_log)) &
2077  & write(ipt,*)"%%%%%%%%%%% FILE ATTRIBUTE LIST IS EMPTY %%%%%%%%%%%%%"
2078  RETURN
2079  ELSE
2080  if(dbg_set(dbg_log)) &
2081  & write(ipt,*)"%%%%%%% PRINTING GLOBAL ATTRIBUTE LIST %%%%%%%%%"
2082  END IF
2083 
2084  cnt = 0
2085  DO
2086  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
2087  cnt = cnt + 1
2088  write(chr,'(I4.4)')cnt
2089  if(dbg_set(dbg_log)) &
2090  & write(ipt,*)"! PRINTING ATTRIBUTE LIST ENTRY #"//chr
2091  CALL print_att(current%ATT)
2092 
2093  previous => previous%NEXT
2094  current => current%NEXT
2095  END DO
2096  if(dbg_set(dbg_log)) &
2097  & write(ipt,*)"%%%%%%%%%%% END OF ATTRIBUTE LIST %%%%%%%%%%%%%"
Here is the call graph for this function:

◆ print_ncf_dim_list()

subroutine mod_ncll::print_ncf_dim_list ( type(ncfile), intent(in)  LIST)

Definition at line 3440 of file mod_ncll.f90.

3440  IMPLICIT NONE
3441  type(NCFILE), intent(IN) :: LIST
3442  TYPE(NCDIMP), POINTER :: CURRENT, PREVIOUS
3443  INTEGER :: CNT
3444  Character(len=4) :: chr
3445 
3446  previous => list%DIMS
3447  current => previous%NEXT
3448 
3449  IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
3450  if(dbg_set(dbg_log)) &
3451  & write(ipt,*)"%%%%%%%%%%% FILE DIMENSION LIST IS EMPTY %%%%%%%%%%%%%"
3452  RETURN
3453  ELSE
3454  if(dbg_set(dbg_log)) then
3455  write(ipt,*)"%%%%%%% PRINTING FILE DIMENSION LIST %%%%%%%%%"
3456  write(ipt,*)"%%%%%%% FILE NAME: "//trim(list%FNAME)//" %%%%%%%%%"
3457  end if
3458  END IF
3459 
3460  cnt = 0
3461  DO
3462  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
3463  cnt = cnt + 1
3464  write(chr,'(I4.4)')cnt
3465  if(dbg_set(dbg_log)) &
3466  & write(ipt,*)"! PRINTING DIMENSION LIST ENTRY #"//chr
3467  CALL print_dim(current%DIM)
3468 
3469  previous => previous%NEXT
3470  current => current%NEXT
3471  END DO
3472  if(dbg_set(dbg_log)) &
3473  & write(ipt,*)"%%%%%%%%%%% END OF DIMENSION LIST %%%%%%%%%%%%%"
Here is the call graph for this function:

◆ print_var()

subroutine mod_ncll::print_var ( type(ncvar), intent(in), pointer  VAR)

Definition at line 1383 of file mod_ncll.f90.

1383  implicit none
1384  type(NCVAR), POINTER, intent(IN) :: VAR
1385 
1386  if(dbg_set(dbg_log)) then
1387  WRITE(ipt,*) "======== PRINT NCVAR TYPE ======="
1388 
1389  if(.not. associated(var)) then
1390  WRITE(ipt,*) "THIS NCVAR HAS NOT BEEN ASSOCIATED"
1391  WRITE(ipt,*) "======= PRINTED NCVAR TYPE ======"
1392  return
1393  end if
1394 
1395  WRITE(ipt,*) "VARNAME ::"//trim(var%VARNAME)
1396  WRITE(ipt,*) "VARID ::",var%VARID
1397  if(.not. associated(var%NCID)) then
1398  WRITE(ipt,*) "NCID :: NOT ASSOCIATED"
1399  else
1400  WRITE(ipt,*) "NCID ::",var%NCID
1401  end if
1402  WRITE(ipt,*) "CONNECTED ::",var%CONNECTED
1403  WRITE(ipt,*) "CURR_STKCNT ::",var%CURR_STKCNT
1404 
1405  select case(var%XTYPE)
1406  case(nf90_char)
1407  WRITE(ipt,*) "XYTPE :: CHAR"
1408  case(nf90_byte)
1409  WRITE(ipt,*) "XYTPE :: BYTE"
1410  case(nf90_short)
1411  WRITE(ipt,*) "XYTPE :: SHORT"
1412  case(nf90_int)
1413  WRITE(ipt,*) "XYTPE :: INT"
1414  case(nf90_float)
1415  WRITE(ipt,*) "XYTPE :: FLOAT"
1416  case(nf90_double)
1417  WRITE(ipt,*) "XYTPE :: DOUBLE"
1418  END select
1419 
1420  IF(ASSOCIATED(var%SCL_INT)) WRITE(ipt,*) "ASSOCIATED :: SCL_INT"
1421  IF(ASSOCIATED(var%VEC_INT)) WRITE(ipt,*) "ASSOCIATED :: VEC_INT"
1422  IF(ASSOCIATED(var%ARR_INT)) WRITE(ipt,*) "ASSOCIATED :: ARR_INT"
1423  IF(ASSOCIATED(var%CUB_INT)) WRITE(ipt,*) "ASSOCIATED :: CUB_INT"
1424  IF(ASSOCIATED(var%FDA_INT)) WRITE(ipt,*) "ASSOCIATED :: FDA_INT"
1425 
1426  IF(ASSOCIATED(var%SCL_FLT)) WRITE(ipt,*) "ASSOCIATED :: SCL_FLT"
1427  IF(ASSOCIATED(var%VEC_FLT)) WRITE(ipt,*) "ASSOCIATED :: VEC_FLT"
1428  IF(ASSOCIATED(var%ARR_FLT)) WRITE(ipt,*) "ASSOCIATED :: ARR_FLT"
1429  IF(ASSOCIATED(var%CUB_FLT)) WRITE(ipt,*) "ASSOCIATED :: CUB_FLT"
1430  IF(ASSOCIATED(var%FDA_FLT)) WRITE(ipt,*) "ASSOCIATED :: FDA_FLT"
1431 
1432  IF(ASSOCIATED(var%SCL_DBL)) WRITE(ipt,*) "ASSOCIATED :: SCL_DBL"
1433  IF(ASSOCIATED(var%VEC_DBL)) WRITE(ipt,*) "ASSOCIATED :: VEC_DBL"
1434  IF(ASSOCIATED(var%ARR_DBL)) WRITE(ipt,*) "ASSOCIATED :: ARR_DBL"
1435  IF(ASSOCIATED(var%CUB_DBL)) WRITE(ipt,*) "ASSOCIATED :: CUB_DBL"
1436  IF(ASSOCIATED(var%FDA_DBL)) WRITE(ipt,*) "ASSOCIATED :: FDA_DBL"
1437 
1438  IF(ASSOCIATED(var%SCL_CHR)) WRITE(ipt,*) "ASSOCIATED :: SCL_CHR"
1439  IF(ASSOCIATED(var%VEC_CHR)) WRITE(ipt,*) "ASSOCIATED :: VEC_CHR"
1440 
1441 
1442 
1443  WRITE(ipt,*) "DIMS ::",count_dim_list(var)
1444  WRITE(ipt,*) "ATTS ::",count_att_list(var)
1445  WRITE(ipt,*) "======= PRINTED NCVAR TYPE ======"
1446 
1447  end if
Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_var_att_list()

subroutine mod_ncll::print_var_att_list ( type(ncvar), intent(in)  LIST)

Definition at line 2102 of file mod_ncll.f90.

2102  IMPLICIT NONE
2103  type(NCVAR), intent(IN) :: LIST
2104  TYPE(NCATTP) ,POINTER :: CURRENT, PREVIOUS
2105  INTEGER :: CNT
2106  Character(len=4) :: chr
2107 
2108  previous => list%ATTS
2109  current => previous%NEXT
2110 
2111  IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
2112  if(dbg_set(dbg_log)) &
2113  & write(ipt,*)"%%%%%%%% VAIABLE ATTRIBUTE LIST IS EMPTY %%%%%%%%%%"
2114  RETURN
2115  ELSE
2116  if(dbg_set(dbg_log)) &
2117  & write(ipt,*)"%%%%%%% PRINTING VARIALBE: "//trim(list%VARNAME)//"&
2118  &; ATTRIBUTE LIST %%%%%%%%"
2119  END IF
2120 
2121  cnt = 0
2122  DO
2123  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
2124  cnt = cnt + 1
2125  write(chr,'(I4.4)')cnt
2126  if(dbg_set(dbg_log)) &
2127  & write(ipt,*)"! PRINTING ATTRIBUTE LIST ENTRY #"//chr
2128  CALL print_att(current%ATT)
2129 
2130  previous => previous%NEXT
2131  current => current%NEXT
2132  END DO
2133  if(dbg_set(dbg_log)) &
2134  & write(ipt,*)"%%%%%%%%%%% END OF ATTRIBUTE LIST %%%%%%%%%%%%%"
Here is the call graph for this function:

◆ print_var_dim_list()

subroutine mod_ncll::print_var_dim_list ( type(ncvar), intent(in)  LIST)

Definition at line 3478 of file mod_ncll.f90.

3478  IMPLICIT NONE
3479  type(NCVAR), intent(IN) :: LIST
3480  TYPE(NCDIMP) ,POINTER :: CURRENT, PREVIOUS
3481  INTEGER :: CNT
3482  Character(len=4) :: chr
3483 
3484  previous => list%DIMS
3485  current => previous%NEXT
3486 
3487  IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
3488  if(dbg_set(dbg_log)) &
3489  & write(ipt,*)"%%%%%%%%%%% VARIABLE DIMENSION LIST IS EMPTY %%%%%%%%%%%%%"
3490  RETURN
3491  ELSE
3492  if(dbg_set(dbg_log)) &
3493  & write(ipt,*)"%%%%%%% PRINTING VARIABLE: "//trim(list&
3494  &%VARNAME)//"; DIMENSION LIST %%%%%%%%%"
3495  END IF
3496 
3497  cnt = 0
3498  DO
3499  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
3500  cnt = cnt + 1
3501  write(chr,'(I4.4)')cnt
3502  if(dbg_set(dbg_log)) &
3503  & write(ipt,*)"! PRINTING DIMENSION LIST ENTRY #"//chr
3504  CALL print_dim(current%DIM)
3505 
3506  previous => previous%NEXT
3507  current => current%NEXT
3508  END DO
3509  if(dbg_set(dbg_log)) &
3510  & write(ipt,*)"%%%%%%%%%%% END OF DIMENSION LIST %%%%%%%%%%%%%"
Here is the call graph for this function:

◆ print_var_list()

subroutine mod_ncll::print_var_list ( type(ncfile), intent(in)  LIST)

Definition at line 1347 of file mod_ncll.f90.

1347  IMPLICIT NONE
1348  type(NCFILE), intent(IN) :: LIST
1349  TYPE(NCVARP) ,POINTER :: CURRENT, PREVIOUS
1350  INTEGER :: CNT
1351  Character(len=4) :: chr
1352 
1353  previous => list%VARS
1354  current => previous%NEXT
1355 
1356  IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
1357  if(dbg_set(dbg_log)) &
1358  & write(ipt,*)"%%%%%%%%%%% VARIABLE LIST IS EMPTY %%%%%%%%%%%%%"
1359  RETURN
1360  ELSE
1361  if(dbg_set(dbg_log)) &
1362  & write(ipt,*)"%%%%%%%%%%% PRINTING VARIABLE LIST %%%%%%%%%%%%%"
1363  END IF
1364 
1365  cnt = 0
1366  DO
1367  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
1368  cnt = cnt + 1
1369  write(chr,'(I4.4)')cnt
1370  if(dbg_set(dbg_log)) &
1371  & write(ipt,*)"! PRINTING VARIABLE LIST ENTRY #"//chr
1372  CALL print_var(current%VAR)
1373 
1374  previous => previous%NEXT
1375  current => current%NEXT
1376  END DO
1377  if(dbg_set(dbg_log)) &
1378  & write(ipt,*)"%%%%%%%%%%% END OF VARIABLE LIST %%%%%%%%%%%%%"
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reference_var()

type(ncvar) function, pointer mod_ncll::reference_var ( type(ncvar), pointer  VARIN)

Definition at line 1056 of file mod_ncll.f90.

1056  IMPLICIT NONE
1057  TYPE(NCVAR), POINTER :: VARIN, VAROUT
1058  integer status
1059 
1060  varout => new_var()
1061 
1062  varout%NCID => varin%NCID
1063  varout%CONNECTED = varin%CONNECTED
1064  varout%VARID = varin%VARID
1065  varout%VARNAME = varin%VARNAME
1066  varout%XTYPE = varin%XTYPE
1067  varout%DIMS%NEXT => varin%DIMS%NEXT
1068  varout%ATTS%NEXT => varin%ATTS%NEXT
1069 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ var_dimids()

integer function, dimension(:), pointer mod_ncll::var_dimids ( type(ncvar), intent(in)  LIST)

Definition at line 2942 of file mod_ncll.f90.

2942  TYPE(NCVAR), INTENT(IN) :: LIST
2943  INTEGER, POINTER :: DIMIDS(:)
2944  TYPE(NCDIMP),POINTER :: CURRENT, PREVIOUS
2945  INTEGER :: CNT, status, SZ
2946 
2947  previous => list%DIMS
2948  current => previous%NEXT
2949  cnt = 0
2950  ALLOCATE(dimids(count_dim_list(list)),stat=status)
2951  if(status /= 0) CALL fatal_error("VAR_DIMIDS: Can not allocate DIMIDS")
2952 
2953  IF(SIZE(dimids)==0) RETURN
2954 
2955  dimids=0
2956 
2957  DO
2958  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
2959  cnt = cnt + 1
2960 
2961  dimids(cnt) = current%DIM%DIMID
2962 
2963  previous => previous%NEXT
2964  current => current%NEXT
2965 
2966  END DO
2967 
2968  if(cnt .NE. count_dim_list(list)) CALL fatal_error&
2969  &("VAR_DIMIDS: THE NUMBER OF DIMENSION OBJECTS IN THE VARIABL&
2970  &ES LIST EXCEEDS THE VARIABLES NDIMS PROPERTY")
2971 
2972 
Here is the call graph for this function:
Here is the caller graph for this function:

◆ var_dims()

integer function, dimension(:), pointer mod_ncll::var_dims ( type(ncvar), intent(in)  LIST)

Definition at line 2977 of file mod_ncll.f90.

2977  TYPE(NCVAR), INTENT(IN) :: LIST
2978  INTEGER, POINTER :: DIMS(:)
2979  TYPE(NCDIMP),POINTER :: CURRENT, PREVIOUS
2980  INTEGER :: CNT, status
2981 
2982  previous => list%DIMS
2983  current => previous%NEXT
2984  cnt = 0
2985  ALLOCATE(dims(count_dim_list(list)),stat=status)
2986  if(status /= 0) CALL fatal_error("VAR_DIMS: Can not allocate DIMS")
2987 
2988  IF(SIZE(dims)==0) RETURN
2989 
2990  dims=0
2991 
2992  DO
2993  IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
2994  cnt= cnt+1
2995 
2996  dims(cnt) = current%DIM%DIM
2997 
2998  previous => previous%NEXT
2999  current => current%NEXT
3000 
3001  END DO
3002 
3003  if(cnt .NE. count_dim_list(list)) CALL fatal_error&
3004  &("VAR_DIMS: THE NUMBER OF DIMENSION OBJECTS IN THE VARIABL&
3005  &ES LIST EXCEEDS THE VARIABLES NDIMS PROPERTY")
3006 
3007 
Here is the call graph for this function:

◆ var_plus_att()

type(ncvar) function, pointer mod_ncll::var_plus_att ( type(ncvar), pointer  VAR,
type(ncatt), pointer  ATT 
)

Definition at line 3589 of file mod_ncll.f90.

3589  ! ADD THE ATTRIBUTE TO THE VARIABLE ATT LIST IF IT DOES NOT EXIST
3590  IMPLICIT NONE
3591  type(NCVAR), POINTER :: VAR
3592  type(NCATT), POINTER :: ATT
3593  type(NCVAR), POINTER :: RET
3594  LOGICAL FOUND
3595  if(dbg_set(dbg_sbr)) &
3596  & write(ipt,*) "START VAR_PLUS_ATT"
3597 
3598  IF(.NOT. ASSOCIATED(var)) CALL fatal_error &
3599  & ("VAR_PLUS_ATT: THE VAR OBJECT ARGUMENT IS NOT ASSOC&
3600  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3601 
3602  IF(.NOT. ASSOCIATED(att)) CALL fatal_error &
3603  & ("VAR_PLUS_ATT: THE ATT OBJECT ARGUMENT IS NOT ASSOC&
3604  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3605 
3606  IF(var%CONNECTED) CALL fatal_error&
3607  ("CAN NOT ADD ATTRIBUTES TO A VARIABLE OBJECT ALREADY IN A FILE")
3608 
3609  CALL insert_att_link(var,att,found)
3610  ! ADD ERROR HANDLING LATER FOR MERGING ATTS
3611  IF(found) CALL fatal_error("ERROR ADDIND ATTRIBUTE TO VARIABLE",&
3612  & "THE ATTRIBUTE: "//trim(att%ATTNAME)//"; ALREADY EXISTS",&
3613  & "IN THE VARIABLE: "//trim(var%VARNAME))
3614 
3615 
3616  !ALL MEMORY NOW BELONGS TO RET
3617  ret => var
3618  NULLIFY(var)
3619  NULLIFY(att)
3620  if(dbg_set(dbg_sbr)) &
3621  & write(ipt,*) "END VAR_PLUS_ATT"
Here is the call graph for this function:

◆ var_plus_dim()

type(ncvar) function, pointer mod_ncll::var_plus_dim ( type(ncvar), pointer  VAR,
type(ncdim), pointer  DIM 
)

Definition at line 3551 of file mod_ncll.f90.

3551  ! ADD THE DIMENSION TO THE VARIABLE DIM LIST IF IT DOES NOT EXIST
3552  IMPLICIT NONE
3553  type(NCVAR), POINTER :: VAR
3554  type(NCVAR), POINTER :: RET
3555  type(NCDIM), POINTER :: DIM
3556  LOGICAL FOUND
3557  if(dbg_set(dbg_sbr)) &
3558  & write(ipt,*) "START VAR_PLUS_DIM"
3559 
3560  IF(.NOT. ASSOCIATED(var)) CALL fatal_error &
3561  & ("VAR_PLUS_DIM: THE VAR OBJECT ARGUMENT IS NOT ASSOC&
3562  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3563 
3564  IF(.NOT. ASSOCIATED(dim)) CALL fatal_error &
3565  & ("VAR_PLUS_DIM: THE DIM OBJECT ARGUMENT IS NOT ASSOC&
3566  &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
3567 
3568  IF(var%CONNECTED) CALL fatal_error&
3569  ("CAN NOT ADD DIMENSIONS TO A VARIABLE OBJECT ALREADY IN A FILE")
3570 
3571  CALL insert_dim_link(var,dim,found)
3572 
3573 
3574 ! IF(FOUND) CALL FATAL_ERROR("ERROR ADDIND DIMENSION TO VARIABLE",&
3575 ! & "THE DIMENSION: "//TRIM(DIM%DIMNAME)//"; ALREADY EXISTS",&
3576 ! & "IN THE VARIABLE: "//TRIM(VAR%VARNAME))
3577 
3578 
3579  !ALL MEMORY NOW BELONGS TO RET
3580  ret => var
3581  NULLIFY(var)
3582  NULLIFY(dim)
3583  if(dbg_set(dbg_sbr)) &
3584  & write(ipt,*) "END VAR_PLUS_DIM"
Here is the call graph for this function:

Variable Documentation

◆ char_max_attlen

integer, parameter mod_ncll::char_max_attlen = 160

Definition at line 69 of file mod_ncll.f90.

69  integer, parameter :: Char_max_attlen = 160

◆ tmtype_char_date

integer, parameter mod_ncll::tmtype_char_date = 1

Definition at line 49 of file mod_ncll.f90.

49  INTEGER, PARAMETER :: TMtype_CHAR_DATE = 1

◆ tmtype_float_days

integer, parameter mod_ncll::tmtype_float_days = 3

Definition at line 51 of file mod_ncll.f90.

51  INTEGER, PARAMETER :: TMtype_FLOAT_DAYS = 3

◆ tmtype_float_seconds

integer, parameter mod_ncll::tmtype_float_seconds = 4

Definition at line 52 of file mod_ncll.f90.

52  INTEGER, PARAMETER :: TMtype_FLOAT_SECONDS = 4

◆ tmtype_int2_mjd

integer, parameter mod_ncll::tmtype_int2_mjd = 2

Definition at line 50 of file mod_ncll.f90.

50  INTEGER, PARAMETER :: TMtype_INT2_MJD = 2

◆ tmtype_unknown

integer, parameter mod_ncll::tmtype_unknown = 0

Definition at line 48 of file mod_ncll.f90.

48  INTEGER, PARAMETER :: TMtype_UNKNOWN = 0
Generated by   doxygen 1.8.15