ncexportcreatemodule Module Reference

This module contains the NCExportCreateModule. More...

Functions/Subroutines
subroutine	create_nc_export (export_model, num_model)
	create model netcdf export type More...
subroutine	create_export_pkglist (pkglist, loaders, iout)
subroutine, public	nc_export_create ()
	initialize netcdf model export type More...

Detailed Description

This module creates derived model netcdf export objects. It is dependent on netcdf libraries.

Function/Subroutine Documentation

create_export_pkglist()

subroutine ncexportcreatemodule::create_export_pkglist	(	type(listtype), intent(inout)	pkglist,
		type(modeldynamicpkgstype), intent(in), pointer	loaders,
		integer(i4b), intent(in)	iout
	)

Definition at line 141 of file NCExportCreate.f90.

    use listmodule, only: listtype
    use memorymanagerextmodule, only: mem_set_value
    use inputloadtypemodule, only: modeldynamicpkgstype
    use inputloadtypemodule, only: dynamicpkgloadbasetype
    use asciiinputloadtypemodule, only: asciidynamicpkgloadbasetype
    use layerarrayloadmodule, only: layerarrayloadtype
    use gridarrayloadmodule, only: gridarrayloadtype
    use idmmf6filemodule, only: mf6filedynamicpkgloadtype
    type(ListType), intent(inout) :: pkglist
    type(ModelDynamicPkgsType), pointer, intent(in) :: loaders
    integer(I4B), intent(in) :: iout
    class(DynamicPkgLoadBaseType), pointer :: dynamic_pkg
    class(AsciiDynamicPkgLoadBaseType), pointer :: rp_loader
    type(ExportPackageType), pointer :: export_pkg
    integer(I4B), pointer :: export_arrays
    class(*), pointer :: obj
    logical(LGP) :: found, readasarrays
    integer(I4B) :: n
 
    ! create list of in scope loaders
    allocate (export_arrays)
 
    do n = 1, loaders%pkglist%Count()
      ! initialize export arrays option
      export_arrays = 0
 
      dynamic_pkg => loaders%get(n)
 
      ! update export arrays option
      call mem_set_value(export_arrays, 'EXPORT_NC', &
                         dynamic_pkg%mf6_input%mempath, found)
 
      readasarrays = (dynamic_pkg%readasarrays .or. dynamic_pkg%readarraygrid)
      if (export_arrays > 0 .and. readasarrays) then
        select type (dynamic_pkg)
        type is (mf6filedynamicpkgloadtype)
          rp_loader => dynamic_pkg%rp_loader
          select type (rp_loader)
          type is (layerarrayloadtype)
            ! create the export object
            allocate (export_pkg)
            call export_pkg%init(rp_loader%mf6_input, &
                                 rp_loader%ctx%mshape, &
                                 rp_loader%ctx%naux, &
                                 rp_loader%param_names, rp_loader%nparam)
            obj => export_pkg
            call pkglist%add(obj)
          type is (gridarrayloadtype)
            ! create the export object
            allocate (export_pkg)
            call export_pkg%init(rp_loader%mf6_input, &
                                 rp_loader%ctx%mshape, &
                                 rp_loader%ctx%naux, &
                                 rp_loader%param_names, rp_loader%nparam)
            obj => export_pkg
            call pkglist%add(obj)
          end select
        end select
      end if
    end do
 
    ! cleanup
    deallocate (export_arrays)

Here is the caller graph for this function:

create_nc_export()

subroutine ncexportcreatemodule::create_nc_export ( type(exportmodeltype), intent(inout), pointer  export_model, class(numericalmodeltype), intent(in), pointer  num_model  )

private

Definition at line 30 of file NCExportCreate.f90.

    use ncmodelexportmodule, only: netcdf_mesh2d, netcdf_structured
    use meshdismodelmodule, only: mesh2ddisexporttype
    use meshdisvmodelmodule, only: mesh2ddisvexporttype
    use disncstructuredmodule, only: disncstructuredtype
    use inputloadtypemodule, only: modeldynamicpkgstype
    type(ExportModelType), pointer, intent(inout) :: export_model
    class(NumericalModelType), pointer, intent(in) :: num_model
    class(Mesh2dDisExportType), pointer :: ugrid_dis
    class(Mesh2dDisvExportType), pointer :: ugrid_disv
    class(DisNCStructuredType), pointer :: structured_dis
    class(DisBaseType), pointer :: disbase
 
    select case (export_model%disenum)
    case (dis)
      ! allocate nc structured grid export object
      if (export_model%nctype == netcdf_mesh2d) then
        ! allocate nc structured grid export object
        allocate (ugrid_dis)
 
        ! set dis base type
        disbase => num_model%dis
        select type (disbase)
        type is (distype)
          ugrid_dis%dis => disbase
        end select
 
        ! set dynamic loaders
        call create_export_pkglist(ugrid_dis%pkglist, export_model%loaders, &
                                   export_model%iout)
 
        ! initialize export object
        call ugrid_dis%init(export_model%modelname, export_model%modeltype, &
                            export_model%modelfname, export_model%nc_fname, &
                            export_model%disenum, netcdf_mesh2d, &
                            export_model%iout)
 
        ! define export object
        call ugrid_dis%df()
 
        ! set base pointer
        export_model%nc_export => ugrid_dis
      else if (export_model%nctype == netcdf_structured) then
        ! allocate nc structured grid export object
        allocate (structured_dis)
 
        ! set dis base type
        disbase => num_model%dis
        select type (disbase)
        type is (distype)
          structured_dis%dis => disbase
        end select
 
        ! set dynamic loaders
        call create_export_pkglist(structured_dis%pkglist, export_model%loaders, &
                                   export_model%iout)
 
        ! initialize export object
        call structured_dis%init(export_model%modelname, export_model%modeltype, &
                                 export_model%modelfname, export_model%nc_fname, &
                                 export_model%disenum, netcdf_structured, &
                                 export_model%iout)
 
        ! define export object
        call structured_dis%df()
 
        ! set base pointer
        export_model%nc_export => structured_dis
      end if
    case (disv)
      if (export_model%nctype == netcdf_mesh2d) then
        ! allocate nc structured grid export object
        allocate (ugrid_disv)
 
        ! set dis base type
        disbase => num_model%dis
        select type (disbase)
        type is (disvtype)
          ugrid_disv%disv => disbase
        end select
 
        ! set dynamic loaders
        call create_export_pkglist(ugrid_disv%pkglist, export_model%loaders, &
                                   export_model%iout)
 
        ! initialize export object
        call ugrid_disv%init(export_model%modelname, export_model%modeltype, &
                             export_model%modelfname, export_model%nc_fname, &
                             export_model%disenum, netcdf_mesh2d, &
                             export_model%iout)
 
        ! define export object
        call ugrid_disv%df()
 
        ! set base pointer
        export_model%nc_export => ugrid_disv
      else
        errmsg = 'DISV model discretization only &
                 &supported as UGRID NetCDF export. &
                 &Model='//trim(export_model%modelname)//'.'
        call store_error(errmsg)
        call store_error_filename(export_model%modelfname)
      end if
    case default
      errmsg = 'Unsupported discretization for NetCDF model export. &
               &Model='//trim(export_model%modelname)//'.'
      call store_error(errmsg)
      call store_error_filename(export_model%modelfname)
    end select

Here is the call graph for this function:

Here is the caller graph for this function:

nc_export_create()

subroutine, public ncexportcreatemodule::nc_export_create

Definition at line 209 of file NCExportCreate.f90.

    use numericalmodelmodule, only: getnumericalmodelfromlist
    use listsmodule, only: basemodellist
    use ncmodelexportmodule, only: netcdf_undef
    integer(I4B) :: n
    type(ExportModelType), pointer :: export_model
    class(NumericalModelType), pointer :: num_model
    integer(I4B) :: im
    do n = 1, export_models%Count()
      ! set pointer to export model
      export_model => get_export_model(n)
      if (export_model%nctype /= netcdf_undef) then
        ! netcdf export is active identify model
        do im = 1, basemodellist%Count()
          ! set model pointer
          num_model => getnumericalmodelfromlist(basemodellist, im)
          if (num_model%name == export_model%modelname .and. &
              num_model%macronym == export_model%modeltype) then
            ! allocate and initialize nc export model
            call create_nc_export(export_model, num_model)
            exit
          end if
        end do
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function: