meshmodelmodule Module Reference

This module contains the MeshModelModule. More...

Data Types
type	meshncdimidtype
	type for storing model export dimension ids More...
type	meshncvaridtype
	type for storing model export variable ids More...
type	meshmodeltype
	base ugrid netcdf export type More...
interface	nc_array_export_if
	abstract interfaces for derived ugrid netcd export types More...
type	mesh2dmodeltype

Functions/Subroutines
subroutine	mesh_init (this, modelname, modeltype, modelfname, nc_fname, disenum, nctype, lenuni, iout)
	initialize More...
subroutine	mesh_destroy (this)
	initialize More...
subroutine	df_export (this)
	define timeseries input variables More...
subroutine	export_df (this, export_pkg)
	define export package More...
subroutine	create_timeseries (this, idt, iparam, iaux, layer, export_pkg)
	create timeseries export variable More...
subroutine	add_global_att (this)
	create file (group) attributes More...
subroutine	export_input_arrays (this, pkgtype, pkgname, mempath, param_dfns)
	write package gridded input data More...
subroutine	add_pkg_data (this)
	determine packages to write gridded input More...
subroutine	define_dependent (this)
	create the model layer dependent variables More...
subroutine	define_gridmap (this)
	create the file grid mapping container variable More...
subroutine	create_mesh (this)
	create the file mesh container variable More...
subroutine, public	ncvar_chunk (ncid, varid, chunk_face, nc_fname)
	define variable chunking More...
subroutine, public	ncvar_deflate (ncid, varid, deflate, shuffle, nc_fname)
	define variable compression More...
subroutine, public	ncvar_gridmap (ncid, varid, gridmap_name, layer, nc_fname)
	put variable gridmap attributes More...
subroutine, public	ncvar_mf6attr (ncid, varid, layer, iaux, nc_tag, nc_fname)
	put variable internal attributes More...
subroutine, public	ncvar_layer (ncid, varid, layer, nc_fname)
	put the layer attribute (only when layer > 0) More...

Detailed Description

This module defines a base class for UGRID based (mesh) model netcdf exports. It is dependent on external netcdf libraries.

Function/Subroutine Documentation

add_global_att()

subroutine meshmodelmodule::add_global_att

(

class(meshmodeltype), intent(inout)

this

)

Definition at line 332 of file MeshNCModel.f90.

    class(MeshModelType), intent(inout) :: this
    ! file scoped title
    call nf_verify(nf90_put_att(this%ncid, nf90_global, 'title', &
                                this%annotation%title), this%nc_fname)
    ! source (MODFLOW 6)
    call nf_verify(nf90_put_att(this%ncid, nf90_global, 'source', &
                                this%annotation%source), this%nc_fname)
    ! grid type (MODFLOW 6)
    call nf_verify(nf90_put_att(this%ncid, nf90_global, 'modflow_grid', &
                                this%annotation%grid), this%nc_fname)
    ! mesh type (MODFLOW 6)
    if (this%annotation%mesh /= '') then
      call nf_verify(nf90_put_att(this%ncid, nf90_global, 'modflow_mesh', &
                                  this%annotation%mesh), this%nc_fname)
 
    end if
    ! MODFLOW 6 model type
    call nf_verify(nf90_put_att(this%ncid, nf90_global, 'modflow_model', &
                                this%annotation%model), this%nc_fname)
    ! generation datetime
    call nf_verify(nf90_put_att(this%ncid, nf90_global, 'history', &
                                this%annotation%history), this%nc_fname)
    ! supported conventions
    call nf_verify(nf90_put_att(this%ncid, nf90_global, 'Conventions', &
                                this%annotation%conventions), &
                   this%nc_fname)

Here is the call graph for this function:

add_pkg_data()

subroutine meshmodelmodule::add_pkg_data

(

class(meshmodeltype), intent(inout)

this

)

Definition at line 390 of file MeshNCModel.f90.

    use simvariablesmodule, only: idm_context
    use memorymanagerextmodule, only: mem_set_value
    use memoryhelpermodule, only: create_mem_path
    use idmdfnselectormodule, only: param_definitions
    use sourcecommonmodule, only: idm_subcomponent_type
    use idmdfnselectormodule, only: idm_multi_package
    class(MeshModelType), intent(inout) :: this
    character(LENCOMPONENTNAME) :: ptype, pname, pkgtype
    character(len=LENMEMPATH) :: input_mempath
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: pkgtypes => null()
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: pkgnames => null()
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mempaths => null()
    type(InputParamDefinitionType), dimension(:), pointer :: param_dfns
    character(len=LENMEMPATH) :: mempath
    integer(I4B) :: n
    integer(I4B), pointer :: export_arrays
    logical(LGP) :: found
 
    input_mempath = create_mem_path(component=this%modelname, context=idm_context)
 
    ! set pointers to model path package info
    call mem_setptr(pkgtypes, 'PKGTYPES', input_mempath)
    call mem_setptr(pkgnames, 'PKGNAMES', input_mempath)
    call mem_setptr(mempaths, 'MEMPATHS', input_mempath)
 
    allocate (export_arrays)
 
    do n = 1, size(mempaths)
      ! initialize export_arrays
      export_arrays = 0
 
      ! set package attributes
      mempath = mempaths(n)
      pname = pkgnames(n)
      ptype = pkgtypes(n)
 
      ! export input arrays
      if (mempath /= '') then
        ! update export
        call mem_set_value(export_arrays, 'EXPORT_NC', mempath, found, &
                           release=.false.)
        if (export_arrays > 0) then
          pkgtype = idm_subcomponent_type(this%modeltype, ptype)
          param_dfns => param_definitions(this%modeltype, pkgtype)
          call this%export_input_arrays(ptype, pname, mempath, param_dfns)
        end if
      end if
    end do
 
    ! cleanup
    deallocate (export_arrays)

Here is the call graph for this function:

create_mesh()

subroutine meshmodelmodule::create_mesh ( class(mesh2dmodeltype), intent(inout)  this )

private

Definition at line 555 of file MeshNCModel.f90.

    class(Mesh2dModelType), intent(inout) :: this
 
    ! create mesh container variable
    call nf_verify(nf90_def_var(this%ncid, this%mesh_name, nf90_int, &
                                this%var_ids%mesh), this%nc_fname)
 
    ! assign container variable attributes
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh, 'cf_role', &
                                'mesh_topology'), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh, 'long_name', &
                                '2D mesh topology'), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh, &
                                'topology_dimension', 2), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh, 'face_dimension', &
                                'nmesh_face'), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh, &
                                'node_coordinates', 'mesh_node_x mesh_node_y'), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh, &
                                'face_coordinates', 'mesh_face_x mesh_face_y'), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh, &
                                'face_node_connectivity', 'mesh_face_nodes'), &
                   this%nc_fname)
 
    ! create mesh x node (mesh vertex) variable
    call nf_verify(nf90_def_var(this%ncid, 'mesh_node_x', nf90_double, &
                                (/this%dim_ids%nmesh_node/), &
                                this%var_ids%mesh_node_x), this%nc_fname)
 
    ! assign mesh x node variable attributes
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_node_x, &
                                'units', this%lenunits), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_node_x, &
                                'standard_name', 'projection_x_coordinate'), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_node_x, &
                                'long_name', 'Easting'), this%nc_fname)
 
    if (this%gridmap_name /= '') then
      ! associate with projection
      call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_node_x, &
                                  'grid_mapping', this%gridmap_name), &
                     this%nc_fname)
    end if
 
    ! create mesh y node (mesh vertex) variable
    call nf_verify(nf90_def_var(this%ncid, 'mesh_node_y', nf90_double, &
                                (/this%dim_ids%nmesh_node/), &
                                this%var_ids%mesh_node_y), this%nc_fname)
 
    ! assign mesh y variable attributes
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_node_y, &
                                'units', this%lenunits), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_node_y, &
                                'standard_name', 'projection_y_coordinate'), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_node_y, &
                                'long_name', 'Northing'), this%nc_fname)
 
    if (this%gridmap_name /= '') then
      ! associate with projection
      call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_node_y, &
                                  'grid_mapping', this%gridmap_name), &
                     this%nc_fname)
    end if
 
    ! create mesh x face (cell vertex) variable
    call nf_verify(nf90_def_var(this%ncid, 'mesh_face_x', nf90_double, &
                                (/this%dim_ids%nmesh_face/), &
                                this%var_ids%mesh_face_x), this%nc_fname)
 
    ! assign mesh x face variable attributes
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_x, &
                                'units', this%lenunits), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_x, &
                                'standard_name', 'projection_x_coordinate'), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_x, &
                                'long_name', 'Easting'), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_x, 'bounds', &
                                'mesh_face_xbnds'), this%nc_fname)
    if (this%gridmap_name /= '') then
      ! associate with projection
      call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_x, &
                                  'grid_mapping', this%gridmap_name), &
                     this%nc_fname)
    end if
 
    ! create mesh x cell bounds variable
    call nf_verify(nf90_def_var(this%ncid, 'mesh_face_xbnds', nf90_double, &
                                (/this%dim_ids%max_nmesh_face_nodes, &
                                  this%dim_ids%nmesh_face/), &
                                this%var_ids%mesh_face_xbnds), &
                   this%nc_fname)
 
    ! create mesh y face (cell vertex) variable
    call nf_verify(nf90_def_var(this%ncid, 'mesh_face_y', nf90_double, &
                                (/this%dim_ids%nmesh_face/), &
                                this%var_ids%mesh_face_y), this%nc_fname)
 
    ! assign mesh y face variable attributes
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_y, &
                                'units', this%lenunits), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_y, &
                                'standard_name', 'projection_y_coordinate'), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_y, &
                                'long_name', 'Northing'), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_y, 'bounds', &
                                'mesh_face_ybnds'), this%nc_fname)
 
    if (this%gridmap_name /= '') then
      ! associate with projection
      call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_y, &
                                  'grid_mapping', this%gridmap_name), &
                     this%nc_fname)
    end if
 
    ! create mesh y cell bounds variable
    call nf_verify(nf90_def_var(this%ncid, 'mesh_face_ybnds', nf90_double, &
                                (/this%dim_ids%max_nmesh_face_nodes, &
                                  this%dim_ids%nmesh_face/), &
                                this%var_ids%mesh_face_ybnds), &
                   this%nc_fname)
 
    ! create mesh face nodes variable
    call nf_verify(nf90_def_var(this%ncid, 'mesh_face_nodes', nf90_int, &
                                (/this%dim_ids%max_nmesh_face_nodes, &
                                  this%dim_ids%nmesh_face/), &
                                this%var_ids%mesh_face_nodes), &
                   this%nc_fname)
 
    ! assign variable attributes
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_nodes, &
                                'cf_role', 'face_node_connectivity'), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_nodes, &
                                'long_name', &
                                'Vertices bounding cell (counterclockwise)'), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_nodes, &
                                '_FillValue', (/nf90_fill_int/)), &
                   this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, this%var_ids%mesh_face_nodes, &
                                'start_index', 1), this%nc_fname)

Here is the call graph for this function:

create_timeseries()

subroutine meshmodelmodule::create_timeseries	(	class(meshmodeltype), intent(inout)	this,
		type(inputparamdefinitiontype), intent(in), pointer	idt,
		integer(i4b), intent(in)	iparam,
		integer(i4b), intent(in)	iaux,
		integer(i4b), intent(in)	layer,
		class(exportpackagetype), intent(in), pointer	export_pkg
	)

Definition at line 240 of file MeshNCModel.f90.

    use constantsmodule, only: dnodata
    use ncmodelexportmodule, only: exportpackagetype
    class(MeshModelType), intent(inout) :: this
    type(InputParamDefinitionType), pointer, intent(in) :: idt
    integer(I4B), intent(in) :: iparam
    integer(I4B), intent(in) :: iaux
    integer(I4B), intent(in) :: layer
    class(ExportPackageType), pointer, intent(in) :: export_pkg
    character(len=LINELENGTH) :: varname, longname, nc_tag
    integer(I4B) :: varid
 
    ! set variable input tag
    nc_tag = this%input_attribute(export_pkg%mf6_input%subcomponent_name, &
                                  idt)
 
    ! set names
    varname = export_varname(export_pkg%mf6_input%subcomponent_name, &
                             idt%tagname, export_pkg%mf6_input%mempath, &
                             layer=layer, iaux=iaux)
    longname = export_longname(idt%longname, &
                               export_pkg%mf6_input%subcomponent_name, &
                               idt%tagname, export_pkg%mf6_input%mempath, &
                               layer=layer, iaux=iaux, &
                               component_type=idt%component_type, &
                               subcomponent_type=idt%subcomponent_type)
 
    ! create the netcdf dependent layer variable
    select case (idt%datatype)
    case ('DOUBLE1D', 'DOUBLE2D')
      call nf_verify(nf90_def_var(this%ncid, varname, nf90_double, &
                                  (/this%dim_ids%nmesh_face, &
                                    this%dim_ids%time/), &
                                  varid), &
                     this%nc_fname)
      call nf_verify(nf90_put_att(this%ncid, varid, &
                                  '_FillValue', (/dnodata/)), &
                     this%nc_fname)
    case ('INTEGER1D')
      call nf_verify(nf90_def_var(this%ncid, varname, nf90_int, &
                                  (/this%dim_ids%nmesh_face, &
                                    this%dim_ids%time/), &
                                  varid), &
                     this%nc_fname)
      call nf_verify(nf90_put_att(this%ncid, varid, &
                                  '_FillValue', (/nf90_fill_int/)), &
                     this%nc_fname)
    end select
 
    ! apply chunking parameters
    if (this%chunking_active) then
      call nf_verify(nf90_def_var_chunking(this%ncid, &
                                           varid, &
                                           nf90_chunked, &
                                           (/this%chunk_face, &
                                             this%chunk_time/)), &
                     this%nc_fname)
    end if
 
    ! deflate and shuffle
    call ncvar_deflate(this%ncid, varid, this%deflate, &
                       this%shuffle, this%nc_fname)
 
    ! assign variable attributes
    call nf_verify(nf90_put_att(this%ncid, varid, &
                                'units', this%lenunits), this%nc_fname)
    call nf_verify(nf90_put_att(this%ncid, varid, &
                                'long_name', longname), this%nc_fname)
 
    ! add grid mapping and mf6 attr (mesh, location, coordinates, grid_mapping)
    call ncvar_gridmap(this%ncid, varid, &
                       this%gridmap_name, layer, this%nc_fname)
    call ncvar_mf6attr(this%ncid, varid, layer, iaux, nc_tag, this%nc_fname)
 
    ! store variable id
    if (idt%tagname == 'AUX') then
      if (layer > 0) then
        export_pkg%varids_aux(iaux, layer) = varid
      else
        export_pkg%varids_aux(iaux, 1) = varid
      end if
    else
      if (layer > 0) then
        export_pkg%varids_param(iparam, layer) = varid
      else
        export_pkg%varids_param(iparam, 1) = varid
      end if
    end if

Here is the call graph for this function:

define_dependent()

subroutine meshmodelmodule::define_dependent

(

class(meshmodeltype), intent(inout)

this

)

Definition at line 449 of file MeshNCModel.f90.

    class(MeshModelType), intent(inout) :: this
    character(len=LINELENGTH) :: varname, longname
    integer(I4B) :: k
 
    ! create a dependent variable for each layer
    do k = 1, this%nlay
      ! initialize names
      varname = ''
      longname = ''
 
      ! set layer variable and longnames
      write (varname, '(a,i0)') trim(this%xname)//'_l', k
      write (longname, '(a,i0,a)') trim(this%annotation%longname)// &
        ' (layer ', k, ')'
 
      ! create the netcdf dependent layer variable
      call nf_verify(nf90_def_var(this%ncid, varname, nf90_double, &
                                  (/this%dim_ids%nmesh_face, &
                                    this%dim_ids%time/), &
                                  this%var_ids%dependent(k)), &
                     this%nc_fname)
 
      ! apply chunking parameters
      if (this%chunking_active) then
        call nf_verify(nf90_def_var_chunking(this%ncid, &
                                             this%var_ids%dependent(k), &
                                             nf90_chunked, &
                                             (/this%chunk_face, &
                                               this%chunk_time/)), &
                       this%nc_fname)
      end if
 
      ! deflate and shuffle
      call ncvar_deflate(this%ncid, this%var_ids%dependent(k), this%deflate, &
                         this%shuffle, this%nc_fname)
 
      ! assign variable attributes
      call nf_verify(nf90_put_att(this%ncid, this%var_ids%dependent(k), &
                                  'units', this%lenunits), this%nc_fname)
      call nf_verify(nf90_put_att(this%ncid, this%var_ids%dependent(k), &
                                  'long_name', longname), this%nc_fname)
      call nf_verify(nf90_put_att(this%ncid, this%var_ids%dependent(k), &
                                  '_FillValue', (/dhnoflo/)), &
                     this%nc_fname)
      ! cell_methods (CF-1.13 7.3): dependent variable values are the
      ! instantaneous simulated state at each output time, not a time
      ! mean/accumulation over the interval -- an intensive quantity whose
      ! default method is already "point" per CF's own Appendix E, stated
      ! explicitly here per CF's recommendation to do so for every
      ! spatio-temporal dimension.
      call nf_verify(nf90_put_att(this%ncid, this%var_ids%dependent(k), &
                                  'cell_methods', 'time: point'), &
                     this%nc_fname)
 
      ! add grid mapping (mesh, location, coordinates, grid_mapping)
      call ncvar_gridmap(this%ncid, this%var_ids%dependent(k), &
                         this%gridmap_name, k, this%nc_fname)
 
      ! add layer attribute
      call ncvar_layer(this%ncid, this%var_ids%dependent(k), k, &
                       this%nc_fname)
    end do

Here is the call graph for this function:

define_gridmap()

subroutine meshmodelmodule::define_gridmap ( class(meshmodeltype), intent(inout)  this )

private

Definition at line 516 of file MeshNCModel.f90.

    class(MeshModelType), intent(inout) :: this
    integer(I4B) :: var_id
    character(len=LINELENGTH) :: gmname
    character(len=LENBIGLINE) :: effective_crs_wkt
 
    ! was projection info provided
    if (this%wkt /= '' .or. this%crs_wkt /= '') then
      ! create projection variable
      call nf_verify(nf90_redef(this%ncid), this%nc_fname)
      call nf_verify(nf90_def_var(this%ncid, this%gridmap_name, nf90_int, &
                                  var_id), this%nc_fname)
      ! wkt (WKT1, OGC 01-009) -- for legacy/QGIS compatibility
      if (this%wkt /= '') then
        call nf_verify(nf90_put_att(this%ncid, var_id, 'wkt', this%wkt), &
                       this%nc_fname)
      end if
      ! crs_wkt (WKT2, ISO 19162:2019) -- required by CF-1.13
      if (this%crs_wkt /= '') then
        effective_crs_wkt = this%crs_wkt
      else
        effective_crs_wkt = this%wkt
      end if
      call nf_verify(nf90_put_att(this%ncid, var_id, 'crs_wkt', &
                                  trim(effective_crs_wkt)), this%nc_fname)
      ! grid_mapping_name derived from WKT projection keyword
      gmname = wkt_to_cf_gridmapping(trim(effective_crs_wkt))
      if (gmname /= '') then
        call nf_verify(nf90_put_att(this%ncid, var_id, 'grid_mapping_name', &
                                    trim(gmname)), this%nc_fname)
      end if
      call nf_verify(nf90_enddef(this%ncid), this%nc_fname)
      call nf_verify(nf90_put_var(this%ncid, var_id, 1), &
                     this%nc_fname)
    end if

Here is the call graph for this function:

df_export()

subroutine meshmodelmodule::df_export

(

class(meshmodeltype), intent(inout)

this

)

Definition at line 183 of file MeshNCModel.f90.

    use ncmodelexportmodule, only: exportpackagetype
    class(MeshModelType), intent(inout) :: this
    class(ExportPackageType), pointer :: export_pkg
    integer(I4B) :: idx
    do idx = 1, this%pkglist%Count()
      export_pkg => this%get(idx)
      call this%export_df(export_pkg)
    end do

export_df()

subroutine meshmodelmodule::export_df	(	class(meshmodeltype), intent(inout)	this,
		class(exportpackagetype), intent(in), pointer	export_pkg
	)

Definition at line 196 of file MeshNCModel.f90.

    use ncmodelexportmodule, only: exportpackagetype
    use definitionselectmodule, only: get_param_definition_type
    class(MeshModelType), intent(inout) :: this
    class(ExportPackageType), pointer, intent(in) :: export_pkg
    type(InputParamDefinitionType), pointer :: idt
    integer(I4B) :: iparam, iaux, layer
 
    ! export defined period input
    do iparam = 1, export_pkg%nparam
      ! initialize
      iaux = 0
      layer = 0
      ! set input definition
      idt => &
        get_param_definition_type(export_pkg%mf6_input%param_dfns, &
                                  export_pkg%mf6_input%component_type, &
                                  export_pkg%mf6_input%subcomponent_type, &
                                  'PERIOD', export_pkg%param_names(iparam), '')
 
      select case (idt%shape)
      case ('NCPL')
        call this%create_timeseries(idt, iparam, iaux, layer, export_pkg)
      case ('NODES')
        do layer = 1, this%nlay
          call this%create_timeseries(idt, iparam, iaux, layer, export_pkg)
        end do
      case ('NAUX NCPL')
        do iaux = 1, export_pkg%naux
          call this%create_timeseries(idt, iparam, iaux, layer, export_pkg)
        end do
      case ('NAUX NODES')
        do iaux = 1, export_pkg%naux
          do layer = 1, this%nlay
            call this%create_timeseries(idt, iparam, iaux, layer, export_pkg)
          end do
        end do
      case default
      end select
    end do

Here is the call graph for this function:

export_input_arrays()

subroutine meshmodelmodule::export_input_arrays ( class(meshmodeltype), intent(inout)  this, character(len=*), intent(in)  pkgtype, character(len=*), intent(in)  pkgname, character(len=*), intent(in)  mempath, type(inputparamdefinitiontype), dimension(:), intent(in), pointer  param_dfns  )

private

Definition at line 363 of file MeshNCModel.f90.

    use memorymanagermodule, only: get_isize
    class(MeshModelType), intent(inout) :: this
    character(len=*), intent(in) :: pkgtype
    character(len=*), intent(in) :: pkgname
    character(len=*), intent(in) :: mempath
    type(InputParamDefinitionType), dimension(:), pointer, &
      intent(in) :: param_dfns
    type(InputParamDefinitionType), pointer :: idt
    integer(I4B) :: iparam, isize
    ! export griddata block parameters
    do iparam = 1, size(param_dfns)
      ! assign param definition pointer
      idt => param_dfns(iparam)
      ! for now only griddata is exported
      if (idt%blockname == 'GRIDDATA') then
        ! veriy variable is allocated
        call get_isize(idt%mf6varname, mempath, isize)
        if (isize > 0) then
          call this%export_input_array(pkgtype, pkgname, mempath, idt)
        end if
      end if
    end do

Here is the call graph for this function:

mesh_destroy()

subroutine meshmodelmodule::mesh_destroy

(

class(meshmodeltype), intent(inout)

this

)

Definition at line 173 of file MeshNCModel.f90.

    use memorymanagerextmodule, only: mem_set_value
    class(MeshModelType), intent(inout) :: this
    call nf_verify(nf90_close(this%ncid), this%nc_fname)
    deallocate (this%chunk_face)
    nullify (this%chunk_face)

Here is the call graph for this function:

mesh_init()

subroutine meshmodelmodule::mesh_init ( class(meshmodeltype), intent(inout)  this, character(len=*), intent(in)  modelname, character(len=*), intent(in)  modeltype, character(len=*), intent(in)  modelfname, character(len=*), intent(in)  nc_fname, integer(i4b), intent(in)  disenum, integer(i4b), intent(in)  nctype, integer(i4b), intent(in)  lenuni, integer(i4b), intent(in)  iout  )

private

Definition at line 105 of file MeshNCModel.f90.

    use memorymanagerextmodule, only: mem_set_value
    class(MeshModelType), intent(inout) :: this
    character(len=*), intent(in) :: modelname
    character(len=*), intent(in) :: modeltype
    character(len=*), intent(in) :: modelfname
    character(len=*), intent(in) :: nc_fname
    integer(I4B), intent(in) :: disenum
    integer(I4B), intent(in) :: nctype
    integer(I4B), intent(in) :: lenuni
    integer(I4B), intent(in) :: iout
    logical(LGP) :: found
    integer(I4B) :: latsz, lonsz
 
    ! initialize base class
    call this%NCModelExportType%init(modelname, modeltype, modelfname, nc_fname, &
                                     disenum, nctype, iout)
 
    if (this%ncf_mempath /= '') then
      latsz = 0
      lonsz = 0
      call get_isize('LATITUDE', this%ncf_mempath, latsz)
      call get_isize('LONGITUDE', this%ncf_mempath, lonsz)
      if (latsz > 0 .or. lonsz > 0) then
        write (warnmsg, '(a)') 'LATITUDE and LONGITUDE griddata are not &
          &supported for a NETCDF_MESH2D export and will be ignored. &
          &Applies to file "'//trim(nc_fname)//'".'
        call store_warning(warnmsg)
      end if
    end if
 
    ! allocate and initialize
    allocate (this%chunk_face)
    this%chunk_face = -1
 
    ! update values from input context
    if (this%ncf_mempath /= '') then
      call mem_set_value(this%chunk_face, 'CHUNK_FACE', this%ncf_mempath, found)
    end if
 
    if (this%chunk_time > 0 .and. this%chunk_face > 0) then
      this%chunking_active = .true.
    else if (this%chunk_time > 0 .or. this%chunk_face > 0) then
      this%chunk_face = -1
      this%chunk_time = -1
      write (warnmsg, '(a)') 'Ignoring user provided NetCDF chunking parameter. &
        &Define chunk_time and chunk_face input parameters to see an effect in &
        &file "'//trim(nc_fname)//'".'
      call store_warning(warnmsg)
    end if
 
    if (lenuni == 1) then
      this%lenunits = 'ft'
    else if (lenuni == 3) then
      this%lenunits = 'cm'
    else
      this%lenunits = 'm'
    end if
 
    ! create the netcdf file
    call nf_verify(nf90_create(this%nc_fname, &
                               ior(nf90_clobber, nf90_netcdf4), this%ncid), &
                   this%nc_fname)

Here is the call graph for this function:

ncvar_chunk()

subroutine, public meshmodelmodule::ncvar_chunk	(	integer(i4b), intent(in)	ncid,
		integer(i4b), intent(in)	varid,
		integer(i4b), intent(in)	chunk_face,
		character(len=*), intent(in)	nc_fname
	)

Definition at line 706 of file MeshNCModel.f90.

    integer(I4B), intent(in) :: ncid
    integer(I4B), intent(in) :: varid
    integer(I4B), intent(in) :: chunk_face
    character(len=*), intent(in) :: nc_fname
    if (chunk_face > 0) then
      call nf_verify(nf90_def_var_chunking(ncid, varid, nf90_chunked, &
                                           (/chunk_face/)), nc_fname)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

ncvar_deflate()

subroutine, public meshmodelmodule::ncvar_deflate	(	integer(i4b), intent(in)	ncid,
		integer(i4b), intent(in)	varid,
		integer(i4b), intent(in)	deflate,
		integer(i4b), intent(in)	shuffle,
		character(len=*), intent(in)	nc_fname
	)

Definition at line 719 of file MeshNCModel.f90.

    integer(I4B), intent(in) :: ncid
    integer(I4B), intent(in) :: varid
    integer(I4B), intent(in) :: deflate
    integer(I4B), intent(in) :: shuffle
    character(len=*), intent(in) :: nc_fname
    if (deflate >= 0) then
      call nf_verify(nf90_def_var_deflate(ncid, varid, shuffle=shuffle, &
                                          deflate=1, deflate_level=deflate), &
                     nc_fname)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

ncvar_gridmap()

subroutine, public meshmodelmodule::ncvar_gridmap	(	integer(i4b), intent(in)	ncid,
		integer(i4b), intent(in)	varid,
		character(len=*), intent(in)	gridmap_name,
		integer(i4b), intent(in)	layer,
		character(len=*), intent(in)	nc_fname
	)

layer must be the 1-based layer number when varid is a per-layer variable (e.g. npf_k_l3), or 0 when it is not layered (e.g. a flat NCPL-shaped array). z_l{layer} is only referenced from coordinates when layer > 0, since it is the only case where z_l{layer} shares nmesh_face with varid (CF-1.13 5.2 subset rule).

Definition at line 740 of file MeshNCModel.f90.

    integer(I4B), intent(in) :: ncid
    integer(I4B), intent(in) :: varid
    character(len=*), intent(in) :: gridmap_name
    integer(I4B), intent(in) :: layer
    character(len=*), intent(in) :: nc_fname
    character(len=LINELENGTH) :: coords
    ! UGRID topology attrs are CRS-independent -- always written on face vars
    call nf_verify(nf90_put_att(ncid, varid, 'mesh', 'mesh'), nc_fname)
    call nf_verify(nf90_put_att(ncid, varid, 'location', 'face'), nc_fname)
    if (layer > 0) then
      write (coords, '(a,i0)') 'mesh_face_x mesh_face_y z_l', layer
    else
      coords = 'mesh_face_x mesh_face_y'
    end if
    call nf_verify(nf90_put_att(ncid, varid, 'coordinates', trim(coords)), &
                   nc_fname)
    ! grid_mapping only written when a CRS is configured
    if (gridmap_name /= '') then
      call nf_verify(nf90_put_att(ncid, varid, 'grid_mapping', &
                                  gridmap_name), nc_fname)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

ncvar_layer()

subroutine, public meshmodelmodule::ncvar_layer	(	integer(i4b), intent(in)	ncid,
		integer(i4b), intent(in)	varid,
		integer(i4b), intent(in)	layer,
		character(len=*), intent(in)	nc_fname
	)

layer identifies which layer a per-layer-split mesh variable belongs to (e.g. head_l3, npf_k_l3) – distinct from the layer dimension coordinate. Not a CF/UGRID attribute; MF6-internal. Applies to every per-layer-split variable.

Definition at line 791 of file MeshNCModel.f90.

    integer(I4B), intent(in) :: ncid
    integer(I4B), intent(in) :: varid
    integer(I4B), intent(in) :: layer
    character(len=*), intent(in) :: nc_fname
    if (layer > 0) then
      call nf_verify(nf90_put_att(ncid, varid, 'layer', layer), nc_fname)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

ncvar_mf6attr()

subroutine, public meshmodelmodule::ncvar_mf6attr	(	integer(i4b), intent(in)	ncid,
		integer(i4b), intent(in)	varid,
		integer(i4b), intent(in)	layer,
		integer(i4b), intent(in)	iaux,
		character(len=*), intent(in)	nc_tag,
		character(len=*), intent(in)	nc_fname
	)

Definition at line 766 of file MeshNCModel.f90.

    integer(I4B), intent(in) :: ncid
    integer(I4B), intent(in) :: varid
    integer(I4B), intent(in) :: layer
    integer(I4B), intent(in) :: iaux
    character(len=*), intent(in) :: nc_tag
    character(len=*), intent(in) :: nc_fname
    if (nc_tag /= '') then
      call nf_verify(nf90_put_att(ncid, varid, 'modflow_input', &
                                  nc_tag), nc_fname)
      call ncvar_layer(ncid, varid, layer, nc_fname)
      if (iaux > 0) then
        call nf_verify(nf90_put_att(ncid, varid, 'modflow_iaux', &
                                    iaux), nc_fname)
      end if
    end if

Here is the call graph for this function:

Here is the caller graph for this function: