diamesh/src/m3d_wids.cpp

/* ecriture des fichiers */
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include "m3d_const.h"
#include "m3d_hotes.h"
#include "m3d_struct.h"
#include "m3d_erreur.h"
#include "prototype.h"

#define PRINT_DOUBLE(output,val) \
if ( (float)fabs((double)val) <1.e-9) fprintf(output,"   0.0000000000000000D+00") ;\
else if (val>0.) \
{\
fprintf(output,"   ") ;\
fprintf(output,"%1.16E",val) ;\
}\
else\
{\
        fprintf(output,"  ") ;\
        fprintf(output,"%1.16E",val) ;\
}\
 
extern GEST_MEM *gest ;
extern int debug ;
extern  char ext_out[MAX_LINE] ;
void m3d_wids(int nb_noeud,int nb_tetra_cree,float *coord,int *numele,int *ierr)
{
    FILE *output, *output2 ;
    char  *ext_mai ;
    char temp[MAX_LINE] ;
    char copie[MAX_LINE], line[MAX_LINE] ;
    int i, j, ief, index ;
    int nb, type ;
    float *coord2,crit ;
    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 ;

    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,"    -1\n") ;
        fprintf(output,"   151\n") ;
        fprintf(output,"DIAMESH\n") ;
        fprintf(output,",\n") ;
        fprintf(output,"ERIN - DIAMESH %s -\n\n",gest->release) ;
        fprintf(output,"%s\n",gest->name) ;
        fprintf(output,"*********************\n") ;
        fprintf(output,"*********************\n") ;
        fprintf(output,"    -1\n") ;
        /* ecriture des noeuds */
        fprintf(output,"    -1\n   781\n") ;
        /* peau */
        for (i=0;i<gest->nb_init;i++)
        {
            fprintf(output,"%10d%10d%10d%10d\n",gest->tabcor[i+1],0,0,11) ;
            PRINT_DOUBLE(output,coord[x(i)]) ;
            PRINT_DOUBLE(output,coord[y(i)]) ;
            PRINT_DOUBLE(output,coord[z(i)]) ;
            fprintf(output,"\n") ;
        }
        for (i=gest->nb_init;i<nb_noeud;i++)
        {
            fprintf(output,"%10d%10d%10d%10d\n",gest->numax+i+1-(gest->nb_init),0,0,11) ;
            PRINT_DOUBLE(output,coord[x(i)]) ;
            PRINT_DOUBLE(output,coord[y(i)]) ;
            PRINT_DOUBLE(output,coord[z(i)]) ;
            fprintf(output,"\n") ;
        }

        fprintf(output,"    -1\n") ;
        fprintf(output,"    -1\n") ;
        fprintf(output,"   780\n") ;

        nb = 0 ;
        j = 0 ;
        while (nb<nb_tetra_cree)
        {
            if (numele[4 * j] !=123456789)
            {
                nb++ ;
                fprintf(output,"%10d%10d%10d%10d%10d%10d%10d%10d\n",nb,111,0,1,0,1,7,4) ;
                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 */
                fprintf(output,"%10d%10d%10d%10d\n",j1,j2,j3,j4) ;
            }
            j ++ ;
        }
        fprintf(output,"    -1\n") ;
        fclose(output) ;
    }
    else/* traitement mailles quadratiques */
    {
        /* pas aussi facile que l'on peut le pretendre */
        /* donnees
        nombre de noeuds quadratiques gest->nb_qua
        nombre de noeuds initial : gest->nb_init = noeuds du maillage lineaire
        */
        /* ecriture des noeuds */
        fprintf(output,"    -1\n") ;
        fprintf(output,"   151\n") ;
        fprintf(output,"DIAMESH\n") ;
        fprintf(output,",\n") ;
        fprintf(output,"ERIN - DIAMESH %s -\n\n",gest->release) ;
        fprintf(output,"%s\n",gest->name) ;
        fprintf(output,"*********************\n") ;
        fprintf(output,"*********************\n") ;
        fprintf(output,"    -1\n") ;
        /* ecriture des noeuds */
        fprintf(output,"    -1\n   781\n") ;
        /* noeuds appartenant au maillage de la peau */
        for (i=0;i<gest->nb_noe_qua;i++)
        {
            fprintf(output,"%10d%10d%10d%10d\n",gest->tabcor[i+1],0,0,11) ;
            PRINT_DOUBLE(output,coord2[x(i)]) ;
            PRINT_DOUBLE(output,coord2[y(i)]) ;
            PRINT_DOUBLE(output,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,"%10d%10d%10d%10d\n",gest->numax+i+1-(gest->nb_init),0,0,11) ;
            PRINT_DOUBLE(output,coord[x(i)]) ;
            PRINT_DOUBLE(output,coord[y(i)]) ;
            PRINT_DOUBLE(output,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_cree)
        {
            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,"%10d%10d%10d%10d\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,0,0,11) ;
                    PRINT_DOUBLE(output,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    PRINT_DOUBLE(output,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    PRINT_DOUBLE(output,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,"%10d%10d%10d%10d\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,0,0,11) ;
                    PRINT_DOUBLE(output,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    PRINT_DOUBLE(output,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    PRINT_DOUBLE(output,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,"%10d%10d%10d%10d\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,0,0,11) ;
                    PRINT_DOUBLE(output,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    PRINT_DOUBLE(output,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    PRINT_DOUBLE(output,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,"%10d%10d%10d%10d\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,0,0,11) ;
                    PRINT_DOUBLE(output,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    PRINT_DOUBLE(output,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    PRINT_DOUBLE(output,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,"%10d%10d%10d%10d\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,0,0,11) ;
                    PRINT_DOUBLE(output,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    PRINT_DOUBLE(output,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    PRINT_DOUBLE(output,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,"%10d%10d%10d%10d\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,0,0,11) ;
                    PRINT_DOUBLE(output,0.5*(coord[x(num1)]+coord[x(num2)])) ;
                    PRINT_DOUBLE(output,0.5*(coord[y(num1)]+coord[y(num2)])) ;
                    PRINT_DOUBLE(output,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 ;
        */
        fprintf(output,"    -1\n") ;
        /* ecriture du bloc elements */
        fprintf(output,"    -1\n   780\n") ;

        /* renumerotation des noeuds */
        nb = 0 ;
        j = 0 ;
        while (nb<nb_tetra_cree)
        {
            if (numele[4 * j] !=123456789)
            {
                nb++ ;
                crit = 1. - m3d_e_qual(coord,numele[4*j],numele[4*j+1],numele[4*j+2],numele[4*j+3]) ;
                if (crit>0.9) type = BAD_CRIT ;
                else if (crit>0.8) type = LOW_CRIT ;
                else if (crit>0.5) type = MEDIUM_CRIT ;
                else type = GOOD_CRIT ;

                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 - n2 */
                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] ;

                /* n1 - n2 */
                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] ;

                /* n1 - n2 */
                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,"%10d%10d%10d%10d%10d%10d%10d%10d\n",nb,118,0,1,0,1,7,10) ;
                fprintf(output,"%10d%10d%10d%10d%10d%10d%10d%10d\n",j1,j5,j2,j6,j3,j7,j8,j9) ;
                fprintf(output,"%10d%10d\n",j10,j4) ;
            }
            j ++ ;
        }
        fprintf(output,"    -1\n") ;
        fclose(output) ;
    }
    output2 = fopen(temp,"w") ;
    output = fopen("temp","r") ;
    while (fgets(line,MAX_LINE,output))
    {
        copie[0] = 0 ;
        k = 0 ;
        while (strncmp(line+k,"\0",1))
        {
            if ((!strncmp(line+k,"E",1)) &&  ((!strncmp(line+k+1,"+",1)) ||(!strncmp(line+k+1,"-",1))) )
            {
                strncat(copie,"D",1) ;
            }
            else strncat(copie,line+k,1) ;
            k++ ;
        }
        fprintf(output2,"%s",copie) ;
    }
    fclose(output) ;
    fclose(output2) ;
    return ;
}

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