diamesh/src/m3d_wansys.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.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_wansys(int nb_noeud,int nb_tetra,float *coord,int *numele,int *ierr)
{
        FILE *output ;
        char *ext_sor ;
        char *ext_noe, *ext_mai ;
        char temp[MAX_LINE];
        int icode ;
        int i, j, imat ;
        int nb_ligne, nb_rest, 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, decpt, sign ;

        /* 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,"/COM,ANSYS REVISION 5.0 - DIAMESH %s - %s\n",gest->release,temp) ;
                fprintf(output,"/NOPR\n") ;
                fprintf(output,"/TITLE,\n") ;
                fprintf(output,"NUMOFF,NODE,%6d\n",gest->numax+nb_noeud-gest->nb_init) ;
                fprintf(output,"NUMOFF,ELEM,%6d\n",nb_tetra) ;
                fprintf(output,"NUMOFF,TYPE,     1\n") ;
                fprintf(output,"ET,  1, 45\n") ;
                fprintf(output,"DOF,UX  ,UY  ,UZ  ,\n") ;
                /* noeuds de la peau */
                for (i=0;i<gest->nb_init;i++)
fprintf(output,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->tabcor[i+1],coord[x(i)],coord[y(i)],coord[z(i)]) ;
                /* 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,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->numax+i+1-gest->nb_init,coord[x(i)],coord[y(i)],coord[z(i)]) ;

                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 */
                                fprintf(output,"EN,R5.0,ATTR,      8,      1,      1,      1,%7d,      0\n",nb) ;
                                fprintf(output,"EN,R5.0,NODE,%7d,%7d,%7d,%7d,%7d,%7d,%7d,%7d\n",j1,j2,j3,j3,j4,j4,j4,j4) ;
                        }
                        j ++ ;
                }                       
        }
        else /* traitement mailles quadratiques */
        {
                fprintf(output,"/COM,ANSYS REVISION 5.0 - DIAMESH %s - %s\n",gest->release,temp) ;
                fprintf(output,"/NOPR\n") ;
                fprintf(output,"/TITLE,\n") ;
                fprintf(output,"") ;
                fprintf(output,"NUMOFF,ELEM,%6d\n",nb_tetra) ;
                fprintf(output,"NUMOFF,TYPE,     1\n") ;
                fprintf(output,"ET,  1, 92\n") ;
                fprintf(output,"DOF,UX  ,UY  ,UZ  ,\n") ;
                /* noeuds appartenant au maillage de la peau */
                for (i=0;i<gest->nb_noe_qua;i++)
fprintf(output,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->tabcor[i+1],coord2[x(i)],coord2[y(i)],coord2[z(i)]) ;
                /* 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,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->numax+i+1-gest->nb_init,coord[x(i)],coord[y(i)],coord[z(i)]) ;
                /* 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,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,
0.5*(coord[x(num1)]+coord[x(num2)]),0.5*(coord[y(num1)]+coord[y(num2)]),0.5*(coord[z(num1)]+coord[z(num2)]));
                                }

                                /* 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,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,
0.5*(coord[x(num1)]+coord[x(num2)]),0.5*(coord[y(num1)]+coord[y(num2)]),0.5*(coord[z(num1)]+coord[z(num2)]));
                                }

                                /* 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,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,
0.5*(coord[x(num1)]+coord[x(num2)]),0.5*(coord[y(num1)]+coord[y(num2)]),0.5*(coord[z(num1)]+coord[z(num2)]));
                                }

                                /* 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,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,
0.5*(coord[x(num1)]+coord[x(num2)]),0.5*(coord[y(num1)]+coord[y(num2)]),0.5*(coord[z(num1)]+coord[z(num2)]));
                                }

                                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,"N,R5.0,LOC,%7d,%16f,%16f,%16f\n",gest->numax+nb_noeud-(gest->nb_init)+nb_cree,
0.5*(coord[x(num1)]+coord[x(num2)]),0.5*(coord[y(num1)]+coord[y(num2)]),0.5*(coord[z(num1)]+coord[z(num2)]));
                                }

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