Changeset 3263


Ignore:
Timestamp:
03/11/10 15:13:57 (15 years ago)
Author:
Mathieu Morlighem
Message:

Big reorg

Location:
issm/trunk/src/c
Files:
13 added
7 deleted
29 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/Bamgx/Bamgx.cpp

    r3243 r3263  
    1717#include <stdio.h>
    1818#include <string.h>
    19 #include "BamgObjects.h"
    20 #include "objects/QuadTree.h"
     19#include "objects/BamgObjects.h"
    2120
    2221using namespace bamg;

  • issm/trunk/src/c/Bamgx/objects/CrackedEdge.h

    r3243 r3263  
    1212#include "Edge.h"
    1313#include "Triangle.h"
    14 #include "../shared/TheVertex.h"
    15 #include "../shared/FindTriangleAdjacent.h"
    1614
    1715namespace bamg {
    … …  
    3735
    3836                        //Methods
    39                         void Crack(){
    40                                 Triangle & T(*t);
    41                                 int i0=VerticesOfTriangularEdge[i][0];
    42                                 int i1=VerticesOfTriangularEdge[i][0];
    43                                 if (!New[0] && !New[1]){
    44                                         throw ErrorException(__FUNCT__,exprintf("!New[0] && !New[1]"));
    45                                 }
    46                                 T(i0) = New[0];
    47                                 T(i1) = New[1];
    48                         }   
    49                         void UnCrack(){
    50                                 Triangle & T(*t);
    51                                 int i0=VerticesOfTriangularEdge[i][0];
    52                                 int i1=VerticesOfTriangularEdge[i][0];
    53                                 if (!New[0] && !New[1]){
    54                                         throw ErrorException(__FUNCT__,exprintf("!New[0] && !New[1]"));
    55                                 }
    56                                 T(i0) = TheVertex(T(i0));
    57                                 T(i1) = TheVertex(T(i1));
    58                         }
    59                         void Set() {
    60                                 TriangleAdjacent ta ( FindTriangleAdjacent(*edge));
    61                                 t = ta;
    62                                 i = ta;
    63 
    64                                 New[0] = ta.EdgeVertex(0);
    65                                 New[1] = ta.EdgeVertex(1);
    66                                 // warning the ref
    67                         }   
     37                        void Crack();
     38                        void UnCrack();
     39                        void Set();
    6840                };
    6941
    … …  
    7749
    7850                        //Methods
    79                         void Crack() { a.Crack(); b.Crack();}
    80                         void UnCrack() { a.UnCrack(); b.UnCrack();}
    81                         void Set() { a.Set(), b.Set();}
     51                        void Crack();
     52                        void UnCrack();
     53                        void Set();
    8254        };
     55
     56        /*Intermediary*/
     57        inline TriangleAdjacent FindTriangleAdjacent(Edge &E){
     58                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
     59
     60                Vertex * a = E.v[0];
     61                Vertex * b = E.v[1];
     62
     63                Triangle * t = a->t;
     64                int i = a->vint;
     65                TriangleAdjacent ta(t,EdgesVertexTriangle[i][0]); // Previous edge
     66                if (!t || i<0 || i>=3){
     67                        throw ErrorException(__FUNCT__,exprintf("!t || i<0 !! i>=3"));
     68                }
     69                if ( a!=(*t)(i)){
     70                        throw ErrorException(__FUNCT__,exprintf("a!=(*t)(i)"));
     71                }
     72                int k=0;
     73                do { // turn around vertex in direct sens (trigo)
     74                        k++;
     75                        if (k>=20000){
     76                                throw ErrorException(__FUNCT__,exprintf("k>=20000"));
     77                        }
     78                        //  in no crack => ta.EdgeVertex(1) == a otherwise ???
     79                        if (ta.EdgeVertex(1) ==  a && ta.EdgeVertex(0) ==  b) return ta; // find
     80                        ta = ta.Adj();
     81                        if (ta.EdgeVertex(0) ==  a && ta.EdgeVertex(1) ==  b) return ta; // find
     82                        --ta;
     83                } while (t != (Triangle *)ta);
     84                throw ErrorException(__FUNCT__,exprintf("FindTriangleAdjacent: triangle not found"));
     85                return TriangleAdjacent(0,0);//for compiler
     86        }
     87        inline Vertex* TheVertex(Vertex * a){// for remove crak in mesh
     88                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
     89
     90                // give a unique vertex with smallest number
     91                // in case on crack in mesh
     92                Vertex * r(a), *rr;
     93                Triangle * t = a->t;
     94                int i = a->vint;
     95                TriangleAdjacent ta(t,EdgesVertexTriangle[i][0]); // Previous edge
     96                if (!t || i<0 || i>=3){
     97                        throw ErrorException(__FUNCT__,exprintf("!t || i<0 !! i>=3"));
     98                }
     99                if ( a!=(*t)(i)){
     100                        throw ErrorException(__FUNCT__,exprintf("a!=(*t)(i)"));
     101                }
     102                int k=0;
     103                do { // turn around vertex in direct sens (trigo)
     104                        k++;
     105                        if (k>=20000){
     106                                throw ErrorException(__FUNCT__,exprintf("k>=20000"));
     107                        }
     108                        //  in no crack => ta.EdgeVertex(1) == a
     109                        if ((rr=ta.EdgeVertex(0)) < r) r = rr;
     110                        ta = ta.Adj();
     111                        if ((rr=ta.EdgeVertex(1)) < r) r =rr;
     112                        --ta;
     113                } while (t != (Triangle*) ta); 
     114                return r;
     115        }
    83116
    84117}

  • issm/trunk/src/c/Bamgx/objects/Curve.h

    r3232 r3263  
    2525                        Curve() : be(0),ee(0),kb(0),ke(0),next(0),master(true) {}
    2626                        void Reverse() { Exchange(be,ee); Exchange(kb,ke);} //  revese the sens of the curse
    27 
    28                         //Inline methods
    29                         inline void Set(const Curve & rec,const Geometry & Th ,Geometry & ThNew);
     27                        void Set(const Curve & rec,const Geometry & Th ,Geometry & ThNew);
    3028        };
    3129

  • issm/trunk/src/c/Bamgx/objects/Direction.h

    r3232 r3263  
    1313                        //Methods
    1414                        Direction(): dir(MaxICoor){}; //  no direction set
    15                         Direction(Icoor1 i,Icoor1 j) {
    16                                 Icoor2 n2 = 2*(Abs(i)+Abs(j)); 
    17                                 Icoor2 r  = MaxICoor* (Icoor2) i;
    18                                 Icoor1 r1 = (Icoor1) (2*(r/ n2)); // odd number
    19                                 dir = (j>0) ? r1 : r1+1;          // odd-> j>0 even-> j<0
    20                         }
    21                         int sens(Icoor1 i,Icoor1 j) {
    22                                 int r =1;
    23                                 if (dir!= MaxICoor) {
    24                                         Icoor2 x(dir/2),y1(MaxICoor/2-Abs(x)),y(dir%2?-y1:y1);
    25                                         r = (x*i + y*j) >=0;
    26                                 }
    27                                 return r;
    28                         }
     15                        Direction(Icoor1 i,Icoor1 j);
     16                        int sens(Icoor1 i,Icoor1 j);
    2917        };
    3018}

  • issm/trunk/src/c/Bamgx/objects/Edge.h

    r3243 r3263  
    4545                                return adj[0]==&e ? 0 : 1;
    4646                        }
    47 
    48                         //Inline methods
    49                         inline void Set(const Triangles &,long,Triangles &);
     47                        void Set(const Triangles &,long,Triangles &);
    5048
    5149        };

  • issm/trunk/src/c/Bamgx/objects/GeometricalEdge.cpp

    r3246 r3263  
    55
    66#include "GeometricalEdge.h"
     7#include "Geometry.h"
    78
    89#undef __FUNCT__
    … …  
    133134          }
    134135        /*}}}1*/
     136        /*FUNCTION GeometricalEdge::Set {{{1*/
     137        void GeometricalEdge::Set(const GeometricalEdge & rec,const Geometry & Gh ,Geometry & GhNew){
     138                *this = rec;
     139                v[0] = GhNew.vertices + Gh.Number(v[0]);   
     140                v[1] = GhNew.vertices + Gh.Number(v[1]);
     141                if (Adj[0]) Adj[0] =  GhNew.edges + Gh.Number(Adj[0]);     
     142                if (Adj[1]) Adj[1] =  GhNew.edges + Gh.Number(Adj[1]);     
     143        }
     144        /*}}}*/
    135145
    136146}

  • issm/trunk/src/c/Bamgx/objects/GeometricalEdge.h

    r3243 r3263  
    5555                        void SetRequired() { flag |= 64;}
    5656                        void SetReverseEqui() {flag |= 128;}
    57 
    58                         //Inline methods
    59                         inline void Set(const GeometricalEdge & rec,const Geometry & Th ,Geometry & ThNew);
     57                        void Set(const GeometricalEdge & rec,const Geometry & Th ,Geometry & ThNew);
    6058        };
    6159

  • issm/trunk/src/c/Bamgx/objects/GeometricalSubDomain.h

    r3243 r3263  
    2121                        long ref;
    2222
    23                         //Inline methods
    24                         inline void Set(const GeometricalSubDomain &,const Geometry & ,const Geometry &);
     23                        //Methods
     24                        void Set(const GeometricalSubDomain &,const Geometry & ,const Geometry &);
    2525        };
    2626

  • issm/trunk/src/c/Bamgx/objects/GeometricalVertex.h

    r3252 r3263  
    88
    99#include "../meshtype.h"
     10#include "Vertex.h"
    1011
    1112namespace bamg {
    … …  
    2223                        GeometricalVertex* link; //  link all the same GeometricalVertex circular (Crack)
    2324
     25                        //Constructors
     26                        GeometricalVertex() :cas(0), link(this) {};
     27
    2428                        //Methods
    25                         int  Corner() const {return cas&4;}
    26                         int  Required()const {return cas&6;}// a corner is required
    27                         int  IsThe() const { return link == this;} 
    28                         void SetCorner(){ cas |= 4;}
    29                         void SetRequired(){ cas |= 2;}
    30                         void Set(){cas=0;}
    31                         GeometricalVertex() :cas(0), link(this) {};
    32                         GeometricalVertex* The() {
    33                                 if (!link){ throw ErrorException(__FUNCT__,exprintf("!link"));}
    34                                 return link;
    35                         }// return a unique vertex
     29                        int  Corner() const;
     30                        int  Required()const;
     31                        int  IsThe() const;
     32                        void SetCorner();
     33                        void SetRequired();
     34                        void Set();
     35                        GeometricalVertex* The();
    3636
    3737                        //Inline methods
    38                         inline void Set(const GeometricalVertex & rec,const Geometry & ,const Geometry & ){ 
    39                                 *this  = rec;
     38                        inline void Set(const GeometricalVertex & rec,const Geometry & ,const Geometry & ){
     39                                *this=rec;
    4040                        }
    4141        };

  • issm/trunk/src/c/Bamgx/objects/Geometry.cpp

    r3246 r3263  
    44#include <ctime>
    55
    6 #include "../BamgObjects.h"
     6#include "BamgObjects.h"
    77
    88#undef __FUNCT__

  • issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp

    r3246 r3263  
    44#include <ctime>
    55
    6 #include "../BamgObjects.h"
     6#include "BamgObjects.h"
    77#include "../shared/shared.h"
    88

  • issm/trunk/src/c/Bamgx/objects/QuadTree.cpp

    r3246 r3263  
    44
    55//#include "QuadTree.h"
    6 #include "../BamgObjects.h"
     6#include "BamgObjects.h"
    77
    88#undef __FUNCT__
    … …  
    1111namespace bamg {
    1212
    13         //INTER_SEG(a,b,x,y) returns 1 if [x y] is included in [a b]
     13        /*MACROS {{{1*/
    1414#define INTER_SEG(a,b,x,y) (((y) > (a)) && ((x) <(b)))
    15         //ABS(i) retruns |i|
    1615#define ABS(i) ((i)<0 ?-(i) :(i))
    17         //MAX1(i,j) returns max(i,j)
    1816#define MAX1(i,j) ((i)>(j) ?(i) :(j))
    19         //NORM(i1,j1,i2,j2) returns max(|i1-j1|,|i2-j2|)
    2017#define NORM(i1,j1,i2,j2) MAX1(ABS((i1)-(j1)),ABS((i2)-(j2)))
    2118        //IJ(i,j,l) returns the box number of i and j with respect to l
    … …  
    2926        //J_IJ(k,l) returns l if second bit of k is 1, else 0
    3027#define J_IJ(k,l)  ((k&2) ? l:0)
    31 
    32         /*What is a QuadTree?
     28        /*}}}*/
     29        /*DOCUMENTATION What is a QuadTree? {{{1
    3330         * A Quadtree is a very simple way to group the vertices according
    3431         * to their location. A square that holds all the points of the mesh
    … …  
    7673         * Using the binaries is therefor very easy to locate a vertex in a box:
    7774         * we just need to look at the bits from the left to the right (See ::Add)
    78          */
     75         }}}1*/
    7976
    8077        /*Constructors/Destructors*/

  • issm/trunk/src/c/Bamgx/objects/SetOfE4.cpp

    r3246 r3263  
    11
    2 #include "../BamgObjects.h"
     2#include "BamgObjects.h"
    33
    44#undef __FUNCT__

  • issm/trunk/src/c/Bamgx/objects/SubDomain.h

    r3243 r3263  
    2323                        Edge* edge; // to  geometrical 
    2424
    25                         //Inline methods
    26                         inline void Set(const Triangles &,long,Triangles &);
     25                        //Methods
     26                        void Set(const Triangles &,long,Triangles &);
    2727        };
    2828

  • issm/trunk/src/c/Bamgx/objects/Triangle.cpp

    r3246 r3263  
    44#include <ctime>
    55
    6 #include "../BamgObjects.h"
     6#include "BamgObjects.h"
    77#include "../shared/shared.h"
    88
    … …  
    1212namespace bamg {
    1313
     14        /*Constructors/Destructors*/
     15        /*FUNCTION Triangle(Triangles *Th,long i,long j,long k) {{{1*/
     16        Triangle::Triangle(Triangles *Th,long i,long j,long k) {
     17                Vertex *v=Th->vertices;
     18                long nbv = Th->nbv;
     19                if (i<0 || j<0 || k<0){
     20                        throw ErrorException(__FUNCT__,exprintf("i<0 || j<0 || k<0"));
     21                }
     22                if (i>=nbv || j>=nbv || k>=nbv){
     23                        throw ErrorException(__FUNCT__,exprintf("i>=nbv || j>=nbv || k>=nbv"));
     24                }
     25                TriaVertices[0]=v+i;
     26                TriaVertices[1]=v+j;
     27                TriaVertices[2]=v+k;
     28                TriaAdjTriangles[0]=TriaAdjTriangles[1]=TriaAdjTriangles[2]=0;
     29                TriaAdjSharedEdge[0]=TriaAdjSharedEdge[1]=TriaAdjSharedEdge[2]=0;
     30                det=0;
     31        }
     32        /*}}}*/
     33        /*FUNCTION Triangle(Vertex *v0,Vertex *v1,Vertex *v2) {{{1*/
     34        Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2){
     35                TriaVertices[0]=v0;
     36                TriaVertices[1]=v1;
     37                TriaVertices[2]=v2;
     38                TriaAdjTriangles[0]=TriaAdjTriangles[1]=TriaAdjTriangles[2]=0;
     39                TriaAdjSharedEdge[0]=TriaAdjSharedEdge[1]=TriaAdjSharedEdge[2]=0;
     40                if (v0) det=0;
     41                else {
     42                        det=-1;
     43                        link=NULL;}; 
     44        }
     45        /*}}}*/
     46
    1447        /*Methods*/
     48        /*FUNCTION Triangle::Echo {{{1*/
     49        void Triangle::Echo(void){
     50
     51                int i;
     52
     53                printf("Triangle:\n");
     54                printf("   TriaVertices pointer towards three vertices\n");
     55                printf("      TriaVertices[0] TriaVertices[1] TriaVertices[2] = %p %p %p\n",TriaVertices[0],TriaVertices[1],TriaVertices[2]);
     56                printf("   TriaAdjTriangles pointer towards three adjacent triangles\n");
     57                printf("      TriaAdjTriangles[0] TriaAdjTriangles[1] TriaAdjTriangles[2] = %p %p %p\n",TriaAdjTriangles[0],TriaAdjTriangles[1],TriaAdjTriangles[2]);
     58                printf("   det (integer triangle determinant) = %i\n",det);
     59                if (link){
     60                        printf("   link (pointer toward duplicate triangle)= %p\n",link);
     61                }
     62                else{
     63                        printf("   color = %i\n",color);
     64                }
     65
     66                printf("\nThree vertices:\n");
     67                for(i=0;i<3;i++){
     68                        if (TriaVertices[i]){
     69                                TriaVertices[i]->Echo();
     70                        }
     71                        else{
     72                                printf("   vertex %i does not exist\n",i+1);
     73                        }
     74                }
     75
     76                return;
     77        }
     78        /*}}}*/
    1579        /*FUNCTION Triangle::FindBoundaryEdge{{{1*/
    1680        TriangleAdjacent Triangle::FindBoundaryEdge(int i) const{
    … …  
    60124        }
    61125        /*}}}1*/
    62         /*FUNCTION Triangle::Echo {{{1*/
    63         void Triangle::Echo(void){
    64 
    65                 int i;
    66 
    67                 printf("Triangle:\n");
    68                 printf("   TriaVertices pointer towards three vertices\n");
    69                 printf("      TriaVertices[0] TriaVertices[1] TriaVertices[2] = %p %p %p\n",TriaVertices[0],TriaVertices[1],TriaVertices[2]);
    70                 printf("   TriaAdjTriangles pointer towards three adjacent triangles\n");
    71                 printf("      TriaAdjTriangles[0] TriaAdjTriangles[1] TriaAdjTriangles[2] = %p %p %p\n",TriaAdjTriangles[0],TriaAdjTriangles[1],TriaAdjTriangles[2]);
    72                 printf("   det (integer triangle determinant) = %i\n",det);
    73                 if (link){
    74                         printf("   link (pointer toward duplicate triangle)= %p\n",link);
    75                 }
    76                 else{
    77                         printf("   color = %i\n",color);
    78                 }
    79 
    80                 printf("\nThree vertices:\n");
    81                 for(i=0;i<3;i++){
    82                         if (TriaVertices[i]){
    83                                 TriaVertices[i]->Echo();
    84                         }
    85                         else{
    86                                 printf("   vertex %i does not exist\n",i+1);
    87                         }
    88                 }
    89 
    90                 return;
    91         }
    92         /*}}}*/
    93126        /*FUNCTION Triangle::Optim{{{1*/
    94127        long  Triangle::Optim(short i,int koption) {
    … …  
    124157        }
    125158        /*}}}1*/
     159        /*FUNCTION Triangle::Quadrangle {{{1*/
     160        Triangle* Triangle::Quadrangle(Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const{
     161                // return the other triangle of the quad if a quad or 0 if not a quat
     162                Triangle * t =0;
     163                if (link) {
     164                        int a=-1;
     165                        if (TriaAdjSharedEdge[0] & 16 ) a=0;
     166                        if (TriaAdjSharedEdge[1] & 16 ) a=1;
     167                        if (TriaAdjSharedEdge[2] & 16 ) a=2;
     168                        if (a>=0) {
     169                                t = TriaAdjTriangles[a];
     170                                //  if (t-this<0) return 0;
     171                                v2 = TriaVertices[VerticesOfTriangularEdge[a][0]];
     172                                v0 = TriaVertices[VerticesOfTriangularEdge[a][1]];
     173                                v1 = TriaVertices[OppositeEdge[a]];
     174                                v3 = t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
     175                        }
     176                }
     177                return t;
     178        }
     179        /*}}}*/
     180        /*FUNCTION Triangle::QualityQuad {{{1*/
     181        double   Triangle::QualityQuad(int a,int option) const{
     182                double q;
     183                if (!link || TriaAdjSharedEdge[a] &4)
     184                 q=  -1;
     185                else {
     186                        Triangle * t = TriaAdjTriangles[a];
     187                        if (t-this<0) q=  -1;// because we do 2 times
     188                        else if (!t->link ) q=  -1;
     189                        else if (TriaAdjSharedEdge[0] & 16 || TriaAdjSharedEdge[1] & 16  || TriaAdjSharedEdge[2] & 16 || t->TriaAdjSharedEdge[0] & 16 || t->TriaAdjSharedEdge[1] & 16 || t->TriaAdjSharedEdge[2] & 16 )
     190                         q= -1;
     191                        else if(option){
     192                                const Vertex & v2 = *TriaVertices[VerticesOfTriangularEdge[a][0]];
     193                                const Vertex & v0 = *TriaVertices[VerticesOfTriangularEdge[a][1]];
     194                                const Vertex & v1 = *TriaVertices[OppositeEdge[a]];
     195                                const Vertex & v3 = * t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
     196                                q =  QuadQuality(v0,v1,v2,v3); // do the float part
     197                        }
     198                        else q= 1;
     199                }
     200                return  q;
     201        }
     202        /*}}}*/
     203        /*FUNCTION Triangle::Set {{{1*/
     204        void Triangle::Set(const Triangle & rec,const Triangles & Th ,Triangles & ThNew){
     205                *this = rec;
     206                if ( TriaVertices[0] ) TriaVertices[0] = ThNew.vertices +  Th.Number(TriaVertices[0]);
     207                if ( TriaVertices[1] ) TriaVertices[1] = ThNew.vertices +  Th.Number(TriaVertices[1]);
     208                if ( TriaVertices[2] ) TriaVertices[2] = ThNew.vertices +  Th.Number(TriaVertices[2]);
     209                if(TriaAdjTriangles[0]) TriaAdjTriangles[0] =  ThNew.triangles + Th.Number(TriaAdjTriangles[0]);
     210                if(TriaAdjTriangles[1]) TriaAdjTriangles[1] =  ThNew.triangles + Th.Number(TriaAdjTriangles[1]);
     211                if(TriaAdjTriangles[2]) TriaAdjTriangles[2] =  ThNew.triangles + Th.Number(TriaAdjTriangles[2]);
     212                if (link  >= Th.triangles && link  < Th.triangles + Th.nbt)
     213                 link = ThNew.triangles + Th.Number(link);
     214        }
     215        /*}}}*/
    126216        /*FUNCTION Triangle::swap{{{1*/
    127217        int Triangle::swap(short a,int koption){
    … …  
    226316                                                 OnSwap = som < 2;
    227317                                                 break;
    228                                                 }
     318                                         }
    229319
    230320                                } // OnSwap

  • issm/trunk/src/c/Bamgx/objects/Triangle.h

    r3243 r3263  
    126126
    127127                        //Inline methods
    128                         inline double qualite() ;
    129                         inline void  Set(const Triangle &,const Triangles &,Triangles &);
    130                         inline int   In(Vertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;}
     128                        double qualite() ;
     129                        void  Set(const Triangle &,const Triangles &,Triangles &);
     130                        int   In(Vertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;}
    131131
    132132        };

  • issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h

    r3232 r3263  
    3333
    3434                        //Methods
    35                         int swap();
    3635
    37                         //Inline methods
    38                         inline TriangleAdjacent  Adj() const ;
    39                         inline void SetAdj2(const TriangleAdjacent& , int =0);
    40                         inline Vertex *  EdgeVertex(const int &) const ;
    41                         inline Vertex *  OppositeVertex() const ;
    42                         inline Icoor2 & det() const;
    43                         inline int Locked() const  ;
    44                         inline int GetAllFlag_UnSwap() const ;
    45                         inline void SetLock();
    46                         inline int MarkUnSwap() const;
    47                         inline void SetMarkUnSwap();
    48                         inline void SetCracked();
    49                         inline int Cracked() const ;
     36                        //Methods
     37                        int  Locked() const;
     38                        int  MarkUnSwap() const;
     39                        int  Cracked() const;
     40                        int  GetAllFlag_UnSwap() const;
     41                        void SetLock();
     42                        void SetCracked();
     43                        void SetAdj2(const TriangleAdjacent &ta, int l=0);
     44                        int  swap();
     45                        TriangleAdjacent Adj() const;
     46                        Vertex* EdgeVertex(const int & i) const;
     47                        Vertex* OppositeVertex() const;
     48                        Icoor2& det() const;
    5049        };
    5150}

  • issm/trunk/src/c/Bamgx/objects/Triangles.cpp

    r3252 r3263  
    44#include <ctime>
    55
    6 #include "../BamgObjects.h"
     6#include "BamgObjects.h"
    77#include "../shared/shared.h"
    88#include "QuadTree.h"
    … …  
    54215421
    54225422        /*Intermediary*/
    5423         /*FUNCTION swap{{{1*/
    5424         void  swap(Triangle *t1,short a1, Triangle *t2,short a2, Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2){
    5425                 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
    5426                 // --------------------------------------------------------------
    5427                 // short a2=aa[a];// les 2 numero de l arete dans les 2 triangles
    5428                 //                               
    5429                 //               sb                     sb   
    5430                 //             / | \                   /   \                      !
    5431                 //         as1/  |  \                 /a2   \                     !
    5432                 //           /   |   \               /    t2 \                    !
    5433                 //       s1 /t1  | t2 \s2  -->   s1 /___as2___\s2                 !
    5434                 //          \  a1|a2  /             \   as1   / 
    5435                 //           \   |   /               \ t1    /   
    5436                 //            \  |  / as2             \   a1/   
    5437                 //             \ | /                   \   /     
    5438                 //              sa                       sa   
    5439                 //  -------------------------------------------------------------
    5440                 int as1 = NextEdge[a1];
    5441                 int as2 = NextEdge[a2];
    5442                 int ap1 = PreviousEdge[a1];
    5443                 int ap2 = PreviousEdge[a2];
    5444                 (*t1)(VerticesOfTriangularEdge[a1][1]) = s2 ; // avant sb
    5445                 (*t2)(VerticesOfTriangularEdge[a2][1]) = s1  ; // avant sa
    5446                 // mise a jour des 2 adjacences externes
    5447                 TriangleAdjacent taas1 = t1->Adj(as1),
    5448                                                           taas2 = t2->Adj(as2),
    5449                                                           tas1(t1,as1), tas2(t2,as2),
    5450                                                           ta1(t1,a1),ta2(t2,a2);
    5451                 // externe haut gauche
    5452                 taas1.SetAdj2(ta2, taas1.GetAllFlag_UnSwap());
    5453                 // externe bas droite
    5454                 taas2.SetAdj2(ta1, taas2.GetAllFlag_UnSwap());
    5455                 // remove the Mark  UnMarkSwap
    5456                 t1->SetUnMarkUnSwap(ap1);
    5457                 t2->SetUnMarkUnSwap(ap2);
    5458                 // interne
    5459                 tas1.SetAdj2(tas2);
    5460 
    5461                 t1->det = det1;
    5462                 t2->det = det2;
    5463 
    5464                 t1->SetTriangleContainingTheVertex();
    5465                 t2->SetTriangleContainingTheVertex();
    5466         } // end swap
    5467         /*}}}1*/
    54685423        /*FUNCTION CloseBoundaryEdge{{{1*/
    54695424        TriangleAdjacent CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {
    … …  
    56555610        }
    56565611        /*}}}1*/
     5612/*FUNCTION ForceEdge{{{1*/
     5613int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret)  {
     5614        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
     5615
     5616        int NbSwap =0;
     5617        if (!a.t || !b.t){ // the 2 vertex is in a mesh
     5618                throw ErrorException(__FUNCT__,exprintf("!a.t || !b.t"));
     5619        }
     5620        int k=0;
     5621        taret=TriangleAdjacent(0,0); // erreur
     5622
     5623        TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]);
     5624        Vertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
     5625        // we turn around a in the  direct sens 
     5626
     5627        Icoor2 det2 = v2 ? det(*v2,a,b): -1 , det1;
     5628        if(v2) // normal case
     5629         det2 = det(*v2,a,b);
     5630        else { // no chance infini vertex try the next
     5631                tta= Previous(Adj(tta));
     5632                v2 = tta.EdgeVertex(0);
     5633                vbegin =v2;
     5634                if (!v2){
     5635                        throw ErrorException(__FUNCT__,exprintf("!v2"));
     5636                }
     5637                det2 = det(*v2,a,b);
     5638        }
     5639
     5640        while (v2 != &b) {
     5641                TriangleAdjacent tc = Previous(Adj(tta));   
     5642                v1 = v2;
     5643                v2 = tc.EdgeVertex(0);
     5644                det1 = det2;
     5645                det2 =  v2 ? det(*v2,a,b): det2;
     5646
     5647                if((det1 < 0) && (det2 >0)) {
     5648                        // try to force the edge
     5649                        Vertex * va = &a, *vb = &b;
     5650                        tc = Previous(tc);
     5651                        if (!v1 || !v2){
     5652                                throw ErrorException(__FUNCT__,exprintf("!v1 || !v2"));
     5653                        }
     5654                        Icoor2 detss = 0,l=0,ks;
     5655                        while ((ks=SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
     5656                         if(l++ > 10000000) {
     5657                                 throw ErrorException(__FUNCT__,exprintf("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l));
     5658                         }
     5659                        Vertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
     5660                        if (( aa == &a ) && (bb == &b) ||  (bb ==  &a ) && (aa == &b)) {
     5661                                tc.SetLock();
     5662                                a.Optim(1,0);
     5663                                b.Optim(1,0);
     5664                                taret = tc;
     5665                                return NbSwap;
     5666                        }
     5667                        else
     5668                          {
     5669                                taret = tc;
     5670                                return -2; // error  boundary is crossing
     5671                          }
     5672                }
     5673                tta = tc;
     5674                k++;
     5675                if (k>=2000){
     5676                        throw ErrorException(__FUNCT__,exprintf("k>=2000"));
     5677                }
     5678                if ( vbegin == v2 ) return -1;// error
     5679        }
     5680
     5681        tta.SetLock();
     5682        taret=tta;
     5683        a.Optim(1,0);
     5684        b.Optim(1,0);
     5685        return NbSwap;
     5686}
     5687/*}}}1*/
     5688/*FUNCTION swap{{{1*/
     5689void  swap(Triangle *t1,short a1, Triangle *t2,short a2, Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2){
     5690        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
     5691        // --------------------------------------------------------------
     5692        // short a2=aa[a];// les 2 numero de l arete dans les 2 triangles
     5693        //                               
     5694        //               sb                     sb   
     5695        //             / | \                   /   \                      !
     5696        //         as1/  |  \                 /a2   \                     !
     5697        //           /   |   \               /    t2 \                    !
     5698        //       s1 /t1  | t2 \s2  -->   s1 /___as2___\s2                 !
     5699        //          \  a1|a2  /             \   as1   / 
     5700        //           \   |   /               \ t1    /   
     5701        //            \  |  / as2             \   a1/   
     5702        //             \ | /                   \   /     
     5703        //              sa                       sa   
     5704        //  -------------------------------------------------------------
     5705        int as1 = NextEdge[a1];
     5706        int as2 = NextEdge[a2];
     5707        int ap1 = PreviousEdge[a1];
     5708        int ap2 = PreviousEdge[a2];
     5709        (*t1)(VerticesOfTriangularEdge[a1][1]) = s2 ; // avant sb
     5710        (*t2)(VerticesOfTriangularEdge[a2][1]) = s1  ; // avant sa
     5711        // mise a jour des 2 adjacences externes
     5712        TriangleAdjacent taas1 = t1->Adj(as1),
     5713                                                  taas2 = t2->Adj(as2),
     5714                                                  tas1(t1,as1), tas2(t2,as2),
     5715                                                  ta1(t1,a1),ta2(t2,a2);
     5716        // externe haut gauche
     5717        taas1.SetAdj2(ta2, taas1.GetAllFlag_UnSwap());
     5718        // externe bas droite
     5719        taas2.SetAdj2(ta1, taas2.GetAllFlag_UnSwap());
     5720        // remove the Mark  UnMarkSwap
     5721        t1->SetUnMarkUnSwap(ap1);
     5722        t2->SetUnMarkUnSwap(ap2);
     5723        // interne
     5724        tas1.SetAdj2(tas2);
     5725
     5726        t1->det = det1;
     5727        t2->det = det2;
     5728
     5729        t1->SetTriangleContainingTheVertex();
     5730        t2->SetTriangleContainingTheVertex();
     5731} // end swap
     5732/*}}}1*/
    56575733        /*FUNCTION SwapForForcingEdge{{{1*/
    56585734        int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
    … …  
    57435819        }
    57445820        /*}}}1*/
    5745         /*FUNCTION ForceEdge{{{1*/
    5746         int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret)  {
    5747                 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
    5748 
    5749                 int NbSwap =0;
    5750                 if (!a.t || !b.t){ // the 2 vertex is in a mesh
    5751                         throw ErrorException(__FUNCT__,exprintf("!a.t || !b.t"));
    5752                 }
    5753                 int k=0;
    5754                 taret=TriangleAdjacent(0,0); // erreur
    5755 
    5756                 TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]);
    5757                 Vertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
    5758                 // we turn around a in the  direct sens 
    5759 
    5760                 Icoor2 det2 = v2 ? det(*v2,a,b): -1 , det1;
    5761                 if(v2) // normal case
    5762                  det2 = det(*v2,a,b);
    5763                 else { // no chance infini vertex try the next
    5764                         tta= Previous(Adj(tta));
    5765                         v2 = tta.EdgeVertex(0);
    5766                         vbegin =v2;
    5767                         if (!v2){
    5768                                 throw ErrorException(__FUNCT__,exprintf("!v2"));
    5769                         }
    5770                         det2 = det(*v2,a,b);
    5771                 }
    5772 
    5773                 while (v2 != &b) {
    5774                         TriangleAdjacent tc = Previous(Adj(tta));   
    5775                         v1 = v2;
    5776                         v2 = tc.EdgeVertex(0);
    5777                         det1 = det2;
    5778                         det2 =  v2 ? det(*v2,a,b): det2;
    5779 
    5780                         if((det1 < 0) && (det2 >0)) {
    5781                                 // try to force the edge
    5782                                 Vertex * va = &a, *vb = &b;
    5783                                 tc = Previous(tc);
    5784                                 if (!v1 || !v2){
    5785                                         throw ErrorException(__FUNCT__,exprintf("!v1 || !v2"));
    5786                                 }
    5787                                 Icoor2 detss = 0,l=0,ks;
    5788                                 while ((ks=SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
    5789                                  if(l++ > 10000000) {
    5790                                          throw ErrorException(__FUNCT__,exprintf("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l));
    5791                                  }
    5792                                 Vertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
    5793                                 if (( aa == &a ) && (bb == &b) ||  (bb ==  &a ) && (aa == &b)) {
    5794                                         tc.SetLock();
    5795                                         a.Optim(1,0);
    5796                                         b.Optim(1,0);
    5797                                         taret = tc;
    5798                                         return NbSwap;
    5799                                 }
    5800                                 else
    5801                                   {
    5802                                         taret = tc;
    5803                                         return -2; // error  boundary is crossing
    5804                                   }
    5805                         }
    5806                         tta = tc;
    5807                         k++;
    5808                         if (k>=2000){
    5809                                 throw ErrorException(__FUNCT__,exprintf("k>=2000"));
    5810                         }
    5811                         if ( vbegin == v2 ) return -1;// error
    5812                 }
    5813 
    5814                 tta.SetLock();
    5815                 taret=tta;
    5816                 a.Optim(1,0);
    5817                 b.Optim(1,0);
    5818                 return NbSwap;
    5819         }
    5820         /*}}}1*/
    58215821
    58225822}

  • issm/trunk/src/c/Bamgx/objects/Triangles.h

    r3245 r3263  
    106106                        void ShowHistogram() const;
    107107                        void ShowRegulaty() const;
    108                         void ReMakeTriangleContainingTheVertex();
    109                         void UnMarkUnSwapTriangle();
    110108                        void SmoothMetric(double raisonmax) ;
    111109                        void BoundAnisotropy(double anisomax,double hminaniso= 1e-100) ;
    112110                        void MaxSubDivision(double maxsubdiv);
    113111                        Edge** MakeGeometricalEdgeToEdge();
    114                         void SetVertexFieldOn(); 
    115                         void SetVertexFieldOnBTh();
    116112                        long SplitInternalEdgeWithBorderVertices();
    117113                        void MakeQuadrangles(double costheta);
    … …  
    152148                        int  CrackMesh();
    153149
     150                        //Inline methods
     151                        inline  void ReMakeTriangleContainingTheVertex(){
     152                                for (int i=0;i<nbv;i++) vertices[i].vint=0, vertices[i].t=0;
     153                                for (int i=0;i<nbt;i++) triangles[i].SetTriangleContainingTheVertex();
     154                        }
     155                        inline  void  UnMarkUnSwapTriangle(){
     156                                for (int i=0;i<nbt;i++)
     157                                 for(int j=0;j<3;j++)
     158                                  triangles[i].SetUnMarkUnSwap(j);
     159                          }
     160                        inline  void  SetVertexFieldOn(){
     161                                for (int i=0;i<nbv;i++)                    vertices[i].onGeometry=0;
     162                                for (int j=0;j<NbVerticesOnGeomVertex;j++) VerticesOnGeomVertex[j].SetOn();
     163                                for (int k=0;k<NbVerticesOnGeomEdge;k++ )  VerticesOnGeomEdge[k].SetOn();
     164                        }             
     165                        inline  void   SetVertexFieldOnBTh(){
     166                                for (int i=0;i<nbv;i++)                 vertices[i].onGeometry=0;
     167                                for (int j=0;j<NbVertexOnBThVertex;j++) VertexOnBThVertex[j].SetOnBTh();
     168                                for (int k=0;k<NbVertexOnBThEdge;k++ )  VertexOnBThEdge[k].SetOnBTh();
     169                        }
     170
    154171                private:
    155172                        void GeomToTriangles1(long nbvx,BamgOpts* bamgopts,int KeepVertices=1);// the real constructor mesh adaption
    … …  
    159176        };
    160177
     178        /*Intermediary*/
     179        TriangleAdjacent CloseBoundaryEdge(I2 ,Triangle *, double &,double &) ;
     180        TriangleAdjacent CloseBoundaryEdgeV2(I2 A,Triangle *t, double &a,double &b);
     181        void  swap(Triangle *t1,short a1,
     182                                Triangle *t2,short a2,
     183                                Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2);
     184        int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,
     185                                TriangleAdjacent & tt1,Icoor2 & dets1,
     186                                Icoor2 & detsa,Icoor2 & detsb, int & nbswap);
     187        int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret) ;
     188        inline TriangleAdjacent Previous(const TriangleAdjacent & ta){
     189                return TriangleAdjacent(ta.t,PreviousEdge[ta.a]);
     190        }
     191        inline TriangleAdjacent Next(const TriangleAdjacent & ta){
     192                return TriangleAdjacent(ta.t,NextEdge[ta.a]);
     193        }
     194        inline  TriangleAdjacent Adj(const TriangleAdjacent & a){
     195                return  a.Adj();
     196        }
     197        inline void Adj(GeometricalEdge * & on,int &i){
     198                int j=i;i=on->DirAdj[i];on=on->Adj[j];
     199        }
     200        inline double qualite(const Vertex &va,const Vertex &vb,const Vertex &vc){
     201                double ret;
     202                I2 ia=va,ib=vb,ic=vc;
     203                I2 ab=ib-ia,bc=ic-ib,ac=ic-ia;
     204                Icoor2 deta=Det(ab,ac);
     205                if (deta <=0) ret = -1;
     206                else {
     207                        double a = sqrt((double) (ac,ac)),
     208                                         b = sqrt((double) (bc,bc)),
     209                                         c = sqrt((double) (ab,ab)),
     210                                         p = a+b+c;
     211                        double h= Max(Max(a,b),c),ro=deta/p;
     212                        ret = ro/h;
     213                }
     214                return ret;
     215        }
     216
    161217}
    162218#endif

  • issm/trunk/src/c/Bamgx/objects/Vertex.cpp

    r3246 r3263  
    44#include <ctime>
    55
    6 #include "../BamgObjects.h"
     6#include "BamgObjects.h"
    77#include "../shared/shared.h"
    88
    … …  
    209209        }
    210210        /*}}}*/
     211        /*FUNCTION Vertex::Optim {{{1*/
     212        long Vertex::Optim(int i,int koption){
     213                long ret=0;
     214                if ( t && (vint >= 0 ) && (vint <3) ){
     215                        ret = t->Optim(vint,koption);
     216                        if(!i){
     217                                t =0; // for no future optime
     218                                vint= 0;
     219                        }
     220                }
     221                return ret;
     222        }
     223        /*}}}*/
    211224
    212225        /*Intermediary*/

  • issm/trunk/src/c/Bamgx/objects/Vertex.h

    r3243 r3263  
    4848                        void  Echo();
    4949                        int   ref() const { return ReferenceNumber;}
     50                        long  Optim(int =1,int =0);
    5051
    5152                        //inline functions
    52                         inline long Optim(int =1,int =0);
    53                         inline void Set(const Vertex & rec,const Triangles &,Triangles &);
     53                        inline void Set(const Vertex &rec,const Triangles & ,Triangles & ){*this=rec;}
    5454        };
    5555

  • issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h

    r3243 r3263  
    3535                        //Methods
    3636                        void SetOnBTh(){v->onBackgroundEdge=this;v->vint=IsVertexOnEdge;} 
    37 
    38                         //Inline methods
    39                         inline void Set(const Triangles &,long,Triangles &); 
     37                        void Set(const Triangles &,long,Triangles &); 
    4038        };
    4139

  • issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h

    r3243 r3263  
    4646
    4747                        //Inline methods
    48                         inline void Set(const Triangles &,long,Triangles &);
    49                         inline void Set(const VertexOnGeom&,const Triangles &,Triangles &); 
     48                        //inline void Set(const Triangles &,long,Triangles &);
     49                        void Set(const VertexOnGeom&,const Triangles &,Triangles &); 
    5050
    5151        };

  • issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h

    r3243 r3263  
    2727                        //Methods
    2828                        void SetOnBTh(){v->onBackgroundVertex=bv;v->vint=IsVertexOnVertex;}
    29 
    30                         //Inline methods
    31                         inline void Set(const Triangles &,long,Triangles &);
     29                        void Set(const Triangles &,long,Triangles &);
    3230        };
    3331

  • issm/trunk/src/c/Bamgx/shared/shared.h

    r3254 r3263  
    88
    99#include "BigPrimeNumber.h"
    10 #include "qualite.h"
    11 #include "Next.h"
    12 #include "Previous.h"
    13 #include "Adj.h"
    14 #include "TheVertex.h"
    15 #include "FindTriangleAdjacent.h"
    1610
    1711#endif

  • issm/trunk/src/c/InterpFromMeshToMesh2dx/InterpFromMeshToMesh2dx.cpp

    r3244 r3263  
    1616#include <stdio.h>
    1717#include <string.h>
    18 #include "../Bamgx/BamgObjects.h"
    19 #include "../Bamgx/objects/QuadTree.h"
     18#include "../Bamgx/objects/BamgObjects.h"
    2019
    2120using namespace bamg;

  • issm/trunk/src/c/Makefile.am

    r3254 r3263  
    334334                                        ./Bamgx/meshtype.h\
    335335                                        ./Bamgx/objects/CrackedEdge.h\
     336                                        ./Bamgx/objects/CrackedEdge.cpp\
     337                                        ./Bamgx/objects/CrackedTriangle.h\
     338                                        ./Bamgx/objects/CrackedTriangle.cpp\
    336339                                        ./Bamgx/objects/Curve.h\
     340                                        ./Bamgx/objects/Curve.cpp\
    337341                                        ./Bamgx/objects/Direction.h\
     342                                        ./Bamgx/objects/Direction.cpp\
    338343                                        ./Bamgx/objects/DoubleAndInt.h\
    339344                                        ./Bamgx/objects/Edge.h\
     345                                        ./Bamgx/objects/Edge.cpp\
     346                                        ./Bamgx/objects/GeometricalEdge.h\
    340347                                        ./Bamgx/objects/GeometricalEdge.cpp\
    341                                         ./Bamgx/objects/GeometricalEdge.h\
    342348                                        ./Bamgx/objects/GeometricalSubDomain.h\
     349                                        ./Bamgx/objects/GeometricalSubDomain.cpp\
    343350                                        ./Bamgx/objects/GeometricalVertex.h\
     351                                        ./Bamgx/objects/GeometricalVertex.cpp\
    344352                                        ./Bamgx/objects/Geometry.cpp\
    345353                                        ./Bamgx/objects/Geometry.h\
    … …  
    355363                                        ./Bamgx/objects/SetOfE4.h\
    356364                                        ./Bamgx/objects/SubDomain.h\
     365                                        ./Bamgx/objects/SubDomain.cpp\
    357366                                        ./Bamgx/objects/TriangleAdjacent.h\
     367                                        ./Bamgx/objects/TriangleAdjacent.cpp\
    358368                                        ./Bamgx/objects/Triangle.cpp\
    359369                                        ./Bamgx/objects/Triangle.h\
    360370                                        ./Bamgx/shared/BigPrimeNumber.h\
    361371                                        ./Bamgx/shared/BigPrimeNumber.cpp\
    362                                         ./Bamgx/shared/Adj.h\
    363                                         ./Bamgx/shared/Next.h\
    364                                         ./Bamgx/shared/Previous.h\
    365                                         ./Bamgx/shared/qualite.h\
    366372                                        ./Bamgx/objects/Triangles.cpp\
    367373                                        ./Bamgx/objects/Triangles.h\
    … …  
    369375                                        ./Bamgx/objects/Vertex.h\
    370376                                        ./Bamgx/objects/VertexOnEdge.h\
     377                                        ./Bamgx/objects/VertexOnEdge.cpp\
    371378                                        ./Bamgx/objects/VertexOnGeom.h\
     379                                        ./Bamgx/objects/VertexOnGeom.cpp\
    372380                                        ./Bamgx/objects/VertexOnVertex.h\
    373                                         ./Bamgx/shared/FindTriangleAdjacent.h\
    374                                         ./Bamgx/shared/shared.h\
    375                                         ./Bamgx/shared/TheVertex.h
     381                                        ./Bamgx/objects/VertexOnVertex.cpp\
     382                                        ./Bamgx/shared/shared.h
    376383
    377384
    … …  
    706713                                        ./Bamgx/meshtype.h\
    707714                                        ./Bamgx/objects/CrackedEdge.h\
     715                                        ./Bamgx/objects/CrackedEdge.cpp\
     716                                        ./Bamgx/objects/CrackedTriangle.h\
     717                                        ./Bamgx/objects/CrackedTriangle.cpp\
    708718                                        ./Bamgx/objects/Curve.h\
     719                                        ./Bamgx/objects/Curve.cpp\
    709720                                        ./Bamgx/objects/Direction.h\
     721                                        ./Bamgx/objects/Direction.cpp\
    710722                                        ./Bamgx/objects/DoubleAndInt.h\
    711723                                        ./Bamgx/objects/Edge.h\
     724                                        ./Bamgx/objects/Edge.cpp\
     725                                        ./Bamgx/objects/GeometricalEdge.h\
    712726                                        ./Bamgx/objects/GeometricalEdge.cpp\
    713                                         ./Bamgx/objects/GeometricalEdge.h\
    714727                                        ./Bamgx/objects/GeometricalSubDomain.h\
     728                                        ./Bamgx/objects/GeometricalSubDomain.cpp\
    715729                                        ./Bamgx/objects/GeometricalVertex.h\
     730                                        ./Bamgx/objects/GeometricalVertex.cpp\
    716731                                        ./Bamgx/objects/Geometry.cpp\
    717732                                        ./Bamgx/objects/Geometry.h\
    … …  
    727742                                        ./Bamgx/objects/SetOfE4.h\
    728743                                        ./Bamgx/objects/SubDomain.h\
     744                                        ./Bamgx/objects/SubDomain.cpp\
    729745                                        ./Bamgx/objects/TriangleAdjacent.h\
     746                                        ./Bamgx/objects/TriangleAdjacent.cpp\
    730747                                        ./Bamgx/objects/Triangle.cpp\
    731748                                        ./Bamgx/objects/Triangle.h\
    732749                                        ./Bamgx/shared/BigPrimeNumber.h\
    733750                                        ./Bamgx/shared/BigPrimeNumber.cpp\
    734                                         ./Bamgx/shared/Adj.h\
    735                                         ./Bamgx/shared/Next.h\
    736                                         ./Bamgx/shared/Previous.h\
    737                                         ./Bamgx/shared/qualite.h\
    738751                                        ./Bamgx/objects/Triangles.cpp\
    739752                                        ./Bamgx/objects/Triangles.h\
    … …  
    741754                                        ./Bamgx/objects/Vertex.h\
    742755                                        ./Bamgx/objects/VertexOnEdge.h\
     756                                        ./Bamgx/objects/VertexOnEdge.cpp\
    743757                                        ./Bamgx/objects/VertexOnGeom.h\
     758                                        ./Bamgx/objects/VertexOnGeom.cpp\
    744759                                        ./Bamgx/objects/VertexOnVertex.h\
    745                                         ./Bamgx/shared/FindTriangleAdjacent.h\
    746                                         ./Bamgx/shared/shared.h\
    747                                         ./Bamgx/shared/TheVertex.h
     760                                        ./Bamgx/objects/VertexOnVertex.cpp\
     761                                        ./Bamgx/shared/shared.h
    748762
    749763libpISSM_a_CXXFLAGS = -fPIC -D_PARALLEL_   -D_C_ $(CXXOPTFLAGS)

  • issm/trunk/src/c/include/macros.h

    r3252 r3263  
    33 */
    44
    5 
    65#ifndef _MACROS_H_
    76#define _MACROS_H_
    87
    9 
    108/*Printing macro: */
    119#define _printf_(...) PrintfFunction(__VA_ARGS__)
    12 
    1310
    1411/*The following macros hide the error exception handling in a matlab module. Just put
    … …  
    3128        }
    3229
    33 
    34 
    3530#else
    36 
    3731
    3832#define MODULEBOOT(); \
    … …  
    5246
    5347#endif
    54 

  • issm/trunk/src/c/include/types.h

    r2333 r3263  
    55#ifndef _TYPES_H_
    66#define  _TYPES_H_
    7 
    87
    98/*Define abstract type for I/O: */
    … …  
    1918
    2019#endif //ifndef _TYPES_H_
    21 
Note: See TracChangeset for help on using the changeset viewer.