split_joint.F File Reference

#include "implicit_f.inc"
#include "com01_c.inc"
#include "com04_c.inc"

Go to the source code of this file.

Functions/Subroutines
subroutine	split_joint ()
subroutine	print_joint (a)

Function/Subroutine Documentation

print_joint()

subroutine print_joint

(

character(len=*)

a

)

Definition at line 252 of file split_joint.F.

C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
        USE joint_mod
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include      "implicit_f.inc"
C-----------------------------------------------
C   C o m m o n   B l o c k s
C-----------------------------------------------
#include      "com01_c.inc"
#include      "com04_c.inc"
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
        character(len=*) :: a
        INTEGER :: I,NS,K
        INTEGER :: M1,M2
        INTEGER :: P,PROC_NUMBER,NB_NODE
        INTEGER, DIMENSION(NSPMD) :: PROC_LIST
      INTEGER, EXTERNAL :: NLOCAL  
C-----------------------------------------------
C   E x t e r n a l   F u n c t i o n s
C-----------------------------------------------
 
C=======================================================================
        k = 0
        DO i=1,njoint                
            proc_list(1:nspmd) = -1
            proc_number = 0
            ns = cyl_join(i)%NB_SECONDARY_NODE
 
            nb_node = 0
            proc_number = 0
            cyl_join(i)%PROC_MAIN = -1
            proc_list(1:nspmd) = 0
            DO p=1,nspmd
                m1 = cyl_join(i)%MAIN_NODE(1)
                m2 = cyl_join(i)%MAIN_NODE(2)
!                IF(NLOCAL(M1,P)==1) CALL IFRONTPLUS(M2,P)
!                IF(NLOCAL(M2,P)==1) CALL IFRONTPLUS(M1,P)
!                print*,' split_joint :',p,NLOCAL(M1,P),NLOCAL(M2,P)
            ENDDO
!            CYL_JOIN(I)%NUMBER_PROC = PROC_NUMBER
!            ALLOCATE( CYL_JOIN(I)%LIST_PROC( PROC_NUMBER ) )
!            CYL_JOIN(I)%LIST_PROC(1:PROC_NUMBER) = PROC_LIST(1:PROC_NUMBER)
            k=k+ns+1
 
                    proc_number = 0
        CALL plist_ifront(proc_list,cyl_join(i)%MAIN_NODE(1),proc_number)
        print*,' ------- '
        print*,i,' M1:',a,proc_list(1:proc_number)
                    proc_number = 0
        CALL plist_ifront(proc_list,cyl_join(i)%MAIN_NODE(2),proc_number)
        print*,i,' M2:',a,proc_list(1:proc_number)
        print*,' ------- '
        print*,' '
 
        ENDDO
 
 
        RETURN

split_joint()

subroutine split_joint

Definition at line 34 of file split_joint.F.

!$COMMENT
!       SPLIT_JOINT description
!       split the node (secondary & main node) on the different processor
!       
!       SPLIT_JOINT organization :
!       loop over the joint :
!           - for each joint, loop over the node to find where is the node
!           - for each node, add the ID node to the CYL_JOIN(I)%PROC(P)%NODE
!           - count the max number of secondary node in order to find the main proc
!           - if 1 secondary node is on a given proc --> need to add the 2 main nodes to the proc
!           - if 1 main node is on a given proc --> need to add the other main to the proc
!$ENDCOMMENT
C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
        USE joint_mod
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include      "implicit_f.inc"
C-----------------------------------------------
C   C o m m o n   B l o c k s
C-----------------------------------------------
#include      "com01_c.inc"
#include      "com04_c.inc"
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
        INTEGER :: I,II,NS,LJ,K
        INTEGER :: J,N,NN,IJK
        INTEGER :: WEIGHT,M1
        INTEGER :: P,PROC_NUMBER,NB_NODE
        INTEGER, DIMENSION(NSPMD) :: PROC_LIST
        INTEGER, EXTERNAL :: NLOCAL
        LOGICAL, DIMENSION(:), ALLOCATABLE :: CHECK_MAIN
        TYPE(joint_main_node), DIMENSION(:), ALLOCATABLE :: MAIN_AND_SECONDARY
C-----------------------------------------------
C   E x t e r n a l   F u n c t i o n s
C-----------------------------------------------
 
C=======================================================================
        k = 0
        ALLOCATE( check_main(numnod) )
        check_main(1:numnod) = .false.
        DO i=1,njoint
            DO j=1,2
                n = cyl_join(i)%MAIN_NODE(j)
                check_main(n) = .true.
            ENDDO
        ENDDO
        ALLOCATE( main_and_secondary(numnod) )
        
        main_and_secondary(1:numnod)%ID_JOINT = 0
        main_and_secondary(1:numnod)%NB_PROC = 0
 
        DO i=1,njoint                
            proc_list(1:nspmd) = -1
            proc_number = 0
            ALLOCATE( cyl_join(i)%PROC(nspmd) )
            cyl_join(i)%NB_NODE(1:nspmd) = 0
            cyl_join(i)%PROC(1:nspmd)%NB_NODE_WEIGHT = 0
            ns = cyl_join(i)%NB_SECONDARY_NODE
            DO lj=1,ns
                !   ----------------------
                !   check where is the secondary node 
                    proc_list(1:nspmd) = -1
                    proc_number = 0
                    nn = cyl_join(i)%SECONDARY_NODE(lj)
                          CALL plist_ifront(proc_list,nn,proc_number)
                    !returns in "PROC_LIST" array list of SPMD domains on which node I is sticked
                    !PROC_NUMBER is the number of SPMD domains on which node I is sticked
                    
!                    IF( check_main(nn) ) THEN
!                        MAIN_AND_SECONDARY(NN)%ID_JOINT = I
!                        MAIN_AND_SECONDARY(NN)%NB_PROC = PROC_NUMBER
!                        ALLOCATE( MAIN_AND_SECONDARY(NN)%PROC_LIST(PROC_NUMBER) )
!                        MAIN_AND_SECONDARY(NN)%PROC_LIST(1:PROC_NUMBER) = PROC_LIST(1:PROC_NUMBER)
!                    ENDIF
 
                    ! add the secondary node to the CYL_JOINT structure for proc P
                    ! for the restart writing
                    DO ii=1,proc_number
                        p = proc_list(ii)
                        cyl_join(i)%NB_NODE(p) = cyl_join(i)%NB_NODE(p) + 1
                        IF(.NOT.ALLOCATED(cyl_join(i)%PROC(p)%NODE)) ALLOCATE( cyl_join(i)%PROC(p)%NODE(ns) )
                        cyl_join(i)%PROC(p)%NODE( cyl_join(i)%NB_NODE(p) ) = cyl_join(i)%SECONDARY_NODE(lj)
                        weight = 0
                        IF(ii==1) weight = 1
                        IF(.NOT.ALLOCATED(cyl_join(i)%PROC(p)%WEIGHT)) ALLOCATE( cyl_join(i)%PROC(p)%WEIGHT(ns) )
                        cyl_join(i)%PROC(p)%WEIGHT( cyl_join(i)%NB_NODE(p) ) = weight
                        IF(weight==1) cyl_join(i)%PROC(p)%NB_NODE_WEIGHT = cyl_join(i)%PROC(p)%NB_NODE_WEIGHT + 1
                    ENDDO
                !   ----------------------
            ENDDO
            k=k+ns+1
        ENDDO
 
        !   ----------------------
        ! loop over the CYL_JOINT in order to find the proc main
        ! and add the main nodes to the processor where at least 1 
        ! secondary node is present
        k = 0
        DO i=1,njoint                
            proc_list(1:nspmd) = -1
            proc_number = 0
            ns = cyl_join(i)%NB_SECONDARY_NODE
            nb_node = 0
            proc_number = 0
            cyl_join(i)%PROC_MAIN = -1
            proc_list(1:nspmd) = 0
            DO p=1,nspmd
                IF(cyl_join(i)%NB_NODE(p)>0) THEN
                    proc_number = proc_number + 1
                    proc_list(proc_number) = p
                    nb_node = cyl_join(i)%NB_NODE(p)
                    !   add the 2 main nodes on each proc
                    DO ijk = 1,2
                        m1 = cyl_join(i)%MAIN_NODE(ijk)
                        IF(nlocal(m1,p)==0) THEN
                            CALL ifrontplus(m1,p)
                            cyl_join(i)%NB_NODE(p) = cyl_join(i)%NB_NODE(p) + 1
                            cyl_join(i)%PROC(p)%WEIGHT( cyl_join(i)%NB_NODE(p) ) = 0
                            cyl_join(i)%PROC(p)%NODE( cyl_join(i)%NB_NODE(p) ) = cyl_join(i)%SECONDARY_NODE(ijk)
                        ENDIF
                    ENDDO
                    IF(cyl_join(i)%NB_NODE(p)>=nb_node) cyl_join(i)%PROC_MAIN = p
                ENDIF
!                M1 = CYL_JOIN(I)%MAIN_NODE(1)
!                M2 = CYL_JOIN(I)%MAIN_NODE(2)
!                IF(NLOCAL(M1,P)==1) CALL IFRONTPLUS(M2,P)
!                IF(NLOCAL(M2,P)==1) CALL IFRONTPLUS(M1,P)
            ENDDO
            cyl_join(i)%NUMBER_PROC = proc_number
            ALLOCATE( cyl_join(i)%LIST_PROC( proc_number ) )
            cyl_join(i)%LIST_PROC(1:proc_number) = proc_list(1:proc_number)
            k=k+ns+1
        ENDDO
 
 
 
        DO i=njoint,1,-1         
            proc_list(1:nspmd) = -1
            proc_number = 0
            ns = cyl_join(i)%NB_SECONDARY_NODE
            nb_node = 0
            proc_number = 0
            cyl_join(i)%PROC_MAIN = -1
            proc_list(1:nspmd) = 0
            DO p=1,nspmd
                IF(cyl_join(i)%NB_NODE(p)>0) THEN
                    proc_number = proc_number + 1
                    proc_list(proc_number) = p
                    nb_node = cyl_join(i)%NB_NODE(p)
                    !   add the 2 main nodes on each proc
                    DO ijk = 1,2
                        m1 = cyl_join(i)%MAIN_NODE(ijk)
                        IF(nlocal(m1,p)==0) THEN
                            CALL ifrontplus(m1,p)
                            cyl_join(i)%NB_NODE(p) = cyl_join(i)%NB_NODE(p) + 1
                            cyl_join(i)%PROC(p)%WEIGHT( cyl_join(i)%NB_NODE(p) ) = 0
                            cyl_join(i)%PROC(p)%NODE( cyl_join(i)%NB_NODE(p) ) = cyl_join(i)%SECONDARY_NODE(ijk)
                        ENDIF
                    ENDDO
                    IF(cyl_join(i)%NB_NODE(p)>=nb_node) cyl_join(i)%PROC_MAIN = p
                ENDIF
!                M1 = CYL_JOIN(I)%MAIN_NODE(1)
!                M2 = CYL_JOIN(I)%MAIN_NODE(2)
!                IF(NLOCAL(M1,P)==1) CALL IFRONTPLUS(M2,P)
!                IF(NLOCAL(M2,P)==1) CALL IFRONTPLUS(M1,P)
            ENDDO
            k=k+ns+1
        ENDDO
 
 
        !   ----------------------
        ! check : if a main node is on a processor, need to add the other main node
!        K = 0
!        DO I=1,NJOINT                
!            PROC_LIST(1:NSPMD) = -1
!            PROC_NUMBER = 0
!            NS = CYL_JOIN(I)%NB_SECONDARY_NODE
!            NB_NODE = 0
!            PROC_NUMBER = 0
!            PROC_LIST_1(1:NSPMD) = 0
!            CALL PLIST_IFRONT(PROC_LIST_1,CYL_JOIN(I)%MAIN_NODE(1),PROC_NUMBER_1)
!            PROC_NUMBER_2 = 0
!            PROC_LIST_2(1:NSPMD) = 0
!            CALL PLIST_IFRONT(PROC_LIST_2,CYL_JOIN(I)%MAIN_NODE(2),PROC_NUMBER_2)!
!
!            DO P=1,PROC_NUMBER_1
!                PROC = PROC_LIST_1(P)
!                CALL IFRONTPLUS(CYL_JOIN(I)%MAIN_NODE(2),PROC)
!            ENDDO
!            DO P=1,PROC_NUMBER_2
!                PROC = PROC_LIST_2(P)
!                CALL IFRONTPLUS(CYL_JOIN(I)%MAIN_NODE(1),PROC)
!            ENDDO
!            K=K+NS+1
!        ENDDO
        !   ----------------------
 
        DEALLOCATE( main_and_secondary )
 
        RETURN