frontplus.F File Reference

#include "implicit_f.inc"

Go to the source code of this file.

Functions/Subroutines
subroutine	frontplus_rm (front, index)
subroutine	ifrontplus (n, p)
subroutine	iddconnectplus (n, p, numel)

Function/Subroutine Documentation

frontplus_rm()

subroutine frontplus_rm	(	integer	front,
		integer	index )

Definition at line 28 of file frontplus.F.

C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include      "implicit_f.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER FRONT,INDEX
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER F_INT,F_KIN,F_ACC
C-----------------------------------------------------
C   S o u r c e  L i n e s
C-----------------------------------------------------
      f_int = front / 100
      f_kin = ( front - f_int*100 ) / 10
      f_acc = front - f_int*100 - f_kin*10
 
      IF(index==1) THEN
        IF(f_acc==0) front = front + 1
      ELSE IF(index==10) THEN
        IF(f_kin==0) front = front + 10
      ELSE IF(index==100) THEN
        IF(f_int==0) front = front + 100
      ENDIF
  
      RETURN

iddconnectplus()

subroutine iddconnectplus	(	integer	n,
		integer	p,
		integer	numel )

Definition at line 210 of file frontplus.F.

C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
      USE front_mod
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include      "implicit_f.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER N,P,NUMEL
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER CURR, NEXT
      LOGICAL SEARCH
C-----------------------------------------------------
C   S o u r c e  L i n e s
C-----------------------------------------------------       
     
      !    New entry for this node
      IF(iddconnect%IENTRYDOM(1,n)==-1)THEN    
        ! create new entry in IFRONT
          ! plug IENTRY(N) to this new entry
        iddconnect%IENTRYDOM(1,n) = n
        iddconnect%IENTRYDOM(2,n) = iddconnect%IENTRYDOM(2,n) + 1
        iddconnect%PDOM(1,n) =  p
          iddconnect%PDOM(2,n) =  0
        RETURN
      ENDIF
      !    One or more entries for this node 
 
      !    Set current index to IENTRY(N)
      curr = iddconnect%IENTRYDOM(1,n)
 
      !    If node N to insert is equal than current node --> quit
      IF(iddconnect%PDOM(1,curr)==p) RETURN
 
      !    Test if node to insert is lower than current node 
      !    Test assure that P is different from IFRONT%P(1,CURR)
      IF(iddconnect%PDOM(1,curr)>p)THEN
          !    Insert P at beginning of the list
        IF(iddconnect_end+1>siddconnect)THEN
            !    realloc if needed
            CALL realloc_iddconnect(numel) 
          ENDIF
          !    create a new entry
          !    plug IENTRY(N) to this new entry
        iddconnect_end = iddconnect_end+1
          iddconnect%IENTRYDOM(1,n) = iddconnect_end
          !    set new entry to P
        iddconnect%PDOM(1,iddconnect_end) =  p
          !    following is CURR index
          iddconnect%PDOM(2,iddconnect_end) =  curr
        iddconnect%IENTRYDOM(2,n) = iddconnect%IENTRYDOM(2,n) + 1
          RETURN
      ENDIF
      
      next = iddconnect%PDOM(2,curr)     
      !    insertion must be done between CURR and NEXT
      !    when CURR < P < NEXT
      search = .true.
      !    move forward in the list while IFRONT%P(1,CURR) < P
      !    and while P not found 
      DO WHILE((search .EQV. .true.).AND.(iddconnect%PDOM(1,curr)/=p))
        IF(next==0)THEN
            ! insert at end of list
            IF(iddconnect_end+1>siddconnect)THEN
              CALL realloc_iddconnect(numel) 
            ENDIF      
            iddconnect_end = iddconnect_end+1         
            iddconnect%PDOM(2,curr) =  iddconnect_end
          iddconnect%PDOM(1,iddconnect_end) =  p
            iddconnect%PDOM(2,iddconnect_end) =  0
            search = .false.
          iddconnect%IENTRYDOM(2,n) = iddconnect%IENTRYDOM(2,n) + 1
            RETURN
          ELSEIF(iddconnect%PDOM(1,next)>p)THEN
            !   insert between current and next
            IF(iddconnect_end+1>siddconnect)THEN
              CALL realloc_iddconnect(numel) 
            ENDIF     
            iddconnect_end = iddconnect_end+1         
            iddconnect%PDOM(2,curr) =  iddconnect_end
          iddconnect%PDOM(1,iddconnect_end) =  p
            iddconnect%PDOM(2,iddconnect_end) =  next
            search = .false.
          iddconnect%IENTRYDOM(2,n) = iddconnect%IENTRYDOM(2,n) + 1
            RETURN     
          ELSE
             !   move forward in list
             curr = next
             next = iddconnect%PDOM(2,next)  
          ENDIF      
      ENDDO        
  
      RETURN

ifrontplus()

subroutine ifrontplus	(	integer	n,
		integer	p )

Definition at line 100 of file frontplus.F.

C sort insert in chained-list IFRONT node N on SPMD domain P
C IFRONT%IENTRY : entry in IFRONT for node N
C IFRONT%P(1,N) : SPMD domain for node N
C IFRONT%P(2,N) : next index in IFRONT for node N
C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
      USE front_mod
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include      "implicit_f.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
      INTEGER N, P
      LOGICAL SEARCH
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER CURR, NEXT
C-----------------------------------------------------
C   S o u r c e  L i n e s
C-----------------------------------------------------       
     
c no SPMD domain already attributed for this node
      IF(ifront%IENTRY(n)==-1)THEN    
        ! create new entry in IFRONT
          ! plug IENTRY(N) to this new entry
        ifront%IENTRY(n) = n
        ifront%P(1,n) =  p
          ifront%P(2,n) =  0
        RETURN
      ENDIF
      
c one or more SPMD domain(s) already attributed for this node
 
      ! set current index to ientry(n)
      curr = ifront%IENTRY(n)
 
      ! if domain to insert is equal than current domain -> quit
      IF(ifront%P(1,curr)==p) RETURN
 
      ! test if domain to insert is lower than current domain 
      ! test assure that P is different from IFRONT%P(1,CURR)
      IF(ifront%P(1,curr)>p)THEN
          ! insert P at beginning of the list
        IF(ifront_end+1>sifront)THEN
            ! realloc if needed
            CALL realloc_ifront() 
          ENDIF
          ! create a new entry
          ! plug IENTRY(N) to this new entry
        ifront_end = ifront_end+1
          ifront%IENTRY(n) = ifront_end
          ! set new entry to P
        ifront%P(1,ifront_end) =  p
          ! following is CURR index
          ifront%P(2,ifront_end) =  curr  
          RETURN
      ENDIF
      
      next = ifront%P(2,curr)     
      ! insertion must be done between CURR and NEXT
      ! when CURR < P < NEXT
      search = .true.
      ! move forward in the list while IFRONT%P(1,CURR) < P
      ! and while P not found 
      DO WHILE((search .EQV. .true.).AND.(ifront%P(1,curr)/=p))
        IF(next==0)THEN
            ! insert at end of list
            IF(ifront_end+1>sifront)THEN
              CALL realloc_ifront() 
            ENDIF      
            ifront_end = ifront_end+1         
            ifront%P(2,curr) =  ifront_end
          ifront%P(1,ifront_end) =  p
            ifront%P(2,ifront_end) =  0
            search = .false.
            RETURN
          ELSEIF(ifront%P(1,next)>p)THEN
            !insert between current and next
            IF(ifront_end+1>sifront)THEN
              CALL realloc_ifront() 
            ENDIF     
            ifront_end = ifront_end+1         
            ifront%P(2,curr) =  ifront_end
          ifront%P(1,ifront_end) =  p
            ifront%P(2,ifront_end) =  next
            search = .false.
            RETURN     
          ELSE
            !move forward in list
             curr = next
             next = ifront%P(2,next)   
          ENDIF      
      ENDDO        
  
      RETURN