Télécharger la plaquette Cast3M


fr en

Télécharger cv2maa.eso

Retour à la liste

Numérotation des lignes : 

cv2maa

  1. C CV2MAA    SOURCE    GOUNAND   21/06/02    21:15:38     11022          
  2.       SUBROUTINE CV2MAA(CGEOME,TABVDC,TABMAT,
  3.      $     MYFALS,
  4.      $     MATLSA,
  5.      $     IMPR,IRET)
  6.       IMPLICIT REAL*8 (A-H,O-Z)
  7.       IMPLICIT INTEGER (I-N)
  8. C***********************************************************************
  9. C NOM         : CV2MAA
  10. C DESCRIPTION : Transforme un MCHAEL (mon champ par éléments)
  11. C               représentant un ensemble de matrices élémentaires en
  12. C               RIGIDITE...
  13. C
  14. C LANGAGE     : ESOPE
  15. C AUTEUR      : Stéphane GOUNAND (CEA/DRN/DMT/SEMT/LTMF)
  16. C               mél : gounand@semt2.smts.cea.fr
  17. C***********************************************************************
  18. C APPELES          :
  19. C APPELES (E/S)    :
  20. C APPELE PAR       : CV2MCA
  21. C***********************************************************************
  22. C ENTREES            :
  23. C ENTREES/SORTIES    : -
  24. C SORTIES            :
  25. C CODE RETOUR (IRET) : = 0 si tout s'est bien passé
  26. C***********************************************************************
  27. C VERSION    : v1, 06/03/06, version initiale
  28. C HISTORIQUE : v1, 06/03/06, création
  29. C HISTORIQUE :
  30. C HISTORIQUE :
  31. C***********************************************************************
  32. C Prière de PRENDRE LE TEMPS de compléter les commentaires
  33. C en cas de modification de ce sous-programme afin de faciliter
  34. C la maintenance !
  35. C***********************************************************************
  36.  
  37. -INC PPARAM
  38. -INC CCOPTIO
  39. -INC CCHAMP
  40. -INC SMLMOTS
  41.       POINTEUR NCVAPR.MLMOTS
  42.       POINTEUR NCVADU.MLMOTS
  43. -INC SMELEME
  44.       POINTEUR CGEOME.MELEME
  45.       POINTEUR MYMEL.MELEME
  46.       POINTEUR RIGMEL.MELEME
  47.       INTEGER NBNN,NBELEM,NBSOUS,NBREF
  48. -INC SMLENTI
  49.       INTEGER JG
  50.       POINTEUR LINCPR.MLENTI,LINCDU.MLENTI
  51.       POINTEUR KINCPR.MLENTI,KINCDU.MLENTI
  52.       POINTEUR LPOQUF.MLENTI,KPOQUF.MLENTI
  53.       POINTEUR NOFSPR.MLENTI,NOFSDU.MLENTI
  54.       POINTEUR COPRDU.MLENTI,LINCD2.MLENTI
  55. -INC SMRIGID
  56.       POINTEUR MATLSA.MRIGID
  57.       POINTEUR MYDSCR.DESCR
  58.       POINTEUR MYIMAT.IMATRI
  59.       POINTEUR MYXMAT.XMATRI
  60.       INTEGER NRIGE,NRIGEL,NELRIG,NLIGRP,NLIGRD
  61. *
  62. * Includes persos
  63. *
  64. -INC TNLIN      
  65. *-INC SMTNLIN
  66. *-INC SMCHAEL
  67.       POINTEUR IMTLSA.MCHAEL
  68.       POINTEUR JMTLSA.MCHEVA
  69.       INTEGER NBLIG,NBCOL,N2LIG,N2COL,NBPOI,NBELM
  70. *-INC SFALRF
  71.       POINTEUR MYFALS.FALRFS
  72. *-INC SELREF
  73.       POINTEUR LRFPR.ELREF
  74.       POINTEUR LRFDU.ELREF
  75. *
  76.       CHARACTER*4 MDISPR,MDISDU,MOPR,MODU
  77.       INTEGER IMPR,IRET
  78. *
  79.       INTEGER IBNN,IBELEM
  80.       INTEGER ITQUAF,NDDLPR,NDDLDU
  81.       INTEGER        IDDLPR,IDDLDU
  82.       INTEGER               NSOUS,NPOQUF
  83.       INTEGER ISOUS
  84.       INTEGER ILIGRP,ILIGRD,IELRIG,ICMPP,ICMPD
  85.       LOGICAL LOK,LFOUND,LCORES,LEQ1,LEQ2,LFIRST
  86.  
  87. *
  88. * Executable statements
  89. *
  90.       IF (IMPR.GT.1) WRITE(IOIMP,*) 'Entrée dans cv2maa'
  91. *
  92. *      Vérification sur les inconnues
  93. *
  94.       SEGACT TABVDC
  95.       SEGACT TABMAT
  96. *      SEGPRT,TABVDC
  97. *      SEGPRT,TABMAT
  98.  
  99.       NUMVPR=TABMAT.VMAT(/2)
  100.       NUMVDU=TABMAT.VMAT(/1)
  101. *
  102. * Construction des listes d'inconnues primales et duales
  103. * qui interviennent dans la matrice et dont la valeur n'est pas
  104. * donnée
  105.       JG=0
  106.       SEGINI LINCPR
  107.       SEGINI LINCDU
  108.       DO IVARPR=1,NUMVPR
  109.          IPR=TABVDC.VVARPR(IVARPR)
  110.          IF (TABVDC.MVD(IPR).EQ.0) THEN
  111.             DO IVARDU=1,NUMVDU
  112.                IDU=TABVDC.VVARDU(IVARDU)
  113.                IF (TABVDC.MVD(IDU).EQ.0) THEN
  114.                   IF (TABMAT.VMAT(IVARDU,IVARPR).NE.0) THEN
  115.                      LINCDU.LECT(**)=IDU
  116.                      LINCPR.LECT(**)=IPR
  117.                   ENDIF
  118.                ENDIF
  119.             ENDDO
  120.          ENDIF
  121.       ENDDO
  122.       NINCPR=LINCPR.LECT(/1)
  123.       NINCDU=LINCDU.LECT(/1)
  124. * Sortie anticipée s'il n'y a pas de matrices à construire
  125.       IF (NINCPR.EQ.0.AND.NINCDU.EQ.0) THEN
  126. *         SEGACT LINCPR
  127. *         SEGACT LINCDU
  128.          SEGSUP LINCPR
  129.          SEGSUP LINCDU
  130.          MATLSA=0
  131.          RETURN
  132.       ENDIF
  133. *
  134. *      WRITE(IOIMP,*) 'LINCPR et LINCDU'
  135. *      SEGPRT,LINCPR
  136. *      SEGPRT,LINCDU
  137. * Suppression des doublons
  138.       CALL IUNIQ(LINCPR.LECT,LINCPR.LECT(/1),
  139.      $     LINCPR.LECT,NINCPR,
  140.      $     IMPR,IRET)
  141.       IF (IRET.NE.0) GOTO 9999
  142.       JG=NINCPR
  143.       SEGADJ,LINCPR
  144.       CALL IUNIQ(LINCDU.LECT,LINCDU.LECT(/1),
  145.      $     LINCDU.LECT,NINCDU,
  146.      $     IMPR,IRET)
  147.       IF (IRET.NE.0) GOTO 9999
  148.       JG=NINCDU
  149.       SEGADJ,LINCDU
  150. *      WRITE(IOIMP,*) 'LINCPR et LINCDU sans doublons'
  151. *      SEGPRT,LINCPR
  152. *      SEGPRT,LINCDU
  153. *
  154. * Si les listes d'inconnues ont même taille, on se fatigue
  155. * à chercher une permutation des inconnues duales qui les
  156. * recollent sur les primales
  157. * Ca ne marche pas pour l'instant : COPRDU n'est pas forcément
  158. * une permutation ex : primale = 'TN' ; duale = 'SCAL'
  159. *
  160.       IF (.FALSE.) THEN
  161.          IF (NINCPR.EQ.NINCDU) THEN
  162.             JG=NINCPR
  163.             SEGINI COPRDU
  164.             LOK=.TRUE.
  165.             IINCPR=0
  166.  3          CONTINUE
  167.             IF (LOK.AND.IINCPR.LT.NINCPR) THEN
  168.                IINCPR=IINCPR+1
  169.                JGVDPR=LINCPR.LECT(IINCPR)
  170.                NCVAPR=TABVDC.NOMVD(JGVDPR)
  171.                SEGACT NCVAPR
  172. *            SEGPRT,NCVAPR
  173.                NMOVPR=NCVAPR.MOTS(/2)
  174.                IINCDU=0
  175.                LFOUND=.FALSE.
  176.  1             CONTINUE
  177. *            WRITE(IOIMP,*) '1'
  178.                IF (.NOT.LFOUND.AND.IINCDU.LT.NINCDU) THEN
  179.                   IINCDU=IINCDU+1
  180.                   JGVDDU=LINCDU.LECT(IINCDU)
  181.                   NCVADU=TABVDC.NOMVD(JGVDDU)
  182.                   SEGACT NCVADU
  183. *               SEGPRT,NCVADU
  184.                   NMOVDU=NCVADU.MOTS(/2)
  185.                   LCORES=.FALSE.
  186.                   IF (NMOVDU.EQ.NMOVPR) THEN
  187.                      LCORES=.TRUE.
  188.                      IMOV=0
  189.  2                   CONTINUE
  190. *                  WRITE(IOIMP,*) '2'
  191.                      IF (LCORES.AND.IMOV.LT.NMOVDU) THEN
  192.  
  193.                         IMOV=IMOV+1
  194.                         MOPR=NCVAPR.MOTS(IMOV)
  195.                         MODU=NCVADU.MOTS(IMOV)
  196. *                     WRITE(IOIMP,*) 'avant fimot2'
  197.                         CALL FIMOT2(MOPR,NOMDD,LNOMDD,
  198.      $                       IPR,IMPR,IRET)
  199.                         IF (IRET.NE.0) GOTO 9999
  200. *                     WRITE(IOIMP,*) 'apres fimot2'
  201.                         LEQ1=MOPR.EQ.MODU
  202. *                     WRITE(IOIMP,*) 'LEQ1=',LEQ1
  203. *                     WRITE(IOIMP,*) 'IPR=',IPR
  204.                         IF (IPR.NE.0) THEN
  205.                            LEQ2=MODU.EQ.NOMDU(IPR)
  206.                         ELSE
  207.                            LEQ2=.FALSE.
  208.                         ENDIF
  209. *                     WRITE(IOIMP,*) 'LEQ2=',LEQ2
  210.                         LCORES=LCORES.AND.(LEQ1.OR.LEQ2)
  211.                         GOTO 2
  212.                      ENDIF
  213.                   ENDIF
  214.                   SEGDES NCVADU
  215.                   LFOUND=LCORES
  216.                   GOTO 1
  217.                ENDIF
  218.                IF (LFOUND) THEN
  219.                   COPRDU.LECT(IINCPR)=IINCDU
  220.                ENDIF
  221.                SEGDES NCVAPR
  222.                LOK=LOK.AND.LFOUND
  223.                GOTO 3
  224.             ENDIF
  225. *         SEGPRT,COPRDU
  226. *
  227. * On permute LINCDU
  228. *
  229.             LINCD2=LINCDU
  230.             JG=NINCDU
  231.             SEGINI LINCDU
  232.             DO IINCDU=1,NINCDU
  233.                LINCDU.LECT(IINCDU)=LINCD2.LECT(COPRDU.LECT(IINCDU))
  234.             ENDDO
  235.             SEGSUP LINCD2
  236.             SEGSUP COPRDU
  237.          ENDIF
  238. *      WRITE(IOIMP,*) 'LINCDU permuté'
  239. *      SEGPRT,LINCPR
  240. *      SEGPRT,LINCDU
  241.       ENDIF
  242. *
  243. * Maintenant on construit la table de repérage dans LINCPR et LINCDU
  244. *
  245.       JG=TABVDC.DJSVD(/1)
  246.       SEGINI KINCPR
  247.       CALL RSETXI(KINCPR.LECT,LINCPR.LECT,LINCPR.LECT(/1))
  248.       SEGINI KINCDU
  249.       CALL RSETXI(KINCDU.LECT,LINCDU.LECT,LINCDU.LECT(/1))
  250. *      WRITE(IOIMP,*) 'KINCPR et KINCDU'
  251. *      SEGPRT,KINCPR
  252. *      SEGPRT,KINCDU
  253. *
  254.       SEGACT CGEOME
  255.       NSOUS=CGEOME.LISOUS(/1)
  256. *
  257. * Initialisation de la matrice
  258. *
  259.       NRIGE=7
  260.       NRIGEL=NSOUS
  261.       SEGINI,MATLSA
  262.       MATLSA.MTYMAT='LEASTSQU'
  263. * Parcours
  264.       DO ISOUS=1,NSOUS
  265. *         WRITE(IOIMP,*) 'ISOUS=',ISOUS
  266.          MYMEL=CGEOME.LISOUS(ISOUS)
  267.          SEGACT MYMEL
  268. *         SEGPRT,MYMEL
  269.          ITQUAF=MYMEL.ITYPEL
  270. *
  271. * Maintenant on construit :
  272. * - L'objet géométrie
  273. * - La table d'offset pour les variables primales et duales
  274. * - Le segment descripteur
  275. *
  276. *   Liste des points du QUAF sur lequels il y a des ddl
  277.          JG=0
  278.          SEGINI LPOQUF
  279. *   Tables d'offset
  280.          JG=NINCPR+1
  281.          SEGINI NOFSPR
  282.          NOFSPR.LECT(1)=0
  283.          JG=NINCDU+1
  284.          SEGINI NOFSDU
  285.          NOFSDU.LECT(1)=0
  286.          NLIGRP=0
  287.          NLIGRD=0
  288. *       Primale
  289.          DO IINCPR=1,NINCPR
  290.             IJGVD=LINCPR.LECT(IINCPR)
  291.             IKGVD=TABVDC.DJSVD(IJGVD)
  292.             MDISPR=TABVDC.DISVD(IKGVD)
  293.             CALL KEEF(ITQUAF,MDISPR,MYFALS,
  294.      $           LRFPR,IMPR,IRET)
  295.             IF (IRET.NE.0) GOTO 9999
  296.             SEGACT LRFPR
  297.             NDDLPR=LRFPR.NPQUAF(/1)
  298.             DO IDDLPR=1,NDDLPR
  299.                LPOQUF.LECT(**)=LRFPR.NPQUAF(IDDLPR)
  300.             ENDDO
  301.             SEGDES LRFPR
  302.             NLIGRP=NLIGRP+NDDLPR
  303.             NOFSPR.LECT(IINCPR+1)=NLIGRP
  304.          ENDDO
  305. *       Duale
  306.          DO IINCDU=1,NINCDU
  307.             IJGVD=LINCDU.LECT(IINCDU)
  308.             IKGVD=TABVDC.DJSVD(IJGVD)
  309.             MDISDU=TABVDC.DISVD(IKGVD)
  310.             CALL KEEF(ITQUAF,MDISDU,MYFALS,
  311.      $           LRFDU,IMPR,IRET)
  312.             IF (IRET.NE.0) GOTO 9999
  313.             SEGACT LRFDU
  314.             NDDLDU=LRFDU.NPQUAF(/1)
  315.             DO IDDLDU=1,NDDLDU
  316.                LPOQUF.LECT(**)=LRFDU.NPQUAF(IDDLDU)
  317.             ENDDO
  318.             SEGDES LRFDU
  319.             NLIGRD=NLIGRD+NDDLDU
  320.             NOFSDU.LECT(IINCDU+1)=NLIGRD
  321.          ENDDO
  322. * Suppression des doublons de LPOQUF
  323.          CALL IUNIQ(LPOQUF.LECT,LPOQUF.LECT(/1),
  324.      $        LPOQUF.LECT,NPOQUF,
  325.      $        IMPR,IRET)
  326.          IF (IRET.NE.0) GOTO 9999
  327.          JG=NPOQUF
  328.          SEGADJ,LPOQUF
  329. * Segment de repérage dans LPOQUF
  330.          JG=MYMEL.NUM(/1)
  331.          SEGINI,KPOQUF
  332.          CALL RSETXI(KPOQUF.LECT,LPOQUF.LECT,LPOQUF.LECT(/1))
  333. *         SEGPRT,LPOQUF
  334. *         SEGPRT,KPOQUF
  335. *
  336. * Remplissage de l'objet géométrie
  337. *
  338.          NBNN=NPOQUF
  339.          NBELEM=MYMEL.NUM(/2)
  340.          NBSOUS=0
  341.          NBREF=0
  342.          SEGINI,RIGMEL
  343. * Type 32 POLY
  344.          RIGMEL.ITYPEL=32
  345.          DO IBELEM=1,NBELEM
  346.             DO IBNN=1,NBNN
  347.                RIGMEL.NUM(IBNN,IBELEM)=
  348.      $              MYMEL.NUM(LPOQUF.LECT(IBNN),IBELEM)
  349.             ENDDO
  350.          ENDDO
  351.          SEGDES RIGMEL
  352.          SEGSUP LPOQUF
  353. *        SEGPRT,RIGMEL
  354. *
  355. * Remplissage du segment DESCR
  356. *
  357.          SEGINI MYDSCR
  358. *       Primale
  359.          DO IINCPR=1,NINCPR
  360.             IJGVD=LINCPR.LECT(IINCPR)
  361.             IKGVD=TABVDC.DJSVD(IJGVD)
  362.             MDISPR=TABVDC.DISVD(IKGVD)
  363.             CALL KEEF(ITQUAF,MDISPR,MYFALS,
  364.      $           LRFPR,IMPR,IRET)
  365.             IF (IRET.NE.0) GOTO 9999
  366.             SEGACT LRFPR
  367.             NCVAPR=TABVDC.NOMVD(IJGVD)
  368.             SEGACT NCVAPR
  369.             NDDLPR=LRFPR.NPQUAF(/1)
  370.             DO IDDLPR=1,NDDLPR
  371.                ILIGPR=IDDLPR+NOFSPR.LECT(IINCPR)
  372.                ICMPR=LRFPR.NUMCMP(IDDLPR)
  373.                MYDSCR.LISINC(ILIGPR)=NCVAPR.MOTS(ICMPR)
  374.                MYDSCR.NOELEP(ILIGPR)=
  375.      $              KPOQUF.LECT(LRFPR.NPQUAF(IDDLPR))
  376.             ENDDO
  377.             SEGDES NCVAPR
  378.             SEGDES LRFPR
  379.          ENDDO
  380. *       Duale
  381.          DO IINCDU=1,NINCDU
  382.             IJGVD=LINCDU.LECT(IINCDU)
  383.             IKGVD=TABVDC.DJSVD(IJGVD)
  384.             MDISDU=TABVDC.DISVD(IKGVD)
  385.             CALL KEEF(ITQUAF,MDISDU,MYFALS,
  386.      $           LRFDU,IMPR,IRET)
  387.             IF (IRET.NE.0) GOTO 9999
  388.             SEGACT LRFDU
  389.             NCVADU=TABVDC.NOMVD(IJGVD)
  390.             SEGACT NCVADU
  391.             NDDLDU=LRFDU.NPQUAF(/1)
  392.             DO IDDLDU=1,NDDLDU
  393.                ILIGDU=IDDLDU+NOFSDU.LECT(IINCDU)
  394.                ICMDU=LRFDU.NUMCMP(IDDLDU)
  395.                MYDSCR.LISDUA(ILIGDU)=NCVADU.MOTS(ICMDU)
  396.                MYDSCR.NOELED(ILIGDU)=
  397.      $              KPOQUF.LECT(LRFDU.NPQUAF(IDDLDU))
  398.             ENDDO
  399.             SEGDES NCVADU
  400.             SEGDES LRFDU
  401.          ENDDO
  402.          SEGDES MYDSCR
  403. *         SEGPRT,MYDSCR
  404.          SEGSUP KPOQUF
  405. *
  406. * Remplissage du IMATRI
  407. *
  408.          NELRIG=MYMEL.NUM(/2)
  409.          SEGDES MYMEL
  410.          SEGINI MYxMAT
  411. *      NLIGRP et NLIGRD déjà calculés
  412.          DO IVARPR=1,NUMVPR
  413. *            write(ioimp,*) 'ivarpr=',ivarpr
  414.             JGVDPR=TABVDC.VVARPR(IVARPR)
  415.             IF (TABVDC.MVD(JGVDPR).EQ.0) THEN
  416.                IINCPR=KINCPR.LECT(JGVDPR)
  417. *               write(ioimp,*) 'iincpr=',iincpr
  418.                DO IVARDU=1,NUMVDU
  419. *                  write(ioimp,*) 'ivardu=',ivardu
  420.                   JGVDDU=TABVDC.VVARDU(IVARDU)
  421.                   IF (TABVDC.MVD(JGVDDU).EQ.0) THEN
  422.                      IINCDU=KINCDU.LECT(JGVDDU)
  423. *                     write(ioimp,*) 'iincdu=',iincdu
  424.                      IMTLSA=TABMAT.VMAT(IVARDU,IVARPR)
  425.                      IF (IMTLSA.NE.0) THEN
  426.                         SEGACT IMTLSA
  427.                         JMTLSA=IMTLSA.ICHEVA(ISOUS)
  428.                         SEGACT JMTLSA
  429.                         NBLIG=JMTLSA.WELCHE(/1)
  430.                         NBCOL=JMTLSA.WELCHE(/2)
  431.                         N2LIG=JMTLSA.WELCHE(/3)
  432.                         N2COL=JMTLSA.WELCHE(/4)
  433.                         NBPOI=JMTLSA.WELCHE(/5)
  434.                         NBELM=JMTLSA.WELCHE(/6)
  435.                         IOFSPR=NOFSPR.LECT(IINCPR)
  436.                         IOFSDU=NOFSDU.LECT(IINCDU)
  437. *                        write(ioimp,*) 'iofspr=',iofspr
  438. *                        write(ioimp,*) 'iofsdu=',iofsdu
  439.                         NDDLPR=NOFSPR.LECT(IINCPR+1)-IOFSPR
  440.                         NDDLDU=NOFSDU.LECT(IINCDU+1)-IOFSDU
  441.                         IF (NBLIG.NE.NDDLDU.OR.NBCOL.NE.NDDLPR.OR.N2LIG
  442.      $                       .NE.1.OR.N2COL.NE.1.OR.NBPOI.NE.1.OR.NBELM
  443.      $                       .NE.NELRIG) THEN
  444.                            WRITE(IOIMP,*) 'NBLIG=',NBLIG
  445.                            WRITE(IOIMP,*) 'NBCOL=',NBCOL
  446.                            WRITE(IOIMP,*) 'NBELM=',NBELM
  447.                            WRITE(IOIMP,*) 'NDDLDU=',NDDLDU
  448.                            WRITE(IOIMP,*) 'NDDLPR=',NDDLPR
  449.                            WRITE(IOIMP,*) 'NELRIG=',NELRIG
  450.  
  451.  
  452.                            WRITE(IOIMP,*) 'Erreur dims JMTLSA'
  453.                            GOTO 9999
  454.                         ENDIF
  455. *                        WRITE(IOIMP,*) 'IINCPR=',IINCPR
  456. *                        WRITE(IOIMP,*) 'IINCDU=',IINCDU
  457.                         DO IELRIG=1,NELRIG
  458. *                           WRITE(IOIMP,*) 'IELRIG=',IELRIG
  459. *                           MYXMAT=MYIMAT.IMATTT(IELRIG)
  460. *                           IF (MYXMAT.EQ.0) THEN
  461. *                              LFIRST=.TRUE.
  462. *                              SEGINI MYXMAT
  463. *                           ELSE
  464. *                              LFIRST=.FALSE.
  465. *                              SEGACT MYXMAT*MOD
  466. *                           ENDIF
  467.                            DO IDDLPR=1,NDDLPR
  468. *                              write(ioimp,*) 'iddlpr=',iddlpr
  469.                               DO IDDLDU=1,NDDLDU
  470. *                                 write(ioimp,*) 'iddldu=',iddldu
  471.                                  MYXMAT.RE(IOFSDU+IDDLDU,IOFSPR+IDDLPR
  472.      $                                ,ielrig)=JMTLSA.WELCHE(IDDLDU
  473.      $                                ,IDDLPR,1,1,1,IELRIG)
  474.                               ENDDO
  475.                            ENDDO
  476. *                           IF (LFIRST) THEN
  477. *                              SEGDES MYXMAT
  478. *                              MYIMAT.IMATTT(IELRIG)=MYXMAT
  479. *                           ELSE
  480. *                              SEGDES MYXMAT
  481. *                           ENDIF
  482. *                           SEGPRT,MYXMAT
  483.                         ENDDO
  484.                         SEGDES JMTLSA
  485.                         SEGDES IMTLSA
  486.                      ENDIF
  487.                   ENDIF
  488.                ENDDO
  489.             ENDIF
  490.          ENDDO
  491.          SEGSUP NOFSDU
  492.          SEGSUP NOFSPR
  493.          SEGDES MYxMAT
  494. *         SEGPRT,MYIMAT
  495. *
  496. * Remplissage du chapeau
  497. *
  498.          MATLSA.COERIG(ISOUS)=1.D0
  499.          MATLSA.IRIGEL(1,ISOUS)=RIGMEL
  500.          MATLSA.IRIGEL(2,ISOUS)=0
  501.          MATLSA.IRIGEL(3,ISOUS)=MYDSCR
  502.          MATLSA.IRIGEL(4,ISOUS)=MYxMAT
  503.          MATLSA.IRIGEL(5,ISOUS)=0
  504.          MATLSA.IRIGEL(6,ISOUS)=0
  505. *
  506. * la matrice ne possède pas de symétries (a priori...)
  507. *
  508.          MATLSA.IRIGEL(7,ISOUS)=2
  509.       ENDDO
  510.       SEGDES MATLSA
  511.       IF (IMPR.GT.3) THEN
  512.          WRITE(IOIMP,*) 'On a créé MATLSA=',MATLSA
  513.          CALL ECROBJ('RIGIDITE',MATLSA)
  514.          CALL PRLIST
  515.       ENDIF
  516.  
  517.       SEGDES CGEOME
  518.       SEGSUP KINCPR
  519.       SEGSUP KINCDU
  520.       SEGSUP LINCPR
  521.       SEGSUP LINCDU
  522.       SEGDES TABMAT
  523.       SEGDES TABVDC
  524. *
  525. * Normal termination
  526. *
  527.       IRET=0
  528.       RETURN
  529. *
  530. * Format handling
  531. *
  532. *
  533. * Error handling
  534. *
  535.  9999 CONTINUE
  536.       IRET=1
  537.       WRITE(IOIMP,*) 'An error was detected in subroutine cv2maa'
  538.       RETURN
  539. *
  540. * End of subroutine CV2MAA
  541. *
  542.       END
  543.  
  544.  
  545.  
  546.  
  547.  
  548.  
  549.  
  550.  
  551.  
  552.  

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