check_skew.F

Go to the documentation of this file.

Copyright>        OpenRadioss
Copyright>        Copyright (C) 1986-2025 Altair Engineering Inc.
Copyright>
Copyright>        This program is free software: you can redistribute it and/or modify
Copyright>        it under the terms of the GNU Affero General Public License as published by
Copyright>        the Free Software Foundation, either version 3 of the License, or
Copyright>        (at your option) any later version.
Copyright>
Copyright>        This program is distributed in the hope that it will be useful,
Copyright>        but WITHOUT ANY WARRANTY; without even the implied warranty of
Copyright>        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Copyright>        GNU Affero General Public License for more details.
Copyright>
Copyright>        You should have received a copy of the GNU Affero General Public License
Copyright>        along with this program.  If not, see <https://www.gnu.org/licenses/>.
Copyright>
Copyright>
Copyright>        Commercial Alternative: Altair Radioss Software
Copyright>
Copyright>        As an alternative to this open-source version, Altair also offers Altair Radioss
Copyright>        software under a commercial license.  Contact Altair to discuss further if the
Copyright>        commercial version may interest you: https://www.altair.com/radioss/.
!||====================================================================
!||    check_skew                   ../starter/source/spmd/domain_decomposition/check_skew.F
!||--- called by ------------------------------------------------------
!||    domdec2                      ../starter/source/spmd/domdec2.F
!||--- calls      -----------------------------------------------------
!||    hm_entity_reference_number   ../starter/source/devtools/hm_reader/hm_entity_reference_number.F
!||    ifrontplus                   ../starter/source/spmd/node/frontplus.F
!||--- uses       -----------------------------------------------------
!||    submodel_mod                 ../starter/share/modules1/submodel_mod.F
!||====================================================================
        SUBROUTINE check_skew(IXR,IGEO,ISKN,CEP,ISKWP,NSKWP,TAG_SKN,MULTIPLE_SKEW,
     .                        R_SKEW,IPM,OFFSET)
C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
        USE skew_mod
        USE submodel_mod , ONLY : nsubmod
        use element_mod , only : nixr
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      "tabsiz_c.inc"
#include      "com01_c.inc"
#include      "com04_c.inc"
#include      "param_c.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
        INTEGER, INTENT(INOUT) :: NSKWP(NSPMD),R_SKEW(NUMELR)
        INTEGER, DIMENSION(NUMSKW+NSUBMOD+1), INTENT(INOUT) :: TAG_SKN
        INTEGER, DIMENSION(SCEP), INTENT(IN) :: CEP
        INTEGER, DIMENSION(NUMSKW+1), INTENT(INOUT) :: ISKWP
        INTEGER, DIMENSION(NIXR,NUMELR), INTENT(IN) :: IXR
        INTEGER, DIMENSION(NPROPGI,NUMGEO), INTENT(IN) :: IGEO
        INTEGER, DIMENSION(LISKN,SISKWN/LISKN), INTENT(IN) :: ISKN
        INTEGER, DIMENSION(NPROPMI,NUMMAT), INTENT(IN) :: IPM
        TYPE(plist_skew_), DIMENSION(NUMSKW+1), INTENT(INOUT) :: MULTIPLE_SKEW
        INTEGER :: OFFSET
!       -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*
!       NSKWP : integer ; dimension = NSPMD
!               number of skew per processor
!       TAG_SKN : integer ; dimension=NUMSKW+NSUBMOD+1
!                 tag array --> tag the i SKEW if a SPRING uses it
!                 tag array=0 --> the SKEW is not used by a SPRING
!                 tag array=1 --> the SKEW is used by one SPRING      
!                 tag array>1 --> the SKEW is used by several SPRING
!                 tag array <0 --> the SKEW is used by several options (has to be duplicated to all domains that have the nodes)
!       CEP : integer ; dimension=NUMNOD
!             gives the ID processor of the current i node
!       ISKWP : integer ; dimension=NUMSKW+1
!               gives the ID processir of the current i SKEW
!               ISKWP < 0 --> the SKEW is local on a processor
!               and we don't need to communicate the data
!               ISKWP > 0 --> the SKEW is global and the data must be
!               communicated
!       IXR : integer ; dimension=NIXR*number of SPRING
!             SPRING array
!       IGEO : integer ; dimension=NPROPGI*number of /PROP
!              PROP array
!       ISKN : integer ; dimension=LISKN*number of SKEW
!              skew array
!       MULTIPLE_SKEW : SKEW_TYPE ; dimension=NUMSKW+1
!                       MULTIPLE_SKEW(I)%PLIST(:) is a list of processor
!                       where the SKEW is stuck
!       OFFSET :: integer, offset to point to the good place in CEP array
!       -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*
 
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
        INTEGER :: I,J,II
        INTEGER :: NUMBER_SKEW_SP,SPRING_TYPE
        INTEGER :: N1,N2,N3,IMAIN,SUM_NI,SIZE_SKEW,MAT_TYPE
        INTEGER ::  NB
        INTEGER, DIMENSION(:), ALLOCATABLE :: SKEW_PER_SP,LOCAL_P,P_SKEW
        INTEGER, DIMENSION(NSPMD) :: PROC_SKEW
C-----------------------------------------------
C   E x t e r n a l   F u n c t i o n s
C-----------------------------------------------
C=======================================================================
!$COMMENT
!       CHECK_SKEW description
!       CHECK_SKEW sticks a SKEW on a given processor in order to reduce
!       the SKEW communication in the engine.
!       A SKEW can be linked to a SPRING --> in this case, the SKEW is 
!       stuck on the local SPRING processor
!       If a SKEW is used by several SPRING, the SKEW is stuck on each 
!       processors that need it
!       
!       CHECK_SKEW organization :
!       - link every SPRING with theirs SKEW
!       - if several SPRING use a same SKEW, allocate MULTIPLE_SKEW(I)%PLIST
!       - stick a SKEW on a given processor, count the number of SKEW per
!         processor, initialize the MULTIPLE_SKEW(I)%PLIST array
!       - count the number of SKEW per processor in the case of multiple 
!         SPRING per SKEW
!$ENDCOMMENT
C
!       compute adhoc size for local arrays
        number_skew_sp = 0
        tag_skn(1:numskw+nsubmod+1) = -1
        nb = 0
        DO i = 1,numskw
            ! The optimization of restricting a skew to the domains having the corresponding spring nodes
            ! works only for skew referenced by only one options
            CALL hm_entity_reference_number("/SKEW",len_trim("/SKEW"),iskn(4,i+1),nb)
            IF(nb == 1) tag_skn(i+1) = 0
        ENDDO
 
 
        DO i=1,numelr
          spring_type = igeo( 11,ixr(1,i) )
          mat_type   = 0
          IF (ixr(5,i) > 0) mat_type = ipm(2,ixr(5,i))
C
          IF (r_skew(i) > 1) THEN
            IF( tag_skn(r_skew(i)) >= 0 ) THEN
              IF(spring_type==8 .OR. (spring_type== 23 .AND. mat_type == 108)) number_skew_sp = number_skew_sp + 1
            ENDIF
          ENDIF
C
          IF (igeo(2,ixr(1,i) )>1) THEN
            IF(  tag_skn( igeo(2,ixr(1,i))) >= 0  ) THEN
            IF(spring_type==8 .OR. spring_type==13 .OR. spring_type== 23) number_skew_sp = number_skew_sp + 1     
            ENDIF
          ENDIF
        ENDDO
 
!       allocation and initialization of local array
        ALLOCATE(skew_per_sp(number_skew_sp))
        ALLOCATE(local_p(number_skew_sp))
 
 
 
 
        skew_per_sp(1:number_skew_sp) = 0
        local_p(1:number_skew_sp) = 0
        number_skew_sp = 0
 
!       link between SPRING and SKEW (only for SPRING type =8,13 or 23)
        DO i=1,numelr
                spring_type = igeo( 11,ixr(1,i) )
                mat_type   = 0
                IF (ixr(5,i) > 0) mat_type = ipm(2,ixr(5,i))
C
                IF (r_skew(i) > 1) THEN
                    IF( tag_skn(r_skew(i)) >= 0) THEN    
                        IF(spring_type==8 .OR. (spring_type== 23 .AND. mat_type == 108)) THEN
                                number_skew_sp = number_skew_sp + 1
                                skew_per_sp( number_skew_sp ) = r_skew(i)   
                                local_p(number_skew_sp) = cep(offset+i)+1
                                tag_skn( r_skew(i) ) = tag_skn( r_skew(i) ) + 1
                        ENDIF
                     ENDIF
                ENDIF
C
                IF (igeo( 2,ixr(1,i) )>1) THEN
                    IF(  tag_skn(igeo(2,ixr(1,i))) >=0 ) THEN
                        IF(spring_type==8 .OR. spring_type==13 .OR. spring_type== 23) THEN
                                number_skew_sp = number_skew_sp + 1
                                skew_per_sp( number_skew_sp ) = igeo( 2,ixr(1,i) )    
                                local_p(number_skew_sp) = cep(offset+i)+1
                                tag_skn( igeo(2,ixr(1,i)) ) = tag_skn( igeo(2,ixr(1,i)) ) + 1
                        ENDIF     
                    ENDIF
                ENDIF
        ENDDO
 
!       allocation of MULTIPLE_SKEW
        DO i=1,numskw+1
                size_skew = tag_skn(i)
                IF(size_skew>1) THEN
                        IF(.NOT.ALLOCATED(multiple_skew(i)%PLIST)) ALLOCATE( multiple_skew(i)%PLIST(size_skew) )
                        multiple_skew(i)%PLIST(1:size_skew) = 0
                ENDIF
        ENDDO    
 
        ALLOCATE(p_skew(numskw+1))
        p_skew(1:numskw+1) = 0
                
!       stick a SKEW on a given processor
        DO j=1,number_skew_sp
                i = skew_per_sp(j)
                imain = local_p(j)
                n1=iskn(1,i)
                n2=iskn(2,i)
                n3=iskn(3,i)
                sum_ni = n1+n2+n3
                IF(sum_ni/=0) THEN
 
                        CALL ifrontplus(n1,imain)
                        CALL ifrontplus(n2,imain)
                        CALL ifrontplus(n3,imain)
                        IF(iskwp(i)==0) iskwp(i) = -imain
                        IF(tag_skn(i)>1) THEN
                                p_skew(i) = p_skew(i) + 1
                                multiple_skew(i)%PLIST(p_skew(i)) =  imain
                        ELSE
                                nskwp(imain) = nskwp(imain) + 1
                        ENDIF                                
                ENDIF
        ENDDO
 
!       count and add the number of SKEW per processor in the case of multiple SPRING per SKEW
        DO i=1,numskw+1
                size_skew = tag_skn(i)
                IF(size_skew>1) THEN
                        proc_skew(1:nspmd) = 0
                        DO ii=1,size_skew
                                imain = multiple_skew(i)%PLIST(ii)
                                IF(imain>0) proc_skew(imain) = proc_skew(imain) + 1
                        ENDDO
                        DO ii=1,nspmd
                                IF(proc_skew(ii)>0) nskwp(ii) = nskwp(ii) + 1
                        ENDDO
                ENDIF
        ENDDO
 
!       deallocation of local arrais
        DEALLOCATE(skew_per_sp,local_p)
        DEALLOCATE(p_skew)
 
        RETURN
        END SUBROUTINE check_skew