methodcellmodule Module Reference

Data Types
type	methodcelltype

Functions/Subroutines
subroutine	try_pass (this, particle, nextlevel, advancing)
	Try passing the particle to the next subdomain. or to a boundary of this method's tracking domain. More...
subroutine	assess (this, particle, cell_defn, tmax)
	Check reporting/terminating conditions before tracking the particle across the cell. More...
subroutine	cellexit (this, particle)
	Particle exits a cell. More...
logical(lgp) function	forms_cycle (this, particle, event)
	Check if the event forms a cycle in the particle path. More...
subroutine	store_event (this, particle, event)
	Save the event in the particle's history. Acts like a queue, the oldest event is removed when the event count exceeds the maximum size. More...
integer(i4b) function	get_level (this)
	Get the cell method's level. More...
integer(i4b) function	iboundary_to_icellface (this, iboundary)
	Convert an iboundary number to an iface number. More...

Function/Subroutine Documentation

assess()

subroutine methodcellmodule::assess ( class(methodcelltype), intent(inout)  this, type(particletype), intent(inout), pointer  particle, type(celldefntype), intent(inout), pointer  cell_defn, real(dp), intent(in)  tmax  )

private

Check a number of conditions determining whether to continue tracking the particle or terminate it, as well as whether to record any output data as per selected reporting conditions.

Definition at line 77 of file MethodCell.f90.

    ! modules
    use tdismodule, only: endofsimulation, totimc, totim
    use particlemodule, only: term_weaksink, term_no_exits, &
                              term_stopzone, term_inactive
    use particleeventmodule, only: terminate, timestep, weaksink, usertime
    ! dummy
    class(MethodCellType), intent(inout) :: this
    type(ParticleType), pointer, intent(inout) :: particle
    type(CellDefnType), pointer, intent(inout) :: cell_defn
    real(DP), intent(in) :: tmax
    ! local
    logical(LGP) :: dry_cell, dry_particle, no_exit_face, stop_zone, weak_sink
    integer(I4B) :: i
    real(DP) :: t, ttrackmax
 
    dry_cell = cell_defn%isatstat == saturation_dry
    dry_particle = particle%z > cell_defn%top
    no_exit_face = cell_defn%inoexitface > 0
    stop_zone = cell_defn%izone > 0 .and. particle%istopzone == cell_defn%izone
    weak_sink = cell_defn%iweaksink > 0
 
    particle%izone = cell_defn%izone
    if (stop_zone) then
      call this%terminate(particle, status=term_stopzone)
      return
    end if
 
    if (no_exit_face .and. .not. dry_cell) then
      call this%terminate(particle, status=term_no_exits)
      return
    end if
 
    if (weak_sink) then
      if (particle%istopweaksink > 0) then
        call this%terminate(particle, status=term_weaksink)
        return
      else
        call this%weaksink(particle)
      end if
    end if
 
    if (dry_cell) then
      if (particle%idrymeth == 0) then
        ! drop to cell bottom. handled by pass
        ! to bottom method, nothing to do here
        no_exit_face = .false.
      else if (particle%idrymeth == 1) then
        ! stop
        call this%terminate(particle, status=term_inactive)
        return
      else if (particle%idrymeth == 2) then
        ! stay
        particle%advancing = .false.
        no_exit_face = .false.
 
        ! we might report tracking times
        ! out of order here, but we want
        ! the particle termination event
        ! (if this is the last time step)
        ! to have the maximum tracking t,
        ! so we need to keep tabs on it.
        ttrackmax = totim
 
        ! update tracking time to time
        ! step end time and save record
        particle%ttrack = totim
        call this%timestep(particle)
 
        ! record user tracking times
        call this%tracktimes%advance()
        if (this%tracktimes%any()) then
          do i = this%tracktimes%selection(1), this%tracktimes%selection(2)
            t = this%tracktimes%times(i)
            if (t < totimc) cycle
            if (t >= tmax) exit
            particle%ttrack = t
            call this%usertime(particle)
            if (t > ttrackmax) ttrackmax = t
          end do
        end if
 
        ! terminate if last period/step
        if (endofsimulation) then
          particle%ttrack = ttrackmax
          call this%terminate(particle, status=term_no_exits)
          return
        end if
      end if
    else if (dry_particle .and. this%name /= "passtobottom") then
      if (particle%idrymeth == 0) then
        ! drop to water table
        particle%z = cell_defn%top
        call this%dropped(particle)
      else if (particle%idrymeth == 1) then
        ! stop
        call this%terminate(particle, status=term_inactive)
        return
      else if (particle%idrymeth == 2) then
        ! stay
        particle%advancing = .false.
        no_exit_face = .false.
 
        ! we might report tracking times
        ! out of order here, but we want
        ! the particle termination event
        ! (if this is the last time step)
        ! to have the maximum tracking t,
        ! so we need to keep tabs on it.
        ttrackmax = totim
 
        ! update tracking time to time
        ! step end time and save record
        particle%ttrack = totim
        call this%timestep(particle)
 
        ! record user tracking times
        call this%tracktimes%advance()
        if (this%tracktimes%any()) then
          do i = this%tracktimes%selection(1), this%tracktimes%selection(2)
            t = this%tracktimes%times(i)
            if (t < totimc) cycle
            if (t >= tmax) exit
            particle%ttrack = t
            call this%usertime(particle)
            if (t > ttrackmax) ttrackmax = t
          end do
        end if
      end if
    end if
 
    if (no_exit_face) then
      particle%advancing = .false.
      particle%istatus = term_no_exits
      call this%terminate(particle)
      return
    end if
 

cellexit()

subroutine methodcellmodule::cellexit	(	class(methodcelltype), intent(inout)	this,
		type(particletype), intent(inout), pointer	particle
	)

Definition at line 218 of file MethodCell.f90.

    class(MethodCellType), intent(inout) :: this
    type(ParticleType), pointer, intent(inout) :: particle
    class(ParticleEventType), pointer :: event
    ! local
    integer(I4B) :: i, nhist
    class(*), pointer :: prev
 
    allocate (cellexiteventtype :: event)
    select type (event)
    type is (cellexiteventtype)
      event%exit_face = particle%iboundary(level_feature)
    end select
    call this%events%dispatch(particle, event)
    if (particle%icycwin == 0) then
      deallocate (event)
      return
    end if
    if (this%forms_cycle(particle, event)) then
      ! print event history
      print *, "Cyclic pathline detected"
      nhist = particle%history%Count()
      do i = 1, nhist
        prev => particle%history%GetItem(i)
        select type (prev)
        class is (particleeventtype)
          print *, "Back ", nhist - i + 1, ": ", prev%get_text()
        end select
      end do
      print *, "Current :", event%get_text()
      call pstop(1, 'Cyclic pathline detected, aborting')
    else
      call this%store_event(particle, event)
    end if

Here is the call graph for this function:

forms_cycle()

logical(lgp) function methodcellmodule::forms_cycle ( class(methodcelltype), intent(inout)  this, type(particletype), intent(inout), pointer  particle, class(particleeventtype), intent(in), pointer  event  )

private

Definition at line 255 of file MethodCell.f90.

    ! dummy
    class(MethodCellType), intent(inout) :: this
    type(ParticleType), pointer, intent(inout) :: particle
    class(ParticleEventType), pointer, intent(in) :: event
    ! local
    class(IteratorType), allocatable :: itr
    logical(LGP) :: found_cycle
 
    found_cycle = .false.
    select type (event)
    type is (cellexiteventtype)
      itr = particle%history%Iterator()
      do while (itr%has_next())
        call itr%next()
        select type (prev => itr%value())
        class is (cellexiteventtype)
          if (event%icu == prev%icu .and. &
              event%ilay == prev%ilay .and. &
              event%izone == prev%izone .and. &
              event%exit_face == prev%exit_face .and. &
              event%exit_face /= 0) then
            found_cycle = .true.
            exit
          end if
        end select
      end do
    end select

get_level()

integer(i4b) function methodcellmodule::get_level ( class(methodcelltype), intent(in)  this )

private

Definition at line 306 of file MethodCell.f90.

    class(MethodCellType), intent(in) :: this
    integer(I4B) :: level
    level = level_feature

iboundary_to_icellface()

integer(i4b) function methodcellmodule::iboundary_to_icellface ( class(methodcelltype), intent(inout)  this, integer(i4b), intent(in)  iboundary  )

private

Definition at line 313 of file MethodCell.f90.

    class(MethodCellType), intent(inout) :: this
    integer(I4B), intent(in) :: iboundary
    integer(I4B) :: iface
    integer(I4B) :: nfaces
 
    iface = iboundary
    nfaces = this%cell%defn%npolyverts + 2
    if (iface >= nfaces) &
      ! uncompress and drop wraparound index
      iface = iface + (this%fmi%max_faces - nfaces) - 1

store_event()

subroutine methodcellmodule::store_event ( class(methodcelltype), intent(inout)  this, type(particletype), intent(inout), pointer  particle, class(particleeventtype), intent(in), pointer  event  )

private

Definition at line 288 of file MethodCell.f90.

    ! dummy
    class(MethodCellType), intent(inout) :: this
    type(ParticleType), pointer, intent(inout) :: particle
    class(ParticleEventType), pointer, intent(in) :: event
    ! local
    class(*), pointer :: p
 
    select type (event)
    type is (cellexiteventtype)
      p => event
      call particle%history%Add(p)
      if (particle%history%Count() > particle%icycwin) &
        call particle%history%RemoveNode(1, .true.)
    end select

try_pass()

subroutine methodcellmodule::try_pass ( class(methodcelltype), intent(inout)  this, type(particletype), intent(inout), pointer  particle, integer(i4b)  nextlevel, logical(lgp)  advancing  )

private

If the particle is not advancing, or if it's not at a boundary, nothing happens. Otherwise, raise a cell exit event. Then, if at a net outflow boundary face, or top face of a partially saturated cell, terminate.

Definition at line 37 of file MethodCell.f90.

    class(MethodCellType), intent(inout) :: this
    type(ParticleType), pointer, intent(inout) :: particle
    logical(LGP) :: advancing
    integer(I4B) :: nextlevel
    ! local
    integer(I4B) :: ic, iboundary, icellface
 
    if (.not. particle%advancing) then
      advancing = .false.
      particle%iboundary = 0
      return
    end if
 
    call this%pass(particle)
 
    iboundary = particle%iboundary(level_feature)
    icellface = this%iboundary_to_icellface(iboundary)
    if (icellface <= 0) return
 
    ! on a cell face, done advancing. raise an exit event
    advancing = .false.
    call this%cellexit(particle)
 
    ! assigned boundary face with net outflow? terminate
    ic = particle%itrdomain(level_feature)
    if (this%fmi%is_net_out_boundary_face(ic, icellface)) then
      call this%terminate(particle, status=term_boundary)
      return
    end if