disutilsmodule Module Reference

Functions/Subroutines
integer(i4b) function, public	number_connected_faces (dis, n)
	Returns the number of connected faces for a given cell. More...
real(dp) function, dimension(3), public	node_distance (dis, n, m)
	Returns the vector distance from cell n to cell m. More...
real(dp) function, dimension(3), public	cell_center (dis, n)
	Returns the center coordinates of a given cell. More...

Function/Subroutine Documentation

cell_center()

real(dp) function, dimension(3), public disutilsmodule::cell_center	(	class(disbasetype), intent(in)	dis,
		integer(i4b), intent(in)	n
	)

This function computes the center of cell n in the discretization. The center is returned as a 3-element vector containing the x, y, and z coordinates. The x and y coordinates are taken directly from the cell center arrays, while the z coordinate is computed as the average of the cell's top and bottom elevations.

Definition at line 89 of file DisUtils.f90.

    ! -- dummy
    class(DisBaseType), intent(in) :: dis
    integer(I4B), intent(in) :: n
    real(DP), dimension(3) :: center
 
    center(1) = dis%xc(n)
    center(2) = dis%yc(n)
    center(3) = (dis%top(n) + dis%bot(n)) / 2.0_dp

Here is the caller graph for this function:

node_distance()

real(dp) function, dimension(3), public disutilsmodule::node_distance	(	class(disbasetype), intent(in)	dis,
		integer(i4b), intent(in)	n,
		integer(i4b), intent(in)	m
	)

This function computes the vector from the center of cell n to the center of cell m in the discretization. If the cells are directly connected, the vector is computed along the connection direction, taking into account cell geometry and, if available, cell saturation. If the cells are not directly connected (e.g., when using an extended stencil such as neighbors-of-neighbors), the vector is simply the difference between their centroids: d = centroid(m) - centroid(n). The returned vector always points from cell n to cell m.

Definition at line 38 of file DisUtils.f90.

    !-- modules
    use tspfmimodule, only: tspfmitype
    ! -- return
    real(DP), dimension(3) :: d
    ! -- dummy
    class(DisBaseType), intent(in) :: dis
    integer(I4B), intent(in) :: n, m
    ! -- local
    real(DP) :: x_dir, y_dir, z_dir, length
    integer(I4B) :: ipos, isympos, ihc
    real(DP), dimension(3) :: xn, xm
 
    ! -- Find the connection position (isympos) between cell n and cell m
    isympos = -1
    do ipos = dis%con%ia(n) + 1, dis%con%ia(n + 1) - 1
      if (dis%con%ja(ipos) == m) then
        isympos = dis%con%jas(ipos)
        exit
      end if
    end do
 
    ! -- if the connection is not found, then return the distance between the two nodes
    ! -- This can happen when using an extended stencil (neighbours-of-neigbhours) to compute the gradients
    if (isympos == -1) then
      xn = cell_center(dis, n)
      xm = cell_center(dis, m)
 
      d = xm - xn
      return
    end if
 
    ! -- Get the connection direction and length
    ihc = dis%con%ihc(isympos)
    call dis%connection_vector(n, m, .false., done, done, ihc, x_dir, &
                               y_dir, z_dir, length)
 
    ! -- Compute the distance vector
    d(1) = x_dir * length
    d(2) = y_dir * length
    d(3) = z_dir * length
 

Here is the call graph for this function:

Here is the caller graph for this function:

number_connected_faces()

integer(i4b) function, public disutilsmodule::number_connected_faces	(	class(disbasetype), intent(in)	dis,
		integer(i4b), intent(in)	n
	)

This function computes the number of faces of cell n that are connected to neighboring cells in the discretization. The value is determined from the connectivity information in the connection arrays, and does not include boundary faces (faces not connected to another cell).

Definition at line 21 of file DisUtils.f90.

    class(DisBaseType), intent(in) :: dis
    integer(I4B), intent(in) :: n
    integer(I4B) :: connected_faces_count
 
    connected_faces_count = dis%con%ia(n + 1) - dis%con%ia(n) - 1

Here is the caller graph for this function: