MODFLOW 6  version 6.7.0.dev1
USGS Modular Hydrologic Model
Data Types | Functions/Subroutines
disncstructuredmodule Module Reference

This module contains the DisNCStructuredModule. More...

Data Types

type  structuredncdimidtype
 
type  structuredncvaridtype
 
type  disncstructuredtype
 
interface  nc_export_array
 

Functions/Subroutines

subroutine dis_export_init (this, modelname, modeltype, modelfname, nc_fname, disenum, nctype, iout)
 netcdf export dis init More...
 
subroutine dis_export_destroy (this)
 netcdf export dis destroy More...
 
subroutine df (this)
 netcdf export define More...
 
subroutine step (this)
 netcdf export step More...
 
subroutine export_input_array (this, pkgtype, pkgname, mempath, idt)
 netcdf export an input array More...
 
subroutine export_input_arrays (this, pkgtype, pkgname, mempath, param_dfns)
 write package gridded input data More...
 
subroutine package_step_ilayer (this, export_pkg, ilayer_varname, ilayer)
 netcdf export package dynamic input with ilayer index variable More...
 
subroutine package_step (this, export_pkg)
 netcdf export package dynamic input More...
 
subroutine export_layer_3d (this, export_pkg, idt, ilayer_read, ialayer, dbl1d, nc_varname, input_attr, iaux)
 export layer variable as full grid More...
 
subroutine add_pkg_data (this)
 determine packages to write gridded input More...
 
subroutine add_global_att (this)
 create file (group) attributes More...
 
subroutine define_dim (this)
 netcdf export define dimensions 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 define_projection (this)
 define grid projection variables More...
 
subroutine add_proj_data (this)
 add grid projection data More...
 
subroutine add_grid_data (this)
 add grid coordinates More...
 
subroutine ncvar_chunk2d (ncid, varid, chunk_x, chunk_y, nc_fname)
 define 2d variable chunking More...
 
subroutine ncvar_chunk3d (ncid, varid, chunk_x, chunk_y, chunk_z, nc_fname)
 define 3d variable chunking More...
 
subroutine ncvar_deflate (ncid, varid, deflate, shuffle, nc_fname)
 define variable compression More...
 
subroutine ncvar_gridmap (ncid, varid, gridmap_name, latlon, nc_fname)
 put variable gridmap attributes More...
 
subroutine ncvar_mf6attr (ncid, varid, iper, iaux, nc_tag, nc_fname)
 put variable internal modflow6 attributes More...
 
subroutine nc_export_int1d (ncid, dim_ids, var_ids, dis, p_mem, nc_varname, pkgname, tagname, shapestr, longname, nc_tag, gridmap_name, latlon, deflate, shuffle, chunk_z, chunk_y, chunk_x, iper, nc_fname)
 netcdf export 1D integer More...
 
subroutine nc_export_int2d (ncid, dim_ids, var_ids, dis, p_mem, nc_varname, pkgname, tagname, shapestr, longname, nc_tag, gridmap_name, latlon, deflate, shuffle, chunk_z, chunk_y, chunk_x, nc_fname)
 netcdf export 2D integer More...
 
subroutine nc_export_int3d (ncid, dim_ids, var_ids, dis, p_mem, nc_varname, pkgname, tagname, shapestr, longname, nc_tag, gridmap_name, latlon, deflate, shuffle, chunk_z, chunk_y, chunk_x, nc_fname)
 netcdf export 3D integer More...
 
subroutine nc_export_dbl1d (ncid, dim_ids, var_ids, dis, p_mem, nc_varname, pkgname, tagname, shapestr, longname, nc_tag, gridmap_name, latlon, deflate, shuffle, chunk_z, chunk_y, chunk_x, iper, nc_fname)
 netcdf export 1D double More...
 
subroutine nc_export_dbl2d (ncid, dim_ids, var_ids, dis, p_mem, nc_varname, pkgname, tagname, shapestr, longname, nc_tag, gridmap_name, latlon, deflate, shuffle, chunk_z, chunk_y, chunk_x, nc_fname)
 netcdf export 2D double More...
 
subroutine nc_export_dbl3d (ncid, dim_ids, var_ids, dis, p_mem, nc_varname, pkgname, tagname, shapestr, longname, nc_tag, gridmap_name, latlon, deflate, shuffle, chunk_z, chunk_y, chunk_x, iper, iaux, nc_fname)
 netcdf export 3D double More...
 
character(len=linelength) function export_varname (pkgname, idt, iper, iaux)
 build netcdf variable name More...
 

Detailed Description

This module defines a STRUCTURED (non-ugrid) netcdf export type for DIS models. It is dependent on netcdf libraries.

Function/Subroutine Documentation

◆ add_global_att()

subroutine disncstructuredmodule::add_global_att ( class(disncstructuredtype), intent(inout)  this)

Definition at line 634 of file DisNCStructured.f90.

635  class(DisNCStructuredType), intent(inout) :: this
636  ! file scoped title
637  call nf_verify(nf90_put_att(this%ncid, nf90_global, 'title', &
638  this%annotation%title), this%nc_fname)
639  ! source (MODFLOW 6)
640  call nf_verify(nf90_put_att(this%ncid, nf90_global, 'source', &
641  this%annotation%source), this%nc_fname)
642  ! export type (MODFLOW 6)
643  call nf_verify(nf90_put_att(this%ncid, nf90_global, 'modflow6_grid', &
644  this%annotation%grid), this%nc_fname)
645  ! MODFLOW 6 model type
646  call nf_verify(nf90_put_att(this%ncid, nf90_global, 'modflow6_model', &
647  this%annotation%model), this%nc_fname)
648  ! generation datetime
649  call nf_verify(nf90_put_att(this%ncid, nf90_global, 'history', &
650  this%annotation%history), this%nc_fname)
651  ! supported conventions
652  call nf_verify(nf90_put_att(this%ncid, nf90_global, 'Conventions', &
653  this%annotation%conventions), &
654  this%nc_fname)
Here is the call graph for this function:

◆ add_grid_data()

subroutine disncstructuredmodule::add_grid_data ( class(disncstructuredtype), intent(inout)  this)
private

Definition at line 867 of file DisNCStructured.f90.

868  class(DisNCStructuredType), intent(inout) :: this
869  integer(I4B) :: ibnd, n !, k, i, j
870  real(DP), dimension(:, :), pointer, contiguous :: dbl2d
871  real(DP), dimension(:), allocatable :: x, y
872 
873  allocate (x(size(this%dis%cellx)))
874  allocate (y(size(this%dis%celly)))
875 
876  do n = 1, size(this%dis%cellx)
877  x(n) = this%dis%cellx(n) + this%dis%xorigin
878  end do
879 
880  do n = 1, size(this%dis%celly)
881  y(n) = this%dis%celly(n) + this%dis%yorigin
882  end do
883 
884  call nf_verify(nf90_put_var(this%ncid, this%var_ids%x, x), &
885  this%nc_fname)
886  call nf_verify(nf90_put_var(this%ncid, this%var_ids%y, y), &
887  this%nc_fname)
888  ! TODO see cf-conventions 4.3.3. Parametric Vertical Coordinate
889  call nf_verify(nf90_put_var(this%ncid, this%var_ids%z, this%layers), &
890  this%nc_fname)
891 
892  deallocate (x)
893  deallocate (y)
894 
895  ! bounds x
896  allocate (dbl2d(2, size(this%dis%cellx)))
897  ibnd = 1
898  do n = 1, size(this%dis%cellx)
899  if (ibnd == 1) then
900  dbl2d(1, ibnd) = this%dis%xorigin
901  dbl2d(2, ibnd) = this%dis%xorigin + this%dis%delr(ibnd)
902  else
903  dbl2d(1, ibnd) = dbl2d(1, ibnd - 1) + this%dis%delr(ibnd)
904  dbl2d(2, ibnd) = dbl2d(2, ibnd - 1) + this%dis%delr(ibnd)
905  end if
906  ibnd = ibnd + 1
907  end do
908  call nf_verify(nf90_put_var(this%ncid, this%var_ids%x_bnds, dbl2d), &
909  this%nc_fname)
910  deallocate (dbl2d)
911 
912  ! bounds y
913  allocate (dbl2d(2, size(this%dis%celly)))
914  ibnd = 1
915  do n = size(this%dis%celly), 1, -1
916  if (ibnd == 1) then
917  dbl2d(1, ibnd) = this%dis%yorigin + sum(this%dis%delc) - this%dis%delc(n)
918  dbl2d(2, ibnd) = this%dis%yorigin + sum(this%dis%delc)
919  else
920  dbl2d(1, ibnd) = dbl2d(1, ibnd - 1) - this%dis%delc(n)
921  dbl2d(2, ibnd) = dbl2d(2, ibnd - 1) - this%dis%delc(n)
922  end if
923  ibnd = ibnd + 1
924  end do
925  call nf_verify(nf90_put_var(this%ncid, this%var_ids%y_bnds, dbl2d), &
926  this%nc_fname)
927  deallocate (dbl2d)
Here is the call graph for this function:

◆ add_pkg_data()

subroutine disncstructuredmodule::add_pkg_data ( class(disncstructuredtype), intent(inout)  this)

Definition at line 578 of file DisNCStructured.f90.

579  use simvariablesmodule, only: idm_context
580  use memorymanagerextmodule, only: mem_set_value
581  use memoryhelpermodule, only: create_mem_path
582  use idmdfnselectormodule, only: param_definitions
583  use sourcecommonmodule, only: idm_subcomponent_type
584  class(DisNCStructuredType), intent(inout) :: this
585  character(LENCOMPONENTNAME) :: ptype, pname, pkgtype
586  type(CharacterStringType), dimension(:), contiguous, &
587  pointer :: pkgtypes => null()
588  type(CharacterStringType), dimension(:), contiguous, &
589  pointer :: pkgnames => null()
590  type(CharacterStringType), dimension(:), contiguous, &
591  pointer :: mempaths => null()
592  type(InputParamDefinitionType), dimension(:), pointer :: param_dfns
593  character(len=LENMEMPATH) :: input_mempath, mempath
594  integer(I4B) :: n
595  integer(I4B), pointer :: export_arrays
596  logical(LGP) :: found
597 
598  input_mempath = create_mem_path(component=this%modelname, context=idm_context)
599 
600  ! set pointers to model path package info
601  call mem_setptr(pkgtypes, 'PKGTYPES', input_mempath)
602  call mem_setptr(pkgnames, 'PKGNAMES', input_mempath)
603  call mem_setptr(mempaths, 'MEMPATHS', input_mempath)
604 
605  do n = 1, size(mempaths)
606  ! allocate export_arrays
607  allocate (export_arrays)
608  export_arrays = 0
609 
610  ! set package attributes
611  mempath = mempaths(n)
612  pname = pkgnames(n)
613  ptype = pkgtypes(n)
614 
615  ! export input arrays
616  if (mempath /= '') then
617  ! update export
618  call mem_set_value(export_arrays, 'EXPORT_NC', mempath, found)
619 
620  if (export_arrays > 0) then
621  pkgtype = idm_subcomponent_type(this%modeltype, ptype)
622  param_dfns => param_definitions(this%modeltype, pkgtype)
623  call this%export_input_arrays(ptype, pname, mempath, param_dfns)
624  end if
625  end if
626 
627  ! cleanup
628  deallocate (export_arrays)
629  end do
memorymanagerextmodule::mem_set_value
Definition: MemoryManagerExt.f90:14
idmdfnselectormodule::param_definitions
type(inputparamdefinitiontype) function, dimension(:), pointer, public param_definitions(component, subcomponent)
Definition: IdmDfnSelector.f90:32
memoryhelpermodule::create_mem_path
character(len=lenmempath) function create_mem_path(component, subcomponent, context)
returns the path to the memory object
Definition: MemoryHelper.f90:22
simvariablesmodule
This module contains simulation variables.
Definition: SimVariables.f90:9
simvariablesmodule::idm_context
character(len=linelength) idm_context
Definition: SimVariables.f90:18
sourcecommonmodule
This module contains the SourceCommonModule.
Definition: SourceCommon.f90:7
sourcecommonmodule::idm_subcomponent_type
character(len=lencomponentname) function, public idm_subcomponent_type(component, subcomponent)
component from package or model type
Definition: SourceCommon.f90:91
Here is the call graph for this function:

◆ add_proj_data()

subroutine disncstructuredmodule::add_proj_data ( class(disncstructuredtype), intent(inout)  this)
private

Definition at line 848 of file DisNCStructured.f90.

849  class(DisNCStructuredType), intent(inout) :: this
850  if (this%latlon .and. this%wkt /= '') then
851  ! lat
852  call nf_verify(nf90_put_var(this%ncid, this%var_ids%latitude, &
853  this%latitude, start=(/1, 1/), &
854  count=(/this%dis%ncol, this%dis%nrow/)), &
855  this%nc_fname)
856 
857  ! lon
858  call nf_verify(nf90_put_var(this%ncid, this%var_ids%longitude, &
859  this%longitude, start=(/1, 1/), &
860  count=(/this%dis%ncol, this%dis%nrow/)), &
861  this%nc_fname)
862  end if
Here is the call graph for this function:

◆ define_dependent()

subroutine disncstructuredmodule::define_dependent ( class(disncstructuredtype), intent(inout)  this)

Definition at line 759 of file DisNCStructured.f90.

760  use constantsmodule, only: dhnoflo
761  class(DisNCStructuredType), intent(inout) :: this
762 
763  call nf_verify(nf90_def_var(this%ncid, this%xname, nf90_double, &
764  (/this%dim_ids%x, this%dim_ids%y, &
765  this%dim_ids%z, this%dim_ids%time/), &
766  this%var_ids%dependent), &
767  this%nc_fname)
768 
769  ! apply chunking parameters
770  if (this%chunking_active) then
771  call nf_verify(nf90_def_var_chunking(this%ncid, &
772  this%var_ids%dependent, &
773  nf90_chunked, &
774  (/this%chunk_x, this%chunk_y, &
775  this%chunk_z, this%chunk_time/)), &
776  this%nc_fname)
777  end if
778 
779  ! deflate and shuffle
780  call ncvar_deflate(this%ncid, this%var_ids%dependent, this%deflate, &
781  this%shuffle, this%nc_fname)
782 
783  ! put attr
784  call nf_verify(nf90_put_att(this%ncid, this%var_ids%dependent, &
785  'units', 'm'), this%nc_fname)
786  call nf_verify(nf90_put_att(this%ncid, this%var_ids%dependent, &
787  'standard_name', this%annotation%stdname), &
788  this%nc_fname)
789  call nf_verify(nf90_put_att(this%ncid, this%var_ids%dependent, 'long_name', &
790  this%annotation%longname), this%nc_fname)
791  call nf_verify(nf90_put_att(this%ncid, this%var_ids%dependent, '_FillValue', &
792  (/dhnoflo/)), this%nc_fname)
793 
794  ! add grid mapping
795  call ncvar_gridmap(this%ncid, this%var_ids%dependent, this%gridmap_name, &
796  this%latlon, this%nc_fname)
constantsmodule
This module contains simulation constants.
Definition: Constants.f90:9
constantsmodule::dhnoflo
real(dp), parameter dhnoflo
real no flow constant
Definition: Constants.f90:93
Here is the call graph for this function:

◆ define_dim()

subroutine disncstructuredmodule::define_dim ( class(disncstructuredtype), intent(inout)  this)
private

Definition at line 659 of file DisNCStructured.f90.

660  use constantsmodule, only: mvalidate
661  use simvariablesmodule, only: isim_mode
662  class(DisNCStructuredType), intent(inout) :: this
663 
664  ! bound dim
665  call nf_verify(nf90_def_dim(this%ncid, 'bnd', 2, this%dim_ids%bnd), &
666  this%nc_fname)
667 
668  ! Time
669  if (isim_mode /= mvalidate) then
670  call nf_verify(nf90_def_dim(this%ncid, 'time', this%totnstp, &
671  this%dim_ids%time), this%nc_fname)
672  call nf_verify(nf90_def_var(this%ncid, 'time', nf90_double, &
673  this%dim_ids%time, this%var_ids%time), &
674  this%nc_fname)
675  call nf_verify(nf90_put_att(this%ncid, this%var_ids%time, 'calendar', &
676  'standard'), this%nc_fname)
677  call nf_verify(nf90_put_att(this%ncid, this%var_ids%time, 'units', &
678  this%datetime), this%nc_fname)
679  call nf_verify(nf90_put_att(this%ncid, this%var_ids%time, 'axis', 'T'), &
680  this%nc_fname)
681  !call nf_verify(nf90_put_att(ncid, var_ids%time, 'bounds', 'time_bnds'), this%nc_fname)
682  call nf_verify(nf90_put_att(this%ncid, this%var_ids%time, 'standard_name', &
683  'time'), this%nc_fname)
684  call nf_verify(nf90_put_att(this%ncid, this%var_ids%time, 'long_name', &
685  'time'), this%nc_fname)
686  end if
687 
688  ! Z dimension
689  call nf_verify(nf90_def_dim(this%ncid, 'z', this%dis%nlay, this%dim_ids%z), &
690  this%nc_fname)
691  call nf_verify(nf90_def_var(this%ncid, 'z', nf90_double, this%dim_ids%z, &
692  this%var_ids%z), this%nc_fname)
693  call nf_verify(nf90_put_att(this%ncid, this%var_ids%z, 'units', 'layer'), &
694  this%nc_fname)
695  call nf_verify(nf90_put_att(this%ncid, this%var_ids%z, 'long_name', &
696  'layer number'), this%nc_fname)
697  !call nf_verify(nf90_put_att(this%ncid, this%var_ids%z, 'bounds', 'z_bnds'), &
698  ! this%nc_fname)
699  !call nf_verify(nf90_def_var(this%ncid, 'z_bnds', NF90_DOUBLE, &
700  ! (/this%dim_ids%bnd, this%dim_ids%z/), &
701  ! this%var_ids%z_bnds), this%nc_fname)
702  !call nf_verify(nf90_put_var(this%ncid, this%var_ids%z_bnds, &
703  ! this%elev_bnds), this%nc_fname)
704 
705  ! Y dimension
706  call nf_verify(nf90_def_dim(this%ncid, 'y', this%dis%nrow, this%dim_ids%y), &
707  this%nc_fname)
708  call nf_verify(nf90_def_var(this%ncid, 'y', nf90_double, this%dim_ids%y, &
709  this%var_ids%y), this%nc_fname)
710  call nf_verify(nf90_put_att(this%ncid, this%var_ids%y, 'units', 'm'), &
711  this%nc_fname)
712  call nf_verify(nf90_put_att(this%ncid, this%var_ids%y, 'axis', 'Y'), &
713  this%nc_fname)
714  call nf_verify(nf90_put_att(this%ncid, this%var_ids%y, 'standard_name', &
715  'projection_y_coordinate'), this%nc_fname)
716  call nf_verify(nf90_put_att(this%ncid, this%var_ids%y, 'long_name', &
717  'Northing'), this%nc_fname)
718  if (this%wkt /= '') then
719  call nf_verify(nf90_put_att(this%ncid, this%var_ids%y, 'grid_mapping', &
720  this%gridmap_name), this%nc_fname)
721  end if
722  call nf_verify(nf90_put_att(this%ncid, this%var_ids%y, 'bounds', 'y_bnds'), &
723  this%nc_fname)
724  call nf_verify(nf90_def_var(this%ncid, 'y_bnds', nf90_double, &
725  (/this%dim_ids%bnd, this%dim_ids%y/), &
726  this%var_ids%y_bnds), this%nc_fname)
727 
728  ! X dimension
729  call nf_verify(nf90_def_dim(this%ncid, 'x', this%dis%ncol, this%dim_ids%x), &
730  this%nc_fname)
731  call nf_verify(nf90_def_var(this%ncid, 'x', nf90_double, this%dim_ids%x, &
732  this%var_ids%x), this%nc_fname)
733  call nf_verify(nf90_put_att(this%ncid, this%var_ids%x, 'units', 'm'), &
734  this%nc_fname)
735  call nf_verify(nf90_put_att(this%ncid, this%var_ids%x, 'axis', 'X'), &
736  this%nc_fname)
737  call nf_verify(nf90_put_att(this%ncid, this%var_ids%x, 'standard_name', &
738  'projection_x_coordinate'), this%nc_fname)
739  call nf_verify(nf90_put_att(this%ncid, this%var_ids%x, 'long_name', &
740  'Easting'), this%nc_fname)
741  if (this%wkt /= '') then
742  call nf_verify(nf90_put_att(this%ncid, this%var_ids%x, 'grid_mapping', &
743  this%gridmap_name), this%nc_fname)
744  end if
745  call nf_verify(nf90_put_att(this%ncid, this%var_ids%x, 'bounds', 'x_bnds'), &
746  this%nc_fname)
747  call nf_verify(nf90_def_var(this%ncid, 'x_bnds', nf90_double, &
748  (/this%dim_ids%bnd, this%dim_ids%x/), &
749  this%var_ids%x_bnds), this%nc_fname)
750 
751  ! NCPL dimension
752  call nf_verify(nf90_def_dim(this%ncid, 'ncpl', &
753  this%dis%ncol * this%dis%nrow, &
754  this%dim_ids%ncpl), this%nc_fname)
constantsmodule::mvalidate
@ mvalidate
validation mode - do not run time steps
Definition: Constants.f90:205
simvariablesmodule::isim_mode
integer(i4b) isim_mode
simulation mode
Definition: SimVariables.f90:32
Here is the call graph for this function:

◆ define_gridmap()

subroutine disncstructuredmodule::define_gridmap ( class(disncstructuredtype), intent(inout)  this)

Definition at line 801 of file DisNCStructured.f90.

802  class(DisNCStructuredType), intent(inout) :: this
803  integer(I4B) :: var_id
804  if (this%wkt /= '') then
805  call nf_verify(nf90_redef(this%ncid), this%nc_fname)
806  call nf_verify(nf90_def_var(this%ncid, this%gridmap_name, nf90_int, &
807  var_id), this%nc_fname)
808  ! TODO: consider variants epsg_code, spatial_ref, esri_pe_string, wkt, etc
809  call nf_verify(nf90_put_att(this%ncid, var_id, 'crs_wkt', this%wkt), &
810  this%nc_fname)
811  call nf_verify(nf90_enddef(this%ncid), this%nc_fname)
812  call nf_verify(nf90_put_var(this%ncid, var_id, 1), &
813  this%nc_fname)
814  end if
Here is the call graph for this function:

◆ define_projection()

subroutine disncstructuredmodule::define_projection ( class(disncstructuredtype), intent(inout)  this)
private

Definition at line 819 of file DisNCStructured.f90.

820  class(DisNCStructuredType), intent(inout) :: this
821  if (this%latlon .and. this%wkt /= '') then
822  ! lat
823  call nf_verify(nf90_def_var(this%ncid, 'lat', nf90_double, &
824  (/this%dim_ids%x, this%dim_ids%y/), &
825  this%var_ids%latitude), this%nc_fname)
826  call nf_verify(nf90_put_att(this%ncid, this%var_ids%latitude, &
827  'units', 'degrees_north'), this%nc_fname)
828  call nf_verify(nf90_put_att(this%ncid, this%var_ids%latitude, &
829  'standard_name', 'latitude'), this%nc_fname)
830  call nf_verify(nf90_put_att(this%ncid, this%var_ids%latitude, &
831  'long_name', 'latitude'), this%nc_fname)
832 
833  ! lon
834  call nf_verify(nf90_def_var(this%ncid, 'lon', nf90_double, &
835  (/this%dim_ids%x, this%dim_ids%y/), &
836  this%var_ids%longitude), this%nc_fname)
837  call nf_verify(nf90_put_att(this%ncid, this%var_ids%longitude, &
838  'units', 'degrees_east'), this%nc_fname)
839  call nf_verify(nf90_put_att(this%ncid, this%var_ids%longitude, &
840  'standard_name', 'longitude'), this%nc_fname)
841  call nf_verify(nf90_put_att(this%ncid, this%var_ids%longitude, &
842  'long_name', 'longitude'), this%nc_fname)
843  end if
Here is the call graph for this function:

◆ df()

subroutine disncstructuredmodule::df ( class(disncstructuredtype), intent(inout)  this)
private

Definition at line 185 of file DisNCStructured.f90.

186  use constantsmodule, only: mvalidate
187  use simvariablesmodule, only: isim_mode
188  class(DisNCStructuredType), intent(inout) :: this
189  ! put root group file scope attributes
190  call this%add_global_att()
191  ! define root group dimensions and coordinate variables
192  call this%define_dim()
193  ! define grid projection variables
194  call this%define_projection()
195  if (isim_mode /= mvalidate) then
196  ! define the dependent variable
197  call this%define_dependent()
198  end if
199  ! exit define mode
200  call nf_verify(nf90_enddef(this%ncid), this%nc_fname)
201  ! add data locations
202  call this%add_grid_data()
203  ! add projection data
204  call this%add_proj_data()
205  ! define and set package input griddata
206  call this%add_pkg_data()
207  ! define and set gridmap variable
208  call this%define_gridmap()
209  ! synchronize file
210  call nf_verify(nf90_sync(this%ncid), this%nc_fname)
Here is the call graph for this function:

◆ dis_export_destroy()

subroutine disncstructuredmodule::dis_export_destroy ( class(disncstructuredtype), intent(inout)  this)

Definition at line 169 of file DisNCStructured.f90.

170  class(DisNCStructuredType), intent(inout) :: this
171  call nf_verify(nf90_close(this%ncid), this%nc_fname)
172  deallocate (this%chunk_z)
173  deallocate (this%chunk_y)
174  deallocate (this%chunk_x)
175  deallocate (this%layers)
176  nullify (this%chunk_z)
177  nullify (this%chunk_y)
178  nullify (this%chunk_x)
179  ! destroy base class
180  call this%NCModelExportType%destroy()
Here is the call graph for this function:

◆ dis_export_init()

subroutine disncstructuredmodule::dis_export_init ( class(disncstructuredtype), 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)  iout 
)
private

Definition at line 93 of file DisNCStructured.f90.

95  use memorymanagermodule, only: get_isize
96  use memorymanagerextmodule, only: mem_set_value
97  class(DisNCStructuredType), intent(inout) :: this
98  character(len=*), intent(in) :: modelname
99  character(len=*), intent(in) :: modeltype
100  character(len=*), intent(in) :: modelfname
101  character(len=*), intent(in) :: nc_fname
102  integer(I4B), intent(in) :: disenum
103  integer(I4B), intent(in) :: nctype
104  integer(I4B), intent(in) :: iout
105  integer(I4B) :: k, latsz, lonsz
106  logical(LGP) :: found
107 
108  ! set nlay
109  this%nlay = this%dis%nlay
110 
111  ! allocate
112  allocate (this%chunk_z)
113  allocate (this%chunk_y)
114  allocate (this%chunk_x)
115  allocate (this%layers(this%nlay))
116 
117  ! initialize
118  this%chunk_z = -1
119  this%chunk_y = -1
120  this%chunk_x = -1
121  do k = 1, this%nlay
122  this%layers(k) = k
123  end do
124 
125  this%latlon = .false.
126 
127  ! initialize base class
128  call this%NCModelExportType%init(modelname, modeltype, modelfname, nc_fname, &
129  disenum, nctype, iout)
130  ! update values from input context
131  if (this%ncf_mempath /= '') then
132  call mem_set_value(this%chunk_z, 'CHUNK_Z', this%ncf_mempath, found)
133  call mem_set_value(this%chunk_y, 'CHUNK_Y', this%ncf_mempath, found)
134  call mem_set_value(this%chunk_x, 'CHUNK_X', this%ncf_mempath, found)
135 
136  if (this%chunk_time > 0 .and. this%chunk_z > 0 .and. &
137  this%chunk_y > 0 .and. this%chunk_x > 0) then
138  this%chunking_active = .true.
139  else if (this%chunk_time > 0 .or. this%chunk_z > 0 .or. &
140  this%chunk_y > 0 .or. this%chunk_x > 0) then
141  this%chunk_time = -1
142  this%chunk_z = -1
143  this%chunk_y = -1
144  this%chunk_x = -1
145  write (warnmsg, '(a)') 'Ignoring user provided NetCDF chunking &
146  &parameters. Define chunk_time, chunk_x, chunk_y and chunk_z input &
147  &parameters to see an effect.'
148  call store_warning(warnmsg)
149  end if
150 
151  call get_isize('LATITUDE', this%ncf_mempath, latsz)
152  call get_isize('LONGITUDE', this%ncf_mempath, lonsz)
153 
154  if (latsz > 0 .and. lonsz > 0) then
155  this%latlon = .true.
156  call mem_setptr(this%latitude, 'LATITUDE', this%ncf_mempath)
157  call mem_setptr(this%longitude, 'LONGITUDE', this%ncf_mempath)
158  end if
159  end if
160 
161  ! create the netcdf file
162  call nf_verify(nf90_create(this%nc_fname, &
163  ior(nf90_clobber, nf90_netcdf4), this%ncid), &
164  this%nc_fname)
memorymanagermodule::mem_setptr
Definition: MemoryManager.f90:89
memorymanagermodule::get_isize
subroutine, public get_isize(name, mem_path, isize)
@ brief Get the number of elements for this variable
Definition: MemoryManager.f90:265
Here is the call graph for this function:

◆ export_input_array()

subroutine disncstructuredmodule::export_input_array ( class(disncstructuredtype), intent(inout)  this,
character(len=*), intent(in)  pkgtype,
character(len=*), intent(in)  pkgname,
character(len=*), intent(in)  mempath,
type(inputparamdefinitiontype), intent(in), pointer  idt 
)

Definition at line 264 of file DisNCStructured.f90.

265  class(DisNCStructuredType), intent(inout) :: this
266  character(len=*), intent(in) :: pkgtype
267  character(len=*), intent(in) :: pkgname
268  character(len=*), intent(in) :: mempath
269  type(InputParamDefinitionType), pointer, intent(in) :: idt
270  integer(I4B), dimension(:), pointer, contiguous :: int1d
271  integer(I4B), dimension(:, :), pointer, contiguous :: int2d
272  integer(I4B), dimension(:, :, :), pointer, contiguous :: int3d
273  real(DP), dimension(:), pointer, contiguous :: dbl1d
274  real(DP), dimension(:, :), pointer, contiguous :: dbl2d
275  real(DP), dimension(:, :, :), pointer, contiguous :: dbl3d
276  character(len=LINELENGTH) :: nc_varname, input_attr
277  integer(I4B) :: iper, iaux
278 
279  ! initialize
280  iper = 0
281  iaux = 0
282 
283  ! set variable name and input attribute string
284  nc_varname = export_varname(pkgname, idt)
285  input_attr = this%input_attribute(pkgname, idt)
286 
287  select case (idt%datatype)
288  case ('INTEGER1D')
289  call mem_setptr(int1d, idt%mf6varname, mempath)
290  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
291  int1d, nc_varname, pkgname, idt%tagname, &
292  idt%shape, idt%longname, input_attr, &
293  this%gridmap_name, this%latlon, this%deflate, &
294  this%shuffle, this%chunk_z, this%chunk_y, &
295  this%chunk_x, iper, this%nc_fname)
296  case ('INTEGER2D')
297  call mem_setptr(int2d, idt%mf6varname, mempath)
298  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
299  int2d, nc_varname, pkgname, idt%tagname, &
300  idt%shape, idt%longname, input_attr, &
301  this%gridmap_name, this%latlon, this%deflate, &
302  this%shuffle, this%chunk_z, this%chunk_y, &
303  this%chunk_x, this%nc_fname)
304  case ('INTEGER3D')
305  call mem_setptr(int3d, idt%mf6varname, mempath)
306  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
307  int3d, nc_varname, pkgname, idt%tagname, &
308  idt%shape, idt%longname, input_attr, &
309  this%gridmap_name, this%latlon, this%deflate, &
310  this%shuffle, this%chunk_z, this%chunk_y, &
311  this%chunk_x, this%nc_fname)
312  case ('DOUBLE1D')
313  call mem_setptr(dbl1d, idt%mf6varname, mempath)
314  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
315  dbl1d, nc_varname, pkgname, idt%tagname, &
316  idt%shape, idt%longname, input_attr, &
317  this%gridmap_name, this%latlon, this%deflate, &
318  this%shuffle, this%chunk_z, this%chunk_y, &
319  this%chunk_x, iper, this%nc_fname)
320  case ('DOUBLE2D')
321  call mem_setptr(dbl2d, idt%mf6varname, mempath)
322  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
323  dbl2d, nc_varname, pkgname, idt%tagname, &
324  idt%shape, idt%longname, input_attr, &
325  this%gridmap_name, this%latlon, this%deflate, &
326  this%shuffle, this%chunk_z, this%chunk_y, &
327  this%chunk_x, this%nc_fname)
328  case ('DOUBLE3D')
329  call mem_setptr(dbl3d, idt%mf6varname, mempath)
330  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
331  dbl3d, nc_varname, pkgname, idt%tagname, &
332  idt%shape, idt%longname, input_attr, &
333  this%gridmap_name, this%latlon, this%deflate, &
334  this%shuffle, this%chunk_z, this%chunk_y, &
335  this%chunk_x, iper, iaux, this%nc_fname)
336  case default
337  ! no-op, no other datatypes exported
338  end select
Here is the call graph for this function:

◆ export_input_arrays()

subroutine disncstructuredmodule::export_input_arrays ( class(disncstructuredtype), 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 343 of file DisNCStructured.f90.

344  use memorymanagermodule, only: get_isize
345  class(DisNCStructuredType), intent(inout) :: this
346  character(len=*), intent(in) :: pkgtype
347  character(len=*), intent(in) :: pkgname
348  character(len=*), intent(in) :: mempath
349  type(InputParamDefinitionType), dimension(:), pointer, &
350  intent(in) :: param_dfns
351  type(InputParamDefinitionType), pointer :: idt
352  integer(I4B) :: iparam, isize
353  do iparam = 1, size(param_dfns)
354  ! assign param definition pointer
355  idt => param_dfns(iparam)
356  ! for now only griddata is exported
357  if (idt%blockname == 'GRIDDATA') then
358  ! check if variable is already allocated
359  call get_isize(idt%mf6varname, mempath, isize)
360  if (isize > 0) then
361  call this%export_input_array(pkgtype, pkgname, mempath, idt)
362  end if
363  end if
364  end do
Here is the call graph for this function:

◆ export_layer_3d()

subroutine disncstructuredmodule::export_layer_3d ( class(disncstructuredtype), intent(inout)  this,
class(exportpackagetype), intent(in), pointer  export_pkg,
type(inputparamdefinitiontype), intent(in), pointer  idt,
logical(lgp), intent(in)  ilayer_read,
integer(i4b), dimension(:), intent(in), pointer, contiguous  ialayer,
real(dp), dimension(:), intent(in), pointer, contiguous  dbl1d,
character(len=*), intent(inout)  nc_varname,
character(len=*), intent(in)  input_attr,
integer(i4b), intent(in), optional  iaux 
)

Definition at line 516 of file DisNCStructured.f90.

518  use constantsmodule, only: dnodata, dzero
519  use tdismodule, only: kper
520  use ncmodelexportmodule, only: exportpackagetype
521  class(DisNCStructuredType), intent(inout) :: this
522  class(ExportPackageType), pointer, intent(in) :: export_pkg
523  type(InputParamDefinitionType), pointer, intent(in) :: idt
524  logical(LGP), intent(in) :: ilayer_read
525  integer(I4B), dimension(:), pointer, contiguous, intent(in) :: ialayer
526  real(DP), dimension(:), pointer, contiguous, intent(in) :: dbl1d
527  character(len=*), intent(inout) :: nc_varname
528  character(len=*), intent(in) :: input_attr
529  integer(I4B), optional, intent(in) :: iaux
530  real(DP), dimension(:, :, :), pointer, contiguous :: dbl3d
531  integer(I4B) :: n, i, j, k, nvals, idxaux
532  real(DP), dimension(:, :), contiguous, pointer :: dbl2d_ptr
533 
534  ! initialize
535  idxaux = 0
536  if (present(iaux)) then
537  nc_varname = export_varname(export_pkg%mf6_input%subcomponent_name, &
538  idt, iper=kper, iaux=iaux)
539  idxaux = iaux
540  end if
541 
542  allocate (dbl3d(export_pkg%mshape(3), export_pkg%mshape(2), &
543  export_pkg%mshape(1)))
544 
545  if (ilayer_read) then
546  do k = 1, size(dbl3d, dim=3)
547  n = 0
548  do i = 1, size(dbl3d, dim=2)
549  do j = 1, size(dbl3d, dim=1)
550  n = n + 1
551  if (ialayer(n) == k) then
552  dbl3d(j, i, k) = dbl1d(n)
553  else
554  dbl3d(j, i, k) = dnodata
555  end if
556  end do
557  end do
558  end do
559  else
560  dbl3d = dnodata
561  nvals = export_pkg%mshape(3) * export_pkg%mshape(2)
562  dbl2d_ptr(1:export_pkg%mshape(3), 1:export_pkg%mshape(2)) => dbl1d(1:nvals)
563  dbl3d(:, :, 1) = dbl2d_ptr(:, :)
564  end if
565 
566  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, dbl3d, &
567  nc_varname, export_pkg%mf6_input%subcomponent_name, &
568  idt%tagname, idt%shape, idt%longname, input_attr, &
569  this%gridmap_name, this%latlon, this%deflate, &
570  this%shuffle, this%chunk_z, this%chunk_y, this%chunk_x, &
571  export_pkg%iper, idxaux, this%nc_fname)
572 
573  deallocate (dbl3d)
constantsmodule::dnodata
real(dp), parameter dnodata
real no data constant
Definition: Constants.f90:95
constantsmodule::dzero
real(dp), parameter dzero
real constant zero
Definition: Constants.f90:65
ncmodelexportmodule
This module contains the NCModelExportModule.
Definition: NCModel.f90:8
tdismodule::kper
integer(i4b), pointer, public kper
current stress period number
Definition: tdis.f90:23
Here is the call graph for this function:

◆ export_varname()

character(len=linelength) function disncstructuredmodule::export_varname ( character(len=*), intent(in)  pkgname,
type(inputparamdefinitiontype), intent(in), pointer  idt,
integer(i4b), intent(in), optional  iper,
integer(i4b), intent(in), optional  iaux 
)

Definition at line 1457 of file DisNCStructured.f90.

1458  use inputoutputmodule, only: lowcase
1459  character(len=*), intent(in) :: pkgname
1460  type(InputParamDefinitionType), pointer, intent(in) :: idt
1461  integer(I4B), optional, intent(in) :: iper
1462  integer(I4B), optional, intent(in) :: iaux
1463  character(len=LINELENGTH) :: varname
1464  character(len=LINELENGTH) :: pname, vname
1465  pname = pkgname
1466  vname = idt%mf6varname
1467  call lowcase(pname)
1468  call lowcase(vname)
1469  if (present(iper)) then
1470  if (present(iaux)) then
1471  write (varname, '(a,i0,a,i0)') trim(pname)//'_'//trim(vname)// &
1472  '_p', iper, 'a', iaux
1473  else
1474  write (varname, '(a,i0)') trim(pname)//'_'//trim(vname)//'_p', iper
1475  end if
1476  else
1477  varname = trim(pname)//'_'//trim(vname)
1478  end if
inputoutputmodule::lowcase
subroutine, public lowcase(word)
Convert to lower case.
Definition: InputOutput.f90:230
Here is the call graph for this function:
Here is the caller graph for this function:

◆ nc_export_dbl1d()

subroutine disncstructuredmodule::nc_export_dbl1d ( integer(i4b), intent(in)  ncid,
type(structuredncdimidtype), intent(inout)  dim_ids,
type(structuredncvaridtype), intent(inout)  var_ids,
type(distype), intent(in), pointer  dis,
real(dp), dimension(:), intent(in), pointer, contiguous  p_mem,
character(len=*), intent(in)  nc_varname,
character(len=*), intent(in)  pkgname,
character(len=*), intent(in)  tagname,
character(len=*), intent(in)  shapestr,
character(len=*), intent(in)  longname,
character(len=*), intent(in)  nc_tag,
character(len=*), intent(in)  gridmap_name,
logical(lgp), intent(in)  latlon,
integer(i4b), intent(in)  deflate,
integer(i4b), intent(in)  shuffle,
integer(i4b), intent(in)  chunk_z,
integer(i4b), intent(in)  chunk_y,
integer(i4b), intent(in)  chunk_x,
integer(i4b), intent(in)  iper,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 1229 of file DisNCStructured.f90.

1233  use constantsmodule, only: dnodata
1234  integer(I4B), intent(in) :: ncid
1235  type(StructuredNCDimIdType), intent(inout) :: dim_ids
1236  type(StructuredNCVarIdType), intent(inout) :: var_ids
1237  type(DisType), pointer, intent(in) :: dis
1238  real(DP), dimension(:), pointer, contiguous, intent(in) :: p_mem
1239  character(len=*), intent(in) :: nc_varname
1240  character(len=*), intent(in) :: pkgname
1241  character(len=*), intent(in) :: tagname
1242  character(len=*), intent(in) :: shapestr
1243  character(len=*), intent(in) :: longname
1244  character(len=*), intent(in) :: nc_tag
1245  character(len=*), intent(in) :: gridmap_name
1246  logical(LGP), intent(in) :: latlon
1247  integer(I4B), intent(in) :: deflate
1248  integer(I4B), intent(in) :: shuffle
1249  integer(I4B), intent(in) :: chunk_z
1250  integer(I4B), intent(in) :: chunk_y
1251  integer(I4B), intent(in) :: chunk_x
1252  integer(I4B), intent(in) :: iper
1253  character(len=*), intent(in) :: nc_fname
1254  integer(I4B) :: var_id, axis_sz
1255  real(DP) :: fill_value
1256  character(len=LINELENGTH) :: longname_l
1257 
1258  if (shapestr == 'NROW' .or. &
1259  shapestr == 'NCOL' .or. &
1260  shapestr == 'NCPL') then
1261 
1262  select case (shapestr)
1263  case ('NROW')
1264  axis_sz = dim_ids%y
1265  case ('NCOL')
1266  axis_sz = dim_ids%x
1267  case ('NCPL')
1268  axis_sz = dim_ids%ncpl
1269  end select
1270 
1271  ! reenter define mode and create variable
1272  call nf_verify(nf90_redef(ncid), nc_fname)
1273  call nf_verify(nf90_def_var(ncid, nc_varname, nf90_double, &
1274  (/axis_sz/), var_id), &
1275  nc_fname)
1276 
1277  ! NROW/NCOL shapes use default chunking
1278  call ncvar_deflate(ncid, var_id, deflate, shuffle, nc_fname)
1279 
1280  ! put attr
1281  call nf_verify(nf90_put_att(ncid, var_id, '_FillValue', &
1282  (/nf90_fill_double/)), nc_fname)
1283  call nf_verify(nf90_put_att(ncid, var_id, 'long_name', &
1284  longname), nc_fname)
1285 
1286  ! add mf6 attr
1287  call ncvar_mf6attr(ncid, var_id, 0, 0, nc_tag, nc_fname)
1288 
1289  ! exit define mode and write data
1290  call nf_verify(nf90_enddef(ncid), nc_fname)
1291  call nf_verify(nf90_put_var(ncid, var_id, p_mem), &
1292  nc_fname)
1293 
1294  else
1295  if (iper > 0) then
1296  fill_value = dnodata
1297  else
1298  fill_value = nf90_fill_double
1299  end if
1300 
1301  longname_l = export_longname(longname, pkgname, tagname, layer=0, iper=iper)
1302 
1303  ! reenter define mode and create variable
1304  call nf_verify(nf90_redef(ncid), nc_fname)
1305  call nf_verify(nf90_def_var(ncid, nc_varname, nf90_double, &
1306  (/dim_ids%x, dim_ids%y, dim_ids%z/), var_id), &
1307  nc_fname)
1308 
1309  ! apply chunking parameters
1310  call ncvar_chunk3d(ncid, var_id, chunk_x, chunk_y, chunk_z, nc_fname)
1311  ! deflate and shuffle
1312  call ncvar_deflate(ncid, var_id, deflate, shuffle, nc_fname)
1313 
1314  ! put attr
1315  call nf_verify(nf90_put_att(ncid, var_id, '_FillValue', &
1316  (/fill_value/)), nc_fname)
1317  call nf_verify(nf90_put_att(ncid, var_id, 'long_name', &
1318  longname_l), nc_fname)
1319 
1320  ! add grid mapping and mf6 attr
1321  call ncvar_gridmap(ncid, var_id, gridmap_name, latlon, nc_fname)
1322  call ncvar_mf6attr(ncid, var_id, iper, 0, nc_tag, nc_fname)
1323 
1324  ! exit define mode and write data
1325  call nf_verify(nf90_enddef(ncid), nc_fname)
1326  call nf_verify(nf90_put_var(ncid, var_id, p_mem, start=(/1, 1, 1/), &
1327  count=(/dis%ncol, dis%nrow, dis%nlay/)), &
1328  nc_fname)
1329  end if

◆ nc_export_dbl2d()

subroutine disncstructuredmodule::nc_export_dbl2d ( integer(i4b), intent(in)  ncid,
type(structuredncdimidtype), intent(inout)  dim_ids,
type(structuredncvaridtype), intent(inout)  var_ids,
type(distype), intent(in), pointer  dis,
real(dp), dimension(:, :), intent(in), pointer, contiguous  p_mem,
character(len=*), intent(in)  nc_varname,
character(len=*), intent(in)  pkgname,
character(len=*), intent(in)  tagname,
character(len=*), intent(in)  shapestr,
character(len=*), intent(in)  longname,
character(len=*), intent(in)  nc_tag,
character(len=*), intent(in)  gridmap_name,
logical(lgp), intent(in)  latlon,
integer(i4b), intent(in)  deflate,
integer(i4b), intent(in)  shuffle,
integer(i4b), intent(in)  chunk_z,
integer(i4b), intent(in)  chunk_y,
integer(i4b), intent(in)  chunk_x,
character(len=*), intent(in)  nc_fname 
)

Definition at line 1334 of file DisNCStructured.f90.

1338  integer(I4B), intent(in) :: ncid
1339  type(StructuredNCDimIdType), intent(inout) :: dim_ids
1340  type(StructuredNCVarIdType), intent(inout) :: var_ids
1341  type(DisType), pointer, intent(in) :: dis
1342  real(DP), dimension(:, :), pointer, contiguous, intent(in) :: p_mem
1343  character(len=*), intent(in) :: nc_varname
1344  character(len=*), intent(in) :: pkgname
1345  character(len=*), intent(in) :: tagname
1346  character(len=*), intent(in) :: shapestr
1347  character(len=*), intent(in) :: longname
1348  character(len=*), intent(in) :: nc_tag
1349  character(len=*), intent(in) :: gridmap_name
1350  logical(LGP), intent(in) :: latlon
1351  integer(I4B), intent(in) :: deflate
1352  integer(I4B), intent(in) :: shuffle
1353  integer(I4B), intent(in) :: chunk_z
1354  integer(I4B), intent(in) :: chunk_y
1355  integer(I4B), intent(in) :: chunk_x
1356  character(len=*), intent(in) :: nc_fname
1357  integer(I4B) :: var_id
1358 
1359  ! reenter define mode and create variable
1360  call nf_verify(nf90_redef(ncid), nc_fname)
1361  call nf_verify(nf90_def_var(ncid, nc_varname, nf90_double, &
1362  (/dim_ids%x, dim_ids%y/), var_id), &
1363  nc_fname)
1364 
1365  ! apply chunking parameters
1366  call ncvar_chunk2d(ncid, var_id, chunk_x, chunk_y, nc_fname)
1367  ! deflate and shuffle
1368  call ncvar_deflate(ncid, var_id, deflate, shuffle, nc_fname)
1369 
1370  ! put attr
1371  call nf_verify(nf90_put_att(ncid, var_id, '_FillValue', &
1372  (/nf90_fill_double/)), nc_fname)
1373  call nf_verify(nf90_put_att(ncid, var_id, 'long_name', &
1374  longname), nc_fname)
1375 
1376  ! add grid mapping and mf6 attr
1377  call ncvar_gridmap(ncid, var_id, gridmap_name, latlon, nc_fname)
1378  call ncvar_mf6attr(ncid, var_id, 0, 0, nc_tag, nc_fname)
1379 
1380  ! exit define mode and write data
1381  call nf_verify(nf90_enddef(ncid), nc_fname)
1382  call nf_verify(nf90_put_var(ncid, var_id, p_mem, start=(/1, 1/), &
1383  count=(/dis%ncol, dis%nrow/)), &
1384  nc_fname)

◆ nc_export_dbl3d()

subroutine disncstructuredmodule::nc_export_dbl3d ( integer(i4b), intent(in)  ncid,
type(structuredncdimidtype), intent(inout)  dim_ids,
type(structuredncvaridtype), intent(inout)  var_ids,
type(distype), intent(in), pointer  dis,
real(dp), dimension(:, :, :), intent(in), pointer, contiguous  p_mem,
character(len=*), intent(in)  nc_varname,
character(len=*), intent(in)  pkgname,
character(len=*), intent(in)  tagname,
character(len=*), intent(in)  shapestr,
character(len=*), intent(in)  longname,
character(len=*), intent(in)  nc_tag,
character(len=*), intent(in)  gridmap_name,
logical(lgp), intent(in)  latlon,
integer(i4b), intent(in)  deflate,
integer(i4b), intent(in)  shuffle,
integer(i4b), intent(in)  chunk_z,
integer(i4b), intent(in)  chunk_y,
integer(i4b), intent(in)  chunk_x,
integer(i4b), intent(in)  iper,
integer(i4b), intent(in)  iaux,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 1389 of file DisNCStructured.f90.

1393  use constantsmodule, only: dnodata
1394  integer(I4B), intent(in) :: ncid
1395  type(StructuredNCDimIdType), intent(inout) :: dim_ids
1396  type(StructuredNCVarIdType), intent(inout) :: var_ids
1397  type(DisType), pointer, intent(in) :: dis
1398  real(DP), dimension(:, :, :), pointer, contiguous, intent(in) :: p_mem
1399  character(len=*), intent(in) :: nc_varname
1400  character(len=*), intent(in) :: pkgname
1401  character(len=*), intent(in) :: tagname
1402  character(len=*), intent(in) :: shapestr
1403  character(len=*), intent(in) :: longname
1404  character(len=*), intent(in) :: nc_tag
1405  character(len=*), intent(in) :: gridmap_name
1406  logical(LGP), intent(in) :: latlon
1407  integer(I4B), intent(in) :: deflate
1408  integer(I4B), intent(in) :: shuffle
1409  integer(I4B), intent(in) :: chunk_z
1410  integer(I4B), intent(in) :: chunk_y
1411  integer(I4B), intent(in) :: chunk_x
1412  integer(I4B), intent(in) :: iper
1413  integer(I4B), intent(in) :: iaux
1414  character(len=*), intent(in) :: nc_fname
1415  integer(I4B) :: var_id
1416  real(DP) :: fill_value
1417  character(len=LINELENGTH) :: longname_l
1418 
1419  if (iper > 0) then
1420  fill_value = dnodata
1421  else
1422  fill_value = nf90_fill_double
1423  end if
1424 
1425  longname_l = export_longname(longname, pkgname, tagname, layer=0, iper=iper)
1426 
1427  ! reenter define mode and create variable
1428  call nf_verify(nf90_redef(ncid), nc_fname)
1429  call nf_verify(nf90_def_var(ncid, nc_varname, nf90_double, &
1430  (/dim_ids%x, dim_ids%y, dim_ids%z/), var_id), &
1431  nc_fname)
1432 
1433  ! apply chunking parameters
1434  call ncvar_chunk3d(ncid, var_id, chunk_x, chunk_y, chunk_z, nc_fname)
1435  ! deflate and shuffle
1436  call ncvar_deflate(ncid, var_id, deflate, shuffle, nc_fname)
1437 
1438  ! put attr
1439  call nf_verify(nf90_put_att(ncid, var_id, '_FillValue', &
1440  (/fill_value/)), nc_fname)
1441  call nf_verify(nf90_put_att(ncid, var_id, 'long_name', &
1442  longname_l), nc_fname)
1443 
1444  ! add grid mapping and mf6 attr
1445  call ncvar_gridmap(ncid, var_id, gridmap_name, latlon, nc_fname)
1446  call ncvar_mf6attr(ncid, var_id, iper, iaux, nc_tag, nc_fname)
1447 
1448  ! exit define mode and write data
1449  call nf_verify(nf90_enddef(ncid), nc_fname)
1450  call nf_verify(nf90_put_var(ncid, var_id, p_mem, start=(/1, 1, 1/), &
1451  count=(/dis%ncol, dis%nrow, dis%nlay/)), &
1452  nc_fname)

◆ nc_export_int1d()

subroutine disncstructuredmodule::nc_export_int1d ( integer(i4b), intent(in)  ncid,
type(structuredncdimidtype), intent(inout)  dim_ids,
type(structuredncvaridtype), intent(inout)  var_ids,
type(distype), intent(in), pointer  dis,
integer(i4b), dimension(:), intent(in), pointer, contiguous  p_mem,
character(len=*), intent(in)  nc_varname,
character(len=*), intent(in)  pkgname,
character(len=*), intent(in)  tagname,
character(len=*), intent(in)  shapestr,
character(len=*), intent(in)  longname,
character(len=*), intent(in)  nc_tag,
character(len=*), intent(in)  gridmap_name,
logical(lgp), intent(in)  latlon,
integer(i4b), intent(in)  deflate,
integer(i4b), intent(in)  shuffle,
integer(i4b), intent(in)  chunk_z,
integer(i4b), intent(in)  chunk_y,
integer(i4b), intent(in)  chunk_x,
integer(i4b), intent(in)  iper,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 1022 of file DisNCStructured.f90.

1026  integer(I4B), intent(in) :: ncid
1027  type(StructuredNCDimIdType), intent(inout) :: dim_ids
1028  type(StructuredNCVarIdType), intent(inout) :: var_ids
1029  type(DisType), pointer, intent(in) :: dis
1030  integer(I4B), dimension(:), pointer, contiguous, intent(in) :: p_mem
1031  character(len=*), intent(in) :: nc_varname
1032  character(len=*), intent(in) :: pkgname
1033  character(len=*), intent(in) :: tagname
1034  character(len=*), intent(in) :: shapestr
1035  character(len=*), intent(in) :: longname
1036  character(len=*), intent(in) :: nc_tag
1037  character(len=*), intent(in) :: gridmap_name
1038  logical(LGP), intent(in) :: latlon
1039  integer(I4B), intent(in) :: deflate
1040  integer(I4B), intent(in) :: shuffle
1041  integer(I4B), intent(in) :: chunk_z
1042  integer(I4B), intent(in) :: chunk_y
1043  integer(I4B), intent(in) :: chunk_x
1044  integer(I4B), intent(in) :: iper
1045  character(len=*), intent(in) :: nc_fname
1046  integer(I4B) :: var_id, axis_sz
1047  character(len=LINELENGTH) :: longname_l
1048 
1049  if (shapestr == 'NROW' .or. &
1050  shapestr == 'NCOL' .or. &
1051  shapestr == 'NCPL') then
1052 
1053  select case (shapestr)
1054  case ('NROW')
1055  axis_sz = dim_ids%y
1056  case ('NCOL')
1057  axis_sz = dim_ids%x
1058  case ('NCPL')
1059  axis_sz = dim_ids%ncpl
1060  end select
1061 
1062  longname_l = export_longname(longname, pkgname, tagname, layer=0, iper=iper)
1063 
1064  ! reenter define mode and create variable
1065  call nf_verify(nf90_redef(ncid), nc_fname)
1066  call nf_verify(nf90_def_var(ncid, nc_varname, nf90_int, &
1067  (/axis_sz/), var_id), &
1068  nc_fname)
1069 
1070  ! NROW/NCOL shapes use default chunking
1071  call ncvar_deflate(ncid, var_id, deflate, shuffle, nc_fname)
1072 
1073  ! put attr
1074  call nf_verify(nf90_put_att(ncid, var_id, '_FillValue', &
1075  (/nf90_fill_int/)), nc_fname)
1076  call nf_verify(nf90_put_att(ncid, var_id, 'long_name', &
1077  longname_l), nc_fname)
1078 
1079  ! add mf6 attr
1080  call ncvar_mf6attr(ncid, var_id, iper, 0, nc_tag, nc_fname)
1081 
1082  ! exit define mode and write data
1083  call nf_verify(nf90_enddef(ncid), nc_fname)
1084  call nf_verify(nf90_put_var(ncid, var_id, p_mem), &
1085  nc_fname)
1086 
1087  else
1088  ! reenter define mode and create variable
1089  call nf_verify(nf90_redef(ncid), nc_fname)
1090  call nf_verify(nf90_def_var(ncid, nc_varname, nf90_int, &
1091  (/dim_ids%x, dim_ids%y, dim_ids%z/), var_id), &
1092  nc_fname)
1093 
1094  ! apply chunking parameters
1095  call ncvar_chunk3d(ncid, var_id, chunk_x, chunk_y, chunk_z, nc_fname)
1096  ! deflate and shuffle
1097  call ncvar_deflate(ncid, var_id, deflate, shuffle, nc_fname)
1098 
1099  ! put attr
1100  call nf_verify(nf90_put_att(ncid, var_id, '_FillValue', &
1101  (/nf90_fill_int/)), nc_fname)
1102  call nf_verify(nf90_put_att(ncid, var_id, 'long_name', &
1103  longname), nc_fname)
1104 
1105  ! add grid mapping and mf6 attr
1106  call ncvar_gridmap(ncid, var_id, gridmap_name, latlon, nc_fname)
1107  call ncvar_mf6attr(ncid, var_id, 0, 0, nc_tag, nc_fname)
1108 
1109  ! exit define mode and write data
1110  call nf_verify(nf90_enddef(ncid), nc_fname)
1111  call nf_verify(nf90_put_var(ncid, var_id, p_mem, start=(/1, 1, 1/), &
1112  count=(/dis%ncol, dis%nrow, dis%nlay/)), &
1113  nc_fname)
1114  end if

◆ nc_export_int2d()

subroutine disncstructuredmodule::nc_export_int2d ( integer(i4b), intent(in)  ncid,
type(structuredncdimidtype), intent(inout)  dim_ids,
type(structuredncvaridtype), intent(inout)  var_ids,
type(distype), intent(in), pointer  dis,
integer(i4b), dimension(:, :), intent(in), pointer, contiguous  p_mem,
character(len=*), intent(in)  nc_varname,
character(len=*), intent(in)  pkgname,
character(len=*), intent(in)  tagname,
character(len=*), intent(in)  shapestr,
character(len=*), intent(in)  longname,
character(len=*), intent(in)  nc_tag,
character(len=*), intent(in)  gridmap_name,
logical(lgp), intent(in)  latlon,
integer(i4b), intent(in)  deflate,
integer(i4b), intent(in)  shuffle,
integer(i4b), intent(in)  chunk_z,
integer(i4b), intent(in)  chunk_y,
integer(i4b), intent(in)  chunk_x,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 1119 of file DisNCStructured.f90.

1123  integer(I4B), intent(in) :: ncid
1124  type(StructuredNCDimIdType), intent(inout) :: dim_ids
1125  type(StructuredNCVarIdType), intent(inout) :: var_ids
1126  type(DisType), pointer, intent(in) :: dis
1127  integer(I4B), dimension(:, :), pointer, contiguous, intent(in) :: p_mem
1128  character(len=*), intent(in) :: nc_varname
1129  character(len=*), intent(in) :: pkgname
1130  character(len=*), intent(in) :: tagname
1131  character(len=*), intent(in) :: shapestr
1132  character(len=*), intent(in) :: longname
1133  character(len=*), intent(in) :: nc_tag
1134  character(len=*), intent(in) :: gridmap_name
1135  logical(LGP), intent(in) :: latlon
1136  integer(I4B), intent(in) :: deflate
1137  integer(I4B), intent(in) :: shuffle
1138  integer(I4B), intent(in) :: chunk_z
1139  integer(I4B), intent(in) :: chunk_y
1140  integer(I4B), intent(in) :: chunk_x
1141  character(len=*), intent(in) :: nc_fname
1142  integer(I4B) :: var_id
1143 
1144  ! reenter define mode and create variable
1145  call nf_verify(nf90_redef(ncid), nc_fname)
1146  call nf_verify(nf90_def_var(ncid, nc_varname, nf90_int, &
1147  (/dim_ids%x, dim_ids%y/), var_id), &
1148  nc_fname)
1149 
1150  ! apply chunking parameters
1151  call ncvar_chunk2d(ncid, var_id, chunk_x, chunk_y, nc_fname)
1152  ! deflate and shuffle
1153  call ncvar_deflate(ncid, var_id, deflate, shuffle, nc_fname)
1154 
1155  ! put attr
1156  call nf_verify(nf90_put_att(ncid, var_id, '_FillValue', &
1157  (/nf90_fill_int/)), nc_fname)
1158  call nf_verify(nf90_put_att(ncid, var_id, 'long_name', &
1159  longname), nc_fname)
1160 
1161  ! add grid mapping and mf6 attr
1162  call ncvar_gridmap(ncid, var_id, gridmap_name, latlon, nc_fname)
1163  call ncvar_mf6attr(ncid, var_id, 0, 0, nc_tag, nc_fname)
1164 
1165  ! exit define mode and write data
1166  call nf_verify(nf90_enddef(ncid), nc_fname)
1167  call nf_verify(nf90_put_var(ncid, var_id, p_mem, start=(/1, 1/), &
1168  count=(/dis%ncol, dis%nrow/)), &
1169  nc_fname)

◆ nc_export_int3d()

subroutine disncstructuredmodule::nc_export_int3d ( integer(i4b), intent(in)  ncid,
type(structuredncdimidtype), intent(inout)  dim_ids,
type(structuredncvaridtype), intent(inout)  var_ids,
type(distype), intent(in), pointer  dis,
integer(i4b), dimension(:, :, :), intent(in), pointer, contiguous  p_mem,
character(len=*), intent(in)  nc_varname,
character(len=*), intent(in)  pkgname,
character(len=*), intent(in)  tagname,
character(len=*), intent(in)  shapestr,
character(len=*), intent(in)  longname,
character(len=*), intent(in)  nc_tag,
character(len=*), intent(in)  gridmap_name,
logical(lgp), intent(in)  latlon,
integer(i4b), intent(in)  deflate,
integer(i4b), intent(in)  shuffle,
integer(i4b), intent(in)  chunk_z,
integer(i4b), intent(in)  chunk_y,
integer(i4b), intent(in)  chunk_x,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 1174 of file DisNCStructured.f90.

1178  integer(I4B), intent(in) :: ncid
1179  type(StructuredNCDimIdType), intent(inout) :: dim_ids
1180  type(StructuredNCVarIdType), intent(inout) :: var_ids
1181  type(DisType), pointer, intent(in) :: dis
1182  integer(I4B), dimension(:, :, :), pointer, contiguous, intent(in) :: p_mem
1183  character(len=*), intent(in) :: nc_varname
1184  character(len=*), intent(in) :: pkgname
1185  character(len=*), intent(in) :: tagname
1186  character(len=*), intent(in) :: shapestr
1187  character(len=*), intent(in) :: longname
1188  character(len=*), intent(in) :: nc_tag
1189  character(len=*), intent(in) :: gridmap_name
1190  logical(LGP), intent(in) :: latlon
1191  integer(I4B), intent(in) :: deflate
1192  integer(I4B), intent(in) :: shuffle
1193  integer(I4B), intent(in) :: chunk_z
1194  integer(I4B), intent(in) :: chunk_y
1195  integer(I4B), intent(in) :: chunk_x
1196  character(len=*), intent(in) :: nc_fname
1197  integer(I4B) :: var_id
1198 
1199  ! reenter define mode and create variable
1200  call nf_verify(nf90_redef(ncid), nc_fname)
1201  call nf_verify(nf90_def_var(ncid, nc_varname, nf90_int, &
1202  (/dim_ids%x, dim_ids%y, dim_ids%z/), var_id), &
1203  nc_fname)
1204 
1205  ! apply chunking parameters
1206  call ncvar_chunk3d(ncid, var_id, chunk_x, chunk_y, chunk_z, nc_fname)
1207  ! deflate and shuffle
1208  call ncvar_deflate(ncid, var_id, deflate, shuffle, nc_fname)
1209 
1210  ! put attr
1211  call nf_verify(nf90_put_att(ncid, var_id, '_FillValue', &
1212  (/nf90_fill_int/)), nc_fname)
1213  call nf_verify(nf90_put_att(ncid, var_id, 'long_name', &
1214  longname), nc_fname)
1215 
1216  ! add grid mapping and mf6 attr
1217  call ncvar_gridmap(ncid, var_id, gridmap_name, latlon, nc_fname)
1218  call ncvar_mf6attr(ncid, var_id, 0, 0, nc_tag, nc_fname)
1219 
1220  ! exit define mode and write data
1221  call nf_verify(nf90_enddef(ncid), nc_fname)
1222  call nf_verify(nf90_put_var(ncid, var_id, p_mem, start=(/1, 1, 1/), &
1223  count=(/dis%ncol, dis%nrow, dis%nlay/)), &
1224  nc_fname)

◆ ncvar_chunk2d()

subroutine disncstructuredmodule::ncvar_chunk2d ( integer(i4b), intent(in)  ncid,
integer(i4b), intent(in)  varid,
integer(i4b), intent(in)  chunk_x,
integer(i4b), intent(in)  chunk_y,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 932 of file DisNCStructured.f90.

933  integer(I4B), intent(in) :: ncid
934  integer(I4B), intent(in) :: varid
935  integer(I4B), intent(in) :: chunk_x
936  integer(I4B), intent(in) :: chunk_y
937  character(len=*), intent(in) :: nc_fname
938  if (chunk_y > 0 .and. chunk_x > 0) then
939  call nf_verify(nf90_def_var_chunking(ncid, varid, nf90_chunked, &
940  (/chunk_x, chunk_y/)), nc_fname)
941  end if
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ncvar_chunk3d()

subroutine disncstructuredmodule::ncvar_chunk3d ( integer(i4b), intent(in)  ncid,
integer(i4b), intent(in)  varid,
integer(i4b), intent(in)  chunk_x,
integer(i4b), intent(in)  chunk_y,
integer(i4b), intent(in)  chunk_z,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 946 of file DisNCStructured.f90.

947  integer(I4B), intent(in) :: ncid
948  integer(I4B), intent(in) :: varid
949  integer(I4B), intent(in) :: chunk_x
950  integer(I4B), intent(in) :: chunk_y
951  integer(I4B), intent(in) :: chunk_z
952  character(len=*), intent(in) :: nc_fname
953  if (chunk_z > 0 .and. chunk_y > 0 .and. chunk_x > 0) then
954  call nf_verify(nf90_def_var_chunking(ncid, varid, nf90_chunked, &
955  (/chunk_x, chunk_y, chunk_z/)), &
956  nc_fname)
957  end if
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ncvar_deflate()

subroutine disncstructuredmodule::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 
)
private

Definition at line 962 of file DisNCStructured.f90.

963  integer(I4B), intent(in) :: ncid
964  integer(I4B), intent(in) :: varid
965  integer(I4B), intent(in) :: deflate
966  integer(I4B), intent(in) :: shuffle
967  character(len=*), intent(in) :: nc_fname
968  ! deflate and shuffle
969  if (deflate >= 0) then
970  call nf_verify(nf90_def_var_deflate(ncid, varid, shuffle=shuffle, &
971  deflate=1, deflate_level=deflate), &
972  nc_fname)
973  end if
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ncvar_gridmap()

subroutine disncstructuredmodule::ncvar_gridmap ( integer(i4b), intent(in)  ncid,
integer(i4b), intent(in)  varid,
character(len=*), intent(in)  gridmap_name,
logical(lgp), intent(in)  latlon,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 978 of file DisNCStructured.f90.

979  integer(I4B), intent(in) :: ncid
980  integer(I4B), intent(in) :: varid
981  character(len=*), intent(in) :: gridmap_name
982  logical(LGP), intent(in) :: latlon
983  character(len=*), intent(in) :: nc_fname
984  if (gridmap_name /= '') then
985  if (latlon) then
986  call nf_verify(nf90_put_att(ncid, varid, 'coordinates', 'lon lat'), &
987  nc_fname)
988  else
989  call nf_verify(nf90_put_att(ncid, varid, 'coordinates', 'x y'), &
990  nc_fname)
991  end if
992  call nf_verify(nf90_put_att(ncid, varid, 'grid_mapping', gridmap_name), &
993  nc_fname)
994  end if
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ncvar_mf6attr()

subroutine disncstructuredmodule::ncvar_mf6attr ( integer(i4b), intent(in)  ncid,
integer(i4b), intent(in)  varid,
integer(i4b), intent(in)  iper,
integer(i4b), intent(in)  iaux,
character(len=*), intent(in)  nc_tag,
character(len=*), intent(in)  nc_fname 
)
private

Definition at line 999 of file DisNCStructured.f90.

1000  integer(I4B), intent(in) :: ncid
1001  integer(I4B), intent(in) :: varid
1002  integer(I4B), intent(in) :: iper
1003  integer(I4B), intent(in) :: iaux
1004  character(len=*), intent(in) :: nc_tag
1005  character(len=*), intent(in) :: nc_fname
1006  if (nc_tag /= '') then
1007  call nf_verify(nf90_put_att(ncid, varid, 'modflow6_input', &
1008  nc_tag), nc_fname)
1009  if (iper > 0) then
1010  call nf_verify(nf90_put_att(ncid, varid, 'modflow6_iper', &
1011  iper), nc_fname)
1012  end if
1013  if (iaux > 0) then
1014  call nf_verify(nf90_put_att(ncid, varid, 'modflow6_iaux', &
1015  iaux), nc_fname)
1016  end if
1017  end if
Here is the call graph for this function:
Here is the caller graph for this function:

◆ package_step()

subroutine disncstructuredmodule::package_step ( class(disncstructuredtype), intent(inout)  this,
class(exportpackagetype), intent(in), pointer  export_pkg 
)

Definition at line 456 of file DisNCStructured.f90.

457  use tdismodule, only: kper
458  use ncmodelexportmodule, only: exportpackagetype
459  use definitionselectmodule, only: get_param_definition_type
460  class(DisNCStructuredType), intent(inout) :: this
461  class(ExportPackageType), pointer, intent(in) :: export_pkg
462  integer(I4B), dimension(:), pointer, contiguous :: int1d
463  real(DP), dimension(:), pointer, contiguous :: dbl1d
464  type(InputParamDefinitionType), pointer :: idt
465  character(len=LINELENGTH) :: nc_varname, input_attr
466  integer(I4B) :: iparam
467 
468  do iparam = 1, export_pkg%nparam
469  ! set input definition
470  idt => get_param_definition_type(export_pkg%mf6_input%param_dfns, &
471  export_pkg%mf6_input%component_type, &
472  export_pkg%mf6_input%subcomponent_type, &
473  'PERIOD', export_pkg%param_names(iparam), &
474  this%nc_fname)
475 
476  ! set variable name and input attribute string
477  nc_varname = export_varname(export_pkg%mf6_input%subcomponent_name, idt, &
478  iper=kper)
479  input_attr = this%input_attribute(export_pkg%mf6_input%subcomponent_name, &
480  idt)
481 
482  ! export arrays
483  select case (idt%datatype)
484  case ('INTEGER1D')
485  call mem_setptr(int1d, export_pkg%param_names(iparam), &
486  export_pkg%mf6_input%mempath)
487  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
488  int1d, nc_varname, &
489  export_pkg%mf6_input%subcomponent_name, &
490  idt%tagname, idt%shape, idt%longname, input_attr, &
491  this%gridmap_name, this%latlon, this%deflate, &
492  this%shuffle, this%chunk_z, this%chunk_y, &
493  this%chunk_x, kper, this%nc_fname)
494  case ('DOUBLE1D')
495  call mem_setptr(dbl1d, export_pkg%param_names(iparam), &
496  export_pkg%mf6_input%mempath)
497  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
498  dbl1d, nc_varname, &
499  export_pkg%mf6_input%subcomponent_name, &
500  idt%tagname, idt%shape, idt%longname, input_attr, &
501  this%gridmap_name, this%latlon, this%deflate, &
502  this%shuffle, this%chunk_z, this%chunk_y, &
503  this%chunk_x, kper, this%nc_fname)
504  case default
505  errmsg = 'EXPORT unsupported datatype='//trim(idt%datatype)
506  call store_error(errmsg, .true.)
507  end select
508  end do
509 
510  ! synchronize file
511  call nf_verify(nf90_sync(this%ncid), this%nc_fname)
definitionselectmodule
This module contains the DefinitionSelectModule.
Definition: DefinitionSelect.f90:8
definitionselectmodule::get_param_definition_type
type(inputparamdefinitiontype) function, pointer, public get_param_definition_type(input_definition_types, component_type, subcomponent_type, blockname, tagname, filename)
Return parameter definition.
Definition: DefinitionSelect.f90:89
Here is the call graph for this function:

◆ package_step_ilayer()

subroutine disncstructuredmodule::package_step_ilayer ( class(disncstructuredtype), intent(inout)  this,
class(exportpackagetype), intent(in), pointer  export_pkg,
character(len=*), intent(in)  ilayer_varname,
integer(i4b), intent(in)  ilayer 
)

Definition at line 369 of file DisNCStructured.f90.

370  use constantsmodule, only: dnodata, dzero
371  use tdismodule, only: kper
372  use ncmodelexportmodule, only: exportpackagetype
373  use definitionselectmodule, only: get_param_definition_type
374  class(DisNCStructuredType), intent(inout) :: this
375  class(ExportPackageType), pointer, intent(in) :: export_pkg
376  character(len=*), intent(in) :: ilayer_varname
377  integer(I4B), intent(in) :: ilayer
378  type(InputParamDefinitionType), pointer :: idt
379  integer(I4B), dimension(:), pointer, contiguous :: int1d
380  real(DP), dimension(:), pointer, contiguous :: dbl1d
381  real(DP), dimension(:, :), pointer, contiguous :: dbl2d
382  integer(I4B), dimension(:), pointer, contiguous :: ialayer
383  real(DP), dimension(:), contiguous, pointer :: dbl1d_ptr
384  character(len=LINELENGTH) :: nc_varname, input_attr
385  integer(I4B) :: n, iparam, nvals
386  logical(LGP) :: ilayer_read
387 
388  ! initialize
389  nullify (ialayer)
390  ilayer_read = .false.
391 
392  ! set pointer to ilayer variable
393  call mem_setptr(ialayer, export_pkg%param_names(ilayer), &
394  export_pkg%mf6_input%mempath)
395 
396  ! check if layer index variable was read
397  if (export_pkg%param_reads(ilayer)%invar == 1) then
398  ilayer_read = .true.
399  end if
400 
401  ! export defined period input
402  do iparam = 1, export_pkg%nparam
403  ! check if variable was read this period
404  if (export_pkg%param_reads(iparam)%invar < 1) cycle
405 
406  ! set input definition
407  idt => &
408  get_param_definition_type(export_pkg%mf6_input%param_dfns, &
409  export_pkg%mf6_input%component_type, &
410  export_pkg%mf6_input%subcomponent_type, &
411  'PERIOD', export_pkg%param_names(iparam), &
412  this%nc_fname)
413  ! set variable name and input attrs
414  nc_varname = export_varname(export_pkg%mf6_input%subcomponent_name, idt, &
415  iper=kper)
416  input_attr = this%input_attribute(export_pkg%mf6_input%subcomponent_name, &
417  idt)
418  ! export arrays
419  select case (idt%datatype)
420  case ('INTEGER1D')
421  call mem_setptr(int1d, idt%mf6varname, export_pkg%mf6_input%mempath)
422  call nc_export_array(this%ncid, this%dim_ids, this%var_ids, this%dis, &
423  int1d, nc_varname, &
424  export_pkg%mf6_input%subcomponent_name, &
425  idt%tagname, idt%shape, idt%longname, input_attr, &
426  this%gridmap_name, this%latlon, this%deflate, &
427  this%shuffle, this%chunk_z, this%chunk_y, &
428  this%chunk_x, export_pkg%iper, this%nc_fname)
429  case ('DOUBLE1D')
430  call mem_setptr(dbl1d, idt%mf6varname, export_pkg%mf6_input%mempath)
431  call this%export_layer_3d(export_pkg, idt, ilayer_read, ialayer, &
432  dbl1d, nc_varname, input_attr)
433  case ('DOUBLE2D')
434  call mem_setptr(dbl2d, idt%mf6varname, export_pkg%mf6_input%mempath)
435  nvals = this%dis%ncol * this%dis%nrow
436  do n = 1, size(dbl2d, dim=1) ! naux
437  dbl1d_ptr(1:nvals) => dbl2d(n, :)
438  if (all(dbl1d_ptr == dzero)) then
439  else
440  call this%export_layer_3d(export_pkg, idt, ilayer_read, ialayer, &
441  dbl1d_ptr, nc_varname, input_attr, n)
442  end if
443  end do
444  case default
445  errmsg = 'EXPORT ilayer unsupported datatype='//trim(idt%datatype)
446  call store_error(errmsg, .true.)
447  end select
448  end do
449 
450  ! synchronize file
451  call nf_verify(nf90_sync(this%ncid), this%nc_fname)
Here is the call graph for this function:

◆ step()

subroutine disncstructuredmodule::step ( class(disncstructuredtype), intent(inout)  this)

Definition at line 215 of file DisNCStructured.f90.

216  use constantsmodule, only: dhnoflo
217  use tdismodule, only: totim
218  class(DisNCStructuredType), intent(inout) :: this
219  real(DP), dimension(:), pointer, contiguous :: dbl1d
220  integer(I4B) :: n
221 
222  this%stepcnt = this%stepcnt + 1
223 
224  if (size(this%dis%nodeuser) < &
225  size(this%dis%nodereduced)) then
226  allocate (dbl1d(size(this%dis%nodereduced)))
227  dbl1d = dhnoflo
228  do n = 1, size(this%dis%nodereduced)
229  if (this%dis%nodereduced(n) > 0) then
230  dbl1d(n) = this%x(this%dis%nodereduced(n))
231  end if
232  end do
233  ! write step data to dependent variable
234  call nf_verify(nf90_put_var(this%ncid, &
235  this%var_ids%dependent, dbl1d, &
236  start=(/1, 1, 1, this%stepcnt/), &
237  count=(/this%dis%ncol, &
238  this%dis%nrow, &
239  this%dis%nlay, 1/)), &
240  this%nc_fname)
241  deallocate (dbl1d)
242  else
243  ! write step data to dependent variable
244  call nf_verify(nf90_put_var(this%ncid, &
245  this%var_ids%dependent, this%x, &
246  start=(/1, 1, 1, this%stepcnt/), &
247  count=(/this%dis%ncol, &
248  this%dis%nrow, &
249  this%dis%nlay, 1/)), &
250  this%nc_fname)
251  end if
252 
253  ! write to time coordinate variable
254  call nf_verify(nf90_put_var(this%ncid, this%var_ids%time, &
255  totim, start=(/this%stepcnt/)), &
256  this%nc_fname)
257 
258  ! synchronize file
259  call nf_verify(nf90_sync(this%ncid), this%nc_fname)
tdismodule::totim
real(dp), pointer, public totim
time relative to start of simulation
Definition: tdis.f90:32
Here is the call graph for this function: