consider_edge_mod Module Reference

Functions/Subroutines
logical function	consider_edge (connectivity, nb_nodes_mini, nelem, e1, e2)
subroutine	sort_descending (array)

Variables
integer, parameter	max_nb_nodes_per_elt = 10

Function/Subroutine Documentation

consider_edge()

logical function consider_edge_mod::consider_edge	(	integer, dimension(max_nb_nodes_per_elt,nelem), intent(in)	connectivity,
		integer, dimension(nelem), intent(in)	nb_nodes_mini,
		integer, intent(in)	nelem,
		integer, intent(in)	e1,
		integer, intent(in)	e2 )

Parameters

[in]	nelem	total number of elements
[in]	connectivity	list of nodes per element (may be zero)
[in]	nb_nodes_mini	minimum number of shared node per element to consider the edge
[in]	e1	index of the first element
[in]	e2	index of the second element

Definition at line 46 of file consider_edge.F.

          implicit none
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Arguments
! ----------------------------------------------------------------------------------------------------------------------
          integer, intent(in) :: nelem !< total number of elements
          integer, intent(in) :: connectivity(max_nb_nodes_per_elt,nelem) !< list of nodes per element (may be zero)
          integer, intent(in) :: nb_nodes_mini(nelem) !< minimum number of shared node per element to consider the edge
          integer, intent(in) :: e1 !< index of the first element
          integer, intent(in) :: e2 !< index of the second element
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Local variables
! ----------------------------------------------------------------------------------------------------------------------
          logical :: bool
          integer :: count
          integer :: i,j
! ----------------------------------------------------------------------------------------------------------------------
!                                                      Body
! ----------------------------------------------------------------------------------------------------------------------
          bool = .false.
          count = 0
 
          i = 1
          j = 1
          do while (i <= max_nb_nodes_per_elt .and. j <= max_nb_nodes_per_elt)
             if(connectivity(i,e1) == 0 .or. connectivity(j,e2) == 0) then
                exit
             elseif (connectivity(i,e1) == connectivity(j,e2)) then
                count = count + 1
                i = i + 1
                j = j + 1
             else if (connectivity(i,e1) > connectivity(j,e2)) then
                i = i + 1
             else
                j = j + 1
             end if
          end do
 
            if (count >= nb_nodes_mini(e1) .or. count >= nb_nodes_mini(e2)) then
               bool = .true.
            end if

sort_descending()

subroutine consider_edge_mod::sort_descending

(

integer, dimension(max_nb_nodes_per_elt), intent(inout)

array

)

Definition at line 95 of file consider_edge.F.

          implicit none
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Arguments
! ----------------------------------------------------------------------------------------------------------------------
          integer, dimension(max_nb_nodes_per_elt), intent(inout) :: array
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Local variables
! ----------------------------------------------------------------------------------------------------------------------
          integer :: i, j, temp
! ----------------------------------------------------------------------------------------------------------------------
!                                                      Body
! ----------------------------------------------------------------------------------------------------------------------
          do i = 1, max_nb_nodes_per_elt-1
             do j = i+1, max_nb_nodes_per_elt
                if (array(i) < array(j)) then
                   temp = array(i)
                   array(i) = array(j)
                   array(j) = temp
                end if
             end do
          end do
 

Variable Documentation

max_nb_nodes_per_elt

integer, parameter consider_edge_mod::max_nb_nodes_per_elt = 10

Definition at line 33 of file consider_edge.F.

        integer, parameter :: max_nb_nodes_per_elt = 10