Télécharger la plaquette Cast3M


fr en

Télécharger separm.eso

Retour à la liste

Numérotation des lignes : 

separm

  1. C SEPARM    SOURCE    MB234859  24/10/30    21:15:05     12060          
  2.       SUBROUTINE SEPARM(MRIGID,RI1,RI2,NOUNIL,LAGDUA,NELIM,IF)
  3. C----------------------------------------------------------------------
  4. C  Distinguer dans le MRIGID les rigidites elementaires pouvant etre 
  5. C  eliminees et celles devant etre conservees.
  6. C  Les rigidites elementaires a eliminer, i.e. pouvant etre traitee 
  7. C  comme des dependances, sont regroupees dans RI1
  8. C  Les rigidites elementaires a conserver sont regroupees dans RI2
  9. C
  10. C  juillet 2003 passage aux simples multiplicateurs de Lagrange, mais
  11. C  separm dualise ceux qu'il garde
  12. C----------------------------------------------------------------------
  13.       IMPLICIT INTEGER(I-N)
  14.       IMPLICIT REAL*8 (A-H,O-Z)
  15.       integer oooval
  16. C
  17. -INC SMRIGID
  18. -INC SMCOORD
  19. -INC SMELEME
  20. -INC PPARAM
  21. -INC CCOPTIO
  22. -INC CCREEL
  23. *-INC CCHAMP
  24. C
  25.       segment trav1
  26.        character*(lochpo) compp(lcomp1)
  27.       endsegment
  28.       segment trav2
  29.        integer ielim(nbnoc,nbincp),iautr(nbnoc,nbincp)
  30.        integer icomb(nbnoc,nbincp),ideja(nbnoc,nbincp)
  31.       endsegment
  32. C     Remplir posinc pour accelerer les tests sur les composantes
  33.       segment trav3
  34.        integer posinc(nligrp)
  35.       endsegment
  36.       segment trav4
  37.        integer itrv1(nbprl)
  38.        integer itrv2(nbprl)
  39.        real*8 dtrv1(nbprl)
  40.        real*8 dtrv2(nbprl)
  41.       endsegment
  42.       segment trav5
  43.        integer idata(2,nligrp)
  44.       endsegment
  45.       segment icpr(nbpts)
  46.       segment itemp(ntemp)
  47.       character*(lochpo) co1
  48.       integer ri1p,ri1s,ri1f,ri2f
  49. C
  50. **     write(6,*) ' entree de separm '
  51. **     call ooodmp(0)
  52. **     nbav=oooval(2,1)
  53. *      write (6,*) ' dans separm nouinl ',nounil
  54. CC     write (6,*) ' matrice mrigid'
  55. CC     call prrigi(mrigid,0)
  56. CC     segact,mrigid
  57.       nbdep=0
  58.       nbpiv=0
  60.       nbpvt=0
  61.       iunil=0
  62. C     -----------------------------------------------------------------
  63. C     Distinguer ce qui peut etre elimine (ri4) et le reste (ri3)
  64. C     -----------------------------------------------------------------
  65.       nbno=nbpts
  66.       segini icpr
  67.       nbnoc=0
  68.       segact mrigid
  69.       nbrig=irigel(/2)
  70.       ntemp=nbrig
  71.       segini,itemp
  72.       nrige3=0
  73.       do 760 irig=1,nbrig
  74.         if (irigel(6,irig).ne.0) iunil=1
  75.         meleme=irigel(1,irig)
  76.         segact meleme
  77.         if ((itypel.ne.22.and.itypel.ne.28).or.
  78.      &      (irigel(7,irig).ne.0)) then
  79.           itemp(irig)=1
  80.           nrige3=nrige3+1
  81.         endif
  82. **      write(6,*) '1 itypel dans separm',itypel
  83.         do il=1,num(/2)
  84.           do ip=1,num(/1)
  85.             ipt=num(ip,il)
  86.             if (icpr(ipt).eq.0) then
  87.               nbnoc=nbnoc+1
  88.               icpr(ipt)=nbnoc
  89.             endif
  90.           enddo
  91.         enddo
  92.  760  continue
  93. C
  94.       nrigel=nrige3
  95.       segini,ri3
  96.       ri3.iforig=iforig
  97.       ri3.mtymat=mtymat
  98.       nrige4=nbrig-nrige3
  99.       nrigel=nrige4
  100.       segini,ri4
  101.       ri4.iforig=iforig
  102.       ri4.mtymat=mtymat
  103.       i3=0
  104.       i4=0
  105.       do 555 jj=1,nbrig
  106.         if (itemp(jj).eq.1) then
  107.           i3=i3+1
  108.           ii=i3
  109.           ri5=ri3
  110.         else
  111.           i4=i4+1
  112.           ii=i4
  113.           ri5=ri4
  114.         endif
  115.         ri5.coerig(ii)=coerig(jj)
  116.         do kk=1,8
  117.           ri5.irigel(kk,ii)=irigel(kk,jj)
  118.         enddo
  119.  555  continue
  120.       segsup,itemp
  121. C     -----------------------------------------------------------------
  122. C     Recuperer les noms de composantes (segment trav1)
  123. C     -----------------------------------------------------------------
  124.       lcomp1 = 50
  125.       segini trav1
  126.       nbincp=0
  127.       do 10 irig=1,nrige4
  128.         descr=ri4.irigel(3,irig)
  129.         segact descr
  130.         do 40 nligrp=2,lisinc(/2)
  131. C         print *,'lisinc(',nligrp,'/',lisinc(/2),')=',lisinc(nligrp)
  132.           do 50 inc=1,nbincp
  133.             if (compp(inc).eq.lisinc(nligrp)) goto 40
  134.   50      continue
  135.           nbincp=nbincp+1
  136.           if (nbincp.GT.lcomp1) then
  137.             lcomp1 = lcomp1 + 50
  138.             segadj trav1
  139.           endif
  140.           compp(nbincp)=lisinc(nligrp)
  141.   40    continue
  142.   10  continue
  143. C     -----------------------------------------------------------------
  144. C     Quelles inconnues peuvent etre eliminees?
  145. C     -----------------------------------------------------------------
  146. C     Interdit d'eliminer les inconnues apparaissant dans des conditions 
  147. C     unilaterales lorsque nounil = 0. Si nelim = 0, tout garder
  148.       segini,trav2
  149.       do 60 irig=1,nrige4
  150.         meleme=ri4.irigel(1,irig)
  151.         if (nelim.ne.0) then
  152.           if(itypel.ne.28) then
  153.             if (ri4.irigel(6,irig).eq.0.or.nounil.eq.1) goto 60
  154.           endif
  155.         endif
  156. C
  157. C       Super-elements : si trop gros ce n'est pas avantageux 
  158. C       d'eliminer. Dans ce cas, idnetifier ses noeuds et ddl pour ne 
  159. C       pas les eliminer.
  160.         if (itypel.ne.22.and.
  161.      >     (itypel.ne.28.or.num(/1).lt.255.or.if.lt.3)) goto 60
  162. C
  163.         descr=ri4.irigel(3,irig)
  164.         nld=2
  165.         if(itypel.eq.28) nld=1
  166. C
  167.         do 70 nligrp=nld,lisinc(/2)
  168.           do 80 inc=1,nbincp
  169. C            print *,'lisinc(',nligrp,'/',lisinc(/2),')=',lisinc(nligrp)
  170. C     &             ,'  compp(',inc,')=',compp(inc)
  171.             if (compp(inc).eq.lisinc(nligrp)) goto 90
  172.   80      continue
  173. ***       write(ioimp,*) '- ',lisinc(nligrp),' non trouve dans trav1'
  174.           goto 70
  175.   90      continue
  176. C
  177. C         La composante lisinc(nligrp) ne doit pas etre eliminee pour
  178. C         les noeuds num(ip,j)
  179.           ip=noelep(nligrp)
  180.           do 100 j=1,num(/2)
  181. C            IF(num(ip,j).GT.ielim(/1).OR.inc.GT.ielim(/2).OR.
  182. C     *         num(ip,j).GT.iautr(/1).OR.inc.GT.iautr(/2))THEN
  183. C               print *,'BUG DANS SEPARM : ',
  184. C     &                 num(ip,j),'>',ielim(/1),iautr(/1),
  185. C     &                 inc,'>',ielim(/2),iautr(/2)
  186. C            ENDIF
  187.             ielim(icpr(num(ip,j)),inc)=1
  188.             iautr(icpr(num(ip,j)),inc)=1
  189.  100      continue
  190.   70    continue
  191.   60  continue
  192. C     -----------------------------------------------------------------
  193. C     Nombre de conditions associees a chaque ddl de chaque noeud
  194. C     -----------------------------------------------------------------
  195.       do 700 irig=1,nrige4
  196.         if (ri4.irigel(6,irig).ne.0.and.nounil.eq.0) goto 700
  197.         meleme=ri4.irigel(1,irig)
  198.         if (itypel.ne.22) goto 700
  199.         descr=ri4.irigel(3,irig)
  200. C
  201.         nligrp=lisinc(/2)
  202.         segini trav3
  203.         do 730 inc=2,nligrp
  204.           do 720 incp=1,nbincp
  205.             if (lisinc(inc).eq.compp(incp)) then
  206.               posinc(inc)=incp
  207.               goto 730
  208.             endif
  209.   720     continue
  210.           call erreur(5)
  211.   730   continue
  212. C
  213.         do 750 ince=2,lisinc(/2)
  214.           incp=posinc(ince)
  215.           do 740 j=1,num(/2)
  216.             ip=num(noelep(ince),j)
  217.             icomb(icpr(ip),incp)=icomb(icpr(ip),incp)+1
  218.   740     continue
  219.   750   continue
  220.         segsup trav3
  221.   700 continue
  222.       ipass=1
  223. C
  224. C     -----------------------------------------------------------------
  225.  2000 CONTINUE
  226.       nrigel=0
  227.       segini,ri1
  228.       ri1.iforig=iforig
  229.       ri1.mtymat=mtymat
  230.       segini,ri2=ri4
  231. C
  232. C     Trier pour attaquer en premier les relations portant sur le moins
  233. C     d'inconnues
  234.       nbprl=ri4.irigel(/2)
  235.       segini trav4
  236.       do 765 irig=1,nbprl        
  237.         descr=ri4.irigel(3,irig)
  238.         dtrv1(irig)= lisinc(/2)+(irig/(nbprl+1.))
  239.         if(irigel(6,irig).ne.0) dtrv1(irig)=dtrv1(irig)+1000000
  240.         if(irigel(6,irig).eq.2) dtrv1(irig)=dtrv1(irig)+1000000
  241. **      if(irigel(6,irig).eq.0) dtrv1(irig)=dtrv1(irig)+1000000
  242. **      itrv1(irig)=nbprl-irig+1
  243.         itrv1(irig)=      irig   
  244. 765   continue
  245.       call triflo(dtrv1,dtrv2,itrv1,itrv2,nbprl)
  246. C
  247.       do 200 iri=1,nbprl
  248.         irig=itrv1(iri) 
  249. **      irig=iri   
  250. **      if (ipass.eq.1) irig=itrv1(iri)
  251.         if (ri4.irigel(6,irig).ne.0.and.nounil.eq.0) goto 190
  252.         meleme=ri4.irigel(1,irig)
  253.         if (itypel.ne.22) goto 190
  254.         Xmatri=ri4.irigel(4,irig)
  255.         segact Xmatri
  256.         if (abs(re(1,1,1)).gt.1d-30) goto 190
  257.         descr=ri4.irigel(3,irig)
  258. C
  259.         nligrp=lisinc(/2)
  260.         segini,trav3,trav5
  261.         do 230 inc=2,nligrp
  262.          do 220 incp=1,nbincp
  263.            if (lisinc(inc).eq.compp(incp)) then
  264.              posinc(inc)=incp
  265.              goto 230
  266.            endif
  267.  220     continue
  268.         call erreur(5)
  269.  230    continue
  270. C
  271.         segini,ipt8=meleme
  272.         nbdepe=0
  273.         do 210 j=1,num(/2)
  274. C
  275. C         Cette matrice elementaire contient elle des inconnues
  276.           if (noelep(/1).le.1) then
  277.             ipt8.num(1,j)=0
  278.             goto 210
  279.           endif
  280. C
  281. C         La matrice est elle augmentee
  282.           if (abs(re(1,1,j)).gt.1d-5) then
  283.             ipt8.num(1,j)=0
  284.             goto 210
  285.           endif
  286. C
  287. C         Cette matrice elementaire contient-elle une inco. eliminee
  288.           remax=abs(re(1,1,j))
  289.           do 240 inc=2,nligrp
  290.             incpp=posinc(inc)
  291.             ipp=ipt8.num(noelep(inc),j)
  292.             if (ielim(icpr(ipp),incpp).eq.1) then
  293.               ipt8.num(1,j)=0
  295.               goto 210
  296.             endif
  297.             remax=max(remax,abs(re(1,inc,j)))
  298.  240      continue
  299. C
  300. C         Choix du pivot
  301.           incf=0
  302.           remaz=remax*0.9
  303.           do 250 inc=2,nligrp
  304.             incpp=posinc(inc)
  305.             ipp=ipt8.num(noelep(inc),j)
  306.             if (iautr(icpr(ipp),incpp).eq.1) goto 250
  307.             if (abs(re(1,inc,j)).lt.remaz) goto 250
  308. *           if (icomb(icpr(ipp),incpp).eq.1) then
  309.               incf=inc
  310.               goto 260
  311. *           endif
  312.  250      continue
  313.  260      continue
  314.           ince=incf
  315.           if (incf.eq.0) ince=2
  316. C
  317. C         Traitement de l'inconnue incp du noeud ip
  318.           incp=posinc(ince)
  319.           ip=ipt8.num(noelep(ince),j)
  320. C
  321. C         Le pivot est il correct
  322.           remax=remax*1d-2
  323.           if (abs(re(1,ince,j)).le.remax) then
  324.             ipt8.num(1,j)=0
  325.             nbpiv=nbpiv+1
  326.             goto 210
  327.           endif
  328. C
  329. C         Cette inconnue apparait-elle dans d'autres CL
  330.           if (ipass.eq.1.and.icomb(icpr(ip),incp).ne.1) then
  331.             ipt8.num(1,j)=0
  333.             goto 210
  334.           endif
  335. C
  336. C         Cette inconnue apparait-elle dans une dependance
  337.           if (iautr(icpr(ip),incp).eq.1) then
  338.             ipt8.num(1,j)=0
  340.             goto 210
  341.           endif
  342. C
  343. C         Cette inconnue apparait-elle deux fois dans la relation
  344.           ideux=0
  345.           do inc=2,nligrp
  346.          if (ideja(icpr(ipt8.num(noelep(inc),j)),posinc(inc)).eq.1) then
  347.               ideux=inc
  348.             else
  349.               ideja(icpr(ipt8.num(noelep(inc),j)),posinc(inc))=1
  350.             endif
  351.           enddo
  352.           do inc=2,nligrp
  353.             ideja(icpr(ipt8.num(noelep(inc),j)),posinc(inc))=0
  354.           enddo
  355.           if (ideux.ne.0) then
  356.             moterr(1:4)=lisinc(ideux)
  357.             interr(1)=ipt8.num(noelep(ideux),j)
  358.             call erreur(-361)
  359.             ipt8.num(1,j)=0
  360.             goto 210
  361.           endif
  362. C
  363. C         Nouvelle dependance
  364.           nbdepe=nbdepe+1
  365.           nbdep=nbdep+1
  366. C         write (6,*) 'Elimination noeud,inco,posi',ip,lisinc(ince),ince
  367. C         Reperer l'inconnue eliminee et le noeud 
  368.           ipt8.num(1,j)=ince
  369.           idata(1,ince)=idata(1,ince)+1
  370.           ielim(icpr(ip),incp)=1
  371.           do 280 inc=2,nligrp
  372.             iautr(icpr(ipt8.num(noelep(inc),j)),posinc(inc))=1
  373.  280      continue
  374. C
  375.  210    continue
  376.         segsup trav3
  377. C
  378. C       Creation de ri1 et ri2 pour scinder la sous-matrice irig
  379. C       ---------------------------------------------------------------
  380. C       Dimensions communes a RI1 et RI2
  381.         nbnn=num(/1)
  382.         nbsous=0
  383.         nbref=0
  384.         nligrd=re(/1)
  385.         nligrp=re(/2)
  386. C
  387. C       Creation de RI2 : rigidites elementaires a conserver
  388.         nbelem=num(/2)-nbdepe
  389.         if (nbelem.gt.0) then
  390.           segini,ipt2
  391.           ipt2.itypel=itypel
  392.           nelrig=nbelem
  393.           segini,xmatr2
  394.           xmatr2.symre=symre
  395.           ri2.irigel(1,irig)=ipt2
  396.           ri2.irigel(3,irig)=descr
  397.           ri2.irigel(4,irig)=xmatr2
  398.           do iii=5,8
  399.             ri2.irigel(iii,irig)=ri4.irigel(iii,irig)
  400.           ENDDO
  401.           ri2.coerig(irig)=ri4.coerig(irig)
  402.         else
  403.           ri2.irigel(1,irig)=0
  404.           xmatr2=0
  405.         endif
  406. C
  407. C       Creation de RI1 : rigidites elementaires a eliminer. 
  408. C       L'inconnue a eliminer doit etre en 2eme position (apres LX)
  409. C       Si l'inconnue a eliminer n'est pas celle apparaissant en   
  410. C       deuxieme position il faut pivoter la rigidite elementaire 
  411. C       et le descripteur associe
  412.         ri1p=ri1
  413.         nrigel=0
  414.         do kkk=1,nligrp
  415.           if (idata(1,kkk).gt.0) nrigel=nrigel+1
  416.         enddo
  417.         nbpvt=nbpvt+nrigel
  418.         segini,ri1
  419.         ri1.iforig=iforig
  420.         ri1.mtymat=mtymat
  421.         icpt=0
  422.         do 25 jjj=1,nligrp
  423.           nelrig=idata(1,jjj)
  424. C         Nombre d'elements elimines en choisissant la jjjeme inconnue
  425.           if (nelrig.eq.0) goto 25
  426.           nbelem=nelrig
  427.           segini,ipt1
  428.           ipt1.itypel=itypel
  429.           segini,xmatr1
  430.           xmatr1.symre=symre
  431.           des1=descr
  432.           if (jjj.ne.2) then
  433.             segini,des1=descr
  434.             co1=des1.lisinc(2)
  435.             des1.lisinc(2)=des1.lisinc(jjj)
  436.             des1.lisinc(jjj)=co1
  437.             co1=des1.lisdua(2)
  438.             des1.lisdua(2)=des1.lisdua(jjj)
  439.             des1.lisdua(jjj)=co1
  440.             noe=des1.noelep(2)
  441.             des1.noelep(2)=des1.noelep(jjj)
  442.             des1.noelep(jjj)=noe
  443.             noe=des1.noeled(2)
  444.             des1.noeled(2)=des1.noeled(jjj)
  445.             des1.noeled(jjj)=noe
  446.           endif
  447. C
  448.           icpt=icpt+1
  449.           ri1.irigel(1,icpt)=ipt1
  450.           ri1.irigel(3,icpt)=des1
  451.           ri1.irigel(4,icpt)=xmatr1
  452.           do iii=5,7
  453.             ri1.irigel(iii,icpt)=ri4.irigel(iii,irig)
  454.           enddo
  455.           ri1.irigel(8,icpt)=1
  456.           ri1.coerig(icpt)=ri4.coerig(irig)
  457. C
  458. C         Compteur des elements et identifiant de la rigidite elem
  459.           idata(1,jjj)=1
  460.           idata(2,jjj)=icpt
  461.  25     continue
  462. C
  463. C       Remplir ri1 et ri2 en creant les xmatri/descr/maillages
  464. C       ---------------------------------------------------------------
  465.         idec=0
  466.         do 300 j=1,num(/2)
  467.           if (ipt8.num(1,j).eq.0) then
  468.             idec=idec+1
  469.             do 310 i=1,num(/1)
  470.              ipt2.num(i,idec)=num(i,j)
  471.  310        continue
  472.             do io=1,nligrp
  473.               do iu=1,nligrd
  474.                 xmatr2.re(iu,io,idec)=re(iu,io,j)
  475.               enddo
  476.             enddo
  477.           else
  478.             ince=ipt8.num(1,j)
  479.             iriel=idata(2,ince)
  480.             ipt1=ri1.irigel(1,iriel)
  481.             xmatr1=ri1.irigel(4,iriel)
  482.             ielt=idata(1,ince)
  483.             idata(1,ince)=idata(1,ince)+1
  484.             do 320 i=1,num(/1)
  485.               ipt1.num(i,ielt)=num(i,j)
  486.  320        continue
  487.             do io=1,nligrp
  488.               do iu=1,nligrd
  489.                 xmatr1.re(iu,io,ielt)=re(iu,io,j)
  490.               enddo
  491.             enddo
  492. C
  493. C           Pivoter les lignes/colonnes ince et 2
  494.             if (ince.ne.2) then
  495.               do 1130 il=1,nligrd
  496.                 ret=xmatr1.re(il,2,ielt)
  497.                 xmatr1.re(il,2,ielt)=xmatr1.re(il,ince,ielt)
  498.                 xmatr1.re(il,ince,ielt)=ret
  499.  1130         continue
  500.               do 1160 il=1,nligrp
  501.                 ret=xmatr1.re(2,il,ielt)
  502.                 xmatr1.re(2,il,ielt)=xmatr1.re(ince,il,ielt)
  503.                 xmatr1.re(ince,il,ielt)=ret
  504.  1160         continue
  505.             endif
  506. C
  507.           endif
  508.  300    continue
  509. C       ---------------------------------------------------------------
  510. C
  511.         call fusrig(ri1p,ri1,ri1f)
  512.         ri1=ri1f
  513.         if (xmatr2.ne.0) segdes,xmatr2
  514.         segsup,trav5
  515.         goto 200
  516. C
  517.  190    continue
  518. C
  519. C       Sous-matrice irig a conserver integralement
  520.         ri2.irigel(1,irig)=ri4.irigel(1,irig)
  521.         ri2.irigel(3,irig)=ri4.irigel(3,irig)
  522.         ri2.irigel(4,irig)=ri4.irigel(4,irig)
  523.         do iii=5,7
  524.           ri2.irigel(iii,irig)=ri4.irigel(iii,irig)
  525.         enddo
  526.         ri2.irigel(8,irig)=0
  527.         ri2.coerig(irig)=ri4.coerig(irig)
  528. C
  529.  200  continue
  530. C     -----------------------------------------------------------------
  531.       segsup trav4
  532. C
  533. C     Compression de ri2
  534.       idec=0
  535.       do 600 irig=1,nbprl
  536.         meleme=ri2.irigel(1,irig)
  537.         if (meleme.eq.0) then
  538.           idec=idec+1
  539.         else
  540.           do 610 ir=1,8
  541.            ri2.irigel(ir,irig-idec)=ri2.irigel(ir,irig)
  542.  610      continue
  543.           ri2.coerig(irig-idec)=ri2.coerig(irig)
  544.         endif
  545.  600  continue
  546.       nrigel=nbprl-idec
  547. C     write (6,*) ' dimension de ri2 ',nrigel
  548.       segadj,ri2
  549. C
  550. C     On va voir si on ne peut pas faire pivoter ri2
  551.       if (ipass.eq.2) goto 2001
  552.       ri1s=ri1
  553.       ri4=ri2
  554.       nbpiv=0
  556.       ipass=ipass+1
  557.       goto 2000
  558. C
  559.  2001 CONTINUE
  560. C     -----------------------------------------------------------------
  561. C
  562. C     RI1 : rigidites elementaires a eliminer
  563.       call fusrig(ri1s,ri1,ri1f)
  564.       ri1=ri1f
  565. C     RI2 : rigidites elementaires a conserver
  566.       call fusrig(ri3,ri2,ri2f)
  567.       ri2=ri2f
  568. C
  569.       segsup trav1,trav2,icpr
  570. C
  571.       if (iimpi.ne.0) then
  572.       write (6,*) ' nombre de relations eliminees',nbdep
  573.       write (6,*) ' nombre de relations gardees a cause du pivot',nbpiv
  574.       write (6,*) ' nombre de relations gardees car non independantes',
  576.       write (6,*) ' nombre de paquets pivotes',nbpvt
  577.       endif
  578. C
  579. C     -----------------------------------------------------------------
  580. C     Dualisation des multiplicateurs de Lagrange
  581. C     -----------------------------------------------------------------
  582. C     si on a des conditions unilaterales, on ne dualise pas, ce sera fait
  583. C     dans le resou de unilater
  584.       if ((iunil.eq.0.or.nounil.eq.1).and.lagdua.ge.0) then
  585.         call dbblx(ri2,lagdua)
  586.       endif
  587. C
  588. *     write(6,*) ' dans separm lagdua ',lagdua
  589. CC    write (6,*) ' matrice ri1 '
  590. CC    call prrigi(ri1,0)
  591. CC    write (6,*) ' matrice ri2 '
  592. CC    call prrigi(ri2,0)
  593. CC    segact,ri1,ri2
  594. CC    write(6,*) ' sortie de separm '
  595. **    call ooodmp(0)
  596. **    nbap=oooval(2,1)
  597. **    write(6,*) 'nb segmts dans separm avant apres ',nbav,nbap
  598.       END
  599.  
  600.  

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