Changeset 3407


Ignore:
Timestamp:
04/06/10 11:19:09 (15 years ago)
Author:
Mathieu Morlighem
Message:

moved BamgVertex to MeshVertex

Location:
issm/trunk/src/c/Bamgx/objects
Files:
2 added
2 deleted
19 edited

Legend:

Unmodified
Added
Removed

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

    r3391 r3407  
    66#include "./DoubleAndInt.h"
    77#include "./Direction.h"
    8 #include "./BamgVertex.h"
     8#include "./MeshVertex.h"
    99#include "./TriangleAdjacent.h"
    1010#include "./Edge.h"

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212#include "TriangleAdjacent.h"
    1313#include "Edge.h"

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212#include "TriangleAdjacent.h"
    1313
    … …  
    2121
    2222                public:
    23                         Vertex* v[2];
     23                        MeshVertex* v[2];
    2424                        long ref;
    2525                        GeometricalEdge* onGeometry;
    … …  
    2727
    2828                        //Operators
    29                         Vertex & operator[](int i){return *v[i];};
    30                         Vertex * operator()(int i){return v[i];};
     29                        MeshVertex & operator[](int i){return *v[i];};
     30                        MeshVertex * operator()(int i){return v[i];};
    3131                        R2       operator()(double t) const; // return the point
    32                         const Vertex & operator[](int i) const { return *v[i];};
     32                        const MeshVertex & operator[](int i) const { return *v[i];};
    3333
    3434                        //Methods
    35                         void ReNumbering(Vertex *vb,Vertex *ve, long *renu){
     35                        void ReNumbering(MeshVertex *vb,MeshVertex *ve, long *renu){
    3636                                if (v[0] >=vb && v[0] <ve) v[0] = vb + renu[v[0]-vb];
    3737                                if (v[1] >=vb && v[1] <ve) v[1] = vb + renu[v[1]-vb];

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212
    1313namespace bamg {
    … …  
    1616        class Geometry;
    1717
    18         class GeometricalVertex : public Vertex {
     18        class GeometricalVertex : public MeshVertex {
    1919
    2020                public:

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

    r3335 r3407  
    120120                }
    121121                else{
    122                         ISSMERROR(exprintf("No Vertex provided"));
     122                        ISSMERROR(exprintf("No MeshVertex provided"));
    123123                }
    124124
    … …  
    438438                double eps=1e-20;
    439439                QuadTree quadtree; // build quadtree to find duplicates
    440                 Vertex* v0=vertices;
     440                MeshVertex* v0=vertices;
    441441                GeometricalVertex* v0g=(GeometricalVertex*) (void*)v0;   
    442442
    … …  
    457457
    458458                        //find nearest vertex already present in the quadtree (NULL if empty)
    459                         Vertex* v=quadtree.NearestVertex(vertices[i].i.x,vertices[i].i.y);
     459                        MeshVertex* v=quadtree.NearestVertex(vertices[i].i.x,vertices[i].i.y);
    460460
    461461                        //if there is a vertex found that is to close to vertices[i] -> error
    … …  
    465465                                j=vg-v0g;
    466466                                //check that the clostest vertex is not itself...
    467                                 if ( v !=  &(Vertex &) vertices[j]){
    468                                         ISSMERROR(exprintf(" v !=  &(Vertex &) vertices[j]"));
     467                                if ( v !=  &(MeshVertex &) vertices[j]){
     468                                        ISSMERROR(exprintf(" v !=  &(MeshVertex &) vertices[j]"));
    469469                                }
    470470                                vertices[i].link = vertices + j;
    … …  
    830830        /*}}}1*/
    831831        /*FUNCTION  Geometry::ProjectOnCurve {{{1*/
    832         GeometricalEdge* Geometry::ProjectOnCurve(const Edge &e,double s,Vertex &V,VertexOnGeom &GV) const {
     832        GeometricalEdge* Geometry::ProjectOnCurve(const Edge &e,double s,MeshVertex &V,VertexOnGeom &GV) const {
    833833                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/ProjectOnCurve)*/
    834834                /*Add a vertex on an existing geometrical edge according to the metrics of the two vertices constituting the edge*/
    … …  
    849849
    850850                //Get the two vertices of the edge
    851                 const Vertex &v0=e[0];
    852                 const Vertex &v1=e[1];
     851                const MeshVertex &v0=e[0];
     852                const MeshVertex &v1=e[1];
    853853
    854854                //Get position of V0, V1 and vector v0->v1
    … …  
    916916
    917917                if ((*eg0)(sens0)==(GeometricalVertex*)vg0)
    918                  vg0=VertexOnGeom(*(Vertex*) vg0,*eg0,sens0); //vg0 = absisce
     918                 vg0=VertexOnGeom(*(MeshVertex*) vg0,*eg0,sens0); //vg0 = absisce
    919919
    920920                if ((*eg1)(sens1)==(GeometricalVertex*)vg1)
    921                  vg1=VertexOnGeom(*(Vertex*) vg1,*eg1,sens1);
     921                 vg1=VertexOnGeom(*(MeshVertex*) vg1,*eg1,sens1);
    922922
    923923                double sg;

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212#include "Edge.h"
    1313#include "GeometricalVertex.h"
    … …  
    7070                        long Number(const Curve * c) const  { return c - curves;}
    7171                        void UnMarkEdges() {for (int i=0;i<nbe;i++) edges[i].SetUnMark();}
    72                         GeometricalEdge *  ProjectOnCurve(const Edge & ,double,Vertex &,VertexOnGeom &) const ;
     72                        GeometricalEdge *  ProjectOnCurve(const Edge & ,double,MeshVertex &,VertexOnGeom &) const ;
    7373                        GeometricalEdge *  Containing(const R2 P,  GeometricalEdge * start) const;
    7474                        void WriteGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts);

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

    r3332 r3407  
    4545                                double ba,bb;
    4646                                TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
    47                                 Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
     47                                MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
    4848                                NewItem(A,Metric(ba,v0,bb,v1));
    4949                                t=edge;
    … …  
    5151                                if (det(v0.i,v1.i,b)>=0) {
    5252                                        TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
    53                                         Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
     53                                        MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
    5454                                        NewItem(A,Metric(ba,v0,bb,v1));
    5555                                        return;
    … …  
    8181                                        long int verbosity=2;
    8282                                        TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
    83                                         Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
     83                                        MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
    8484                                        NewItem(A,Metric(ba,v0,bb,v1));
    8585                                        return;
    … …  
    233233                        lIntTria[Size].x = x;
    234234                        Metric m0,m1,m2;
    235                         register Vertex * v;
     235                        register MeshVertex * v;
    236236                        if ((v=(*tt)(0))) m0    = v->m;
    237237                        if ((v=(*tt)(1))) m1    = v->m;
    … …  
    308308        /*}}}1*/
    309309        /*FUNCTION ListofIntersectionTriangles::NewPoints{{{1*/
    310         long ListofIntersectionTriangles::NewPoints(Vertex* vertices,long &nbv,long nbvx){
     310        long ListofIntersectionTriangles::NewPoints(MeshVertex* vertices,long &nbv,long nbvx){
    311311                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewPoints)*/
    312312

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

    r3391 r3407  
    1010#include "../include/macros.h"
    1111#include "Metric.h"
    12 #include "BamgVertex.h"
     12#include "MeshVertex.h"
    1313#include "Edge.h"
    1414#include "GeometricalEdge.h"
    … …  
    8282                        void  SplitEdge(const Triangles & ,const R2 &,const R2  &,int nbegin=0);
    8383                        double Length();
    84                         long  NewPoints(Vertex *,long & nbv,long nbvx);
     84                        long  NewPoints(MeshVertex *,long & nbv,long nbvx);
    8585                        void  NewSubSeg(GeometricalEdge *e,double s0,double s1){
    8686                                long int verbosity=0;

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

    r3332 r3407  
    121121        /*Methods*/
    122122        /*FUNCTION QuadTree::Add{{{1*/
    123         void  QuadTree::Add(Vertex &w){
     123        void  QuadTree::Add(MeshVertex &w){
    124124                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/Add)*/
    125125
    … …  
    164164
    165165                        //Copy the 4 vertices in the current QuadTreebox
    166                         Vertex* v4[4];
     166                        MeshVertex* v4[4];
    167167                        v4[0]= b->v[0];
    168168                        v4[1]= b->v[1];
    … …  
    206206        /*}}}1*/
    207207        /*FUNCTION QuadTree::NearestVertex{{{1*/
    208         Vertex*  QuadTree::NearestVertex(Icoor1 i,Icoor1 j) {
     208        MeshVertex*  QuadTree::NearestVertex(Icoor1 i,Icoor1 j) {
    209209                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/NearestVertex)*/
    210210
    … …  
    225225                Icoor1   jplus( j<MaxISize?(j<0?0:j):MaxISize-1);
    226226                //initial nearest vertex pointer
    227                 Vertex*  vn=NULL;
     227                MeshVertex*  vn=NULL;
    228228
    229229                //Get initial Quadtree box (largest)
    … …  
    294294
    295295                                //if the current subbox is holding vertices,
    296                                 if (b->n>0){ // Vertex QuadTreeBox not empty
     296                                if (b->n>0){ // MeshVertex QuadTreeBox not empty
    297297                                        NbVerticesSearch++;
    298298                                        I2 i2 =  b->v[k]->i;
    … …  
    345345        /*}}}1*/
    346346        /*FUNCTION QuadTree::NearestVertexWithNormal{{{1*/
    347         Vertex*  QuadTree::NearestVertexWithNormal(Icoor1 i,Icoor1 j) {
     347        MeshVertex*  QuadTree::NearestVertexWithNormal(Icoor1 i,Icoor1 j) {
    348348                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/NearestVertexWithNormal)*/
    349349
    … …  
    359359                Icoor1  jplus( j<MaxISize?(j<0?0:j):MaxISize-1);
    360360
    361                 Vertex *vn=0;
     361                MeshVertex *vn=0;
    362362
    363363                // init for optimisation ---
    … …  
    412412                                int k = pi[l];
    413413
    414                                 if (b->n>0) // Vertex QuadTreeBox none empty
     414                                if (b->n>0) // MeshVertex QuadTreeBox none empty
    415415                                  {
    416416                                        NbVerticesSearch++;
    … …  
    473473        /*}}}1*/
    474474        /*FUNCTION QuadTree::ToClose {{{1*/
    475         Vertex *   QuadTree::ToClose(Vertex & v,double seuil,Icoor1 hx,Icoor1 hy){
     475        MeshVertex *   QuadTree::ToClose(MeshVertex & v,double seuil,Icoor1 hx,Icoor1 hy){
    476476                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/ToClose)*/
    477477
    … …  
    490490                Icoor1 i0=0,j0=0;
    491491
    492                 //  Vertex *vn=0;
     492                //  MeshVertex *vn=0;
    493493
    494494                if (!root->n)
    … …  
    507507                                register int k = pi[l];
    508508
    509                                 if (b->n>0) // Vertex QuadTreeBox none empty
     509                                if (b->n>0) // MeshVertex QuadTreeBox none empty
    510510                                  {
    511511                                        NbVerticesSearch++;

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

    r3332 r3407  
    1616
    1717        class Triangles;
    18         class Vertex;
     18        class MeshVertex;
    1919
    2020        class QuadTree{
    … …  
    2323                                public:
    2424                                        long n;
    25                                         //contains only one object form the list (either Vertex or QuadTreeBox)
    26                                         // if n < 4 => Vertex else =>  QuadTreeBox;
     25                                        //contains only one object form the list (either MeshVertex or QuadTreeBox)
     26                                        // if n < 4 => MeshVertex else =>  QuadTreeBox;
    2727                                        union{
    2828                                                QuadTreeBox* b[4];
    29                                                 Vertex* v[4];
     29                                                MeshVertex* v[4];
    3030                                        };
    3131                        };
    … …  
    5555                        long    NbQuadTreeBox,NbVertices;
    5656                        long    NbQuadTreeBoxSearch,NbVerticesSearch;
    57                         Vertex* NearestVertex(Icoor1 i,Icoor1 j);
    58                         Vertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);
    59                         Vertex* ToClose(Vertex & ,double ,Icoor1,Icoor1);
     57                        MeshVertex* NearestVertex(Icoor1 i,Icoor1 j);
     58                        MeshVertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);
     59                        MeshVertex* ToClose(MeshVertex & ,double ,Icoor1,Icoor1);
    6060                        long    SizeOf() const {return sizeof(QuadTree)+sb->SizeOf();}
    61                         void    Add( Vertex & w);
     61                        void    Add( MeshVertex & w);
    6262                        QuadTreeBox* NewQuadTreeBox(){
    6363                                if(! (sb->bc<sb->be)) sb=new StorageQuadTreeBox(lenStorageQuadTreeBox,sb);

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

    r3332 r3407  
    1212        /*FUNCTION Triangle(Triangles *Th,long i,long j,long k) {{{1*/
    1313        Triangle::Triangle(Triangles *Th,long i,long j,long k) {
    14                 Vertex *v=Th->vertices;
     14                MeshVertex *v=Th->vertices;
    1515                long nbv = Th->nbv;
    1616                if (i<0 || j<0 || k<0){
    … …  
    2828        }
    2929        /*}}}*/
    30         /*FUNCTION Triangle(Vertex *v0,Vertex *v1,Vertex *v2) {{{1*/
    31         Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2){
     30        /*FUNCTION Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2) {{{1*/
     31        Triangle::Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2){
    3232                TriaVertices[0]=v0;
    3333                TriaVertices[1]=v1;
    … …  
    155155        /*}}}1*/
    156156        /*FUNCTION Triangle::Quadrangle {{{1*/
    157         Triangle* Triangle::Quadrangle(Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const{
     157        Triangle* Triangle::Quadrangle(MeshVertex * & v0,MeshVertex * & v1,MeshVertex * & v2,MeshVertex * & v3) const{
    158158                // return the other triangle of the quad if a quad or 0 if not a quat
    159159                Triangle * t =0;
    … …  
    187187                         q= -1;
    188188                        else if(option){
    189                                 const Vertex & v2 = *TriaVertices[VerticesOfTriangularEdge[a][0]];
    190                                 const Vertex & v0 = *TriaVertices[VerticesOfTriangularEdge[a][1]];
    191                                 const Vertex & v1 = *TriaVertices[OppositeEdge[a]];
    192                                 const Vertex & v3 = * t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
     189                                const MeshVertex & v2 = *TriaVertices[VerticesOfTriangularEdge[a][0]];
     190                                const MeshVertex & v0 = *TriaVertices[VerticesOfTriangularEdge[a][1]];
     191                                const MeshVertex & v1 = *TriaVertices[OppositeEdge[a]];
     192                                const MeshVertex & v3 = * t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];
    193193                                q =  QuadQuality(v0,v1,v2,v3); // do the float part
    194194                        }
    … …  
    221221                if(a2/4 !=0) return 0; // arete lock or MarkUnSwap
    222222
    223                 register Vertex  *sa=t1->TriaVertices[VerticesOfTriangularEdge[a1][0]];
    224                 register Vertex  *sb=t1->TriaVertices[VerticesOfTriangularEdge[a1][1]];
    225                 register Vertex  *s1=t1->TriaVertices[OppositeVertex[a1]];
    226                 register Vertex  *s2=t2->TriaVertices[OppositeVertex[a2]];
     223                register MeshVertex  *sa=t1->TriaVertices[VerticesOfTriangularEdge[a1][0]];
     224                register MeshVertex  *sb=t1->TriaVertices[VerticesOfTriangularEdge[a1][1]];
     225                register MeshVertex  *s1=t1->TriaVertices[OppositeVertex[a1]];
     226                register MeshVertex  *s2=t2->TriaVertices[OppositeVertex[a2]];
    227227
    228228                Icoor2 det1=t1->det , det2=t2->det ;

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212#include "TriangleAdjacent.h"
    1313
    … …  
    2222
    2323                private:
    24                         Vertex*   TriaVertices[3];      // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer
     24                        MeshVertex*   TriaVertices[3];      // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer
    2525                        Triangle* TriaAdjTriangles[3];  // 3 pointers toward the adjacent triangles
    2626                        short     TriaAdjSharedEdge[3]; // number of the edges in the adjacent triangles the edge number 1 is the edge number TriaAdjSharedEdge[1] in the Adjacent triangle 1
    … …  
    3636                        Triangle() {}
    3737                        Triangle(Triangles *Th,long i,long j,long k);
    38                         Triangle(Vertex *v0,Vertex *v1,Vertex *v2);
     38                        Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2);
    3939
    4040                        //Operators
    41                         const Vertex & operator[](int i) const {return *TriaVertices[i];};
    42                         Vertex & operator[](int i)  {return *TriaVertices[i];};
    43                         const Vertex * operator()(int i) const {return TriaVertices[i];};
    44                         Vertex * & operator()(int i)  {return TriaVertices[i];};
     41                        const MeshVertex & operator[](int i) const {return *TriaVertices[i];};
     42                        MeshVertex & operator[](int i)  {return *TriaVertices[i];};
     43                        const MeshVertex * operator()(int i) const {return TriaVertices[i];};
     44                        MeshVertex * & operator()(int i)  {return TriaVertices[i];};
    4545
    4646                        //Methods
    … …  
    5757                        TriangleAdjacent Adj(int i)  const {return TriangleAdjacent(TriaAdjTriangles[i],TriaAdjSharedEdge[i]&3);};
    5858                        Triangle* TriangleAdj(int i) const {return TriaAdjTriangles[i&3];}
    59                         Triangle* Quadrangle(Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const ;
     59                        Triangle* Quadrangle(MeshVertex * & v0,MeshVertex * & v1,MeshVertex * & v2,MeshVertex * & v3) const ;
    6060                        void  ReNumbering(Triangle *tb,Triangle *te, long *renu){
    6161                                if (link  >=tb && link  <te) link  = tb + renu[link -tb];
    … …  
    6464                                if (TriaAdjTriangles[2] >=tb && TriaAdjTriangles[2] <te) TriaAdjTriangles[2] = tb + renu[TriaAdjTriangles[2]-tb];   
    6565                        }
    66                         void ReNumbering(Vertex *vb,Vertex *ve, long *renu){
     66                        void ReNumbering(MeshVertex *vb,MeshVertex *ve, long *renu){
    6767                                if (TriaVertices[0] >=vb && TriaVertices[0] <ve) TriaVertices[0] = vb + renu[TriaVertices[0]-vb];
    6868                                if (TriaVertices[1] >=vb && TriaVertices[1] <ve) TriaVertices[1] = vb + renu[TriaVertices[1]-vb];
    … …  
    123123                        double qualite() ;
    124124                        void  Set(const Triangle &,const Triangles &,Triangles &);
    125                         int   In(Vertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;}
     125                        int   In(MeshVertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;}
    126126
    127127        };

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

    r3332 r3407  
    4141        /*}}}*/
    4242        /*FUNCTION TriangleAdjacent::EdgeVertex {{{1*/
    43         Vertex* TriangleAdjacent::EdgeVertex(const int & i) const {
     43        MeshVertex* TriangleAdjacent::EdgeVertex(const int & i) const {
    4444                return t->TriaVertices[VerticesOfTriangularEdge[a][i]];
    4545        }
    4646        /*}}}*/
    4747        /*FUNCTION TriangleAdjacent::OppositeVertex {{{1*/
    48         Vertex* TriangleAdjacent::OppositeVertex() const {
     48        MeshVertex* TriangleAdjacent::OppositeVertex() const {
    4949                return t->TriaVertices[bamg::OppositeVertex[a]];
    5050        }

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212
    1313namespace bamg {
    … …  
    4343                        int  swap();
    4444                        TriangleAdjacent Adj() const;
    45                         Vertex* EdgeVertex(const int & i) const;
    46                         Vertex* OppositeVertex() const;
     45                        MeshVertex* EdgeVertex(const int & i) const;
     46                        MeshVertex* OppositeVertex() const;
    4747                        Icoor2& det() const;
    4848        };

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

    r3354 r3407  
    267267                //Vertices
    268268                if (verbose) printf("Reading vertices (%i)\n",nbv);
    269                 vertices=(Vertex*)xmalloc(nbv*sizeof(Vertex));
    270                 ordre=(Vertex**)xmalloc(nbv*sizeof(Vertex*));
     269                vertices=(MeshVertex*)xmalloc(nbv*sizeof(MeshVertex));
     270                ordre=(MeshVertex**)xmalloc(nbv*sizeof(MeshVertex*));
    271271                for (i=0;i<nbv;i++){
    272272                        vertices[i].r.x=x[i];
    … …  
    319319                        if(verbose>5) printf("      processing Vertices\n");
    320320
    321                         vertices=(Vertex*)xmalloc(nbv*sizeof(Vertex));
    322                         ordre=(Vertex**)xmalloc(nbv*sizeof(Vertex*));
     321                        vertices=(MeshVertex*)xmalloc(nbv*sizeof(MeshVertex));
     322                        ordre=(MeshVertex**)xmalloc(nbv*sizeof(MeshVertex*));
    323323
    324324                        for (i=0;i<nbv;i++){
    … …  
    450450                        for (i=0;i<nbe;i++){
    451451                                for (j=0;j<2;j++) {
    452                                         Vertex *v=edges[i].v[j];
     452                                        MeshVertex *v=edges[i].v[j];
    453453                                        long i0=v->color,j0;
    454454                                        if(i0==-1){
    … …  
    726726                                Triangle &t =triangles[i];
    727727                                Triangle* ta;
    728                                 Vertex *v0,*v1,*v2,*v3;
     728                                MeshVertex *v0,*v1,*v2,*v3;
    729729                                if (reft[i]<0) continue;
    730730                                if ((ta=t.Quadrangle(v0,v1,v2,v3)) !=0 && &t<ta) {
    … …  
    775775                                VertexOnGeom &v=VerticesOnGeomVertex[i];
    776776                                ISSMASSERT(v.OnGeomVertex());
    777                                 bamgmesh->VerticesOnGeometricVertex[i*2+0]=Number((Vertex*)v)+1; //back to Matlab indexing
     777                                bamgmesh->VerticesOnGeometricVertex[i*2+0]=Number((MeshVertex*)v)+1; //back to Matlab indexing
    778778                                bamgmesh->VerticesOnGeometricVertex[i*2+1]=Gh.Number((GeometricalVertex*)v)+1; //back to Matlab indexing
    779779                        }
    … …  
    791791                                        ISSMERROR(exprintf("A vertices supposed to be OnGeometricEdge is actually not"));
    792792                                }
    793                                 bamgmesh->VerticesOnGeometricEdge[i*3+0]=Number((Vertex*)v)+1; //back to Matlab indexing
     793                                bamgmesh->VerticesOnGeometricEdge[i*3+0]=Number((MeshVertex*)v)+1; //back to Matlab indexing
    794794                                bamgmesh->VerticesOnGeometricEdge[i*3+1]=Gh.Number((const GeometricalEdge*)v)+1; //back to Matlab indexing
    795795                                bamgmesh->VerticesOnGeometricEdge[i*3+2]=(double)v; //absisce
    … …  
    10201020                        for (int j=0;j<2;j++){
    10211021
    1022                                 Vertex V;
     1022                                MeshVertex V;
    10231023                                VertexOnGeom GV;
    10241024                                Gh.ProjectOnCurve(edges[i],ss[j],V,GV);
    … …  
    10661066        /*}}}1*/
    10671067        /*FUNCTION Triangles::AddVertex{{{1*/
    1068         void Triangles::AddVertex( Vertex &s,Triangle* t, Icoor2* det3) {
     1068        void Triangles::AddVertex( MeshVertex &s,Triangle* t, Icoor2* det3) {
    10691069                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Add)*/
    10701070                // -------------------------------------------
    … …  
    10861086                Triangle* tt[3];
    10871087                //three vertices of t
    1088                 Vertex &s0 = (*t)[0], &s1=(*t)[1], &s2=(*t)[2];
     1088                MeshVertex &s0 = (*t)[0], &s1=(*t)[1], &s2=(*t)[2];
    10891089                //three determinants
    10901090                Icoor2 det3local[3];
    … …  
    14351435                        for (j=0;j<2;j++){
    14361436                                //get current vertex
    1437                                 Vertex* v=edges[i].v[j];
     1437                                MeshVertex* v=edges[i].v[j];
    14381438                                //get vertex color (i0)
    14391439                                long i0=v->color;
    … …  
    15751575                for (i=0;i<nbv;i++){
    15761576                        if((j=colorV[i])>=0){
    1577                                 Vertex & v = Gh.vertices[j];
     1577                                MeshVertex & v = Gh.vertices[j];
    15781578                                v = vertices[i];
    15791579                                v.color =0;
    … …  
    23262326                delete [] Edgeflags;
    23272327
    2328                 //Reset Vertex to On
     2328                //Reset MeshVertex to On
    23292329                SetVertexFieldOn();
    23302330
    … …  
    25602560                                                ISSMERROR(exprintf("&e==NULL"));
    25612561                                        }
    2562                                         Vertex * v0 =  e(0),*v1 = e(1);
     2562                                        MeshVertex * v0 =  e(0),*v1 = e(1);
    25632563                                        Triangle *t  = v0->t;
    25642564                                        int sens = Gh.subdomains[i].sens;
    … …  
    26402640                                ISSMERROR(exprintf("no starting triangle provided and no quadtree available"));
    26412641                        }
    2642                         Vertex *a = quadtree->NearestVertex(B.x,B.y) ;
     2642                        MeshVertex *a = quadtree->NearestVertex(B.x,B.y) ;
    26432643
    26442644                        if (!a || !a->t ) {
    … …  
    27392739                R2 AB;
    27402740                GeometricalVertex *a,*b;
    2741                 Vertex *va,*vb;
     2741                MeshVertex *va,*vb;
    27422742                GeometricalEdge * e;
    27432743
    … …  
    31183118                        if (vog.IsRequiredVertex()){
    31193119                                GeometricalVertex* gv=vog;
    3120                                 Vertex *bv = vog;
     3120                                MeshVertex *bv = vog;
    31213121                                ISSMASSERT(gv->to); // use of Geom -> Th
    31223122                                VertexOnBThVertex[NbVertexOnBThVertex++]=VertexOnVertex(gv->to,bv);
    … …  
    32053205                                                long i=0;// index of new points on the curve
    32063206                                                register GeometricalVertex * GA0 = *(*peequi)[k0equi].onGeometry;
    3207                                                 Vertex *A0;
     3207                                                MeshVertex *A0;
    32083208                                                A0 = GA0->to;  // the vertex in new mesh
    3209                                                 Vertex *A1;
     3209                                                MeshVertex *A1;
    32103210                                                VertexOnGeom *GA1;
    32113211                                                Edge* PreviousNewEdge = 0;
    … …  
    32253225                                                                ISSMASSERT(pe && ee.onGeometry);
    32263226                                                                ee.onGeometry->SetMark();
    3227                                                                 Vertex & v0=ee[0], & v1=ee[1];
     3227                                                                MeshVertex & v0=ee[0], & v1=ee[1];
    32283228                                                                R2 AB=(R2)v1-(R2)v0;
    32293229                                                                double L0=L,LAB;
    … …  
    34313431                 * the initial simple mesh from this edge and 2 boundary triangles*/
    34323432
    3433                 Vertex *  v0=ordre[0], *v1=ordre[1];
     3433                MeshVertex *  v0=ordre[0], *v1=ordre[1];
    34343434
    34353435                nbt = 2;
    … …  
    34713471
    34723472                        //Get new vertex
    3473                         Vertex *newvertex=ordre[icount];
     3473                        MeshVertex *newvertex=ordre[icount];
    34743474
    34753475                        //Find the triangle in which newvertex is located
    … …  
    35483548                long iv=nbvold;
    35493549                for (i=nbvold;i<nbv;i++){
    3550                         Vertex &vi=*ordre[i];
     3550                        MeshVertex &vi=*ordre[i];
    35513551                        vi.i=toI2(vi.r);
    35523552                        vi.r=toR2(vi.i);
    … …  
    35563556                        if (!quadtree->ToClose(vi,seuil,hi,hj)){
    35573557                                // a good new point
    3558                                 Vertex &vj = vertices[iv];
     3558                                MeshVertex &vj = vertices[iv];
    35593559                                long  j=vj.ReferenceNumber;
    35603560                                if (&vj!=ordre[j]){
    … …  
    37033703                                Triangle &tt = *t.TriangleAdj(j);
    37043704                                if ( ! &tt ||  it < Number(tt) && ( tt.link || t.link)){
    3705                                         Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];
    3706                                         Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];
     3705                                        MeshVertex &v0 = t[VerticesOfTriangularEdge[j][0]];
     3706                                        MeshVertex &v1 = t[VerticesOfTriangularEdge[j][1]];
    37073707                                        R2 AB= (R2) v1-(R2) v0;
    37083708                                        Metric M = v0;
    … …  
    37623762        /*}}}1*/
    37633763/*FUNCTION Triangles::NearestVertex{{{1*/
    3764 Vertex * Triangles::NearestVertex(Icoor1 i,Icoor1 j) {
     3764MeshVertex* Triangles::NearestVertex(Icoor1 i,Icoor1 j) {
    37653765        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NearestVertex)*/
    37663766        return  quadtree->NearestVertex(i,j);
    … …  
    37873787                        if (verbosity>5) printf("         Inserting initial mesh points\n");
    37883788                        for (i=0;i<Bh.nbv;i++){
    3789                                 Vertex &bv=Bh[i];
     3789                                MeshVertex &bv=Bh[i];
    37903790                                if (!bv.onGeometry){
    37913791                                        vertices[nbv].r   = bv.r;
    … …  
    38263826                                for(j=0;j<3;j++){
    38273827                                        TriangleAdjacent tj(t,j);
    3828                                         Vertex &vA = *tj.EdgeVertex(0);
    3829                                         Vertex &vB = *tj.EdgeVertex(1);
     3828                                        MeshVertex &vA = *tj.EdgeVertex(0);
     3829                                        MeshVertex &vB = *tj.EdgeVertex(1);
    38303830
    38313831                                        //if t is a boundary triangle, or tj locked, continue
    … …  
    38583858                        // for all the triangle containing the vertex i
    38593859                        for (i=nbvold;i<nbv;i++){
    3860                                 Vertex*          s  = vertices + i;
     3860                                MeshVertex*          s  = vertices + i;
    38613861                                TriangleAdjacent ta(s->t, EdgesVertexTriangle[s->vint][1]);
    38623862                                Triangle*        tbegin= (Triangle*) ta;
    … …  
    39173917
    39183918        if (inbvx) {
    3919                 vertices=new Vertex[nbvx];
     3919                vertices=new MeshVertex[nbvx];
    39203920                if (!vertices){
    39213921                        ISSMERROR(exprintf("!vertices"));
    39223922                }
    3923                 ordre=new (Vertex* [nbvx]);
     3923                ordre=new (MeshVertex* [nbvx]);
    39243924                if (!ordre){
    39253925                        ISSMERROR(exprintf("!ordre"));
    … …  
    39483948/*}}}1*/
    39493949        /*FUNCTION Triangles::ProjectOnCurve{{{1*/
    3950         GeometricalEdge*   Triangles::ProjectOnCurve( Edge & BhAB, Vertex &  vA, Vertex & vB,
    3951                                 double theta,Vertex & R,VertexOnEdge &  BR,VertexOnGeom & GR) {
     3950        GeometricalEdge*   Triangles::ProjectOnCurve( Edge & BhAB, MeshVertex &  vA, MeshVertex & vB,
     3951                                double theta,MeshVertex & R,VertexOnEdge &  BR,VertexOnGeom & GR) {
    39523952                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/ProjectOnCurve)*/
    39533953
    … …  
    39553955                double tA=0,tB=0;
    39563956                R2 A=vA,B=vB;
    3957                 Vertex * pvA=&vA, * pvB=&vB;
     3957                MeshVertex * pvA=&vA, * pvB=&vB;
    39583958                if (vA.vint == IsVertexOnVertex){
    39593959                        pA=vA.onBackgroundVertex;
    … …  
    39643964                }
    39653965                else {
    3966                         ISSMERROR(exprintf("ProjectOnCurve On Vertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vA)));
     3966                        ISSMERROR(exprintf("ProjectOnCurve On MeshVertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vA)));
    39673967                }
    39683968
    … …  
    39753975                }
    39763976                else {
    3977                         ISSMERROR(exprintf("ProjectOnCurve On Vertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vB)));
     3977                        ISSMERROR(exprintf("ProjectOnCurve On MeshVertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vB)));
    39783978                }
    39793979                Edge * e = &BhAB;
    … …  
    40264026                        //    2 for find the vertex
    40274027                        int  iii;
    4028                         Vertex  *v0=pvA,*v1;
     4028                        MeshVertex  *v0=pvA,*v1;
    40294029                        Edge *neee,*eee;
    40304030                        double lg =0; // length of the curve
    … …  
    42274227
    42284228        /*Reconstruct mesh beginning with 2 triangles*/
    4229         Vertex *  v0=ordre[0], *v1=ordre[1];
     4229        MeshVertex *  v0=ordre[0], *v1=ordre[1];
    42304230
    42314231        triangles[0](0) = NULL; // Infinite vertex
    … …  
    42604260        long NbSwap=0;
    42614261        for (int icount=2; icount<nbvb; icount++) {
    4262                 Vertex *vi  = ordre[icount];
     4262                MeshVertex *vi  = ordre[icount];
    42634263                Icoor2 dete[3];
    42644264                Triangle *tcvi = FindTriangleContaining(vi->i,dete);
    … …  
    42734273        for ( i = 0; i < nbe; i++){
    42744274                if (st[i] >=0){ //edge alone => on border
    4275                         Vertex &a=edges[i][0], &b=edges[i][1];
     4275                        MeshVertex &a=edges[i][0], &b=edges[i][1];
    42764276                        if (a.t && b.t){
    42774277                                knbe++;
    … …  
    42984298                                        // change the link of ta;
    42994299                                        int ja = ta;
    4300                                         Vertex *v0= ta.EdgeVertex(0);
    4301                                         Vertex *v1= ta.EdgeVertex(1);
     4300                                        MeshVertex *v0= ta.EdgeVertex(0);
     4301                                        MeshVertex *v1= ta.EdgeVertex(1);
    43024302                                        long k =edge4->SortAndAdd(v0?Number(v0):nbv,v1? Number(v1):nbv);
    43034303
    … …  
    43134313        for (i=0;i<nbt;i++){
    43144314                if (triangles[i].link) {
    4315                         triangles[i]=Triangle((Vertex *) NULL,(Vertex *) NULL,(Vertex *) NULL);
     4315                        triangles[i]=Triangle((MeshVertex *) NULL,(MeshVertex *) NULL,(MeshVertex *) NULL);
    43164316                        triangles[i].color=-1;
    43174317                }
    … …  
    43794379                                                printf("This edge is on geometrical edge number %i\n",Gh.Number(edges[i].onGeometry)+1);
    43804380                                                if (edges[i][j].onGeometry->OnGeomVertex())
    4381                                                  printf("the vertex number %i of this edge is a geometric Vertex number %i\n",Gh.Number(edges[i][j].onGeometry->gv)+1);
     4381                                                 printf("the vertex number %i of this edge is a geometric MeshVertex number %i\n",Gh.Number(edges[i][j].onGeometry->gv)+1);
    43824382                                                else if (edges[i][j].onGeometry->OnGeomEdge())
    43834383                                                 printf("the vertex number %i of this edge is a geometric Edge number %i\n",Gh.Number(edges[i][j].onGeometry->ge)+1);
    … …  
    44714471                // from on mesh to over mesh
    44724472                //  --  so do ReNumbering at the beginning
    4473                 Vertex * ve = vertices+nbv;
     4473                MeshVertex * ve = vertices+nbv;
    44744474                long it,ie,i;
    44754475
    … …  
    44854485                for (i=0;i< NbVerticesOnGeomVertex;i++)
    44864486                  {
    4487                         Vertex *v = VerticesOnGeomVertex[i].mv;
     4487                        MeshVertex *v = VerticesOnGeomVertex[i].mv;
    44884488                        if (v>=vertices && v < ve)
    44894489                         VerticesOnGeomVertex[i].mv=vertices+renu[Number(v)];
    … …  
    44934493                for (i=0;i< NbVerticesOnGeomEdge;i++)
    44944494                  {
    4495                         Vertex *v =VerticesOnGeomEdge[i].mv;
     4495                        MeshVertex *v =VerticesOnGeomEdge[i].mv;
    44964496                        if (v>=vertices && v < ve)
    44974497                         VerticesOnGeomEdge[i].mv=vertices+renu[Number(v)];
    … …  
    45014501                for (i=0;i< NbVertexOnBThVertex;i++)
    45024502                  {
    4503                         Vertex *v=VertexOnBThVertex[i].v;
     4503                        MeshVertex *v=VertexOnBThVertex[i].v;
    45044504                        if (v>=vertices && v < ve)
    45054505                         VertexOnBThVertex[i].v=vertices+renu[Number(v)];
    … …  
    45084508                for (i=0;i< NbVertexOnBThEdge;i++)
    45094509                  {
    4510                         Vertex *v=VertexOnBThEdge[i].v;
     4510                        MeshVertex *v=VertexOnBThEdge[i].v;
    45114511                        if (v>=vertices && v < ve)
    45124512                         VertexOnBThEdge[i].v=vertices+renu[Number(v)];
    … …  
    45204520                        {
    45214521                         i=it;
    4522                          Vertex ti=vertices[i],tj;
     4522                         MeshVertex ti=vertices[i],tj;
    45234523                         while ( (j=renu[i]) >= 0){
    45244524                                 // i is old, and j is new
    … …  
    45724572        int Nberr=0;
    45734573        for (i=0;i<nbt;i++) {
    4574                 Vertex & v0 = triangles[i][0];
    4575                 Vertex & v1 = triangles[i][1];
    4576                 Vertex & v2 = triangles[i][2];
     4574                MeshVertex & v0 = triangles[i][0];
     4575                MeshVertex & v1 = triangles[i][1];
     4576                MeshVertex & v2 = triangles[i][2];
    45774577
    45784578                //If this is not a boundary triangle
    … …  
    46354635                         hmin=Min(hmin,he);
    46364636                         hmax=Max(hmax,he);
    4637                          Vertex & v=K[j];
     4637                         MeshVertex & v=K[j];
    46384638                         D2xD2 M((Metric)v);
    46394639                         betaK += sqrt(M.det());
    … …  
    46804680                         if ( !ta || !ta->link || Number(ta) >= it)
    46814681                                {
    4682                                  Vertex & vP = triangles[it][VerticesOfTriangularEdge[j][0]];
    4683                                  Vertex & vQ = triangles[it][VerticesOfTriangularEdge[j][1]];
     4682                                 MeshVertex & vP = triangles[it][VerticesOfTriangularEdge[j][0]];
     4683                                 MeshVertex & vQ = triangles[it][VerticesOfTriangularEdge[j][1]];
    46844684                                 if ( !& vP || !&vQ) continue;
    46854685                                 R2 PQ = vQ.r - vP.r;
    … …  
    47774777                                ISSMERROR(exprintf("!t"));
    47784778                        }
    4779                         Vertex & vi = vertices[i];
     4779                        MeshVertex & vi = vertices[i];
    47804780                        TriangleAdjacent ta(t,EdgesVertexTriangle[vertices[i].vint][0]);
    4781                         Vertex *pvj0 = ta.EdgeVertex(0);
     4781                        MeshVertex *pvj0 = ta.EdgeVertex(0);
    47824782                        while (1) {
    47834783                                ta=Previous(Adj(ta));
    … …  
    47854785                                        ISSMERROR(exprintf("vertices+i != ta.EdgeVertex(1)"));
    47864786                                }
    4787                                 Vertex & vj = *(ta.EdgeVertex(0));
     4787                                MeshVertex & vj = *(ta.EdgeVertex(0));
    47884788                                if ( &vj ) {
    47894789                                        j= &vj-vertices;
    … …  
    49244924                                        // get the Info on background mesh
    49254925                                        double s =        newVertexOnBThEdge[kvb];
    4926                                         Vertex &  bv0  = newVertexOnBThEdge[kvb][0];
    4927                                         Vertex &  bv1  = newVertexOnBThEdge[kvb][1];
     4926                                        MeshVertex &  bv0  = newVertexOnBThEdge[kvb][0];
     4927                                        MeshVertex &  bv1  = newVertexOnBThEdge[kvb][1];
    49284928                                        // compute the metrix of the new points
    49294929                                        vertices[k].m =  Metric(1-s,bv0,s,bv1);
    … …  
    49934993                                if (&tt >= lastT)
    49944994                                 t.SetAdj2(j,0,0);// unset adj
    4995                                 const Vertex & v0 = t[VerticesOfTriangularEdge[j][0]];
    4996                                 const Vertex & v1 = t[VerticesOfTriangularEdge[j][1]];
     4995                                const MeshVertex & v0 = t[VerticesOfTriangularEdge[j][0]];
     4996                                const MeshVertex & v1 = t[VerticesOfTriangularEdge[j][1]];
    49974997                                long  ke =edge4->SortAndFind(Number(v0),Number(v1));
    49984998                                if (ke>0)
    … …  
    50045004                                        if (ii<nbt) // good triangle
    50055005                                         kedge[3*ii+jj] = ks;
    5006                                         Vertex &A=vertices[ks];
     5006                                        MeshVertex &A=vertices[ks];
    50075007                                        double aa,bb,cc,dd;
    50085008                                        if ((dd=Area2(v0.r,v1.r,A.r)) >=0){
    … …  
    50425042
    50435043
    5044                                 const Vertex & v0 = t[VerticesOfTriangularEdge[j][0]];
    5045                                 const Vertex & v1 = t[VerticesOfTriangularEdge[j][1]];
     5044                                const MeshVertex & v0 = t[VerticesOfTriangularEdge[j][0]];
     5045                                const MeshVertex & v1 = t[VerticesOfTriangularEdge[j][1]];
    50465046                                if ( kedge[3*i+j] < 0)
    50475047                                  {
    … …  
    51225122
    51235123                        Triangle &t0=triangles[i];
    5124                         Vertex * v0=t0(i0);           
    5125                         Vertex * v1=t0(i1);           
    5126                         Vertex * v2=t0(i2);
     5124                        MeshVertex * v0=t0(i0);           
     5125                        MeshVertex * v1=t0(i1);           
     5126                        MeshVertex * v2=t0(i2);
    51275127
    51285128                        if (nbmkadj>=10){
    … …  
    51475147                                                                ISSMERROR(exprintf("kedge[3*i+i0]<0"));
    51485148                                                        }
    5149                                                         Vertex * v3 = vertices + kedge[3*i+k0];
     5149                                                        MeshVertex * v3 = vertices + kedge[3*i+k0];
    51505150
    51515151                                                        t0(i2) = v3;
    … …  
    51675167                                                        }
    51685168
    5169                                                         Vertex * v01 = vertices + kedge[3*i+k2];
    5170                                                         Vertex * v02 = vertices + kedge[3*i+k1];
     5169                                                        MeshVertex * v01 = vertices + kedge[3*i+k2];
     5170                                                        MeshVertex * v02 = vertices + kedge[3*i+k1];
    51715171                                                        t0(i1) = v01;
    51725172                                                        t0(i2) = v02;
    … …  
    51905190                                                                ISSMERROR(exprintf("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0"));
    51915191                                                        }
    5192                                                         Vertex * v12 = vertices + kedge[3*i+k0];
    5193                                                         Vertex * v02 = vertices + kedge[3*i+k1];
    5194                                                         Vertex * v01 = vertices + kedge[3*i+k2];
     5192                                                        MeshVertex * v12 = vertices + kedge[3*i+k0];
     5193                                                        MeshVertex * v02 = vertices + kedge[3*i+k1];
     5194                                                        MeshVertex * v01 = vertices + kedge[3*i+k2];
    51955195                                                        t0(i1) = v01;
    51965196                                                        t0(i2) = v02;
    … …  
    52375237                                                                        double a3[]={1./3.,1./3.,1./3.};
    52385238                                                                        vertices[nbv].m = Metric(a3,v0->m,v1->m,v2->m);
    5239                                                                         Vertex * vc =  vertices +nbv++;
     5239                                                                        MeshVertex * vc =  vertices +nbv++;
    52405240                                                                        t3(i0) = vc;
    52415241                                                                        t4(i1) = vc;
    … …  
    53535353                          if ( &tt && tt.link && it < Number(tt))
    53545354                                 { // an internal edge
    5355                                   Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];
    5356                                   Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];
     5355                                  MeshVertex &v0 = t[VerticesOfTriangularEdge[j][0]];
     5356                                  MeshVertex &v1 = t[VerticesOfTriangularEdge[j][1]];
    53575357                                  if (v0.onGeometry && v1.onGeometry){
    53585358                                          R2 P= ((R2) v0 + (R2) v1)*0.5;
    … …  
    53745374                Icoor2 dete[3]; 
    53755375                for (int i=nbvold;i<nbv;i++) {// for all the new point
    5376                         Vertex & vi = vertices[i];
     5376                        MeshVertex & vi = vertices[i];
    53775377                        vi.i = toI2(vi.r);
    53785378                        vi.r = toR2(vi.i);
    … …  
    54775477                                ISSMERROR(exprintf("kkk>=1000"));
    54785478                        }
    5479                         Vertex  &vI =  *edge.EdgeVertex(0);
    5480                         Vertex  &vJ =  *edge.EdgeVertex(1);
     5479                        MeshVertex  &vI =  *edge.EdgeVertex(0);
     5480                        MeshVertex  &vJ =  *edge.EdgeVertex(1);
    54815481                        I2 I=vI, J=vJ, IJ= J-I;
    54825482                        IJ_IA = (IJ ,(A-I));
    … …  
    55185518                // the probleme is in case of  the fine and long internal hole
    55195519                // for exemple neart the training edge of a wing
    5520                 Vertex * s=0,*s1=0, *s0=0;
     5520                MeshVertex * s=0,*s1=0, *s0=0;
    55215521                Icoor2 imax = MaxICoor22;
    55225522                Icoor2 l0 = imax,l1 = imax;
    … …  
    56055605                                if ((link + linkp) == 1)
    56065606                                  { // a boundary edge
    5607                                         Vertex * st = edge.EdgeVertex(1);
     5607                                        MeshVertex * st = edge.EdgeVertex(1);
    56085608                                        I2 I=*st;
    56095609                                        Icoor2  ll = Norme2_2 (C-I);
    … …  
    56505650        /*}}}1*/
    56515651/*FUNCTION ForceEdge{{{1*/
    5652 int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret)  {
     5652int ForceEdge(MeshVertex &a, MeshVertex & b,TriangleAdjacent & taret)  {
    56535653        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
    56545654
    … …  
    56615661
    56625662        TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]);
    5663         Vertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
     5663        MeshVertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
    56645664        // we turn around a in the  direct sens 
    56655665
    … …  
    56865686                if((det1 < 0) && (det2 >0)) {
    56875687                        // try to force the edge
    5688                         Vertex * va = &a, *vb = &b;
     5688                        MeshVertex * va = &a, *vb = &b;
    56895689                        tc = Previous(tc);
    56905690                        if (!v1 || !v2){
    … …  
    56965696                                 ISSMERROR(exprintf("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l));
    56975697                         }
    5698                         Vertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
     5698                        MeshVertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
    56995699                        if (( aa == &a ) && (bb == &b) ||  (bb ==  &a ) && (aa == &b)) {
    57005700                                tc.SetLock();
    … …  
    57265726/*}}}1*/
    57275727/*FUNCTION swap{{{1*/
    5728 void  swap(Triangle *t1,short a1, Triangle *t2,short a2, Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2){
     5728void  swap(Triangle *t1,short a1, Triangle *t2,short a2, MeshVertex *s1,MeshVertex *s2,Icoor2 det1,Icoor2 det2){
    57295729        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
    57305730        // --------------------------------------------------------------
    … …  
    57715771/*}}}1*/
    57725772        /*FUNCTION SwapForForcingEdge{{{1*/
    5773         int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
     5773        int SwapForForcingEdge(MeshVertex   *  & pva ,MeshVertex  * &   pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
    57745774                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SwapForForcingEdge)*/
    57755775                // l'arete ta coupe l'arete pva pvb
    … …  
    57885788                }
    57895789
    5790                 Vertex & sa= (* t1)[VerticesOfTriangularEdge[a1][0]];
    5791                 Vertex & s1= (*t1)[OppositeVertex[a1]];
    5792                 Vertex & s2= (*t2)[OppositeVertex[a2]];
     5790                MeshVertex & sa= (* t1)[VerticesOfTriangularEdge[a1][0]];
     5791                MeshVertex & s1= (*t1)[OppositeVertex[a1]];
     5792                MeshVertex & s2= (*t2)[OppositeVertex[a2]];
    57935793
    57945794

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

    r3391 r3407  
    1414#include "DoubleAndInt.h"
    1515#include "Direction.h"
    16 #include "BamgVertex.h"
     16#include "MeshVertex.h"
    1717#include "TriangleAdjacent.h"
    1818#include "Edge.h"
    … …  
    4848                        long NbOfTriangleSearchFind;
    4949                        long NbOfSwapTriangle;
    50                         Vertex* vertices;
     50                        MeshVertex* vertices;
    5151                        long NbVerticesOnGeomVertex;
    5252                        VertexOnGeom * VerticesOnGeomVertex;
    … …  
    6666                        Edge* edges;
    6767                        QuadTree* quadtree;
    68                         Vertex** ordre;
     68                        MeshVertex** ordre;
    6969                        SubDomain* subdomains;
    7070                        ListofIntersectionTriangles lIntTria;
    … …  
    8686
    8787                        //Operators
    88                         const Vertex & operator[]  (long i) const { return vertices[i];};
    89                         Vertex & operator[](long i) { return vertices[i];};
     88                        const MeshVertex & operator[]  (long i) const { return vertices[i];};
     89                        MeshVertex & operator[](long i) { return vertices[i];};
    9090                        const Triangle & operator()  (long i) const { return triangles[i];};
    9191                        Triangle & operator()(long i) { return triangles[i];};
    … …  
    101101                                return  R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y);
    102102                        }
    103                         void AddVertex(Vertex & s,Triangle * t,Icoor2 *  =0) ;
     103                        void AddVertex(MeshVertex & s,Triangle * t,Icoor2 *  =0) ;
    104104                        void Insert();
    105105                        void ForceBoundary();
    … …  
    124124                        void SmoothingVertex(int =3,double=0.3);
    125125                        Metric MetricAt (const R2 &) const;
    126                         GeometricalEdge* ProjectOnCurve( Edge & AB, Vertex &  A, Vertex & B,double theta, Vertex & R,VertexOnEdge & BR,VertexOnGeom & GR);
     126                        GeometricalEdge* ProjectOnCurve( Edge & AB, MeshVertex &  A, MeshVertex & B,double theta, MeshVertex & R,VertexOnEdge & BR,VertexOnGeom & GR);
    127127                        long Number(const Triangle & t) const  { return &t - triangles;}
    128128                        long Number(const Triangle * t) const  { return t - triangles;}
    129                         long Number(const Vertex & t) const  { return &t - vertices;}
    130                         long Number(const Vertex * t) const  { return t - vertices;}
     129                        long Number(const MeshVertex & t) const  { return &t - vertices;}
     130                        long Number(const MeshVertex * t) const  { return t - vertices;}
    131131                        long Number(const Edge & t) const  { return &t - edges;}
    132132                        long Number(const Edge * t) const  { return t - edges;}
    133133                        long Number2(const Triangle * t) const  { return t - triangles; }
    134                         Vertex* NearestVertex(Icoor1 i,Icoor1 j) ;
     134                        MeshVertex* NearestVertex(Icoor1 i,Icoor1 j) ;
    135135                        Triangle* FindTriangleContaining(const I2 & ,Icoor2 [3],Triangle *tstart=0) const;
    136136                        void ReadMesh(double* index,double* x,double* y,int nods,int nels);
    … …  
    180180        void  swap(Triangle *t1,short a1,
    181181                                Triangle *t2,short a2,
    182                                 Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2);
    183         int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,
     182                                MeshVertex *s1,MeshVertex *s2,Icoor2 det1,Icoor2 det2);
     183        int SwapForForcingEdge(MeshVertex   *  & pva ,MeshVertex  * &   pvb ,
    184184                                TriangleAdjacent & tt1,Icoor2 & dets1,
    185185                                Icoor2 & detsa,Icoor2 & detsb, int & nbswap);
    186         int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret) ;
     186        int ForceEdge(MeshVertex &a, MeshVertex & b,TriangleAdjacent & taret) ;
    187187        inline TriangleAdjacent Previous(const TriangleAdjacent & ta){
    188188                return TriangleAdjacent(ta.t,PreviousEdge[ta.a]);
    … …  
    197197                int j=i;i=on->DirAdj[i];on=on->Adj[j];
    198198        }
    199         inline double qualite(const Vertex &va,const Vertex &vb,const Vertex &vc){
     199        inline double qualite(const MeshVertex &va,const MeshVertex &vb,const MeshVertex &vc){
    200200                double ret;
    201201                I2 ia=va,ib=vb,ic=vc;

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212#include "Edge.h"
    1313
    … …  
    2020
    2121                public:
    22                         Vertex* v;
     22                        MeshVertex* v;
    2323                        Edge*   be;
    2424                        double abcisse;
    2525
    2626                        //Constructors
    27                         VertexOnEdge( Vertex * w, Edge *bw,double s) :v(w),be(bw),abcisse(s) {}
     27                        VertexOnEdge( MeshVertex * w, Edge *bw,double s) :v(w),be(bw),abcisse(s) {}
    2828                        VertexOnEdge(){}
    2929
    3030                        //Operators
    3131                        operator double () const { return abcisse;}
    32                         operator Vertex* () const { return v;} 
     32                        operator MeshVertex* () const { return v;} 
    3333                        operator Edge* () const { return be;} 
    34                         Vertex & operator[](int i) const { return (*be)[i];}
     34                        MeshVertex & operator[](int i) const { return (*be)[i];}
    3535
    3636                        //Methods

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212#include "GeometricalVertex.h"
    1313#include "GeometricalEdge.h"
    … …  
    2222                public:
    2323
    24                         Vertex* mv;
     24                        MeshVertex* mv;
    2525                        double abscisse; 
    2626                        union{
    … …  
    3131                        //Constructors/Destructors
    3232                        VertexOnGeom(): mv(0),abscisse(0){gv=0;}
    33                         VertexOnGeom(Vertex & m,GeometricalVertex &g) : mv(&m),abscisse(-1){gv=&g;}
    34                         VertexOnGeom(Vertex & m,GeometricalEdge &g,double s) : mv(&m),abscisse(s){ge=&g;}
     33                        VertexOnGeom(MeshVertex & m,GeometricalVertex &g) : mv(&m),abscisse(-1){gv=&g;}
     34                        VertexOnGeom(MeshVertex & m,GeometricalEdge &g,double s) : mv(&m),abscisse(s){ge=&g;}
    3535
    3636                        //Operators
    37                         operator Vertex*() const  {return mv;}
     37                        operator MeshVertex*() const  {return mv;}
    3838                        operator GeometricalVertex * () const  {return gv;}
    3939                        operator GeometricalEdge * () const  {return ge;}

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

    r3391 r3407  
    99#include "../include/typedefs.h"
    1010#include "../include/macros.h"
    11 #include "BamgVertex.h"
     11#include "MeshVertex.h"
    1212
    1313namespace bamg {
    … …  
    1919
    2020                public:
    21                         Vertex* v;
    22                         Vertex* bv;
     21                        MeshVertex* v;
     22                        MeshVertex* bv;
    2323
    2424                        //Constructors
    25                         VertexOnVertex(Vertex * w,Vertex *bw) :v(w),bv(bw){}
     25                        VertexOnVertex(MeshVertex * w,MeshVertex *bw) :v(w),bv(bw){}
    2626                        VertexOnVertex() {};
    2727
Note: See TracChangeset for help on using the changeset viewer.