timearrayseriesmanagermodule Module Reference

Data Types
type	timearrayseriesmanagertype

Functions/Subroutines
subroutine, public	tasmanager_cr (this, dis, modelname, iout)
	Create the time-array series manager. More...
subroutine	tasmanager_df (this)
	Define the time-array series manager. More...
subroutine	tasmgr_ad (this)
	Time step (or subtime step) advance. More...
subroutine	tasmgr_da (this)
	Deallocate. More...
subroutine	add_tasfile (this, fname)
	Add a time-array series file. More...
subroutine	reset (this, pkgName)
	Zero out arrays that are represented with time series. More...
subroutine	maketaslink (this, pkgName, bndArray, iprpak, tasName, text, convertFlux, nodelist, inunit)
	Make link from time-array series to package array. More...
type(timearrayserieslinktype) function, pointer	getlink (this, indx)
	Get link from the boundtaslinks list. More...
integer(i4b) function	countlinks (this)
	Count number of links in the boundtaslinks list. More...
subroutine	tasmgr_convert_flux (this, tasLink)
	Convert the array from a flux to a flow rate by multiplying by the cell area. More...
subroutine	tasmgr_add_link (this, tasLink)
	Add a time arrays series link. More...

Function/Subroutine Documentation

add_tasfile()

subroutine timearrayseriesmanagermodule::add_tasfile ( class(timearrayseriesmanagertype)  this, character(len=*), intent(in)  fname  )

private

Definition at line 221 of file TimeArraySeriesManager.f90.

    ! -- modules
    use arrayhandlersmodule, only: expandarray
    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    character(len=*), intent(in) :: fname
    ! -- local
    integer(I4B) :: indx
    !
    call expandarray(this%tasfiles, 1)
    indx = size(this%tasfiles)
    this%tasfiles(indx) = fname

countlinks()

integer(i4b) function timearrayseriesmanagermodule::countlinks ( class(timearrayseriesmanagertype)  this )

private

Definition at line 339 of file TimeArraySeriesManager.f90.

    ! -- return
    integer(I4B) :: CountLinks
    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    !
    if (associated(this%boundtaslinks)) then
      countlinks = this%boundTasLinks%Count()
    else
      countlinks = 0
    end if

getlink()

type(timearrayserieslinktype) function, pointer timearrayseriesmanagermodule::getlink ( class(timearrayseriesmanagertype)  this, integer(i4b), intent(in)  indx  )

private

Definition at line 323 of file TimeArraySeriesManager.f90.

    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    integer(I4B), intent(in) :: indx
    ! -- return
    type(TimeArraySeriesLinkType), pointer :: tasLink
    !
    taslink => null()
    !
    if (associated(this%boundTasLinks)) then
      taslink => gettimearrayserieslinkfromlist(this%boundTasLinks, indx)
    end if

Here is the call graph for this function:

maketaslink()

subroutine timearrayseriesmanagermodule::maketaslink ( class(timearrayseriesmanagertype)  this, character(len=*), intent(in)  pkgName, real(dp), dimension(:), pointer  bndArray, integer(i4b), intent(in)  iprpak, character(len=*), intent(in)  tasName, character(len=*), intent(in)  text, logical, intent(in)  convertFlux, integer(i4b), dimension(:), intent(in), pointer, contiguous  nodelist, integer(i4b), intent(in)  inunit  )

private

Definition at line 275 of file TimeArraySeriesManager.f90.

    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    character(len=*), intent(in) :: pkgName
    real(DP), dimension(:), pointer :: bndArray
    integer(I4B), intent(in) :: iprpak
    character(len=*), intent(in) :: tasName
    character(len=*), intent(in) :: text
    logical, intent(in) :: convertFlux
    integer(I4B), dimension(:), pointer, contiguous, intent(in) :: nodelist
    integer(I4B), intent(in) :: inunit
    ! -- local
    integer(I4B) :: i, nfiles, iloc
    character(LINELENGTH) :: ermsg
    type(TimeArraySeriesLinkType), pointer :: newTasLink
    type(TimeArraySeriesType), pointer :: tasptr => null()
    !
    ! -- Find the time array series
    nfiles = size(this%tasnames)
    iloc = 0
    do i = 1, nfiles
      if (this%tasnames(i) == tasname) then
        iloc = i
        exit
      end if
    end do
    if (iloc == 0) then
      ermsg = 'Error: Time-array series "'//trim(tasname)//'" not found.'
      call store_error(ermsg)
      call store_error_unit(inunit)
    end if
    tasptr => this%taslist(iloc)
    !
    ! -- Construct a time-array series link
    newtaslink => null()
    call constructtimearrayserieslink(newtaslink, tasptr, &
                                      pkgname, bndarray, iprpak, &
                                      text)
    newtaslink%ConvertFlux = convertflux
    newtaslink%nodelist => nodelist
    !
    ! -- Add link to list of links
    call this%tasmgr_add_link(newtaslink)

Here is the call graph for this function:

reset()

subroutine timearrayseriesmanagermodule::reset	(	class(timearrayseriesmanagertype)	this,
		character(len=*), intent(in)	pkgName
	)

Delete all existing links from time array series to package arrays as they will need to be created with a new BEGIN PERIOD block

Definition at line 240 of file TimeArraySeriesManager.f90.

    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    character(len=*), intent(in) :: pkgName
    ! -- local
    integer(I4B) :: i, j, nlinks
    type(TimeArraySeriesLinkType), pointer :: taslink
    !
    ! -- Reassign all linked elements to zero
    nlinks = this%boundTasLinks%Count()
    do i = 1, nlinks
      taslink => gettimearrayserieslinkfromlist(this%boundTasLinks, i)
      if (associated(taslink)) then
        do j = 1, size(taslink%BndArray)
          taslink%BndArray(j) = dzero
        end do
      end if
    end do
    !
    ! -- Delete all existing time array links
    if (associated(this%boundTasLinks)) then
      ! Deallocate and remove all links belonging to package
      nlinks = this%boundTasLinks%Count()
      do i = nlinks, 1, -1
        taslink => gettimearrayserieslinkfromlist(this%boundTasLinks, i)
        if (associated(taslink)) then
          call taslink%da()
          call this%boundTasLinks%RemoveNode(i, .true.)
        end if
      end do
    end if

Here is the call graph for this function:

tasmanager_cr()

subroutine, public timearrayseriesmanagermodule::tasmanager_cr	(	type(timearrayseriesmanagertype)	this,
		class(disbasetype), optional, pointer	dis,
		character(len=*), intent(in)	modelname,
		integer(i4b), intent(in)	iout
	)

Definition at line 57 of file TimeArraySeriesManager.f90.

    ! -- dummy
    type(TimeArraySeriesManagerType) :: this
    class(DisBaseType), pointer, optional :: dis
    character(len=*), intent(in) :: modelname
    integer(I4B), intent(in) :: iout
    !
    if (present(dis)) then
      this%dis => dis
    end if
    !
    this%modelname = modelname
    this%iout = iout
    allocate (this%boundTasLinks)
    allocate (this%tasfiles(0))

Here is the caller graph for this function:

tasmanager_df()

subroutine timearrayseriesmanagermodule::tasmanager_df ( class(timearrayseriesmanagertype)  this )

private

Definition at line 76 of file TimeArraySeriesManager.f90.

    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    ! -- local
    type(TimeArraySeriesType), pointer :: tasptr => null()
    integer(I4B) :: nfiles
    integer(I4B) :: i
    !
    ! -- determine how many tasfiles.  This is the number of time array series
    !    so allocate arrays to store them
    nfiles = size(this%tasfiles)
    allocate (this%taslist(nfiles))
    allocate (this%tasnames(nfiles))
    !
    ! -- Setup a time array series for each file specified
    do i = 1, nfiles
      tasptr => this%taslist(i)
      call tasptr%tas_init(this%tasfiles(i), this%modelname, &
                           this%iout, this%tasnames(i))
    end do

tasmgr_ad()

subroutine timearrayseriesmanagermodule::tasmgr_ad ( class(timearrayseriesmanagertype)  this )

private

Call this each time step or subtime step.

Definition at line 102 of file TimeArraySeriesManager.f90.

    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    ! -- local
    type(TimeArraySeriesLinkType), pointer :: tasLink => null()
    type(TimeArraySeriesType), pointer :: timearrayseries => null()
    integer(I4B) :: i, j, nlinks, nvals, isize1, isize2, inunit
    real(DP) :: begintime, endtime
    ! -- formats
    character(len=*), parameter :: fmt5 = &
      "(/,'Time-array-series controlled arrays in stress period ', &
      &i0, ', time step ', i0, ':')"
10  format('"', a, '" package: ', a, ' array obtained from time-array series "', &
           a, '"')
    !
    ! -- Initialize time variables
    begintime = totimc
    endtime = begintime + delt
    !
    ! -- Iterate through boundtaslinks and update specified
    !    array with array of average values obtained from
    !    appropriate time series.
    if (associated(this%boundTasLinks)) then
      nlinks = this%boundTasLinks%Count()
      do i = 1, nlinks
        taslink => gettimearrayserieslinkfromlist(this%boundTasLinks, i)
        if (taslink%Iprpak == 1 .and. i == 1) then
          write (this%iout, fmt5) kper, kstp
        end if
        if (taslink%UseDefaultProc) then
          timearrayseries => taslink%timeArraySeries
          nvals = size(taslink%BndArray)
          !
          ! -- Fill the package array with integrated values
          call timearrayseries%GetAverageValues(nvals, taslink%BndArray, &
                                                begintime, endtime)
          !
          ! -- If conversion from flux to flow is required, multiply by cell area
          if (taslink%ConvertFlux) then
            call this%tasmgr_convert_flux(taslink)
          end if
          !
          ! -- If PRINT_INPUT is specified, write information
          !    regarding source of time-array series data
          if (taslink%Iprpak == 1) then
            write (this%iout, 10) trim(taslink%PackageName), &
              trim(taslink%Text), &
              trim(taslink%timeArraySeries%Name)
          end if
        end if
        if (i == nlinks) then
          write (this%iout, '()')
        end if
      end do
      !
      ! -- Now that all array values have been substituted, can now multiply
      !    an array by a multiplier array
      do i = 1, nlinks
        taslink => gettimearrayserieslinkfromlist(this%boundTasLinks, i)
        if (taslink%UseDefaultProc) then
          if (associated(taslink%RMultArray)) then
            isize1 = size(taslink%BndArray)
            isize2 = size(taslink%RMultArray)
            if (isize1 == isize2 .and. isize1 == nvals) then
              do j = 1, nvals
                taslink%BndArray(j) = taslink%BndArray(j) * taslink%RMultArray(j)
              end do
            else
              errmsg = 'Size mismatch between boundary and multiplier arrays'// &
                       ' using time-array series: '// &
                       trim(taslink%TimeArraySeries%Name)
              call store_error(errmsg)
              inunit = taslink%TimeArraySeries%GetInunit()
              call store_error_unit(inunit)
            end if
          end if
        end if
      end do
    end if

Here is the call graph for this function:

tasmgr_add_link()

subroutine timearrayseriesmanagermodule::tasmgr_add_link ( class(timearrayseriesmanagertype)  this, type(timearrayserieslinktype), pointer  tasLink  )

private

Definition at line 385 of file TimeArraySeriesManager.f90.

    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    type(TimeArraySeriesLinkType), pointer :: tasLink
    ! -- local
    !
    call addtimearrayserieslinktolist(this%boundTasLinks, taslink)

Here is the call graph for this function:

tasmgr_convert_flux()

subroutine timearrayseriesmanagermodule::tasmgr_convert_flux ( class(timearrayseriesmanagertype)  this, type(timearrayserieslinktype), intent(inout), pointer  tasLink  )

private

Definition at line 357 of file TimeArraySeriesManager.f90.

    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    type(TimeArraySeriesLinkType), pointer, intent(inout) :: tasLink
    ! -- local
    integer(I4B) :: i, n, noder
    real(DP) :: area
    !
    if (.not. (associated(this%dis) .and. &
               associated(taslink%nodelist))) then
      errmsg = 'Programming error. Cannot convert flux. Verify that '&
               &'a valid DIS instance and nodelist were provided.'
      call store_error(errmsg)
      call store_error_unit(taslink%TimeArraySeries%GetInunit())
    end if
    !
    n = size(taslink%BndArray)
    do i = 1, n
      noder = taslink%nodelist(i)
      if (noder > 0) then
        area = this%dis%get_area(noder)
        taslink%BndArray(i) = taslink%BndArray(i) * area
      end if
    end do

Here is the call graph for this function:

tasmgr_da()

subroutine timearrayseriesmanagermodule::tasmgr_da ( class(timearrayseriesmanagertype)  this )

private

Definition at line 185 of file TimeArraySeriesManager.f90.

    ! -- dummy
    class(TimeArraySeriesManagerType) :: this
    ! -- local
    integer :: i, n
    type(TimeArraySeriesLinkType), pointer :: tasLink => null()
    !
    ! -- Deallocate contents of each TimeArraySeriesType object in list
    !    of time-array series links.
    n = this%boundTasLinks%Count()
    do i = 1, n
      taslink => gettimearrayserieslinkfromlist(this%boundTasLinks, i)
      call taslink%da()
    end do
    !
    ! -- Go through and deallocate individual time array series
    do i = 1, size(this%taslist)
      call this%taslist(i)%da()
    end do
    !
    ! -- Deallocate the list of time-array series links.
    call this%boundTasLinks%Clear(.true.)
    deallocate (this%boundTasLinks)
    deallocate (this%tasfiles)
    !
    ! -- Deallocate the time array series
    deallocate (this%taslist)
    deallocate (this%tasnames)
    !
    ! -- nullify pointers
    this%dis => null()
    this%boundTasLinks => null()

Here is the call graph for this function: