C PRLIN3    SOURCE    GOUNAND   06/01/18    21:15:45     5293           
      SUBROUTINE PRLIN3(CGEOME,LGDISC,TABCPR,TABCDU,LERF,
     $     MYFALS,MYCOMS,
     $     TABGEO,TABVDC,TATRAV,
     $     IMPR,IRET)
      IMPLICIT REAL*8 (A-H,O-Z)
      IMPLICIT INTEGER (I-N)
C***********************************************************************
C NOM         : PRLIN3
C DESCRIPTION : Initialisations, tests et formatage des données et des
C               résultats pour nlin
C               base sur prls93
C     
C LANGAGE     : ESOPE
C AUTEUR      : Stéphane GOUNAND (CEA/DRN/DMT/SEMT/LTMF)
C               mél : gounand@semt2.smts.cea.fr
C***********************************************************************
C APPELES          :
C APPELE PAR       : PRLIN2
C***********************************************************************
C ENTREES            :
C SORTIES            :
C TRAVAIL            :
C     
C***********************************************************************
C VERSION    : v1, 10/05/2004, version initiale
C HISTORIQUE : v1, 10/05/2004, création
C HISTORIQUE :
C HISTORIQUE :
C***********************************************************************
C Prière de PRENDRE LE TEMPS de compléter les commentaires
C en cas de modification de ce sous-programme afin de faciliter
C la maintenance !
C***********************************************************************
-INC CCOPTIO
-INC SMELEME
      POINTEUR CGEOME.MELEME
-INC SMTABLE
      POINTEUR TABCPR.MTABLE
      POINTEUR TABCDU.MTABLE
      POINTEUR TABLC.MTABLE
      POINTEUR TAVAPR.MTABLE
      POINTEUR TAVADU.MTABLE
      POINTEUR TADAPR.MTABLE
      POINTEUR TADADU.MTABLE
      POINTEUR TAVDPD.MTABLE
      POINTEUR TACOPR.MTABLE
      POINTEUR TACODU.MTABLE
      POINTEUR TABCOF.MTABLE
      POINTEUR TABI.MTABLE
      POINTEUR TABJ.MTABLE
      POINTEUR TABK.MTABLE
-INC SMLMOTS
      POINTEUR MYLMOT.MLMOTS
-INC SMLENTI
      POINTEUR MYLENT.MLENTI
      POINTEUR LDAT.MLENTI
      POINTEUR LDAT3.MLENTI
      POINTEUR LCOF.MLENTI
      POINTEUR LCOF3.MLENTI
      POINTEUR POWCOF.MLENTI
      POINTEUR POWCO2.MLENTI
      POINTEUR KREP.MLENTI
* Segments à moi
CBEGININCLUDE SFALRF
      SEGMENT FALRF
      CHARACTER*(LNNFA) NOMFA
      INTEGER NUQUAF(NBLRF)
      POINTEUR ELEMF(NBLRF).ELREF
      ENDSEGMENT
      SEGMENT FALRFS
      POINTEUR LISFA(0).FALRF
      ENDSEGMENT
CENDINCLUDE SFALRF
      POINTEUR MYFALS.FALRFS
CBEGININCLUDE SLCOMP
      SEGMENT COMP
      CHARACTER*8 NOMCOM
      INTEGER DERCOF(NCOCOF)
      LOGICAL LTREF
      ENDSEGMENT
      SEGMENT COMPS
      POINTEUR LISCOM(NBCOMP).COMP
      ENDSEGMENT
CENDINCLUDE SLCOMP
      POINTEUR MYCOMS.COMPS
      POINTEUR MYCOM.COMP
-INC SMCHPOI
      POINTEUR MYCHPO.MCHPOI
CBEGININCLUDE SMCHAEL
      SEGMENT MCHAEL
      POINTEUR IMACHE(N1).MELEME
      POINTEUR ICHEVA(N1).MCHEVA
      ENDSEGMENT
      SEGMENT MCHEVA
      REAL*8 VELCHE(NBLIG,NBCOL,N2LIG,N2COL,NBPOI,NBELM)
      ENDSEGMENT
      SEGMENT LCHEVA
      POINTEUR LISCHE(NBCHE).MCHEVA
      ENDSEGMENT
CENDINCLUDE SMCHAEL
      POINTEUR ICOOR.MCHAEL
      POINTEUR MYMCHA.MCHAEL
CBEGININCLUDE SMPOUET
      SEGMENT TABGEO
      CHARACTER*4 DISGEO
      POINTEUR IGEO.MCHAEL
      ENDSEGMENT
      SEGMENT TABVDC
      INTEGER VVARPR(NUMVPR)
      INTEGER VVARDU(NUMVDU)
      INTEGER VDATPR(NUMDPR)
      INTEGER VDATDU(NUMDDU)
      INTEGER VCOFPR(NUMCPR)
      INTEGER VCOFDU(NUMCDU)
      INTEGER ILCPR(NUMDER+1,NUMOP,NUMVPR)
      INTEGER ILCDU(NUMDER+1,NUMOP,NUMVDU)
      POINTEUR VLCOF(JLCOF).MLENTI
      POINTEUR VCOMP(JGCOF).COMP
      POINTEUR VLDAT(JGCOF).MLENTI
      INTEGER  DJSVD(JGVD)
      POINTEUR NOMVD(JGVD).MLMOTS
      POINTEUR MVD(JGVD).MCHPOI
      REAL*8 XVD(JGVD)
      CHARACTER*4 DISVD(KGVD)
      ENDSEGMENT
      SEGMENT TATRAV
      POINTEUR VVCOF(JLCOF).MCHEVA
      POINTEUR VCOF(JGCOF).MCHEVA
      POINTEUR IVD(JGVD).MCHAEL
      POINTEUR VD(JGVD).MCHEVA
      POINTEUR DVD(JGVD).MCHEVA
      POINTEUR FFVD(KGVD).MCHEVA
      POINTEUR DFFVD(KGVD).MCHEVA
      LOGICAL LVCOF(JGCOF)
      LOGICAL LVD(JGVD)
      LOGICAL LDVD(JGVD)
      LOGICAL LFFVD(KGVD)
      LOGICAL LDFFVD(KGVD)
      ENDSEGMENT
      SEGMENT TABMAT
      POINTEUR VMAT(NUMVDU,NUMVPR).MCHAEL
      ENDSEGMENT
CENDINCLUDE SMPOUET
      INTEGER NUMOP,NUMDER,NUMVPR,NUMVDU
      INTEGER NUMOP2,NUMDE2
      INTEGER JGVC,KGVC
*     
      INTEGER IMPR,IRET
*     
      CHARACTER*4 LGDISC
      CHARACTER*4 MYDISC
      CHARACTER*8 CNCOM
      REAL*8 MYREAL
      CHARACTER*8 TYP0,TYP1,TYP2,BLAN,TYPE
      CHARACTER*8 TYTABL,TYLMOT,TYCHPO,TYMOT,TYENT,TYFLO,TYLENT
*     
      INTEGER IBID,IVAL,IOBJ
      REAL*8 XBID,XVAL
      CHARACTER*8 CBID,CVD,CPD
      LOGICAL LBID
      INTEGER IOP,JVARPR,JVARDU,KDER
      INTEGER IJVC,IKGVD
      INTEGER LNMOTS
      LOGICAL LFOUND,LEGDAT,LEGCOF
      INTEGER LERF
*     
* Executable statements
*     
      IF (IMPR.GT.1) WRITE(IOIMP,*) 'Entrée dans prlin3'
      BLAN='        '
      TYTABL='TABLE   '
      TYLMOT='LISTMOTS'
      TYLENT='LISTENTI'
      TYCHPO='CHPOINT '
      TYMOT ='MOT     '
      TYENT ='ENTIER  '
      TYFLO ='FLOTTANT'
* Récupération des dimensions
      CALL ACME(TABCPR,'NUMDER',NUMDER)
      IF (IERR.NE.0) GOTO 9999
*     
* Si les dérivées se font sur les éléments de référence, il
* faut vérifier que tous les éléments de CGEOME
* sont de la meme dimension et avoir sa valeur
*     
      IF (LERF.NE.0) THEN
         CALL DIMESH(CGEOME,IDMESH,IMPR,IRET)
         IF (IRET.NE.0) GOTO 9999
         IESDER=IDMESH
      ELSE
         IESDER=IDIM 
      ENDIF
*     
      IF (NUMDER.NE.IESDER) THEN
         WRITE(IOIMP,*) 'NUMDER=',NUMDER,' incorrect'
         GOTO 9999
      ENDIF
      CALL ACME(TABCPR,'NUMOP',NUMOP)
      IF (IERR.NE.0) GOTO 9999
      CALL ACME(TABCPR,'NUMVAR',NUMVPR)
      IF (IERR.NE.0) GOTO 9999
      CALL ACME(TABCPR,'NUMDAT',NUMDPR)
      IF (IERR.NE.0) GOTO 9999
      CALL ACME(TABCPR,'NUMCOF',NUMCPR)
      IF (IERR.NE.0) GOTO 9999
*     
      CALL ACME(TABCDU,'NUMDER',NUMDE2)
      IF (IERR.NE.0) GOTO 9999
      IF (NUMDE2.NE.IESDER) THEN
         WRITE(IOIMP,*) 'NUMDE2=',NUMDE2,' incorrect'
         GOTO 9999
      ENDIF
      CALL ACME(TABCDU,'NUMOP',NUMOP2)
      IF (IERR.NE.0) GOTO 9999
      IF (NUMOP2.NE.NUMOP) THEN
         WRITE(IOIMP,*) 'NUMOP2.NE.NUMOP'
         GOTO 9999
      ENDIF
      CALL ACME(TABCDU,'NUMVAR',NUMVDU)
      IF (IERR.NE.0) GOTO 9999
      CALL ACME(TABCDU,'NUMDAT',NUMDDU)
      IF (IERR.NE.0) GOTO 9999
      CALL ACME(TABCDU,'NUMCOF',NUMCDU)
      IF (IERR.NE.0) GOTO 9999
*     
      CALL ACMO(TABCPR,'VAR',TYTABL,TAVAPR)
      IF (IERR.NE.0) GOTO 9999
      CALL ACMO(TABCDU,'VAR',TYTABL,TAVADU)
      IF (IERR.NE.0) GOTO 9999
      CALL ACMO(TABCPR,'DAT',TYTABL,TADAPR)
      IF (IERR.NE.0) GOTO 9999
      CALL ACMO(TABCDU,'DAT',TYTABL,TADADU)
      IF (IERR.NE.0) GOTO 9999
      CALL ACMO(TABCPR,'COF',TYTABL,TACOPR)
      IF (IERR.NE.0) GOTO 9999
      CALL ACMO(TABCDU,'COF',TYTABL,TACODU)
      IF (IERR.NE.0) GOTO 9999
* Initialisation du gros objet de données
      SEGINI,TABGEO
      JLCOF=(NUMDER+1)*NUMOP*(NUMVPR+NUMVDU)
      JGCOF=NUMCPR+NUMCDU
      JGVD=NUMVPR+NUMVDU+NUMDPR+NUMDDU
      KGVD=JGVD
      IJLCOF=0
      IJGCOF=0
      IJGVD=0
      IKGVD=0
      SEGINI,TABVDC
*   géométrie
      LNMOTS=LEN(LGDISC)
      IF (LNMOTS.NE.4) THEN
         WRITE(IOIMP,*) 'Erreur esp. discr. geometrie'
         GOTO 9999
      ENDIF
      TABGEO.DISGEO=LGDISC
* Pointeur bidon négatif
      IPBID=0
*     
* Lecture des variables et des données primales et duales
*     
      DO IVADA=1,2
         DO IPRDU=1,2
            IF (IVADA.EQ.1) THEN
               CVD='VARIABLE'
               IF (IPRDU.EQ.1) THEN
                  NUMVAR=NUMVPR
                  CPD='PRIMAL  '
               ELSE
                  NUMVAR=NUMVDU
                  CPD='DUAL    '
               ENDIF
            ELSE
               CVD='DATA    '
               IF (IPRDU.EQ.1) THEN
                  NUMVAR=NUMDPR
                  CPD='PRIMAL  '
               ELSE
                  NUMVAR=NUMDDU
                  CPD='DUAL    '
               ENDIF
            ENDIF
*     
            DO JVAR=1,NUMVAR
               IJGVD=IJGVD+1
               IKGVD=IKGVD+1
               IF (IVADA.EQ.1) THEN
                  IF (IPRDU.EQ.1) THEN
                     TABVDC.VVARPR(JVAR)=IJGVD
                     TAVDPD=TAVAPR
                  ELSE
                     TABVDC.VVARDU(JVAR)=IJGVD
                     TAVDPD=TAVADU
                  ENDIF
               ELSE
                  IF (IPRDU.EQ.1) THEN
                     TABVDC.VDATPR(JVAR)=IJGVD
                     TAVDPD=TADAPR
                  ELSE
                     TABVDC.VDATDU(JVAR)=IJGVD
                     TAVDPD=TADADU
                  ENDIF
               ENDIF
               TYPE=TYTABL
               CALL ACCTAB(TAVDPD,'ENTIER',JVAR,XBID,CBID,LBID,IBID,
     $              TYPE,IBID,XBID,CBID,LBID,TABJ)
               IF (IERR.NE.0) GOTO 9999
**    
               TYPE=TYMOT
               CALL ACCTAB(TABJ,'MOT',IBID,XBID,'DISC',LBID,IBID,
     $              TYPE,IBID,XBID,MYDISC,LBID,IBID)
               IF (IERR.NE.0) GOTO 9999
               TABVDC.DISVD(IKGVD)=MYDISC
               TABVDC.DJSVD(IJGVD)=IKGVD
*     
               TYPE=TYLMOT
               CALL ACCTAB(TABJ,'MOT',IBID,XBID,'NOMDDL',LBID,IBID,
     $              TYPE,IBID,XBID,CBID,LBID,MYLMOT)
               IF (IERR.NE.0) GOTO 9999
               TABVDC.NOMVD(IJGVD)=MYLMOT
*     
               TYPE=BLAN
               CALL ACCTAB(TABJ,'MOT',IBID,XBID,'VALEUR',LBID,IBID,
     $              TYPE,IVAL,XVAL,CBID,LBID,IOBJ)
* Seules les variables sont autorisées à ne pas avoir de valeur.
               IF ((TYPE.EQ.BLAN).AND.(IVADA.EQ.1)) THEN
                  TABVDC.MVD(IJGVD)=0
                  TABVDC.XVD(IJGVD)=0.D0
               ELSEIF (TYPE.EQ.TYCHPO) THEN
                  TABVDC.MVD(IJGVD)=IOBJ
                  TABVDC.XVD(IJGVD)=0.D0
               ELSEIF (TYPE.EQ.TYENT) THEN
                  IPBID=IPBID-1
                  TABVDC.MVD(IJGVD)=IPBID
                  TABVDC.XVD(IJGVD)=DBLE(IVAL)
               ELSEIF (TYPE.EQ.TYFLO) THEN
                  IPBID=IPBID-1
                  TABVDC.MVD(IJGVD)=IPBID
                  TABVDC.XVD(IJGVD)=XVAL
               ELSE
                  WRITE(IOIMP,*) CPD,' ',CVD,' number ',JVAR
                  WRITE(IOIMP,*) 'wrong type = ',TYPE
                  WRITE(IOIMP,*) 'should be = ',TYENT, ' or '
     $                 ,TYFLO, ' or ',TYCHPO
                  GOTO 9999
               ENDIF
            ENDDO
         ENDDO
      ENDDO
*     
      JGVD=IJGVD
      KGVD=IKGVD
      SEGADJ,TABVDC
*     
* Lecture des coefficients primaux et duaux
*     
      SEGACT MYCOMS
      CVD='COEFF.  '
      DO IPRDU=1,2
         IF (IPRDU.EQ.1) THEN
            NUMCOF=NUMCPR
            NUMDAT=NUMDPR
            CPD='PRIMAL  '
         ELSE
            NUMCOF=NUMCDU
            NUMDAT=NUMDDU
            CPD='DUAL    '
         ENDIF
         DO JCOF=1,NUMCOF
            IJGCOF=IJGCOF+1
            IF (IPRDU.EQ.1) THEN
               TABVDC.VCOFPR(JCOF)=IJGCOF
               TABCOF=TACOPR
            ELSE
               TABVDC.VCOFDU(JCOF)=IJGCOF
               TABCOF=TACODU
            ENDIF
            TYPE=TYTABL
            CALL ACCTAB(TABCOF,'ENTIER',JCOF,XBID,CBID,LBID,IBID,
     $           TYPE,IBID,XBID,CBID,LBID,TABJ)
            IF (IERR.NE.0) GOTO 9999
**    
            TYP0=BLAN
            CALL ACCTAB(TABJ,'MOT',IBID,XBID,'COMPOR',LBID,IBID,
     $           TYP0,IBID,XBID,CNCOM,LBID,IBID)
            IF (IERR.NE.0) GOTO 9999
*     
            TYP1=BLAN
            CALL ACCTAB(TABJ,'MOT',IBID,XBID,'LDAT',LBID,IBID,
     $           TYP1,IBID,XBID,CBID,LBID,MYLENT)
            IF (IERR.NE.0) GOTO 9999
*     
C            TYP2=BLAN
C            CALL ACCTAB(TABJ,'MOT',IBID,XBID,'FACMUL',LBID,IBID,
C     $           TYP2,IVAL,XVAL,CBID,LBID,IBID)
            IF (.NOT.(TYP0.EQ.BLAN)) THEN
               IF (TYP0.EQ.TYMOT) THEN
                  CALL FICOMP(CNCOM,MYCOMS,MYCOM,IMPR,IRET)
                  IF (IRET.NE.0) GOTO 9999
                  SEGACT MYCOM 
                  NCOCO1=MYCOM.DERCOF(/1)
                  SEGDES MYCOM
                  TABVDC.VCOMP(IJGCOF)=MYCOM
               ELSE
                  WRITE(IOIMP,*) CPD,' ',CVD,' number ',JCOF,' . COMPOR'
     $                 
                  WRITE(IOIMP,*) 'wrong type = ',TYP0
                  WRITE(IOIMP,*) 'should be  = ',TYMOT
                  GOTO 9999
               ENDIF
               IF (TYP1.EQ.BLAN) THEN
                  JG=0
                  SEGINI MYLENT
                  SEGDES MYLENT
                  TYP1=TYLENT
               ENDIF
               IF (TYP1.EQ.TYLENT) THEN
                  SEGACT MYLENT
                  NCOCO2=MYLENT.LECT(/1)
                  JG=NCOCO2
                  SEGINI LDAT
                  LBID=.TRUE.
                  DO ICOCO2=1,NCOCO2
                     IBID=MYLENT.LECT(ICOCO2)
                     IF (IBID.LT.1.OR.IBID.GT.NUMDAT) LBID=.FALSE.
                     IF (IPRDU.EQ.1) THEN
                        LDAT.LECT(ICOCO2)=TABVDC.VDATPR(IBID)
                     ELSE
                        LDAT.LECT(ICOCO2)=TABVDC.VDATDU(IBID)
                     ENDIF
                  ENDDO
                  SEGDES MYLENT
                  SEGDES LDAT
                  IF (.NOT.NCOCO1.EQ.NCOCO2) THEN 
                     WRITE(IOIMP,*) CPD,' ',CVD,' number ',JCOF
     $                    ,' . LDAT' 
                     WRITE(IOIMP,*) 'wrong length = ',NCOCO2
                     WRITE(IOIMP,*) 'should be    = ',NCOCO1
                     GOTO 9999
                  ENDIF
                  IF (.NOT.LBID) THEN
                     WRITE(IOIMP,*) CPD,' ',CVD,' number ',JCOF
     $                    ,' . LDAT' 
                     WRITE(IOIMP,*) 'some values out of range [1,',
     $                    NUMDAT,']'
                     SEGPRT,MYLENT
                     GOTO 9999
                  ENDIF
                  TABVDC.VLDAT(IJGCOF)=LDAT
               ELSE
                  WRITE(IOIMP,*) CPD,' ',CVD,' number ',JCOF
     $                 ,' . LDAT' 
                  WRITE(IOIMP,*) 'wrong type = ',TYP1
                  WRITE(IOIMP,*) 'should be  = ',TYLENT
                  GOTO 9999
               ENDIF
C               IF (TYP2.EQ.TYENT) THEN
C                  XCOF=DBLE(IVAL)
C               ELSEIF (TYP2.EQ.TYFLO) THEN
C                  XCOF=XVAL
C               ELSEIF (TYP2.EQ.BLAN) THEN
C                  XCOF=1.D0
C               ELSE
C                  WRITE(IOIMP,*) CPD,' ',CVD,' number ',JCOF
C     $                 ,' . FACMUL'
C                  WRITE(IOIMP,*) 'wrong type = ',TYP2
C                  WRITE(IOIMP,*) 'should be = ',TYENT, ' or ',TYFLO
C                  GOTO 9999
C               ENDIF
C               IF (IPRDU.EQ.1) THEN
C                  TABVDC.XCOFPR(JCOF)=XCOF
C               ELSE
C                  TABVDC.XCOFDU(JCOF)=XCOF
C               ENDIF
            ENDIF
         ENDDO
      ENDDO
      SEGDES MYCOMS
      JGCOF=IJGCOF
      SEGADJ,TABVDC
*     
* Lecture des listes de coefficients (pour la table primale et
* et la table duale)
*     
      CVD='LISTCOEF'
      DO IPRDU=1,2
         IF (IPRDU.EQ.1) THEN
            NUMVAR=NUMVPR
            TABLC=TABCPR
            CPD='PRIMAL  '
         ELSE
            NUMVAR=NUMVDU
            TABLC=TABCDU
            CPD='DUAL    '
         ENDIF
         DO IOP=1,NUMOP
            TYPE=TYTABL
            CALL ACCTAB(TABLC,'ENTIER',IOP,XBID,CBID,LBID,IBID,
     $           TYPE,IBID,XBID,CBID,LBID,TABI)
            IF (IERR.NE.0) GOTO 9999
            DO JVAR=1,NUMVAR
               TYPE=TYTABL
               CALL ACCTAB(TABI,'ENTIER',JVAR,XBID,CBID,LBID,IBID,
     $              TYPE,IBID,XBID,CBID,LBID,TABJ)
               DO KDER=0,NUMDER
                  TYPE=BLAN
                  CALL ACCTAB(TABJ,'ENTIER',KDER,XBID,CBID,LBID,IBID,
     $                 TYPE,IBID,XBID,CBID,LBID,MYLENT)
**    
                  IF (.NOT.(TYPE.EQ.BLAN)) THEN
                     IF (TYPE.EQ.TYLENT) THEN
                        IJLCOF=IJLCOF+1
                        SEGACT MYLENT
                        NLCOF=MYLENT.LECT(/1)
                        JG=JGCOF
                        SEGINI POWCOF
                        DO ILCOF=1,NLCOF
                           INUC=MYLENT.LECT(ILCOF)
                           IAINUC=ABS(INUC)
                           IF (IPRDU.EQ.1) THEN
                              IF ((IAINUC.LE.0).OR.(IAINUC.GT.NUMCPR)) 
     $                             THEN
                                 WRITE(IOIMP,*) CPD,' ',CVD,' operator '
     $                                ,IOP
                                 WRITE(IOIMP,*) 'variable ',JVAR,
     $                                ' derivative ',KDER
                                 WRITE(IOIMP,*)
     $                                'some values out of range [1,'
     $                                ,NUMCPR,']U[-',NUMCPR,',-1]'
                                 SEGPRT,MYLENT
                                 GOTO 9999
                              ENDIF
                              IGCOF=TABVDC.VCOFPR(IAINUC)
                           ELSE
                              IF ((IAINUC.LE.0).OR.(IAINUC.GT.NUMCDU)) 
     $                             THEN
                                 WRITE(IOIMP,*) CPD,' ',CVD,' operator '
     $                                ,IOP
                                 WRITE(IOIMP,*) 'variable ',JVAR,
     $                                ' derivative ',KDER
                                 WRITE(IOIMP,*)
     $                                'some values out of range [1,'
     $                                ,NUMCDU,']',']U[-',NUMCDU,',-1]'
                                 SEGPRT,MYLENT
                                 GOTO 9999
                              ENDIF
                              IGCOF=TABVDC.VCOFDU(IAINUC)
                           ENDIF
                           IF (INUC.GT.0) THEN
                              POWCOF.LECT(IGCOF)=POWCOF.LECT(IGCOF)+1
                           ELSEIF(INUC.LT.0) THEN
                              POWCOF.LECT(IGCOF)=POWCOF.LECT(IGCOF)-1
                           ELSE
                              WRITE(IOIMP,*) 'Programming error 1' 
                              GOTO 9999
                           ENDIF
                        ENDDO
                        SEGDES MYLENT
                        SEGDES POWCOF
                        TABVDC.VLCOF(IJLCOF)=POWCOF
                        IF (IPRDU.EQ.1) THEN
                           TABVDC.ILCPR(KDER+1,IOP,JVAR)=IJLCOF
                        ELSE
                           TABVDC.ILCDU(KDER+1,IOP,JVAR)=IJLCOF
                        ENDIF
                     ELSE
                        WRITE(IOIMP,*) CPD,' ',CVD,' operator ',IOP
                        WRITE(IOIMP,*) 'variable ',JVAR,
     $                       ' derivative ',KDER
                        WRITE(IOIMP,*) 'wrong type = ',TYPE
                        WRITE(IOIMP,*) 'should be = ',TYLENT
                        GOTO 9999
                     ENDIF
                  ELSE
                     IF (IPRDU.EQ.1) THEN
                        TABVDC.ILCPR(KDER+1,IOP,JVAR)=0
                     ELSE
                        TABVDC.ILCDU(KDER+1,IOP,JVAR)=0
                     ENDIF
                  ENDIF
               ENDDO
            ENDDO
         ENDDO
      ENDDO
      JLCOF=IJLCOF
      SEGADJ,TABVDC
*     
* On supprime les doublons dans les listes d'espaces de discrétisation
* et on corrige les pointeurs sur cette liste
*     
      JG=KGVD
      JG=KGVD
      SEGINI KREP
      IKGVD2=1
      KREP.LECT(1)=IKGVD2
      DO IKGVD=2,KGVD
         LFOUND=.FALSE.
         IKGVD3=0
 12      CONTINUE
         IKGVD3=IKGVD3+1
         IF (TABVDC.DISVD(IKGVD3).EQ.TABVDC.DISVD(IKGVD)) THEN
            LFOUND=.TRUE.
         ELSE
            IF (IKGVD3.LT.IKGVD2) THEN
               GOTO 12
            ENDIF
         ENDIF
         IF (.NOT.LFOUND) THEN
            IKGVD2=IKGVD2+1
            KREP.LECT(IKGVD)=IKGVD2
            TABVDC.DISVD(IKGVD2)=TABVDC.DISVD(IKGVD)
         ELSE
            KREP.LECT(IKGVD)=IKGVD3
         ENDIF
      ENDDO
      KGVD=IKGVD2
      SEGADJ,TABVDC
*     
      DO IJGVD=1,JGVD
         TABVDC.DJSVD(IJGVD)=KREP.LECT(TABVDC.DJSVD(IJGVD))
      ENDDO
      SEGSUP KREP
*     
* On supprime les doublons dans les listes d'espaces de champs
* et on corrige les pointeurs sur cette liste
*     
      JG=JGVD
      SEGINI KREP
      IJGVD2=1
      KREP.LECT(1)=IJGVD2
      DO IJGVD=2,JGVD
         LFOUND=.FALSE.
         IJGVD3=0
 22      CONTINUE
         IJGVD3=IJGVD3+1
         IF (TABVDC.DJSVD(IJGVD3).EQ.TABVDC.DJSVD(IJGVD)
     $        .AND.TABVDC.NOMVD(IJGVD3).EQ.TABVDC.NOMVD(IJGVD)
     $        .AND.TABVDC.MVD(IJGVD3).EQ.TABVDC.MVD(IJGVD)
     $        ) THEN
            LFOUND=.TRUE.
         ELSE
            IF (IJGVD3.LT.IJGVD2) THEN
               GOTO 22
            ENDIF
         ENDIF
         IF (.NOT.LFOUND) THEN
            IJGVD2=IJGVD2+1
            KREP.LECT(IJGVD)=IJGVD2
            TABVDC.DJSVD(IJGVD2)=TABVDC.DJSVD(IJGVD)
            TABVDC.NOMVD(IJGVD2)=TABVDC.NOMVD(IJGVD)
            TABVDC.MVD(IJGVD2)=TABVDC.MVD(IJGVD)
            TABVDC.XVD(IJGVD2)=TABVDC.XVD(IJGVD)
         ELSE
            KREP.LECT(IJGVD)=IJGVD3
         ENDIF
      ENDDO
      JGVD=IJGVD2
      SEGADJ,TABVDC
*     
      DO JVARPR=1,NUMVPR
         TABVDC.VVARPR(JVARPR)=KREP.LECT(TABVDC.VVARPR(JVARPR))
      ENDDO
      DO JVARDU=1,NUMVDU
         TABVDC.VVARDU(JVARDU)=KREP.LECT(TABVDC.VVARDU(JVARDU))
      ENDDO
      DO JDATPR=1,NUMDPR
         TABVDC.VDATPR(JDATPR)=KREP.LECT(TABVDC.VDATPR(JDATPR))
      ENDDO
      DO JDATDU=1,NUMDDU
         TABVDC.VDATDU(JDATDU)=KREP.LECT(TABVDC.VDATDU(JDATDU))
      ENDDO
      DO IJGCOF=1,JGCOF
         LDAT=TABVDC.VLDAT(IJGCOF)
         SEGACT LDAT*MOD
         NLDAT=LDAT.LECT(/1)
         DO ILDAT=1,NLDAT
            LDAT.LECT(ILDAT)=KREP.LECT(LDAT.LECT(ILDAT))
         ENDDO
         SEGDES LDAT
      ENDDO
      SEGSUP KREP
* On supprime les doublons dans les coefficients
* et on corrige les pointeurs sur cette liste
      IF (JGCOF.GT.1) THEN
         JG=JGCOF
         SEGINI KREP
         IJGCO2=1
         KREP.LECT(1)=IJGCO2
         DO IJGCOF=2,JGCOF
            LFOUND=.FALSE.
            LDAT=TABVDC.VLDAT(IJGCOF)
            IJGCO3=0
 32         CONTINUE
            IJGCO3=IJGCO3+1
            IF (TABVDC.VCOMP(IJGCO3).EQ.TABVDC.VCOMP(IJGCOF)) THEN
               LDAT3=TABVDC.VLDAT(IJGCO3)
               CALL EGLENT(LDAT3,LDAT,LEGDAT,IMPR,IRET)
               IF (IRET.NE.0) GOTO 9999
               IF (LEGDAT) THEN
                  LFOUND=.TRUE.
               ENDIF
            ELSE
               IF (IJGCO3.LT.IJGCO2) THEN
                  GOTO 32
               ENDIF
            ENDIF
            IF (.NOT.LFOUND) THEN
               IJGCO2=IJGCO2+1
               KREP.LECT(IJGCOF)=IJGCO2
               TABVDC.VCOMP(IJGCO2)=TABVDC.VCOMP(IJGCOF)
C Je ne suis pas arrivé à savoir quand il faut supprimmer les segments
C               LDAT=TABVDC.VLDAT(IJGCO2)
C*               SEGACT LDAT*MOD
C               SEGSUP LDAT
               TABVDC.VLDAT(IJGCO2)=TABVDC.VLDAT(IJGCOF)
            ELSE
               KREP.LECT(IJGCOF)=IJGCO3
C               LDAT=TABVDC.VLDAT(IJGCO3)
C*               SEGACT LDAT*MOD
C               SEGSUP LDAT
            ENDIF
         ENDDO
C         DO IJGCOF=IJGCO2+1,JGCOF
C            LDAT=TABVDC.VLDAT(IJGCOF)
C*         SEGACT LDAT*MOD
C            SEGSUP LDAT
C         ENDDO
         JGCOF=IJGCO2
         SEGADJ,TABVDC
*     
         DO JCOFPR=1,NUMCPR
            TABVDC.VCOFPR(JCOFPR)=KREP.LECT(TABVDC.VCOFPR(JCOFPR))
         ENDDO
         DO JCOFDU=1,NUMCDU
            TABVDC.VCOFDU(JCOFDU)=KREP.LECT(TABVDC.VCOFDU(JCOFDU))
         ENDDO
*     
         DO IJLCOF=1,JLCOF
            POWCOF=TABVDC.VLCOF(IJLCOF)
            SEGACT POWCOF
            JG=JGCOF
            SEGINI POWCO2
            DO IPC=1,POWCOF.LECT(/1)
               IPC2=KREP.LECT(IPC)
               POWCO2.LECT(IPC2)=POWCO2.LECT(IPC2)+POWCOF.LECT(IPC)
            ENDDO
            SEGDES POWCO2
            SEGSUP POWCOF
            TABVDC.VLCOF(IJLCOF)=POWCO2
         ENDDO
         SEGSUP KREP
      ENDIF

* On supprime les doublons dans les listes de coefficients
* et on corrige les pointeurs sur cette liste
      IF (JLCOF.GT.1) THEN
         JG=JLCOF
         SEGINI KREP
         IJLCO2=1
         KREP.LECT(1)=IJLCO2
         DO IJLCOF=2,JLCOF
            LFOUND=.FALSE.
            LCOF=TABVDC.VLCOF(IJLCOF)
            IJLCO3=0
 42         CONTINUE
            IJLCO3=IJLCO3+1
            LCOF3=TABVDC.VLCOF(IJLCO3)
            CALL EGLENT(LCOF3,LCOF,LEGCOF,IMPR,IRET)
            IF (LEGCOF) THEN
               LFOUND=.TRUE.
            ELSE
               IF (IJLCO3.LT.IJLCO2) THEN
                  GOTO 42
               ENDIF
            ENDIF
            IF (.NOT.LFOUND) THEN
               IJLCO2=IJLCO2+1
               KREP.LECT(IJLCOF)=IJLCO2
C Je ne suis pas arrivé à savoir quand il faut supprimmer les segments
C               LCOF=TABVDC.VLCOF(IJLCO2)
C*               SEGACT LCOF*MOD
C               SEGSUP LCOF
               TABVDC.VLCOF(IJLCO2)=TABVDC.VLCOF(IJLCOF)
            ELSE
               KREP.LECT(IJLCOF)=IJLCO3
C               LCOF=TABVDC.VLCOF(IJLCO3)
C*               SEGACT LCOF*MOD
C               SEGSUP LCOF
            ENDIF
         ENDDO
C         DO IJLCOF=IJLCO2+1,JLCOF
C            LCOF=TABVDC.VLCOF(IJLCOF)
C*         SEGACT LCOF*MOD
C            SEGSUP LCOF
C         ENDDO
         JLCOF=IJLCO2
         SEGADJ,TABVDC
*     
         DO IOP=1,NUMOP
            DO IDER=1,NUMDER+1
               DO JVARPR=1,NUMVPR
                  IJLCOF=TABVDC.ILCPR(IDER,IOP,JVARPR)
                  IF (IJLCOF.NE.0) THEN
                     TABVDC.ILCPR(IDER,IOP,JVARPR)=
     $                    KREP.LECT(IJLCOF)
                  ENDIF
               ENDDO
               DO JVARDU=1,NUMVDU
                  IJLCOF=TABVDC.ILCDU(IDER,IOP,JVARDU)
                  IF (IJLCOF.NE.0) THEN
                     TABVDC.ILCDU(IDER,IOP,JVARDU)=
     $                    KREP.LECT(IJLCOF)
                  ENDIF
               ENDDO
            ENDDO
         ENDDO
         SEGSUP KREP
      ENDIF
*     
*  On crée le champ par éléments contenant les coordonnées
*  des points servant pour la transformation géométrique
*  (ddl de la transformation géométrique)...
*     
      MYDISC=TABGEO.DISGEO
      CALL MKCOOR(CGEOME,MYDISC,
     $     MYFALS,
     $     ICOOR,
     $     IMPR,IRET)
      IF (IRET.NE.0) GOTO 9999
      TABGEO.IGEO=ICOOR
*     
* On teste les noms des ddls des variables et des coefficients
*     
      DO IJGVD=1,JGVD
         MYDISC=TABVDC.DISVD(TABVDC.DJSVD(IJGVD))
         MYLMOT=TABVDC.NOMVD(IJGVD)
         CALL KECOM6(CGEOME,MYLMOT,MYDISC,
     $        MYFALS,
     $        IMPR,IRET)
         IF (IRET.NE.0) GOTO 9999
      ENDDO
*     
* On crée les champs par éléments correspondant aux éventuels
* champs de variables et aux champs coefficients (globaux)
*     
      SEGINI,TATRAV
      DO IJGVD=1,JGVD
         MYDISC=TABVDC.DISVD(TABVDC.DJSVD(IJGVD))
         MYLMOT=TABVDC.NOMVD(IJGVD)
         MYCHPO=TABVDC.MVD(IJGVD)
         MYREAL=TABVDC.XVD(IJGVD)
*         segprt,mychpo
         CALL CP2CV7(CGEOME,MYLMOT,MYDISC,MYCHPO,MYREAL,
     $        MYFALS,
     $        MYMCHA,
     $        IMPR,IRET)
         IF (IRET.NE.0) GOTO 9999
*         segprt,mymcha
         TATRAV.IVD(IJGVD)=MYMCHA
      ENDDO
*     
* Fin...
*     
      SEGDES,TATRAV
      SEGDES,TABVDC
      SEGDES,TABGEO
*      SEGPRT,TABGEO
*      SEGPRT,TABVDC
*     
* Normal termination
*     
      IRET=0
      RETURN
*     
* Format handling
*     
*     
* Error handling
*     
 9999 CONTINUE
      IRET=1
      WRITE(IOIMP,*) 'An error was detected in subroutine prlin3'
      RETURN
*     
* End of subroutine PRLIN3
*     
      END