Télécharger konja4.eso

Retour à la liste

konja4
C KONJA4    SOURCE    CB215821  20/11/25    13:32:12     10792          
      SUBROUTINE KONJA4(ILINC,IRN,IUN,IPN,IGAMN,INORM,ICHPVO
     $     ,ICHPSU,MELEMC,MELEFE,MELLIM,IMAT)
C
C************************************************************************
C
C PROJET            :  CASTEM 2000
C
C NOM               :  KONJA4
C
C DESCRIPTION       :  Voir KONV11
C                      Calcul du jacobien du résidu pour la méthode
C                      AUSM+
C
C                      Cas 3D, gaz "calorically perfect"
C
C LANGAGE           :  FORTRAN 77 + ESOPE 2000 (avec estensions CISI)
C
C AUTEUR            :  S. KUDRIAKOV, SFME/LTMF
C
C************************************************************************
C
C APPELES (Calcul)  :  CONJ3D, CONJ3W
C
C************************************************************************
C
C ENTREES
C
C     ILINC  : liste des inconnues (pointeur d'un objet de type LISTMOTS)
C
C  1) Pointeurs des CHPOINT
C
C     IRN     : CHPOINT CENTRE  contenant la masse volumique ;
C
C     IUN     : CHPOINT CENTRE  contenant la vitesse ;
C
C     IPN     : CHPOINT CENTRE  contenant la pression ;
C
C     IGAMN   : CHPOINT CENTRE  contenant le gamma ;
C
C     INORM   : CHPOINT FACE    contenant les normales aux faces ;
C
C     ICHPOVO : CHPOINT VOLUME  contenant le volume
C
C     ICHPOSU : CHPOINT FACE    contenant la surface des faces
C
C
C  2) Pointeurs de MELEME de la table DOMAINE
C
C     MELEMC  : MELEME 'CENTRE' du SPG des CENTRES
C
C     MELEFE  : MELEME 'FACEL' du connectivité Faces -> Elts
C
C     MELLIM  : MELEME SPG des conditions aux bords
C
C SORTIES
C
C     IMAT    : pointeur de la MATRIK du jacobien du residu
C
C************************************************************************
C
C HISTORIQUE (Anomalies et modifications éventuelles)
C
C HISTORIQUE :
C
C************************************************************************
C
C
C N.B.: On suppose qu'on a déjà controllé RO, P > 0
C                                         GAMMA \in (1,3)
C       Si non il faut le faire!!!
C
C************************************************************************
C
C**** Variables de COOPTIO
C
C      INTEGER IPLLB, IERPER, IERMAX, IERR, INTERR
C     &        ,IOTER,   IOLEC,  IOIMP,     IOCAR,  IOACQ
C     &        ,IOPER,   IOSGB,  IOGRA,     IOSAU,  IORES
C     &        ,IECHO,   IIMPI,  IOSPI
C     &        ,IDIM,    IFICLE, IPREFI
C     &        ,MCOORD
C     &        ,IFOMOD, NIFOUR, IFOUR, NSDPGE, IONIVE
C     &        ,NGMAXY, IZROSF, ISOTYP, IOSCR,LTEXLU
C     &        ,NORINC,NORVAL,NORIND,NORVAD
C     &        ,NUCROU, IPSAUV
C
      IMPLICIT INTEGER(I-N)
      INTEGER ILINC, IRN,IUN,IPN,IGAMN,INORM,ICHPVO,ICHPSU
     &        , IMAT, IGEOMC, IGEOMF
     &        , NFAC, NBSOUS, NBREF, NBELEM, NBNN, NRIGE, NMATRI, NKID
     &        , NKMT, NBME, NBEL,  MP, NP
     &        , IFAC, NGCF, NLCF, NGCG, NGCD, NLCG, NLCD, NLFL
      REAL*8 ROG, PG, UXG, UYG, UZG,  GAMG, VOLG
     &       , ROD, PD, UXD, UYD, UZD,  GAMD, VOLD
     &       , SURF, FUNCEL
      REAL*8 WVEC_L(5), WVEC_R(5), NVECT(3), TVECT1(3),TVECT2(3)
      REAL*8 JTL(5,5), JTR(5,5)
      REAL*8 C11,C12,C13,C21,C22,C23,C31,C32,C33,DET
      REAL*8 ZC11,ZC12,ZC13,ZC21,ZC22,ZC23,ZC31,ZC32,ZC33
      CHARACTER*8 TYPE
C
C**** LES INCLUDES
C
 
-INC PPARAM
-INC CCOPTIO
-INC SMCHPOI
-INC SMMATRIK
-INC SMELEME
-INC SMLMOTS
-INC SMLENTI
      POINTEUR MPRN.MPOVAL, MPUN.MPOVAL, MPPN.MPOVAL, MPGAMN.MPOVAL,
     &         MPNORM.MPOVAL, MPVOLU.MPOVAL, MPOVSU.MPOVAL
      POINTEUR MELEMC.MELEME, MELEMF.MELEME, MELEFE.MELEME,
     &         MELEDU.MELEME, MELLIM.MELEME
      POINTEUR MLENTC.MLENTI, MLENTF.MLENTI, MLELIM.MLENTI
      POINTEUR RR.IZAFM, RUX.IZAFM, RUY.IZAFM, RUZ.IZAFM,RRET.IZAFM,
     &         UXR.IZAFM, UXUX.IZAFM, UXUY.IZAFM, UXUZ.IZAFM,
     &         UXRET.IZAFM,
     &         UYR.IZAFM, UYUX.IZAFM, UYUY.IZAFM, UYUZ.IZAFM,
     &         UYRET.IZAFM,
     &         UZR.IZAFM, UZUX.IZAFM, UZUY.IZAFM, UZUZ.IZAFM,
     &         UZRET.IZAFM,
     &         RETR.IZAFM, RETUX.IZAFM, RETUY.IZAFM, RETUZ.IZAFM,
     &         RETRET.IZAFM
      POINTEUR MLMINC.MLMOTS
C
C**** KRIPAD pour la correspondance global/local des conditions limits
C
      CALL KRIPAD(MELLIM,MLELIM)
c     SEGACT MELLIM
C
C**** KRIPAD pour la correspondance global/local des centres
C
      CALL KRIPAD(MELEMC,MLENTC)
C
C     SEGACT MLENTC
      SEGACT MELEMC
C
      SEGACT MELEFE
C
      CALL LICHT(ICHPSU,MPOVSU,TYPE,IGEOMF)
      CALL LICHT(INORM,MPNORM,TYPE,IGEOMF)
      CALL LICHT(ICHPVO,MPVOLU,TYPE,IGEOMC)
C
C**** LICHT active les MPOVALs en *MOD
C
C     i.e.
C
C     SEGACT MPOVSU*MOD
C     SEGACT MPOVNO*MOD
C     SEGACT MPVOLU*MOD
C
      MELEMF = IGEOMF
      CALL KRIPAD(MELEMF,MLENTF)
C
C     SEGACT MLENTF
      SEGACT MELEMF
C
      CALL LICHT(IRN,MPRN,TYPE,IGEOMC)
      CALL LICHT(IPN,MPPN,TYPE,IGEOMC)
      CALL LICHT(IUN,MPUN,TYPE,IGEOMC)
      CALL LICHT(IGAMN,MPGAMN,TYPE,IGEOMC)
C
C     SEGACT MPRN*MOD
C     SEGACT MPPN*MOD
C     SEGACT MPUN*MOD
C     SEGACT MPGAMN*MOD
C
      NFAC = MELEFE.NUM(/2)
C
C**** Maillage des inconnues primales
C
      NBSOUS = 0
      NBREF = 0
      NBELEM =  NFAC
      NBNN = 2
C
      SEGINI MELEDU
C     MELEPR = MELEDU
C
C**** MELEDU = 'SEG2'
C
      MELEDU.ITYPEL =  2
C
      NRIGE = 7
      NMATRI = 1
      NKID = 9
      NKMT = 7
C
      SEGINI MATRIK
      IMAT = MATRIK
      MATRIK.IRIGEL(1,1) = MELEDU
      MATRIK.IRIGEL(2,1) = MELEDU
C
C**** Matrice non symetrique
C
      MATRIK.IRIGEL(7,1) = 2
C
      NBME = 25
      NBSOUS = 1
      SEGINI IMATRI
      MLMINC = ILINC
      SEGACT MLMINC
      MATRIK.IRIGEL(4,1) = IMATRI
C-----------------------------------------------
      IMATRI.LISPRI(1) = MLMINC.MOTS(1)
      IMATRI.LISPRI(2) = MLMINC.MOTS(2)
      IMATRI.LISPRI(3) = MLMINC.MOTS(3)
      IMATRI.LISPRI(4) = MLMINC.MOTS(4)
      IMATRI.LISPRI(5) = MLMINC.MOTS(5)
C-----------------------------------------------
      IMATRI.LISPRI(6) = MLMINC.MOTS(1)
      IMATRI.LISPRI(7) = MLMINC.MOTS(2)
      IMATRI.LISPRI(8) = MLMINC.MOTS(3)
      IMATRI.LISPRI(9) = MLMINC.MOTS(4)
      IMATRI.LISPRI(10) = MLMINC.MOTS(5)
C-----------------------------------------------
      IMATRI.LISPRI(11) = MLMINC.MOTS(1)
      IMATRI.LISPRI(12) = MLMINC.MOTS(2)
      IMATRI.LISPRI(13) = MLMINC.MOTS(3)
      IMATRI.LISPRI(14) = MLMINC.MOTS(4)
      IMATRI.LISPRI(15) = MLMINC.MOTS(5)
C-----------------------------------------------
      IMATRI.LISPRI(16) = MLMINC.MOTS(1)
      IMATRI.LISPRI(17) = MLMINC.MOTS(2)
      IMATRI.LISPRI(18) = MLMINC.MOTS(3)
      IMATRI.LISPRI(19) = MLMINC.MOTS(4)
      IMATRI.LISPRI(20) = MLMINC.MOTS(5)
C-----------------------------------------------
      IMATRI.LISPRI(21) = MLMINC.MOTS(1)
      IMATRI.LISPRI(22) = MLMINC.MOTS(2)
      IMATRI.LISPRI(23) = MLMINC.MOTS(3)
      IMATRI.LISPRI(24) = MLMINC.MOTS(4)
      IMATRI.LISPRI(25) = MLMINC.MOTS(5)
C-----------------------------------------------
C-----------------------------------------------
      IMATRI.LISDUA(1) = MLMINC.MOTS(1)
      IMATRI.LISDUA(2) = MLMINC.MOTS(1)
      IMATRI.LISDUA(3) = MLMINC.MOTS(1)
      IMATRI.LISDUA(4) = MLMINC.MOTS(1)
      IMATRI.LISDUA(5) = MLMINC.MOTS(1)
C-----------------------------------------------
      IMATRI.LISDUA(6) = MLMINC.MOTS(2)
      IMATRI.LISDUA(7) = MLMINC.MOTS(2)
      IMATRI.LISDUA(8) = MLMINC.MOTS(2)
      IMATRI.LISDUA(9) = MLMINC.MOTS(2)
      IMATRI.LISDUA(10) = MLMINC.MOTS(2)
C----------------------------------------------
      IMATRI.LISDUA(11) = MLMINC.MOTS(3)
      IMATRI.LISDUA(12) = MLMINC.MOTS(3)
      IMATRI.LISDUA(13) = MLMINC.MOTS(3)
      IMATRI.LISDUA(14) = MLMINC.MOTS(3)
      IMATRI.LISDUA(15) = MLMINC.MOTS(3)
C----------------------------------------------
      IMATRI.LISDUA(16) = MLMINC.MOTS(4)
      IMATRI.LISDUA(17) = MLMINC.MOTS(4)
      IMATRI.LISDUA(18) = MLMINC.MOTS(4)
      IMATRI.LISDUA(19) = MLMINC.MOTS(4)
      IMATRI.LISDUA(20) = MLMINC.MOTS(4)
C----------------------------------------------
      IMATRI.LISDUA(21) = MLMINC.MOTS(5)
      IMATRI.LISDUA(22) = MLMINC.MOTS(5)
      IMATRI.LISDUA(23) = MLMINC.MOTS(5)
      IMATRI.LISDUA(24) = MLMINC.MOTS(5)
      IMATRI.LISDUA(25) = MLMINC.MOTS(5)
C----------------------------------------------
C----------------------------------------------
      NBEL = NBELEM
      NBSOUS = 1
      NP = 2
      MP = 2
      SEGINI   RR  , RUX , RUY , RUZ, RRET ,
     &         UXR , UXUX , UXUY , UXUZ, UXRET ,
     &         UYR , UYUX , UYUY , UYUZ, UYRET ,
     &         UZR , UZUX , UZUY , UZUZ, UZRET ,
     &         RETR , RETUX , RETUY , RETUZ, RETRET
C-----------------------------------------------
C**** Duale = IMATRI.LISDUA(1) = 'RN'
C     Primale = IMATRI.LISPRI(1) = 'RN'
C     -> IMATRI.LIZAFM(1,1) = RR
C
C     Duale = IMATRI.LISDUA(2) = 'RN'
C     Primale = IMATRI.LISPRI(1) = 'RUXN'
C     -> IMATRI.LIZAFM(1,2) = RUX
C     ...
C-----------------------------------------------
      IMATRI.LIZAFM(1,1) = RR
      IMATRI.LIZAFM(1,2) = RUX
      IMATRI.LIZAFM(1,3) = RUY
      IMATRI.LIZAFM(1,4) = RUZ
      IMATRI.LIZAFM(1,5) = RRET
C-----------------------------------------------
      IMATRI.LIZAFM(1,6) = UXR
      IMATRI.LIZAFM(1,7) = UXUX
      IMATRI.LIZAFM(1,8) = UXUY
      IMATRI.LIZAFM(1,9) = UXUZ
      IMATRI.LIZAFM(1,10) = UXRET
C-----------------------------------------------
      IMATRI.LIZAFM(1,11) = UYR
      IMATRI.LIZAFM(1,12) = UYUX
      IMATRI.LIZAFM(1,13) = UYUY
      IMATRI.LIZAFM(1,14) = UYUZ
      IMATRI.LIZAFM(1,15) = UYRET
C------------------------------------------------
      IMATRI.LIZAFM(1,16) = UZR
      IMATRI.LIZAFM(1,17) = UZUX
      IMATRI.LIZAFM(1,18) = UZUY
      IMATRI.LIZAFM(1,19) = UZUZ
      IMATRI.LIZAFM(1,20) = UZRET
C-----------------------------------------------
      IMATRI.LIZAFM(1,21) = RETR
      IMATRI.LIZAFM(1,22) = RETUX
      IMATRI.LIZAFM(1,23) = RETUY
      IMATRI.LIZAFM(1,24) = RETUZ
      IMATRI.LIZAFM(1,25) = RETRET
C-----------------------------------------------
      DO IFAC = 1, NFAC, 1
         NGCF = MELEFE.NUM(2,IFAC)
         NLCF = MLENTF.LECT(NGCF)
         IF(NLCF .NE. IFAC)THEN
            WRITE(IOIMP,*) 'Il ne faut pas jouer avec la table domaine'
            CALL ERREUR(5)
            GOTO 9999
         ENDIF
         NGCG = MELEFE.NUM(1,IFAC)
         NGCD = MELEFE.NUM(3,IFAC)
         NLFL = MLELIM.LECT(NGCF)
         IF(NLFL .NE. 0)THEN
C
C********** The point belongs on BC -> No contribution to jacobian!
C
            MELEDU.NUM(1,IFAC) = NGCG
            MELEDU.NUM(2,IFAC) = NGCD
         ELSEIF(NGCG .NE. NGCD)THEN
C-------------------------------------------------
C********** Les MELEMEs
C-------------------------------------------------
            MELEDU.NUM(1,IFAC) = NGCG
            MELEDU.NUM(2,IFAC) = NGCD
C-------------------------------------------------
C********** Les etats G et D
C-------------------------------------------------
            NLCG = MLENTC.LECT(NGCG)
            NLCD = MLENTC.LECT(NGCD)
C-------------------------------------------------
            ROG = MPRN.VPOCHA(NLCG,1)
            PG = MPPN.VPOCHA(NLCG,1)
            UXG = MPUN.VPOCHA(NLCG,1)
            UYG = MPUN.VPOCHA(NLCG,2)
            UZG = MPUN.VPOCHA(NLCG,3)
            GAMG = MPGAMN.VPOCHA(NLCG,1)
            VOLG = MPVOLU.VPOCHA(NLCG,1)
C-------------------------------------------------
            WVEC_L(1)=ROG
            WVEC_L(2)=UXG
            WVEC_L(3)=UYG
            WVEC_L(4)=UZG
            WVEC_L(5)=PG
C-------------------------------------------------
            ROD = MPRN.VPOCHA(NLCD,1)
            PD = MPPN.VPOCHA(NLCD,1)
            UXD = MPUN.VPOCHA(NLCD,1)
            UYD = MPUN.VPOCHA(NLCD,2)
            UZD = MPUN.VPOCHA(NLCD,3)
            GAMD = MPGAMN.VPOCHA(NLCD,1)
            VOLD = MPVOLU.VPOCHA(NLCD,1)
C------------------------------------------------
            WVEC_R(1)=ROD
            WVEC_R(2)=UXD
            WVEC_R(3)=UYD
            WVEC_R(4)=UZD
            WVEC_R(5)=PD
C------------------------------------------------
C
C********** La normale G->D
C           La tangente
C-----------------------------------------------
            SURF = MPOVSU.VPOCHA(NLCF,1)
            NVECT(1) = MPNORM.VPOCHA(NLCF,7)
            NVECT(2) = MPNORM.VPOCHA(NLCF,8)
            NVECT(3) = MPNORM.VPOCHA(NLCF,9)
c-----------------------------------------------
            TVECT1(1) = MPNORM.VPOCHA(NLCF,1)
            TVECT1(2) = MPNORM.VPOCHA(NLCF,2)
            TVECT1(3) = MPNORM.VPOCHA(NLCF,3)
c----------------------------------------------
            TVECT2(1) = MPNORM.VPOCHA(NLCF,4)
            TVECT2(2) = MPNORM.VPOCHA(NLCF,5)
            TVECT2(3) = MPNORM.VPOCHA(NLCF,6)
C-----------------------------------------------
C********** La contribution de Gauche
C-----------------------------------------------
            CALL CONJ3D(JTL,JTR,WVEC_L,WVEC_R,
     &           NVECT,TVECT1,TVECT2,GAMG)
C----------------------------------------------------------
C
C********** AB.AM(IFAC,IPRIM,IDUAL)
C           A = nom de l'inconnu duale (Ro,rUX,rUY,RET)
C           B = nom de l'inconnu primale (Ro,rUX,rUY,RET)
C           IPRIM = 1, 2  -> G, D
C           IDUAL = 1, 2  -> G, D
C           i.e.
C           A_IDUAL = AB.AM(IFAC,IPRIM,IDUAL) * B_IPRIM + ...
C
C
C********** Dual RN
C----------------------------------------------------------
            FUNCEL = SURF * JTL(1,1)
            RR.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RR.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(1,2)
            RUX.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RUX.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(1,3)
            RUY.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RUY.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(1,4)
            RUZ.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RUZ.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(1,5)
            RRET.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RRET.AM(IFAC,1,2) = FUNCEL / VOLD
C------------------------------------------------------------
C********** Dual RUXN
C------------------------------------------------------------
            FUNCEL = SURF * JTL(2,1)
            UXR.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXR.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(2,2)
            UXUX.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXUX.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(2,3)
            UXUY.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXUY.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(2,4)
            UXUZ.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXUZ.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(2,5)
            UXRET.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXRET.AM(IFAC,1,2) = FUNCEL / VOLD
C-------------------------------------------------------------
C********** Dual RUYN
C-------------------------------------------------------------
            FUNCEL = SURF * JTL(3,1)
            UYR.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYR.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(3,2)
            UYUX.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYUX.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(3,3)
            UYUY.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYUY.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(3,4)
            UYUZ.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYUZ.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(3,5)
            UYRET.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYRET.AM(IFAC,1,2) = FUNCEL / VOLD
C-------------------------------------------------------------
C********** Dual RUZN
C-------------------------------------------------------------
            FUNCEL = SURF * JTL(4,1)
            UZR.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZR.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(4,2)
            UZUX.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZUX.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(4,3)
            UZUY.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZUY.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(4,4)
            UZUZ.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZUZ.AM(IFAC,1,2) = FUNCEL / VOLD
C----------------------------------------------------
            FUNCEL = SURF * JTL(4,5)
            UZRET.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZRET.AM(IFAC,1,2) = FUNCEL / VOLD
C-------------------------------------------------------------
C********** Dual RETN
C-------------------------------------------------------------
            FUNCEL = SURF * JTL(5,1)
            RETR.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RETR.AM(IFAC,1,2) = FUNCEL / VOLD
C-----------------------------------------------------
            FUNCEL = SURF * JTL(5,2)
            RETUX.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RETUX.AM(IFAC,1,2) = FUNCEL / VOLD
C-----------------------------------------------------
            FUNCEL = SURF * JTL(5,3)
            RETUY.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RETUY.AM(IFAC,1,2) = FUNCEL / VOLD
C-----------------------------------------------------
            FUNCEL = SURF * JTL(5,4)
            RETUZ.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RETUZ.AM(IFAC,1,2) = FUNCEL / VOLD
C-----------------------------------------------------
            FUNCEL = SURF * JTL(5,5)
            RETRET.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            RETRET.AM(IFAC,1,2) = FUNCEL / VOLD
C-------------------------------------------------------------
C
C********** La contribution de D
C
c            NVECT(1) = -1.0D0 * NVECT(1)
c            NVECT(2) = -1.0D0 * NVECT(2)
c            TVECT(1) = -1.0D0 * TVECT(1)
c            TVECT(2) = -1.0D0 * TVECT(2)
c
c            CALL CONJAK(JTL,JTR,WVEC_L,WVEC_R,
c     &           NVECT,TVECT,GAMD)
C
C
C********** Dual RN
C------------------------------------------------------------
            FUNCEL = SURF * JTR(1,1)
            RR.AM(IFAC,2,2) = FUNCEL / VOLD
            RR.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(1,2)
            RUX.AM(IFAC,2,2) = FUNCEL / VOLD
            RUX.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(1,3)
            RUY.AM(IFAC,2,2) = FUNCEL / VOLD
            RUY.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(1,4)
            RUZ.AM(IFAC,2,2) = FUNCEL / VOLD
            RUZ.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(1,5)
            RRET.AM(IFAC,2,2) = FUNCEL / VOLD
            RRET.AM(IFAC,2,1) = -FUNCEL / VOLG
C-------------------------------------------------------------
C********** Dual RUXN
C-------------------------------------------------------------
            FUNCEL = SURF * JTR(2,1)
            UXR.AM(IFAC,2,2) = FUNCEL / VOLD
            UXR.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(2,2)
            UXUX.AM(IFAC,2,2) = FUNCEL / VOLD
            UXUX.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(2,3)
            UXUY.AM(IFAC,2,2) = FUNCEL / VOLD
            UXUY.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(2,4)
            UXUZ.AM(IFAC,2,2) = FUNCEL / VOLD
            UXUZ.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(2,5)
            UXRET.AM(IFAC,2,2) = FUNCEL / VOLD
            UXRET.AM(IFAC,2,1) = -FUNCEL / VOLG
C-------------------------------------------------------------
C********** Dual RUYN
C-------------------------------------------------------------
            FUNCEL = SURF * JTR(3,1)
            UYR.AM(IFAC,2,2) = FUNCEL / VOLD
            UYR.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(3,2)
            UYUX.AM(IFAC,2,2) = FUNCEL / VOLD
            UYUX.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(3,3)
            UYUY.AM(IFAC,2,2) = FUNCEL / VOLD
            UYUY.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(3,4)
            UYUZ.AM(IFAC,2,2) = FUNCEL / VOLD
            UYUZ.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(3,5)
            UYRET.AM(IFAC,2,2) = FUNCEL / VOLD
            UYRET.AM(IFAC,2,1) = -FUNCEL / VOLG
C-------------------------------------------------------------
C********** Dual RUZN
C-------------------------------------------------------------
            FUNCEL = SURF * JTR(4,1)
            UZR.AM(IFAC,2,2) = FUNCEL / VOLD
            UZR.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(4,2)
            UZUX.AM(IFAC,2,2) = FUNCEL / VOLD
            UZUX.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(4,3)
            UZUY.AM(IFAC,2,2) = FUNCEL / VOLD
            UZUY.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(4,4)
            UZUZ.AM(IFAC,2,2) = FUNCEL / VOLD
            UZUZ.AM(IFAC,2,1) = -FUNCEL / VOLG
C--------------------------------------------
            FUNCEL = SURF * JTR(4,5)
            UZRET.AM(IFAC,2,2) = FUNCEL / VOLD
            UZRET.AM(IFAC,2,1) = -FUNCEL / VOLG
C------------------------------------------------------------
C********** Dual RETN
C------------------------------------------------------------
            FUNCEL = SURF * JTR(5,1)
            RETR.AM(IFAC,2,2) = FUNCEL / VOLD
            RETR.AM(IFAC,2,1) = -FUNCEL / VOLG
C---------------------------------------------
            FUNCEL = SURF * JTR(5,2)
            RETUX.AM(IFAC,2,2) = FUNCEL / VOLD
            RETUX.AM(IFAC,2,1) = -FUNCEL / VOLG
C---------------------------------------------
            FUNCEL = SURF * JTR(5,3)
            RETUY.AM(IFAC,2,2) = FUNCEL / VOLD
            RETUY.AM(IFAC,2,1) = -FUNCEL / VOLG
C---------------------------------------------
            FUNCEL = SURF * JTR(5,4)
            RETUZ.AM(IFAC,2,2) = FUNCEL / VOLD
            RETUZ.AM(IFAC,2,1) = -FUNCEL / VOLG
C---------------------------------------------
            FUNCEL = SURF * JTR(5,5)
            RETRET.AM(IFAC,2,2) = FUNCEL / VOLD
            RETRET.AM(IFAC,2,1) = -FUNCEL / VOLG
C---------------------------------------------
         ELSE
C------------------------------------------------------------
C********** Murs (NGCG = NGCD)
C
C
C********** Les MELEMEs
C-----------------------------------------------------------
            MELEDU.NUM(1,IFAC) = NGCG
            MELEDU.NUM(2,IFAC) = NGCD
            NLCG = MLENTC.LECT(NGCG)
C-------------------------------------
            ROG = MPRN.VPOCHA(NLCG,1)
            PG = MPPN.VPOCHA(NLCG,1)
            UXG = MPUN.VPOCHA(NLCG,1)
            UYG = MPUN.VPOCHA(NLCG,2)
            UZG = MPUN.VPOCHA(NLCG,3)
            GAMG = MPGAMN.VPOCHA(NLCG,1)
            VOLG = MPVOLU.VPOCHA(NLCG,1)
C-------------------------------------------
            WVEC_L(1)=ROG
            WVEC_L(2)=UXG
            WVEC_L(3)=UYG
            WVEC_L(4)=UZG
            WVEC_L(5)=PG
C-------------------------------------------------
            SURF = MPOVSU.VPOCHA(NLCF,1)
            NVECT(1) = MPNORM.VPOCHA(NLCF,7)
            NVECT(2) = MPNORM.VPOCHA(NLCF,8)
            NVECT(3) = MPNORM.VPOCHA(NLCF,9)
c--------------------------------------------
            TVECT1(1) = MPNORM.VPOCHA(NLCF,1)
            TVECT1(2) = MPNORM.VPOCHA(NLCF,2)
            TVECT1(3) = MPNORM.VPOCHA(NLCF,3)
c----------------------------------------------
            TVECT2(1) = MPNORM.VPOCHA(NLCF,4)
            TVECT2(2) = MPNORM.VPOCHA(NLCF,5)
            TVECT2(3) = MPNORM.VPOCHA(NLCF,6)
C------- COEFFICIENTS ----------------------------
            C11=TVECT1(2)*TVECT2(3)-TVECT1(3)*TVECT2(2)
            C12=NVECT(2)*TVECT2(3)-TVECT2(2)*NVECT(3)
            C13=NVECT(2)*TVECT1(3)-TVECT1(2)*NVECT(3)
C---------------------------------
            C21=TVECT1(1)*TVECT2(3)-TVECT1(3)*TVECT2(1)
            C22=NVECT(1)*TVECT2(3)-TVECT2(1)*NVECT(3)
            C23=NVECT(1)*TVECT1(3)-TVECT1(1)*NVECT(3)
C---------------------------------
            C31=TVECT1(1)*TVECT2(2)-TVECT1(2)*TVECT2(1)
            C32=NVECT(1)*TVECT2(2)-TVECT2(1)*NVECT(2)
            C33=NVECT(1)*TVECT1(2)-TVECT1(1)*NVECT(2)
            DET=NVECT(1)*C11-NVECT(2)*C21+NVECT(3)*C31
C---------------------------------
            ZC11=-NVECT(1)*C11-TVECT1(1)*C12+TVECT2(1)*C13
            ZC12=-NVECT(2)*C11-TVECT1(2)*C12+TVECT2(2)*C13
            ZC13=-NVECT(3)*C11-TVECT1(3)*C12+TVECT2(3)*C13
C---------------------------------
            ZC21=NVECT(1)*C21+TVECT1(1)*C22-TVECT2(1)*C23
            ZC22=NVECT(2)*C21+TVECT1(2)*C22-TVECT2(2)*C23
            ZC23=NVECT(3)*C21+TVECT1(3)*C22-TVECT2(3)*C23
C---------------------------------
            ZC31=-NVECT(1)*C31-TVECT1(1)*C32+TVECT2(1)*C33
            ZC32=-NVECT(2)*C31-TVECT1(2)*C32+TVECT2(2)*C33
            ZC33=-NVECT(3)*C31-TVECT1(3)*C32+TVECT2(3)*C33
C-------------------------------------------------
            ROD = ROG
            PD = PG
            UXD = (ZC11*UXG+ZC12*UYG+ZC13*UZG)/DET
            UYD = (ZC21*UXG+ZC22*UYG+ZC23*UZG)/DET
            UZD = (ZC31*UXG+ZC32*UYG+ZC33*UZG)/DET
            GAMD = GAMG
            VOLD = VOLG
C------------------------------------------------
            WVEC_R(1)=ROD
            WVEC_R(2)=UXD
            WVEC_R(3)=UYD
            WVEC_R(4)=UZD
            WVEC_R(5)=PD
C-------------------------------------------
C********** La normale sortante
C-------------------------------------------
             CALL CONJ3W(JTL,JTR,WVEC_L,WVEC_R,
     &           NVECT,TVECT1,TVECT2,GAMG)
C--------------------------------------------------
C********** Dual RN
C--------------------------------------------------
            RR.AM(IFAC,1,1) = 0.0D0
            RR.AM(IFAC,1,2) = 0.0D0
C-----------------------------------
            RUX.AM(IFAC,1,1) = 0.0D0
            RUX.AM(IFAC,1,2) = 0.0D0
C-----------------------------------
            RUY.AM(IFAC,1,1) = 0.0D0
            RUY.AM(IFAC,1,2) = 0.0D0
C-----------------------------------
            RUZ.AM(IFAC,1,1) = 0.0D0
            RUZ.AM(IFAC,1,2) = 0.0D0
C-----------------------------------
            RRET.AM(IFAC,1,1) = 0.0D0
            RRET.AM(IFAC,1,2) = 0.0D0
C---------------------------------------------------
C********** Dual RUXN
C---------------------------------------------------
            FUNCEL = SURF * JTL(2,1)
            UXR.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXR.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(2,2)
            UXUX.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXUX.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(2,3)
            UXUY.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXUY.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(2,4)
            UXUZ.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXUZ.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(2,5)
            UXRET.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UXRET.AM(IFAC,1,2) = 0.0D0
C--------------------------------------------------------
C********** Dual RUYN
C--------------------------------------------------------
            FUNCEL = SURF * JTL(3,1)
            UYR.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYR.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(3,2)
            UYUX.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYUX.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(3,3)
            UYUY.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYUY.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(3,4)
            UYUZ.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYUZ.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(3,5)
            UYRET.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UYRET.AM(IFAC,1,2) = 0.0D0
C--------------------------------------------------------
C********** Dual RUZN
C--------------------------------------------------------
            FUNCEL = SURF * JTL(4,1)
            UZR.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZR.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(4,2)
            UZUX.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZUX.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(4,3)
            UZUY.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZUY.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(4,4)
            UZUZ.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZUZ.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------
            FUNCEL = SURF * JTL(4,5)
            UZRET.AM(IFAC,1,1) = -1.0D0 * FUNCEL / VOLG
            UZRET.AM(IFAC,1,2) = 0.0D0
C---------------------------------------------------------
C********** Dual RETN
C---------------------------------------------------------
            RETR.AM(IFAC,1,1) = 0.0D0
            RETR.AM(IFAC,1,2) = 0.0D0
C--------------------------------------
            RETUX.AM(IFAC,1,1) = 0.0D0
            RETUX.AM(IFAC,1,2) = 0.0D0
C--------------------------------------
            RETUY.AM(IFAC,1,1) = 0.0D0
            RETUY.AM(IFAC,1,2) = 0.0D0
C--------------------------------------
            RETUZ.AM(IFAC,1,1) = 0.0D0
            RETUZ.AM(IFAC,1,2) = 0.0D0
C--------------------------------------
            RETRET.AM(IFAC,1,1) = 0.0D0
            RETRET.AM(IFAC,1,2) = 0.0D0
C----------------------------------------------------------
C********** Dual RN
C----------------------------------------------------------
            RR.AM(IFAC,2,2) = 0.0D0
            RR.AM(IFAC,2,1) = 0.0D0
C-----------------------------------
            RUX.AM(IFAC,2,2) = 0.0D0
            RUX.AM(IFAC,2,1) = 0.0D0
C-----------------------------------
            RUY.AM(IFAC,2,2) = 0.0D0
            RUY.AM(IFAC,2,1) = 0.0D0
C-----------------------------------
            RUZ.AM(IFAC,2,2) = 0.0D0
            RUZ.AM(IFAC,2,1) = 0.0D0
C-----------------------------------
            RRET.AM(IFAC,2,2) = 0.0D0
            RRET.AM(IFAC,2,1) = 0.0D0
C----------------------------------------------------------
C********** Dual RUXN
C----------------------------------------------------------
            UXR.AM(IFAC,2,2) = 0.0D0
            UXR.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UXUX.AM(IFAC,2,2) = 0.0D0
            UXUX.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UXUY.AM(IFAC,2,2) = 0.0D0
            UXUY.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UXUZ.AM(IFAC,2,2) = 0.0D0
            UXUZ.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UXRET.AM(IFAC,2,2) = 0.0D0
            UXRET.AM(IFAC,2,1) = 0.0D0
C----------------------------------------------------------
C********** Dual RUYN
C----------------------------------------------------------
            UYR.AM(IFAC,2,2) = 0.0D0
            UYR.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UYUX.AM(IFAC,2,2) = 0.0D0
            UYUX.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UYUY.AM(IFAC,2,2) = 0.0D0
            UYUY.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UYUZ.AM(IFAC,2,2) = 0.0D0
            UYUZ.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UYRET.AM(IFAC,2,2) = 0.0D0
            UYRET.AM(IFAC,2,1) = 0.0D0
C----------------------------------------------------------
C********** Dual RUZN
C----------------------------------------------------------
            UZR.AM(IFAC,2,2) = 0.0D0
            UZR.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UZUX.AM(IFAC,2,2) = 0.0D0
            UZUX.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UZUY.AM(IFAC,2,2) = 0.0D0
            UZUY.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UZUZ.AM(IFAC,2,2) = 0.0D0
            UZUZ.AM(IFAC,2,1) = 0.0D0
C------------------------------------
            UZRET.AM(IFAC,2,2) = 0.0D0
            UZRET.AM(IFAC,2,1) = 0.0D0
C---------------------------------------------------------
C********** Dual RETN
C---------------------------------------------------------
            RETR.AM(IFAC,2,2) = 0.0D0
            RETR.AM(IFAC,2,1) = 0.0D0
C-------------------------------------
            RETUX.AM(IFAC,2,2) = 0.0D0
            RETUX.AM(IFAC,2,1) = 0.0D0
C-------------------------------------
            RETUY.AM(IFAC,2,2) = 0.0D0
            RETUY.AM(IFAC,2,1) = 0.0D0
C-------------------------------------
            RETUZ.AM(IFAC,2,2) = 0.0D0
            RETUZ.AM(IFAC,2,1) = 0.0D0
C-------------------------------------
            RETRET.AM(IFAC,2,2) = 0.0D0
            RETRET.AM(IFAC,2,1) = 0.0D0
C--------------------------------------
         ENDIF
      ENDDO
C------------------
      SEGDES MELEMC
      SEGDES MELEFE
      SEGDES MELEMF
C------------------
      SEGDES MPOVSU
      SEGDES MPVOLU
      SEGDES MPNORM
C------------------
      SEGDES MPRN
      SEGDES MPPN
      SEGDES MPUN
      SEGDES MPGAMN
C------------------
      SEGDES MELEDU
      SEGDES MATRIK
      SEGDES IMATRI
C------------------
      SEGDES   RR  , RUX , RUY , RUZ , RRET ,
     &         UXR , UXUX , UXUY , UXUZ , UXRET ,
     &         UYR , UYUX , UYUY , UYUZ , UYRET ,
     &         UZR , UZUX , UZUY , UZUZ , UZRET ,
     &         RETR , RETUX , RETUY , RETUZ , RETRET
 
      SEGSUP MLENTC
      SEGSUP MLENTF
      SEGDES MLMINC
      SEGSUP MLELIM
C
 9999 CONTINUE
      RETURN
      END
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

© Cast3M 2003 - Tous droits réservés.
Mentions légales