diamesh/src/m3d_wnastran.cpp


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "m3d_const.h"
#include "m3d_hotes.h"
#include "m3d_struct.h"
#include "m3d_erreur.h"
#include "prototype.h"
extern int sortie ;
extern GEST_MEM *gest ;
extern int debug ;
extern char ext_out[MAX_LINE] ;
void m3d_wnastran(int nb_noeud,int nb_tetra,float *coord,int *numele,int *ierr)
{
    FILE *output ;
    char *ext_mai ;
    char temp[MAX_LINE];
    int icode ;
    int i, j, nb, type ;
    float *coord2 ;
    int *old, *neww, *connec, *numele2 ;
    int n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, ok, k, num1, num2, nb_cree ;
    int j1,j2,j3,j4,j5,j6,j7,j8,j9,j10 ;

    /* debut du code executable */

    neww = gest->neww ;
    old = gest->old ;
    coord2 = gest->coord2 ;

    temp[0] = 0 ;
    strcpy(temp,gest->name) ;
    strcat(temp,"_3D.") ;
    strcat(temp,ext_out) ;

    /* ouverture du fichier */
    if ( (output = fopen(temp,"w")) == NULL)
    {
        m3d_erreur(ERR_OPEN_RESU) ;
        *ierr = VRAI ;
        return ;
    }
    if (gest->is_qua == FAUX)/* mailles lineaires */
    {
        fprintf(output,"%-11s\n","BEGIN BULK") ;
        /* noeuds de la peau */
        for (i=0;i<gest->nb_init;i++)
        {
            fprintf(output,"GRID    %8d        ",gest->tabcor[i+1]) ;
            m3d_prn(output,8,coord[x(i)]) ;
            m3d_prn(output,8,coord[y(i)]) ;
            m3d_prn(output,8,coord[z(i)]) ;
            fprintf(output,"\n") ;
        }
        for (i=gest->nb_init;i<nb_noeud;i++)
        {
            fprintf(output,"GRID    %8d        ",i+1+gest->numax-gest->nb_init) ;
            m3d_prn(output,8,coord[x(i)]) ;
            m3d_prn(output,8,coord[y(i)]) ;
            m3d_prn(output,8,coord[z(i)]) ;
            fprintf(output,"\n") ;
        }
        /* elements */
        nb = 0 ;
        j = 0 ;
        while (nb<nb_tetra)
        {
            if (numele[4 * j] !=123456789)
            {
                nb++ ;
                /* noeud de la peau */
                if (numele[4*j]<gest->nb_init) j1 = gest->tabcor[(numele[4*j])+1] ;
                else j1 = (numele[4*j])+1 + gest->numax - gest->nb_init ;/* noeud genere */

                if (numele[4*j+1]<gest->nb_init) j2 = gest->tabcor[(numele[4*j+1])+1] ;
                else j2 = (numele[4*j+1])+1 + gest->numax - gest->nb_init ;/* noeud genere */

                if (numele[4*j+2]<gest->nb_init) j3 = gest->tabcor[(numele[4*j+2])+1] ;
                else j3 = (numele[4*j+2])+1 + gest->numax - gest->nb_init ;/* noeud genere */

                if (numele[4*j+3]<gest->nb_init) j4 = gest->tabcor[(numele[4*j+3])+1] ;
                else j4 = (numele[4*j+3])+1 + gest->numax - gest->nb_init ;/* noeud genere */
                type = 1 ;
                fprintf(output,"%8s%8d%8d%8d%8d%8d%8d\n","CTETRA  ",nb,type,j1,j2,j3,j4) ;
                /* fprintf(output,"%8d%8d%8d%8d\n",0,0,0,0) ;*/
            }
            j ++ ;
        }
    }
    else /* traitement mailles quadratiques */
    {
        /* ecriture des noeuds */
        fprintf(output,"%-11s\n","BEGIN BULK") ;
        /* noeuds appartenant au maillage de la peau */
        for (i=0;i<gest->nb_noe_qua;i++)
        {
            fprintf(output,"GRID    %8d        ",gest->tabcor[i+1]) ;
            m3d_prn(output,8,coord2[x(i)]) ;
            m3d_prn(output,8,coord2[y(i)]) ;
            m3d_prn(output,8,coord2[z(i)]) ;
            fprintf(output,"\n") ;
        }
        /* creation des noeuds generes pendant le maillage */
        /* le nouveau numero de ces noeuds est superieur ou egal a gest->nb_init */
        for (i=gest->nb_init;i<nb_noeud;i++)
        {
            fprintf(output,"GRID    %8d        ",gest->numax+i+1-gest->nb_init) ;
            m3d_prn(output,8,coord[x(i)]) ;
            m3d_prn(output,8,coord[y(i)]) ;
            m3d_prn(output,8,coord[z(i)]) ;
            fprintf(output,"\n") ;
        }
        /* creation des noeuds intermediaires */
        /* remarque si les 2 numeros des segments (nouvelle numerotation) sont inferieures a
        gest->nb_init, le noeud milieu existe deja sinon , il faut le creer */
        /* creation d'un tableau de connectivite par segment */
        gest->connec = (int*)calloc(2*MAX_CONNEC*nb_noeud,sizeof(int)) ;
        /* une case pour stocker le numero du noeud intermediaire */
        if (gest->connec == NULL)
        {
            m3d_erreur(ERR_OPEN_RESU) ;
            *ierr = VRAI ;
            return ;
        }
        connec = gest->connec ;
        /* connec[i*MAX_CONNEC*j] = jeme voisin du noeud i */
        for (i=0;i<2*MAX_CONNEC*nb_noeud;i++) connec[i] = NUM_STOP ;
        /* passer les sommets de numele2 en nouvelle numerotation -1 */
        numele2 = gest->numele2 ;
        /* les numeros des noeuds intermediaires sont inchanges */
        /* stocker le milieu des segments des elements de peau */
        /* les numeros commencent a 0 = numero du maillage lineaire */
        for (i=0;i<gest->nb_2d;i++) /* elements de peau */
        {
            n1 = neww[numele2[6*i]] - 1 ;
            n2 = neww[numele2[6*i+2]] - 1 ;
            n3 = neww[numele2[6*i+4]] - 1 ;

            /* n1 - n2 */

            num1 = min(n1,n2) ;
            num2 = max(n1,n2) ;

            ok = FAUX ;
            k = 0 ;
            /* table des noeuds connectes a n1 , ke voisins */
            while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
            {
                if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                k++ ;
            }
            /* insertion */
            if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
            {
                m3d_erreur(ERR_OPEN_RESU) ;
                *ierr = VRAI ;
                return ;
            }
            if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
            {
                connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                connec[2*(num1*MAX_CONNEC+k)+1] = numele2[6*i+1] ;
            }

            /* n2 - n3 */

            num1 = min(n2,n3) ;
            num2 = max(n2,n3) ;

            ok = FAUX ;
            k = 0 ;
            /* table des noeuds connectes a n1 , ke voisins */
            while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
            {
                if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                k++ ;
            }
            /* insertion */
            if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
            {
                m3d_erreur(ERR_OPEN_RESU) ;
                *ierr = VRAI ;
                return ;
            }
            if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
            {
                connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                connec[2*(num1*MAX_CONNEC+k)+1] = numele2[6*i+3] ;
            }
            /* n1 - n3 */

            num1 = min(n1,n3) ;
            num2 = max(n1,n3) ;

            ok = FAUX ;
            k = 0 ;
            /* table des noeuds connectes a n1 , ke voisins */
            while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
            {
                if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                k++ ;
            }
            /* insertion */
            if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
            {
                m3d_erreur(ERR_OPEN_RESU) ;
                *ierr = VRAI ;
                return ;
            }
            if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
            {
                connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                connec[2*(num1*MAX_CONNEC+k)+1] = numele2[6*i+5] ;
            }
        }
        /* parcours du tableau des elements */
        nb = 0 ;
        j = 0 ;
        nb_cree = 0 ;
        while (nb<nb_tetra)
        {
            if (numele[4 * j] !=123456789)
            {
                nb++ ;
                n1 = numele[4*j] ;
                n2 = numele[4*j+1] ;
                n3 = numele[4*j+2] ;
                n4  = numele[4*j+3] ;
                /* traitement des segments */
                /* n1 n2 */
                num1 = min(n1,n2) ;
                num2 = max(n1,n2) ;
                /* doit on creer un noeud */
                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                /* insertion */
                if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    nb_cree++ ;
                    connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                    connec[2*(num1*MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
                    fprintf(output,"GRID    %8d        ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
                    m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
                    fprintf(output,"\n") ;
                }

                /* n1 n3 */
                num1 = min(n1,n3) ;
                num2 = max(n1,n3) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                /* insertion */
                if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    nb_cree++ ;
                    connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                    connec[2*(num1*MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
                    fprintf(output,"GRID    %8d        ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
                    m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
                    fprintf(output,"\n") ;
                }

                /* n1 n4 */
                num1 = min(n1,n4) ;
                num2 = max(n1,n4) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                /* insertion */
                if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    nb_cree++ ;
                    connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                    connec[2*(num1*MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
                    fprintf(output,"GRID    %8d        ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
                    m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
                    fprintf(output,"\n") ;
                }

                /* n2 n3 */
                num1 = min(n2,n3) ;
                num2 = max(n2,n3) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                /* insertion */
                if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    nb_cree++ ;
                    connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                    connec[2*(num1*MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
                    fprintf(output,"GRID    %8d        ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
                    m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
                    fprintf(output,"\n") ;
                }

                num1 = min(n2,n4) ;
                num2 = max(n2,n4) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                /* insertion */
                if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    nb_cree++ ;
                    connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                    connec[2*(num1*MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
                    fprintf(output,"GRID    %8d        ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
                    m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
                    fprintf(output,"\n") ;
                }

                num1 = min(n3,n4) ;
                num2 = max(n3,n4) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                /* insertion */
                if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    nb_cree++ ;
                    connec[2*(num1*MAX_CONNEC+k)] = num2 ;
                    connec[2*(num1*MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
                    fprintf(output,"GRID    %8d        ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
                    m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
                    fprintf(output,"\n") ;
                }
            }
            j ++ ;
        }
        /* gest->nb_noeud = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;*/
        type = 1 ;
        nb = 0 ;
        j = 0 ;
        while (nb<nb_tetra)
        {
            if (numele[4 * j] !=123456789)
            {
                nb++ ;
                n1 = numele[4*j] ;
                n2 = numele[4*j+1] ;
                n3 = numele[4*j+2] ;
                n4  = numele[4*j+3] ;

                /* n1 - n2 */
                num1 = min(n1,n2) ;
                num2 = max(n1,n2) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                if (ok == FAUX)
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                n5 = connec[2*(num1*MAX_CONNEC+k-1)+ 1] ;

                /* n2 - n3 */
                num1 = min(n2,n3) ;
                num2 = max(n2,n3) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                n6 = connec[2*(num1*MAX_CONNEC+k-1)+ 1] ;

                /* n1 - n3 */
                num1 = min(n1,n3) ;
                num2 = max(n1,n3) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                n7 = connec[2*(num1*MAX_CONNEC+k-1)+ 1] ;

                /* n1 - n4 */
                num1 = min(n1,n4) ;
                num2 = max(n1,n4) ;
                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                n8 = connec[2*(num1*MAX_CONNEC+k-1)+ 1] ;

                /* n2 - n4 */
                num1 = min(n2,n4) ;
                num2 = max(n2,n4) ;
                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                n9 = connec[2*(num1*MAX_CONNEC+k-1)+ 1] ;

                num1 = min(n3,n4) ;
                num2 = max(n3,n4) ;

                ok = FAUX ;
                k = 0 ;
                /* table des noeuds connectes a n1 , ke voisins */
                while ((connec[2*(num1*MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
                {
                    if (connec[2*(num1*MAX_CONNEC+k)] == num2) ok = VRAI ;
                    k++ ;
                }
                if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
                {
                    m3d_erreur(ERR_OPEN_RESU) ;
                    *ierr = VRAI ;
                    return ;
                }
                n10 = connec[2*(num1*MAX_CONNEC+k-1)+ 1] ;

                if (n1<gest->nb_init) n1 = old[n1+1] ;/* numeros fortran */
                else n1 = (gest->nb_noe_qua - gest->nb_init) + n1 + 1 ;
                if (n2<gest->nb_init) n2 = old[n2+1] ;/* numeros fortran */
                else n2 = (gest->nb_noe_qua - gest->nb_init) + n2 + 1 ;
                if (n3<gest->nb_init) n3 = old[n3+1] ;/* numeros fortran */
                else n3 = (gest->nb_noe_qua - gest->nb_init) + n3 + 1 ;
                if (n4<gest->nb_init) n4 = old[n4+1] ;/* numeros fortran */
                else n4 = (gest->nb_noe_qua - gest->nb_init) + n4 + 1 ;

                if (n1<gest->nb_noe_qua) j1 = gest->tabcor[n1] ;
                else j1 = n1 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n2<gest->nb_noe_qua) j2 = gest->tabcor[n2] ;
                else j2 = n2 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n3<gest->nb_noe_qua) j3 = gest->tabcor[n3] ;
                else j3 = n3 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n4<gest->nb_noe_qua) j4 = gest->tabcor[n4] ;
                else j4 = n4 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n5<gest->nb_noe_qua) j5 = gest->tabcor[n5] ;
                else j5 = n5 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n6<gest->nb_noe_qua) j6 = gest->tabcor[n6] ;
                else j6 = n6 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n7<gest->nb_noe_qua) j7 = gest->tabcor[n7] ;
                else j7 = n7 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n8<gest->nb_noe_qua) j8 = gest->tabcor[n8] ;
                else j8 = n8 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n9<gest->nb_noe_qua) j9 = gest->tabcor[n9] ;
                else j9 = n9 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                if (n10<gest->nb_noe_qua) j10 = gest->tabcor[n10] ;
                else j10 = n10 + gest->numax - gest->nb_noe_qua ;/* noeud genere */

                fprintf(output,"%8s%8d%8d%8d%8d%8d%8d%8d%8d","CTETRA  ",nb,type,j1,j2,j3,j4,j5,j6) ;
                if (nb<10)
                {
                    fprintf(output,"+000000%1d\n",nb) ;
                    fprintf(output,"+000000%1d",nb) ;
                }
                else if (nb<100)
                {
                    fprintf(output,"+00000%2d\n",nb) ;
                    fprintf(output,"+00000%2d",nb) ;
                }
                else if (nb<1000)
                {
                    fprintf(output,"+0000%3d\n",nb) ;
                    fprintf(output,"+0000%3d",nb) ;
                }
                else if (nb<10000)
                {
                    fprintf(output,"+000%4d\n",nb) ;
                    fprintf(output,"+000%4d",nb) ;
                }
                else if (nb<100000)
                {
                    fprintf(output,"+00%3d\n",nb) ;
                    fprintf(output,"+00%3d",nb) ;
                }
                else if (nb<1000000)
                {
                    fprintf(output,"+0%2d\n",nb) ;
                    fprintf(output,"+0%2d",nb) ;
                }
                else if (nb<10000000)
                {
                    fprintf(output,"+%1d\n",nb) ;
                    fprintf(output,"+%1d",nb) ;
                }

                fprintf(output,"%8d%8d%8d%8d\n",j7,j8,j9,j10) ;
            }
            j ++ ;
        }
    }
    fprintf(output,"ENDDATA\n") ;
    fclose(output) ;
    return ;
}
Revision:	283
Committed:	Tue Sep 13 21:11:20 2011 UTC (13 years, 8 months ago) by francois
File size:	25044 byte(s)
Log Message:	structure de l'écriture
#	User	Rev	Content
1	francois	283
2			#include <stdio.h>
3			#include <string.h>
4			#include <stdlib.h>
5			#include "m3d_const.h"
6			#include "m3d_hotes.h"
7			#include "m3d_struct.h"
8			#include "m3d_erreur.h"
9			#include "prototype.h"
10			extern int sortie ;
11			extern GEST_MEM *gest ;
12			extern int debug ;
13			extern char ext_out[MAX_LINE] ;
14			void m3d_wnastran(int nb_noeud,int nb_tetra,float coord,int numele,int *ierr)
15			{
16			FILE *output ;
17			char *ext_mai ;
18			char temp[MAX_LINE];
19			int icode ;
20			int i, j, nb, type ;
21			float *coord2 ;
22			int old, neww, connec, numele2 ;
23			int n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, ok, k, num1, num2, nb_cree ;
24			int j1,j2,j3,j4,j5,j6,j7,j8,j9,j10 ;
25
26			/* debut du code executable */
27
28			neww = gest->neww ;
29			old = gest->old ;
30			coord2 = gest->coord2 ;
31
32			temp[0] = 0 ;
33			strcpy(temp,gest->name) ;
34			strcat(temp,"_3D.") ;
35			strcat(temp,ext_out) ;
36
37			/* ouverture du fichier */
38			if ( (output = fopen(temp,"w")) == NULL)
39			{
40			m3d_erreur(ERR_OPEN_RESU) ;
41			*ierr = VRAI ;
42			return ;
43			}
44			if (gest->is_qua == FAUX)/* mailles lineaires */
45			{
46			fprintf(output,"%-11s\n","BEGIN BULK") ;
47			/* noeuds de la peau */
48			for (i=0;i<gest->nb_init;i++)
49			{
50			fprintf(output,"GRID %8d ",gest->tabcor[i+1]) ;
51			m3d_prn(output,8,coord[x(i)]) ;
52			m3d_prn(output,8,coord[y(i)]) ;
53			m3d_prn(output,8,coord[z(i)]) ;
54			fprintf(output,"\n") ;
55			}
56			for (i=gest->nb_init;i<nb_noeud;i++)
57			{
58			fprintf(output,"GRID %8d ",i+1+gest->numax-gest->nb_init) ;
59			m3d_prn(output,8,coord[x(i)]) ;
60			m3d_prn(output,8,coord[y(i)]) ;
61			m3d_prn(output,8,coord[z(i)]) ;
62			fprintf(output,"\n") ;
63			}
64			/* elements */
65			nb = 0 ;
66			j = 0 ;
67			while (nb<nb_tetra)
68			{
69			if (numele[4 * j] !=123456789)
70			{
71			nb++ ;
72			/* noeud de la peau */
73			if (numele[4j]<gest->nb_init) j1 = gest->tabcor[(numele[4j])+1] ;
74			else j1 = (numele[4j])+1 + gest->numax - gest->nb_init ;/ noeud genere */
75
76			if (numele[4j+1]<gest->nb_init) j2 = gest->tabcor[(numele[4j+1])+1] ;
77			else j2 = (numele[4j+1])+1 + gest->numax - gest->nb_init ;/ noeud genere */
78
79			if (numele[4j+2]<gest->nb_init) j3 = gest->tabcor[(numele[4j+2])+1] ;
80			else j3 = (numele[4j+2])+1 + gest->numax - gest->nb_init ;/ noeud genere */
81
82			if (numele[4j+3]<gest->nb_init) j4 = gest->tabcor[(numele[4j+3])+1] ;
83			else j4 = (numele[4j+3])+1 + gest->numax - gest->nb_init ;/ noeud genere */
84			type = 1 ;
85			fprintf(output,"%8s%8d%8d%8d%8d%8d%8d\n","CTETRA ",nb,type,j1,j2,j3,j4) ;
86			/* fprintf(output,"%8d%8d%8d%8d\n",0,0,0,0) ;*/
87			}
88			j ++ ;
89			}
90			}
91			else /* traitement mailles quadratiques */
92			{
93			/* ecriture des noeuds */
94			fprintf(output,"%-11s\n","BEGIN BULK") ;
95			/* noeuds appartenant au maillage de la peau */
96			for (i=0;i<gest->nb_noe_qua;i++)
97			{
98			fprintf(output,"GRID %8d ",gest->tabcor[i+1]) ;
99			m3d_prn(output,8,coord2[x(i)]) ;
100			m3d_prn(output,8,coord2[y(i)]) ;
101			m3d_prn(output,8,coord2[z(i)]) ;
102			fprintf(output,"\n") ;
103			}
104			/* creation des noeuds generes pendant le maillage */
105			/* le nouveau numero de ces noeuds est superieur ou egal a gest->nb_init */
106			for (i=gest->nb_init;i<nb_noeud;i++)
107			{
108			fprintf(output,"GRID %8d ",gest->numax+i+1-gest->nb_init) ;
109			m3d_prn(output,8,coord[x(i)]) ;
110			m3d_prn(output,8,coord[y(i)]) ;
111			m3d_prn(output,8,coord[z(i)]) ;
112			fprintf(output,"\n") ;
113			}
114			/* creation des noeuds intermediaires */
115			/* remarque si les 2 numeros des segments (nouvelle numerotation) sont inferieures a
116			gest->nb_init, le noeud milieu existe deja sinon , il faut le creer */
117			/* creation d'un tableau de connectivite par segment */
118			gest->connec = (int)calloc(2MAX_CONNEC*nb_noeud,sizeof(int)) ;
119			/* une case pour stocker le numero du noeud intermediaire */
120			if (gest->connec == NULL)
121			{
122			m3d_erreur(ERR_OPEN_RESU) ;
123			*ierr = VRAI ;
124			return ;
125			}
126			connec = gest->connec ;
127			/* connec[iMAX_CONNECj] = jeme voisin du noeud i */
128			for (i=0;i<2MAX_CONNECnb_noeud;i++) connec[i] = NUM_STOP ;
129			/* passer les sommets de numele2 en nouvelle numerotation -1 */
130			numele2 = gest->numele2 ;
131			/* les numeros des noeuds intermediaires sont inchanges */
132			/* stocker le milieu des segments des elements de peau */
133			/* les numeros commencent a 0 = numero du maillage lineaire */
134			for (i=0;i<gest->nb_2d;i++) /* elements de peau */
135			{
136			n1 = neww[numele2[6*i]] - 1 ;
137			n2 = neww[numele2[6*i+2]] - 1 ;
138			n3 = neww[numele2[6*i+4]] - 1 ;
139
140			/* n1 - n2 */
141
142			num1 = min(n1,n2) ;
143			num2 = max(n1,n2) ;
144
145			ok = FAUX ;
146			k = 0 ;
147			/* table des noeuds connectes a n1 , ke voisins */
148			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
149			{
150			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
151			k++ ;
152			}
153			/* insertion */
154			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
155			{
156			m3d_erreur(ERR_OPEN_RESU) ;
157			*ierr = VRAI ;
158			return ;
159			}
160			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
161			{
162			connec[2(num1MAX_CONNEC+k)] = num2 ;
163			connec[2(num1MAX_CONNEC+k)+1] = numele2[6*i+1] ;
164			}
165
166			/* n2 - n3 */
167
168			num1 = min(n2,n3) ;
169			num2 = max(n2,n3) ;
170
171			ok = FAUX ;
172			k = 0 ;
173			/* table des noeuds connectes a n1 , ke voisins */
174			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
175			{
176			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
177			k++ ;
178			}
179			/* insertion */
180			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
181			{
182			m3d_erreur(ERR_OPEN_RESU) ;
183			*ierr = VRAI ;
184			return ;
185			}
186			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
187			{
188			connec[2(num1MAX_CONNEC+k)] = num2 ;
189			connec[2(num1MAX_CONNEC+k)+1] = numele2[6*i+3] ;
190			}
191			/* n1 - n3 */
192
193			num1 = min(n1,n3) ;
194			num2 = max(n1,n3) ;
195
196			ok = FAUX ;
197			k = 0 ;
198			/* table des noeuds connectes a n1 , ke voisins */
199			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
200			{
201			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
202			k++ ;
203			}
204			/* insertion */
205			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
206			{
207			m3d_erreur(ERR_OPEN_RESU) ;
208			*ierr = VRAI ;
209			return ;
210			}
211			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
212			{
213			connec[2(num1MAX_CONNEC+k)] = num2 ;
214			connec[2(num1MAX_CONNEC+k)+1] = numele2[6*i+5] ;
215			}
216			}
217			/* parcours du tableau des elements */
218			nb = 0 ;
219			j = 0 ;
220			nb_cree = 0 ;
221			while (nb<nb_tetra)
222			{
223			if (numele[4 * j] !=123456789)
224			{
225			nb++ ;
226			n1 = numele[4*j] ;
227			n2 = numele[4*j+1] ;
228			n3 = numele[4*j+2] ;
229			n4 = numele[4*j+3] ;
230			/* traitement des segments */
231			/* n1 n2 */
232			num1 = min(n1,n2) ;
233			num2 = max(n1,n2) ;
234			/* doit on creer un noeud */
235			ok = FAUX ;
236			k = 0 ;
237			/* table des noeuds connectes a n1 , ke voisins */
238			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
239			{
240			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
241			k++ ;
242			}
243			/* insertion */
244			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
245			{
246			m3d_erreur(ERR_OPEN_RESU) ;
247			*ierr = VRAI ;
248			return ;
249			}
250			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
251			{
252			nb_cree++ ;
253			connec[2(num1MAX_CONNEC+k)] = num2 ;
254			connec[2(num1MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
255			fprintf(output,"GRID %8d ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
256			m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
257			m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
258			m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
259			fprintf(output,"\n") ;
260			}
261
262			/* n1 n3 */
263			num1 = min(n1,n3) ;
264			num2 = max(n1,n3) ;
265
266			ok = FAUX ;
267			k = 0 ;
268			/* table des noeuds connectes a n1 , ke voisins */
269			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
270			{
271			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
272			k++ ;
273			}
274			/* insertion */
275			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
276			{
277			m3d_erreur(ERR_OPEN_RESU) ;
278			*ierr = VRAI ;
279			return ;
280			}
281			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
282			{
283			nb_cree++ ;
284			connec[2(num1MAX_CONNEC+k)] = num2 ;
285			connec[2(num1MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
286			fprintf(output,"GRID %8d ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
287			m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
288			m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
289			m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
290			fprintf(output,"\n") ;
291			}
292
293			/* n1 n4 */
294			num1 = min(n1,n4) ;
295			num2 = max(n1,n4) ;
296
297			ok = FAUX ;
298			k = 0 ;
299			/* table des noeuds connectes a n1 , ke voisins */
300			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
301			{
302			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
303			k++ ;
304			}
305			/* insertion */
306			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
307			{
308			m3d_erreur(ERR_OPEN_RESU) ;
309			*ierr = VRAI ;
310			return ;
311			}
312			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
313			{
314			nb_cree++ ;
315			connec[2(num1MAX_CONNEC+k)] = num2 ;
316			connec[2(num1MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
317			fprintf(output,"GRID %8d ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
318			m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
319			m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
320			m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
321			fprintf(output,"\n") ;
322			}
323
324			/* n2 n3 */
325			num1 = min(n2,n3) ;
326			num2 = max(n2,n3) ;
327
328			ok = FAUX ;
329			k = 0 ;
330			/* table des noeuds connectes a n1 , ke voisins */
331			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
332			{
333			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
334			k++ ;
335			}
336			/* insertion */
337			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
338			{
339			m3d_erreur(ERR_OPEN_RESU) ;
340			*ierr = VRAI ;
341			return ;
342			}
343			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
344			{
345			nb_cree++ ;
346			connec[2(num1MAX_CONNEC+k)] = num2 ;
347			connec[2(num1MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
348			fprintf(output,"GRID %8d ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
349			m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
350			m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
351			m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
352			fprintf(output,"\n") ;
353			}
354
355			num1 = min(n2,n4) ;
356			num2 = max(n2,n4) ;
357
358			ok = FAUX ;
359			k = 0 ;
360			/* table des noeuds connectes a n1 , ke voisins */
361			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
362			{
363			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
364			k++ ;
365			}
366			/* insertion */
367			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
368			{
369			m3d_erreur(ERR_OPEN_RESU) ;
370			*ierr = VRAI ;
371			return ;
372			}
373			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
374			{
375			nb_cree++ ;
376			connec[2(num1MAX_CONNEC+k)] = num2 ;
377			connec[2(num1MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
378			fprintf(output,"GRID %8d ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
379			m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
380			m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
381			m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
382			fprintf(output,"\n") ;
383			}
384
385			num1 = min(n3,n4) ;
386			num2 = max(n3,n4) ;
387
388			ok = FAUX ;
389			k = 0 ;
390			/* table des noeuds connectes a n1 , ke voisins */
391			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
392			{
393			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
394			k++ ;
395			}
396			/* insertion */
397			if (k>MAX_CONNEC-1) /* il n'y a plus de place : erreur */
398			{
399			m3d_erreur(ERR_OPEN_RESU) ;
400			*ierr = VRAI ;
401			return ;
402			}
403			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
404			{
405			nb_cree++ ;
406			connec[2(num1MAX_CONNEC+k)] = num2 ;
407			connec[2(num1MAX_CONNEC+k)+1] = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;
408			fprintf(output,"GRID %8d ",gest->numax+nb_noeud-(gest->nb_init)+nb_cree) ;
409			m3d_prn(output,8,0.5*(coord[x(num1)]+coord[x(num2)])) ;
410			m3d_prn(output,8,0.5*(coord[y(num1)]+coord[y(num2)])) ;
411			m3d_prn(output,8,0.5*(coord[z(num1)]+coord[z(num2)])) ;
412			fprintf(output,"\n") ;
413			}
414			}
415			j ++ ;
416			}
417			/* gest->nb_noeud = gest->nb_noe_qua+nb_noeud-(gest->nb_init)+nb_cree ;*/
418			type = 1 ;
419			nb = 0 ;
420			j = 0 ;
421			while (nb<nb_tetra)
422			{
423			if (numele[4 * j] !=123456789)
424			{
425			nb++ ;
426			n1 = numele[4*j] ;
427			n2 = numele[4*j+1] ;
428			n3 = numele[4*j+2] ;
429			n4 = numele[4*j+3] ;
430
431			/* n1 - n2 */
432			num1 = min(n1,n2) ;
433			num2 = max(n1,n2) ;
434
435			ok = FAUX ;
436			k = 0 ;
437			/* table des noeuds connectes a n1 , ke voisins */
438			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
439			{
440			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
441			k++ ;
442			}
443			if (ok == FAUX)
444			{
445			m3d_erreur(ERR_OPEN_RESU) ;
446			*ierr = VRAI ;
447			return ;
448			}
449			n5 = connec[2(num1MAX_CONNEC+k-1)+ 1] ;
450
451			/* n2 - n3 */
452			num1 = min(n2,n3) ;
453			num2 = max(n2,n3) ;
454
455			ok = FAUX ;
456			k = 0 ;
457			/* table des noeuds connectes a n1 , ke voisins */
458			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
459			{
460			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
461			k++ ;
462			}
463			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
464			{
465			m3d_erreur(ERR_OPEN_RESU) ;
466			*ierr = VRAI ;
467			return ;
468			}
469			n6 = connec[2(num1MAX_CONNEC+k-1)+ 1] ;
470
471			/* n1 - n3 */
472			num1 = min(n1,n3) ;
473			num2 = max(n1,n3) ;
474
475			ok = FAUX ;
476			k = 0 ;
477			/* table des noeuds connectes a n1 , ke voisins */
478			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
479			{
480			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
481			k++ ;
482			}
483			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
484			{
485			m3d_erreur(ERR_OPEN_RESU) ;
486			*ierr = VRAI ;
487			return ;
488			}
489			n7 = connec[2(num1MAX_CONNEC+k-1)+ 1] ;
490
491			/* n1 - n4 */
492			num1 = min(n1,n4) ;
493			num2 = max(n1,n4) ;
494			ok = FAUX ;
495			k = 0 ;
496			/* table des noeuds connectes a n1 , ke voisins */
497			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
498			{
499			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
500			k++ ;
501			}
502			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
503			{
504			m3d_erreur(ERR_OPEN_RESU) ;
505			*ierr = VRAI ;
506			return ;
507			}
508			n8 = connec[2(num1MAX_CONNEC+k-1)+ 1] ;
509
510			/* n2 - n4 */
511			num1 = min(n2,n4) ;
512			num2 = max(n2,n4) ;
513			ok = FAUX ;
514			k = 0 ;
515			/* table des noeuds connectes a n1 , ke voisins */
516			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
517			{
518			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
519			k++ ;
520			}
521			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
522			{
523			m3d_erreur(ERR_OPEN_RESU) ;
524			*ierr = VRAI ;
525			return ;
526			}
527			n9 = connec[2(num1MAX_CONNEC+k-1)+ 1] ;
528
529			num1 = min(n3,n4) ;
530			num2 = max(n3,n4) ;
531
532			ok = FAUX ;
533			k = 0 ;
534			/* table des noeuds connectes a n1 , ke voisins */
535			while ((connec[2(num1MAX_CONNEC+k)]!=NUM_STOP) && (ok == FAUX) && (k<MAX_CONNEC))
536			{
537			if (connec[2(num1MAX_CONNEC+k)] == num2) ok = VRAI ;
538			k++ ;
539			}
540			if (ok == FAUX)/* le noeud n'a pas ete trouve, on peut le generer */
541			{
542			m3d_erreur(ERR_OPEN_RESU) ;
543			*ierr = VRAI ;
544			return ;
545			}
546			n10 = connec[2(num1MAX_CONNEC+k-1)+ 1] ;
547
548			if (n1<gest->nb_init) n1 = old[n1+1] ;/* numeros fortran */
549			else n1 = (gest->nb_noe_qua - gest->nb_init) + n1 + 1 ;
550			if (n2<gest->nb_init) n2 = old[n2+1] ;/* numeros fortran */
551			else n2 = (gest->nb_noe_qua - gest->nb_init) + n2 + 1 ;
552			if (n3<gest->nb_init) n3 = old[n3+1] ;/* numeros fortran */
553			else n3 = (gest->nb_noe_qua - gest->nb_init) + n3 + 1 ;
554			if (n4<gest->nb_init) n4 = old[n4+1] ;/* numeros fortran */
555			else n4 = (gest->nb_noe_qua - gest->nb_init) + n4 + 1 ;
556
557			if (n1<gest->nb_noe_qua) j1 = gest->tabcor[n1] ;
558			else j1 = n1 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
559
560			if (n2<gest->nb_noe_qua) j2 = gest->tabcor[n2] ;
561			else j2 = n2 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
562
563			if (n3<gest->nb_noe_qua) j3 = gest->tabcor[n3] ;
564			else j3 = n3 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
565
566			if (n4<gest->nb_noe_qua) j4 = gest->tabcor[n4] ;
567			else j4 = n4 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
568
569			if (n5<gest->nb_noe_qua) j5 = gest->tabcor[n5] ;
570			else j5 = n5 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
571
572			if (n6<gest->nb_noe_qua) j6 = gest->tabcor[n6] ;
573			else j6 = n6 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
574
575			if (n7<gest->nb_noe_qua) j7 = gest->tabcor[n7] ;
576			else j7 = n7 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
577
578			if (n8<gest->nb_noe_qua) j8 = gest->tabcor[n8] ;
579			else j8 = n8 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
580
581			if (n9<gest->nb_noe_qua) j9 = gest->tabcor[n9] ;
582			else j9 = n9 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
583
584			if (n10<gest->nb_noe_qua) j10 = gest->tabcor[n10] ;
585			else j10 = n10 + gest->numax - gest->nb_noe_qua ;/* noeud genere */
586
587			fprintf(output,"%8s%8d%8d%8d%8d%8d%8d%8d%8d","CTETRA ",nb,type,j1,j2,j3,j4,j5,j6) ;
588			if (nb<10)
589			{
590			fprintf(output,"+000000%1d\n",nb) ;
591			fprintf(output,"+000000%1d",nb) ;
592			}
593			else if (nb<100)
594			{
595			fprintf(output,"+00000%2d\n",nb) ;
596			fprintf(output,"+00000%2d",nb) ;
597			}
598			else if (nb<1000)
599			{
600			fprintf(output,"+0000%3d\n",nb) ;
601			fprintf(output,"+0000%3d",nb) ;
602			}
603			else if (nb<10000)
604			{
605			fprintf(output,"+000%4d\n",nb) ;
606			fprintf(output,"+000%4d",nb) ;
607			}
608			else if (nb<100000)
609			{
610			fprintf(output,"+00%3d\n",nb) ;
611			fprintf(output,"+00%3d",nb) ;
612			}
613			else if (nb<1000000)
614			{
615			fprintf(output,"+0%2d\n",nb) ;
616			fprintf(output,"+0%2d",nb) ;
617			}
618			else if (nb<10000000)
619			{
620			fprintf(output,"+%1d\n",nb) ;
621			fprintf(output,"+%1d",nb) ;
622			}
623
624			fprintf(output,"%8d%8d%8d%8d\n",j7,j8,j9,j10) ;
625			}
626			j ++ ;
627			}
628			}
629			fprintf(output,"ENDDATA\n") ;
630			fclose(output) ;
631			return ;
632			}