Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 15060) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 15061) @@ -543,55 +543,55 @@ #}}} #Bamg sources {{{ -bamg_sources = ./classes/bamg/bamgobjects.h\ - ./classes/bamg/BamgGeom.h\ - ./classes/bamg/BamgGeom.cpp\ - ./classes/bamg/BamgMesh.h\ - ./classes/bamg/BamgMesh.cpp\ - ./classes/bamg/BamgOpts.h\ - ./classes/bamg/BamgOpts.cpp\ - ./classes/bamg/CrackedEdge.h\ - ./classes/bamg/CrackedEdge.cpp\ - ./classes/bamg/Curve.h\ - ./classes/bamg/Curve.cpp\ - ./classes/bamg/Direction.h\ - ./classes/bamg/Direction.cpp\ - ./classes/bamg/DoubleAndInt.h\ - ./classes/bamg/Edge.h\ - ./classes/bamg/Edge.cpp\ - ./classes/bamg/GeomEdge.h\ - ./classes/bamg/GeomEdge.cpp\ - ./classes/bamg/GeomSubDomain.h\ - ./classes/bamg/GeomSubDomain.cpp\ - ./classes/bamg/GeomVertex.h\ - ./classes/bamg/GeomVertex.cpp\ - ./classes/bamg/Geometry.cpp\ - ./classes/bamg/Geometry.h\ - ./classes/bamg/ListofIntersectionTriangles.cpp\ - ./classes/bamg/ListofIntersectionTriangles.h\ - ./classes/bamg/EigenMetric.cpp\ - ./classes/bamg/Metric.cpp\ - ./classes/bamg/Metric.h\ - ./classes/bamg/BamgQuadtree.cpp\ - ./classes/bamg/BamgQuadtree.h\ - ./classes/bamg/R2.h\ - ./classes/bamg/SetOfE4.cpp\ - ./classes/bamg/SetOfE4.h\ - ./classes/bamg/SubDomain.h\ - ./classes/bamg/SubDomain.cpp\ - ./classes/bamg/AdjacentTriangle.h\ - ./classes/bamg/AdjacentTriangle.cpp\ - ./classes/bamg/Triangle.cpp\ - ./classes/bamg/det.h \ - ./classes/bamg/Triangle.h\ - ./classes/bamg/BamgVertex.cpp\ - ./classes/bamg/BamgVertex.h\ - ./classes/bamg/VertexOnEdge.h\ - ./classes/bamg/VertexOnEdge.cpp\ - ./classes/bamg/VertexOnGeom.h\ - ./classes/bamg/VertexOnGeom.cpp\ - ./classes/bamg/VertexOnVertex.h\ - ./classes/bamg/VertexOnVertex.cpp\ - ./classes/bamg/Mesh.cpp\ - ./classes/bamg/Mesh.h\ +bamg_sources = ./bamg/bamgobjects.h\ + ./bamg/BamgGeom.h\ + ./bamg/BamgGeom.cpp\ + ./bamg/BamgMesh.h\ + ./bamg/BamgMesh.cpp\ + ./bamg/BamgOpts.h\ + ./bamg/BamgOpts.cpp\ + ./bamg/CrackedEdge.h\ + ./bamg/CrackedEdge.cpp\ + ./bamg/Curve.h\ + ./bamg/Curve.cpp\ + ./bamg/Direction.h\ + ./bamg/Direction.cpp\ + ./bamg/DoubleAndInt.h\ + ./bamg/Edge.h\ + ./bamg/Edge.cpp\ + ./bamg/GeomEdge.h\ + ./bamg/GeomEdge.cpp\ + ./bamg/GeomSubDomain.h\ + ./bamg/GeomSubDomain.cpp\ + ./bamg/GeomVertex.h\ + ./bamg/GeomVertex.cpp\ + ./bamg/Geometry.cpp\ + ./bamg/Geometry.h\ + ./bamg/ListofIntersectionTriangles.cpp\ + ./bamg/ListofIntersectionTriangles.h\ + ./bamg/EigenMetric.cpp\ + ./bamg/Metric.cpp\ + ./bamg/Metric.h\ + ./bamg/BamgQuadtree.cpp\ + ./bamg/BamgQuadtree.h\ + ./bamg/R2.h\ + ./bamg/SetOfE4.cpp\ + ./bamg/SetOfE4.h\ + ./bamg/SubDomain.h\ + ./bamg/SubDomain.cpp\ + ./bamg/AdjacentTriangle.h\ + ./bamg/AdjacentTriangle.cpp\ + ./bamg/Triangle.cpp\ + ./bamg/det.h \ + ./bamg/Triangle.h\ + ./bamg/BamgVertex.cpp\ + ./bamg/BamgVertex.h\ + ./bamg/VertexOnEdge.h\ + ./bamg/VertexOnEdge.cpp\ + ./bamg/VertexOnGeom.h\ + ./bamg/VertexOnGeom.cpp\ + ./bamg/VertexOnVertex.h\ + ./bamg/VertexOnVertex.cpp\ + ./bamg/Mesh.cpp\ + ./bamg/Mesh.h\ ./shared/Bamg/Abs.h \ ./shared/Bamg/BigPrimeNumber.h\ Index: /issm/trunk-jpl/src/c/bamg/AdjacentTriangle.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/AdjacentTriangle.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/AdjacentTriangle.cpp (revision 15061) @@ -0,0 +1,75 @@ +#include +#include +#include +#include + +#include "AdjacentTriangle.h" +#include "Mesh.h" + +namespace bamg { + + /*Constructors/Destructors*/ + //See header file + + /*Methods*/ + /*FUNCTION AdjacentTriangle::Locked {{{*/ + int AdjacentTriangle::Locked() const { + return t->AdjEdgeIndex[a] & 4; + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::MarkUnSwap {{{*/ + int AdjacentTriangle::MarkUnSwap() const { + return t->AdjEdgeIndex[a] & 8; + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::GetAllFlag_UnSwap {{{*/ + int AdjacentTriangle::GetAllFlag_UnSwap() const { + // take all flag except MarkUnSwap + return t->AdjEdgeIndex[a] & 1012; + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::SetLock {{{*/ + void AdjacentTriangle::SetLock(){ + t->SetLocked(a); + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::Adj {{{*/ + AdjacentTriangle AdjacentTriangle::Adj() const { + return t->Adj(a); + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::EdgeVertex {{{*/ + BamgVertex* AdjacentTriangle::EdgeVertex(const int & i) const { + return t->vertices[VerticesOfTriangularEdge[a][i]]; + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::OppositeVertex {{{*/ + BamgVertex* AdjacentTriangle::OppositeVertex() const { + return t->vertices[bamg::OppositeVertex[a]]; + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::det {{{*/ + Icoor2 & AdjacentTriangle::det() const { + return t->det; + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::swap {{{*/ + int AdjacentTriangle::swap(){ + return t->swap(a); + } + /*}}}*/ + /*FUNCTION AdjacentTriangle::SetAdj2 {{{*/ + void AdjacentTriangle::SetAdj2(const AdjacentTriangle & ta, int l ){ + //set Adjacent Triangle of a triangle + if(t) { + t->adj[a]=ta.t; + t->AdjEdgeIndex[a]=ta.a|l; + } + if(ta.t) { + ta.t->adj[ta.a] = t ; + ta.t->AdjEdgeIndex[ta.a] = a| l ; + } + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/AdjacentTriangle.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/AdjacentTriangle.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/AdjacentTriangle.h (revision 15061) @@ -0,0 +1,45 @@ +#ifndef _TRIANGLEADJACENT_H_ +#define _TRIANGLEADJACENT_H_ + +#include "./include.h" +#include "./BamgVertex.h" + +namespace bamg { + + //classes + class Triangle; + class Triangle; + + class AdjacentTriangle { + + public: + Triangle* t; //pointer toward the triangle + int a; //Edge number + + //Constructors + AdjacentTriangle():a(0),t(NULL) {}; + AdjacentTriangle(Triangle* tt,int aa): t(tt),a(aa &3) {}; + + //Operators + operator Triangle * () const {return t;} + operator Triangle & () const {return *t;} + operator int() const {return a;} + AdjacentTriangle & operator++(){ a= NextEdge[a]; return *this; } + AdjacentTriangle operator--(){ a= PreviousEdge[a]; return *this; } + + //Methods + + //Methods + int Locked() const; + int MarkUnSwap() const; + int GetAllFlag_UnSwap() const; + void SetLock(); + void SetAdj2(const AdjacentTriangle &ta, int l=0); + int swap(); + AdjacentTriangle Adj() const; + BamgVertex* EdgeVertex(const int & i) const; + BamgVertex* OppositeVertex() const; + Icoor2& det() const; + }; +} +#endif Index: /issm/trunk-jpl/src/c/bamg/BamgGeom.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgGeom.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgGeom.cpp (revision 15061) @@ -0,0 +1,32 @@ +#include "../classes/classes.h" +#include "../shared/shared.h" + +/*Constructors/Destructors*/ +/*FUNCTION BamgGeom::BamgGeom(){{{*/ +BamgGeom::BamgGeom(){ + + this->VerticesSize[0]=0, this->VerticesSize[1]=0; this->Vertices=NULL; + this->EdgesSize[0]=0, this->EdgesSize[1]=0; this->Edges=NULL; + this->TangentAtEdgesSize[0]=0, this->TangentAtEdgesSize[1]=0; this->TangentAtEdges=NULL; + this->CornersSize[0]=0, this->CornersSize[1]=0; this->Corners=NULL; + this->RequiredVerticesSize[0]=0, this->RequiredVerticesSize[1]=0; this->RequiredVertices=NULL; + this->RequiredEdgesSize[0]=0, this->RequiredEdgesSize[1]=0; this->RequiredEdges=NULL; + this->CrackedEdgesSize[0]=0, this->CrackedEdgesSize[1]=0; this->CrackedEdges=NULL; + this->SubDomainsSize[0]=0, this->SubDomainsSize[1]=0; this->SubDomains=NULL; + +} +/*}}}*/ +/*FUNCTION BamgGeom::~BamgGeom(){{{*/ +BamgGeom::~BamgGeom(){ + + xDelete(this->Vertices); + xDelete(this->Edges); + xDelete(this->TangentAtEdges); + xDelete(this->Corners); + xDelete(this->RequiredVertices); + xDelete(this->RequiredEdges); + xDelete(this->CrackedEdges); + xDelete(this->SubDomains); + +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/bamg/BamgGeom.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgGeom.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgGeom.h (revision 15061) @@ -0,0 +1,31 @@ +/*!\file: BamgGeom.h + */ + +#ifndef _BAMGGEOM_H_ +#define _BAMGGEOM_H_ + +class BamgGeom{ + + public: + int VerticesSize[2]; + double* Vertices; + int EdgesSize[2]; + double* Edges; + int TangentAtEdgesSize[2]; + double* TangentAtEdges; + int CornersSize[2]; + double* Corners; + int RequiredVerticesSize[2]; + double* RequiredVertices; + int RequiredEdgesSize[2]; + double* RequiredEdges; + int CrackedEdgesSize[2]; + double* CrackedEdges; + int SubDomainsSize[2]; + double* SubDomains; + + BamgGeom(); + ~BamgGeom(); +}; + +#endif Index: /issm/trunk-jpl/src/c/bamg/BamgMesh.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgMesh.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgMesh.cpp (revision 15061) @@ -0,0 +1,54 @@ +#include "../classes/classes.h" +#include "../shared/shared.h" + +/*Constructors/Destructors*/ +/*FUNCTION BamgMesh::BamgMesh(){{{*/ +BamgMesh::BamgMesh(){ + + this->VerticesSize[0]=0, this->VerticesSize[1]=0; this->Vertices=NULL; + this->EdgesSize[0]=0, this->EdgesSize[1]=0; this->Edges=NULL; + this->TrianglesSize[0]=0, this->TrianglesSize[1]=0; this->Triangles=NULL; + this->QuadrilateralsSize[0]=0, this->QuadrilateralsSize[1]=0; this->Quadrilaterals=NULL; + + this->SubDomainsSize[0]=0, this->SubDomainsSize[1]=0; this->SubDomains=NULL; + this->SubDomainsFromGeomSize[0]=0, this->SubDomainsFromGeomSize[1]=0; this->SubDomainsFromGeom=NULL; + this->CrackedVerticesSize[0]=0, this->CrackedVerticesSize[1]=0; this->CrackedVertices=NULL; + this->CrackedEdgesSize[0]=0, this->CrackedEdgesSize[1]=0; this->CrackedEdges=NULL; + + this->VerticesOnGeomVertexSize[0]=0, this->VerticesOnGeomVertexSize[1]=0; this->VerticesOnGeomVertex=NULL; + this->VerticesOnGeomEdgeSize[0]=0, this->VerticesOnGeomEdgeSize[1]=0; this->VerticesOnGeomEdge=NULL; + this->EdgesOnGeomEdgeSize[0]=0, this->EdgesOnGeomEdgeSize[1]=0; this->EdgesOnGeomEdge=NULL; + + this->IssmEdgesSize[0]=0, this->IssmEdgesSize[1]=0; this->IssmEdges=NULL; + this->IssmSegmentsSize[0]=0, this->IssmSegmentsSize[1]=0; this->IssmSegments=NULL; + + this->ElementConnectivitySize[0]=0, this->ElementConnectivitySize[1]=0; this->ElementConnectivity=NULL; + this->NodalConnectivitySize[0]=0, this->NodalConnectivitySize[1]=0; this->NodalConnectivity=NULL; + this->NodalElementConnectivitySize[0]=0, this->NodalElementConnectivitySize[1]=0; this->NodalElementConnectivity=NULL; +} +/*}}}*/ +/*FUNCTION BamgMesh::~BamgMesh(){{{*/ +BamgMesh::~BamgMesh(){ + + xDelete(this->Vertices); + xDelete(this->Edges); + xDelete(this->Triangles); + xDelete(this->Quadrilaterals); + + xDelete(this->SubDomains); + xDelete(this->SubDomainsFromGeom); + xDelete(this->CrackedVertices); + xDelete(this->CrackedEdges); + + xDelete(this->VerticesOnGeomVertex); + xDelete(this->VerticesOnGeomEdge); + xDelete(this->EdgesOnGeomEdge); + + xDelete(this->IssmEdges); + xDelete(this->IssmSegments); + + xDelete(this->ElementConnectivity); + xDelete(this->NodalConnectivity); + xDelete(this->NodalElementConnectivity); +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/bamg/BamgMesh.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgMesh.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgMesh.h (revision 15061) @@ -0,0 +1,52 @@ +/*!\file: BamgMesh.h + */ + +#ifndef _BAMGMESH_H_ +#define _BAMGMESH_H_ + +class BamgMesh{ + + public: + + int VerticesSize[2]; + double* Vertices; + int EdgesSize[2]; + double* Edges; + int TrianglesSize[2]; + double* Triangles; + int QuadrilateralsSize[2]; + double* Quadrilaterals; + + int VerticesOnGeomVertexSize[2]; + double* VerticesOnGeomVertex; + int VerticesOnGeomEdgeSize[2]; + double* VerticesOnGeomEdge; + int EdgesOnGeomEdgeSize[2]; + double* EdgesOnGeomEdge; + + int SubDomainsSize[2]; + double* SubDomains; + int SubDomainsFromGeomSize[2]; + double* SubDomainsFromGeom; + int CrackedVerticesSize[2]; + double* CrackedVertices; + int CrackedEdgesSize[2]; + double* CrackedEdges; + + /*Output for ISSM*/ + int IssmEdgesSize[2]; + double* IssmEdges; + int IssmSegmentsSize[2]; + double* IssmSegments; + int ElementConnectivitySize[2]; + double* ElementConnectivity; + int NodalConnectivitySize[2]; + double* NodalConnectivity; + int NodalElementConnectivitySize[2]; + double* NodalElementConnectivity; + + BamgMesh(); + ~BamgMesh(); +}; + +#endif Index: /issm/trunk-jpl/src/c/bamg/BamgOpts.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgOpts.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgOpts.cpp (revision 15061) @@ -0,0 +1,86 @@ +#include "../classes/classes.h" +#include "../shared/shared.h" + +/*Constructors/Destructors*/ +/*FUNCTION BamgOpts::BamgOpts() {{{*/ +BamgOpts::BamgOpts(){ + + this->anisomax=0; + this->cutoff=0; + this->coeff=0; + this->errg=0; + this->gradation=0; + this->Hessiantype=0; + this->MaxCornerAngle=0; + this->maxnbv=0; + this->maxsubdiv=0; + this->Metrictype=0; + this->nbjacobi=0; + this->nbsmooth=0; + this->omega=0; + this->power=0; + this->verbose=0; + + this->Crack=0; + this->geometricalmetric=0; + this->KeepVertices=0; + this->splitcorners=0; + + this->hmin=0; + this->hmax=0; + this->hminVertices=NULL; this->hminVerticesSize[0]=this->hminVerticesSize[1]=0; + this->hmaxVertices=NULL; this->hmaxVerticesSize[0]=this->hmaxVerticesSize[1]=0; + this->hVertices=NULL; this->hVerticesSize[0]=this->hVerticesSize[1]=0; + this->metric=NULL; this->metricSize[0]=this->metricSize[1]=0; + this->field=NULL; this->fieldSize[0]=this->fieldSize[1]=0; + this->err=NULL; this->errSize[0]=this->errSize[1]=0; + +} +/*}}}*/ +/*FUNCTION BamgOpts::~BamgOpts() {{{*/ +BamgOpts::~BamgOpts(){ + + xDelete(this->hminVertices); + xDelete(this->hmaxVertices); + xDelete(this->hVertices); + xDelete(this->metric); + xDelete(this->field); + xDelete(this->err); + +} +/*}}}*/ + +/*Methods*/ +/*FUNCTION BamgOpts::Check{{{*/ +void BamgOpts::Check(void){ + + int i; + + if (this->anisomax<1) _error_("'anisomax' option should be >=1"); + if (this->coeff==0) _error_("'coeff' should be positive"); + if (this->errg<0) _error_("'errg' option should be >0"); + if (this->gradation<1) _error_("'gradation' option should be >=1"); + if (this->Hessiantype!=0 && this->Hessiantype!=1) _error_("'Hessiantype' supported options are 0 and 1"); + if (this->maxnbv<3) _error_("'maxnbv' option should be >3"); + if (this->maxsubdiv<=1) _error_("'maxsubdiv' should be >1"); + if (this->Metrictype!=0 && this->Metrictype!=1 && this->Metrictype!=2) _error_("'Metrictype' supported options are 0, 1 and 2"); + if (this->nbjacobi<=0) _error_("'nbjacobi' option should be >0"); + if (this->nbsmooth<=0) _error_("'nbsmooth' option should be >0"); + + if (this->Crack!=0 && this->Crack!=1) _error_("'Crack' supported options are 0 and 1"); + if (this->KeepVertices!=0 && this->KeepVertices!=1) _error_("'KeepVertices' supported options are 0 and 1"); + if (this->geometricalmetric!=0 && this->geometricalmetric!=1) _error_("'geometricalmetric' supported options are 0 and 1"); + + if (this->hmin<=0) _error_("'hmin' option should be >0"); + if (this->hmax<=0 || this->hmaxhmin) _error_("'hmax' option should be between 0 and hmin=" << this->hmin); + if (this->hminVertices && this->hminVerticesSize[1]!=1) _error_("'hminVertices' should be a column"); + if (this->hmaxVertices && this->hmaxVerticesSize[1]!=1) _error_("'hmaxVertices' should be a column"); + if (this->hVertices && this->hVerticesSize[1]!=1) _error_("'hVertices' should be a column"); + if (this->metric && (this->metricSize[1]!=1 && this->metricSize[1]!=3)) _error_("'metric' should have either 1 (iso) or 3 (aniso) columns."); + if (this->field){ + if (this->errSize[0]!=1 || this->errSize[1]!=this->fieldSize[1]) _error_("'err' should be of size " << 1 << " x " << this->fieldSize[1]); + for (i=0;ifieldSize[1];i++) {if (this->err[i]<=0) _error_("'err' option should be >0");}; + } + +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/bamg/BamgOpts.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgOpts.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgOpts.h (revision 15061) @@ -0,0 +1,57 @@ +/*!\file: BamgOpts.h + * \brief place holder for optimization function arguments + */ + +#ifndef _BAMGOPTS_H_ +#define _BAMGOPTS_H_ + +class BamgOpts{ + + public: + + /*Parameters*/ + double anisomax; + double cutoff; + double coeff; + double errg; + double gradation; + int Hessiantype; + double MaxCornerAngle; + int maxnbv; + double maxsubdiv; + int Metrictype; + int nbjacobi; + int nbsmooth; + double omega; + double power; + int verbose; + + /*Flags*/ + int Crack; + int geometricalmetric; + int KeepVertices; + int splitcorners; + + /*Metric related*/ + double hmin; + double hmax; + int hminVerticesSize[2]; + double* hminVertices; + int hmaxVerticesSize[2]; + double* hmaxVertices; + int hVerticesSize[2]; + double* hVertices; + int metricSize[2]; + double* metric; + int fieldSize[2]; + double* field; + int errSize[2]; + double* err; + + BamgOpts(); + ~BamgOpts(); + + void Check(void); + +}; +#endif Index: /issm/trunk-jpl/src/c/bamg/BamgQuadtree.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgQuadtree.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgQuadtree.cpp (revision 15061) @@ -0,0 +1,597 @@ +#include +#include +#include + +#include "../classes/classes.h" + +namespace bamg { + + /*MACROS {{{*/ + /* + * + * J j + * ^ ^ + * | | +--------+--------+ + * | | | | | + * 1X | | | 2 | 3 | + * | | | | | + * | | +--------+--------+ + * | | | | | + * 0X | | | 0 | 1 | + * | | | | | + * | | +--------+--------+ + * | +-----------------------> i + * | + * |----------------------------> I + * X0 X1 + * + * box 0 -> I=0 J=0 IJ=00 = 0 + * box 1 -> I=1 J=0 IJ=01 = 1 + * box 2 -> I=0 J=1 IJ=10 = 2 + * box 3 -> I=1 J=1 IJ=11 = 3 + */ +#define INTER_SEG(a,b,x,y) (((y) > (a)) && ((x) <(b))) +#define ABS(i) ((i)<0 ?-(i) :(i)) +#define MAX1(i,j) ((i)>(j) ?(i) :(j)) +#define NORM(i1,j1,i2,j2) MAX1(ABS((i1)-(j1)),ABS((i2)-(j2))) + + //IJ(i,j,l) returns the box number of i and j with respect to l + //if !j&l and !i&l -> 0 (box zero: lower left ) + //if !j&l and i&l -> 1 (box one: lower right) + //if j&l and !i&l -> 2 (box two: upper left ) + //if j&l and i&l -> 3 (box three:upper right) +#define IJ(i,j,l) ((j&l) ? ((i&l) ? 3:2 ) :((i&l) ? 1:0 )) + + //I_IJ(k,l) returns l if first bit of k is 1, else 0 +#define I_IJ(k,l) ((k&1) ? l:0) + //J_IJ(k,l) returns l if second bit of k is 1, else 0 +#define J_IJ(k,l) ((k&2) ? l:0) + /*}}}*/ + /*DOCUMENTATION What is a BamgQuadtree? {{{ + * A Quadtree is a very simple way to group vertices according + * to their locations. A square that holds all the points of the mesh + * (or the geometry) is divided into 4 boxes. As soon as one box + * hold more than 4 vertices, it is divided into 4 new boxes, etc... + * There cannot be more than MAXDEEP (=30) subdivision. + * This process is like a Dichotomy in dimension 2 + * + * + - - - - - - - - + - - + - + - + - - - - + + * | | | | X | | + * + - + - + + * | | | | | | + * + - - + - + - + + + * | | | | | + * + * | | | | | + * + - - - - - - - - + - - + - - + - - - - + + * | | | | + * + * | | | | + * + * | | | | + * | | | | + * + - - - - - - - - + - - - - + - - - - + + * | | | + * + * | | | + * + * | | | + * + * | | | + * | | | + * | | | + * | | | + * | | | + * + - - - - - - - - + - - - - - - - - + + * + * The coordinate system used in a quadtree are integers to avoid + * round-off errors. The vertex in the lower left box has the coordinates + * (0 0) + * The upper right vertex has the follwing coordinates: + * 2^30 -1 2^30 -1 in decimal + * 0 1 1 1 .... 1 0 1 1 1 .... 1 in binary + * \-- 29 --/ \-- 29 --/ + * Using binaries is therefore very easy to locate a vertex in a box: + * we just need to look at the bits from the left to the right (See ::Add) + }}}*/ + + /*Constructors/Destructors*/ + /*FUNCTION BamgQuadtree::BamgQuadtree(){{{*/ + BamgQuadtree::BamgQuadtree(){ + + /*Number of boxes and vertices*/ + NbBamgQuadtreeBox=0; + NbVertices=0; + + /*Create container*/ + boxcontainer=new DataSet(); + + /*Create Root, pointer toward the main box*/ + root=NewBamgQuadtreeBox(); + + } + /*}}}*/ + /*FUNCTION BamgQuadtree::BamgQuadtree(Mesh * t,long nbv){{{*/ + BamgQuadtree::BamgQuadtree(Mesh * t,long nbv){ + + /*Number of boxes and vertices*/ + NbBamgQuadtreeBox=0; + NbVertices=0; + + /*Create container*/ + boxcontainer=new DataSet(); + + /*Create Root, pointer toward the main box*/ + root=NewBamgQuadtreeBox(); + + /*Check Sizes*/ + _assert_(MaxISize>MaxICoor); + + /*Add all vertices of the mesh*/ + if (nbv==-1) nbv=t->nbv; + for (int i=0;ivertices[i]); + + } + /*}}}*/ + /*FUNCTION BamgQuadtree::~BamgQuadtree(){{{*/ + BamgQuadtree::~BamgQuadtree() { + delete boxcontainer; + root=NULL; + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION BamgQuadtree::Add{{{*/ + void BamgQuadtree::Add(BamgVertex &w){ + /*Original code from Frederic Hecht (BAMG v1.01, BamgQuadtree.cpp/Add)*/ + BamgQuadtreeBox** pb=NULL; + BamgQuadtreeBox* b=NULL; + + /*Get integer coodinate of current point w*/ + register long i=w.i.x, j=w.i.y; + + /*Initialize level*/ + register long level=MaxISize; + + /*Get inital box (the largest)*/ + pb = &root; + + /*Find the smallest box where w is located*/ + while((b=*pb) && (b->nbitems<0)){ + + //shift b->nbitems by -1 + b->nbitems--; + + //shifted righ by one bit: level=00000010 -> 00000001 + level >>= 1; + + //Get next subbox according to the bit value (level) + pb = &b->b[IJ(i,j,level)]; + } + + /*OK, we have found b, a Subbox holding vertices (might be full) + check that the vertex is not already in the box*/ + if (b){ + if (b->nbitems > 3 && b->v[3] == &w) return; + if (b->nbitems > 2 && b->v[2] == &w) return; + if (b->nbitems > 1 && b->v[1] == &w) return; + if (b->nbitems > 0 && b->v[0] == &w) return; + } + + /*check that l is not 0 (this should not happen as MaxDepth = 30)*/ + _assert_(level>0); + + /*Now, try to add the vertex, if the subbox is full (nbitems=4), we have to divide it + in 4 new subboxes*/ + while ((b= *pb) && (b->nbitems == 4)){ // the BamgQuadtreeBox is full + + /*Copy the 4 vertices in the current BamgQuadtreebox*/ + BamgVertex* v4[4]; + v4[0]= b->v[0]; + v4[1]= b->v[1]; + v4[2]= b->v[2]; + v4[3]= b->v[3]; + + /*set nbitems as negative + * (box full -> holds 4 pointers toward subboxes and not 4 vertices)*/ + b->nbitems = -b->nbitems; + + /*Initialize the 4 pointers toward the 4 subboxes*/ + b->b[0]=b->b[1]=b->b[2]=b->b[3]=NULL; + + /*level = 0010000 -> 0001000*/ + level >>= 1; + + /*Put the four vertices in the new boxes*/ + for (int k=0;k<4;k++){ + + int ij; + /*bb is the new "sub"box of b where v4[k] is located*/ + BamgQuadtreeBox *bb = b->b[ij=IJ(v4[k]->i.x,v4[k]->i.y,level)]; + + // alloc the BamgQuadtreeBox + if (!bb) bb=b->b[ij]=NewBamgQuadtreeBox(); + + /*Copy the current vertex*/ + bb->v[bb->nbitems++] = v4[k]; + } + + /*Get the subbox where w (i,j) is located*/ + pb = &b->b[IJ(i,j,level)]; + } + + /*alloc the BamgQuadtreeBox if necessary*/ + if (!(b=*pb)) b=*pb= NewBamgQuadtreeBox(); + + /*Add w*/ + b->v[b->nbitems++]=&w; + + //Increase NbVertices by one (we have one new vertex) + NbVertices++; + } + /*}}}*/ + /*FUNCTION BamgQuadtree::NearestVertex{{{*/ + BamgVertex* BamgQuadtree::NearestVertex(Icoor1 i,Icoor1 j) { + /*Original code from Frederic Hecht (BAMG v1.01, BamgQuadtree.cpp/NearestVertex)*/ + + /*Intermediaries*/ + BamgQuadtreeBox *pb[MaxDepth]; + int pi[MaxDepth]; + Icoor1 ii[MaxDepth]; + Icoor1 jj[MaxDepth]; + int level; + long n0; + BamgQuadtreeBox *b; + long h0; + long h = MaxISize; + long hb= MaxISize; + Icoor1 i0=0,j0=0; + + /*initial output as NULL (no vertex found)*/ + BamgVertex* nearest_v=NULL; + + /*Project w coordinates (i,j) onto [0,MaxISize-1] x [0,MaxISize-1] -> (iplus,jplus)*/ + Icoor1 iplus( inbitems) return nearest_v; + + /*else, find the smallest non-empty BamgQuadtreeBox containing the point (i,j)*/ + while((n0=b->nbitems)<0){ + + Icoor1 hb2 = hb >> 1; //size of the current box + int k = IJ(iplus,jplus,hb2); //box number (0,1,2 or 3) + BamgQuadtreeBox *b0 = b->b[k]; //pointer toward current box + + /* break if NULL box or empty (Keep previous box b)*/ + if (( b0 == NULL) || (b0->nbitems == 0)) break; + + /*Get next Quadtree box*/ + b=b0; + i0 += I_IJ(k,hb2); // i orign of BamgQuadtreeBox (macro) + j0 += J_IJ(k,hb2); // j orign of BamgQuadtreeBox + hb = hb2; // size of the box (in Int) + } + + /*The box b, is the smallest box containing the point (i,j) and + * has the following properties: + * - n0: number of items (>0 if vertices, else boxes) + * - hb: box size (int) + * - i0: x coordinate of the lower left corner + * - j0: y coordinate of the lower left corner*/ + + /* if the current subbox is holding vertices, we are almost done*/ + if (n0>0){ + //loop over the vertices of the box and find the closest vertex + for(int k=0;kv[k]->i; + + /*Compute norm with w*/ + h0=NORM(iplus,i2.x,jplus,i2.y); + + /*is it smaller than previous value*/ + if (h0v[k]; + } + } + /*return closest vertex*/ + return nearest_v; + } + + /* general case: the current box is empty, we have to go backwards + and find the closest not-empty box and find the closest vertex*/ + + /*Initialize search variables*/ + pb[0]=b; //pointer toward the box b + pi[0]=b->nbitems>0?(int)b->nbitems:4;//number of boxes in b + ii[0]=i0; //i coordinate of the box lowest left corner + jj[0]=j0; //j coordinate of the box lowest left corner + + /*initialize h: smallest box size, containing a vertex close to w*/ + h=hb; + + /*Main loop*/ + level=0; + do { + + /*get current box*/ + b= pb[level]; + + /*Loop over the items in current box (if not empty!)*/ + while (pi[level]){ + + /*We are looping now over the items of b. k is the current index (in [0 3])*/ + pi[level]--; + int k=pi[level]; + + /*if the current subbox is holding vertices (b->nbitems<0 is subboxes)*/ + if (b->nbitems>0){ + I2 i2=b->v[k]->i; + h0 = NORM(iplus,i2.x,jplus,i2.y); + if (h0v[k]; + } + } + /*else: current box b is pointing toward 4 boxes + * test sub-box k and go deeper into the tree if it is non empty + * and contains the point w modulo a size h that is either the size of the smallest + * non empty box containing w, or the closest point to w (so far) */ + else{ + BamgQuadtreeBox* b0=b; + + /*if the next box exists:*/ + if (b=b->b[k]){ + + /*Get size (hb) and coordinates of the current sub-box lowest left corner*/ + hb>>=1; + Icoor1 iii = ii[level]+I_IJ(k,hb); + Icoor1 jjj = jj[level]+J_IJ(k,hb); + + /*if the current point (iplus,jplus) is in b (modulo h), this box is good: + * it is holding vertices that are close to w */ + if (INTER_SEG(iii,iii+hb,iplus-h,iplus+h) && INTER_SEG(jjj,jjj+hb,jplus-h,jplus+h)){ + level++; + pb[level]= b; + pi[level]= b->nbitems>0 ?(int) b->nbitems : 4 ; + ii[level]= iii; + jj[level]= jjj; + } + + //else go backwards + else{ + //shifted righ by one bit: hb=001000000 -> 01000000 + b=b0; + hb<<=1; + } + } + else{ + /*Current box is NULL, go to next subbox of b (k=k-1)*/ + b=b0; + } + } + } + + /*We have found a vertex, now, let's try the other boxes of the previous level + * in case there is a vertex closest to w that has not yet been tested*/ + hb <<= 1; + } while (level--); + + /*return nearest_v, nearest vertex*/ + return nearest_v; + + } + /*}}}*/ + /*FUNCTION BamgQuadtree::NearestVertexWithNormal{{{*/ + BamgVertex* BamgQuadtree::NearestVertexWithNormal(Icoor1 i,Icoor1 j) { + /*Original code from Frederic Hecht (BAMG v1.01, BamgQuadtree.cpp/NearestVertexWithNormal)*/ + + BamgQuadtreeBox * pb[ MaxDepth ]; + int pi[ MaxDepth ]; + Icoor1 ii[ MaxDepth ], jj [ MaxDepth]; + int l; // level + BamgQuadtreeBox * b; + long h =MaxISize,h0; + long hb=MaxISize; + Icoor1 i0=0,j0=0; + Icoor1 iplus( inbitems) + return vn; // empty tree + + while( (n0 = b->nbitems) < 0) + { + // search the non empty + // BamgQuadtreeBox containing the point (i,j) + register Icoor1 hb2 = hb >> 1 ; + register int k = IJ(iplus,jplus,hb2);// BamgQuadtreeBox number of size hb2 contening i;j + register BamgQuadtreeBox * b0= b->b[k]; + if ( ( b0 == 0) || (b0->nbitems == 0) ) + break; // null box or empty => break + b=b0; + i0 += I_IJ(k,hb2); // i orign of BamgQuadtreeBox + j0 += J_IJ(k,hb2); // j orign of BamgQuadtreeBox + hb = hb2; + } + + if ( n0 > 0) + { + for(register int k=0;kv[k]->i; + // try if is in the right direction -- + h0 = NORM(iplus,i2.x,jplus,i2.y); + if (h0 v[k];} + } + if (vn) return vn; + } + // general case ----- + // INITIALISATION OF THE HEAP + l =0; // level + pb[0]= b; + pi[0]=b->nbitems>0 ?(int) b->nbitems : 4 ; + ii[0]=i0; + jj[0]=j0; + h=hb; + do { // walk on the tree + b= pb[l]; + while (pi[l]--) // loop on 4 element of the box + { + int k = pi[l]; + + if (b->nbitems>0) // BamgVertex BamgQuadtreeBox none empty + { + I2 i2 = b->v[k]->i; + // if good direction when try -- + + h0 = NORM(iplus,i2.x,jplus,i2.y); + if (h0 v[k]; + } + } + else // Pointer BamgQuadtreeBox + { + register BamgQuadtreeBox *b0=b; + if ((b=b->b[k])) + { + hb >>=1 ; // div by 2 + register Icoor1 iii = ii[l]+I_IJ(k,hb); + register Icoor1 jjj = jj[l]+J_IJ(k,hb); + + if (INTER_SEG(iii,iii+hb,iplus-h,iplus+h) && INTER_SEG(jjj,jjj+hb,jplus-h,jplus+h)) + { + pb[++l]= b; + pi[l]= b->nbitems>0 ?(int) b->nbitems : 4 ; + ii[l]= iii; + jj[l]= jjj; + + } + else + b=b0, hb <<=1 ; + } + else + b=b0; + } + } + hb <<= 1; // mul by 2 + } while (l--); + + return vn; + } + /*}}}*/ + /*FUNCTION BamgQuadtree::NewBamgQuadtreeBox {{{*/ + BamgQuadtree::BamgQuadtreeBox* BamgQuadtree::NewBamgQuadtreeBox(void){ + + /*Output*/ + BamgQuadtreeBox* newbox=NULL; + + /*Create and initialize a new box*/ + newbox=new BamgQuadtreeBox; + newbox->nbitems=0; + newbox->b[0]=NULL; + newbox->b[1]=NULL; + newbox->b[2]=NULL; + newbox->b[3]=NULL; + + /*Add root to the container*/ + boxcontainer->AddObject(newbox); + + /*Increase counter*/ + NbBamgQuadtreeBox++; + + /*currentbox now points toward next quadtree box*/ + return newbox; + }/*}}}*/ + /*FUNCTION BamgQuadtree::ToClose {{{*/ + BamgVertex* BamgQuadtree::ToClose(BamgVertex & v,double seuil,Icoor1 hx,Icoor1 hy){ + /*Original code from Frederic Hecht (BAMG v1.01, BamgQuadtree.cpp/ToClose)*/ + + const Icoor1 i=v.i.x; + const Icoor1 j=v.i.y; + const R2 X(v.r); + const Metric Mx(v.m); + + BamgQuadtreeBox * pb[ MaxDepth ]; + int pi[ MaxDepth ]; + Icoor1 ii[ MaxDepth ], jj [ MaxDepth]; + register int l=0; // level + register BamgQuadtreeBox * b; + Icoor1 h=MaxISize; + Icoor1 hb = MaxISize; + Icoor1 i0=0,j0=0; + + // BamgVertex *vn=0; + + if (!root->nbitems) + return 0; // empty tree + + // general case ----- + pb[0]=root; + pi[0]=root->nbitems>0 ?(int) root->nbitems : 4 ; + ii[0]=i0; + jj[0]=j0; + h=hb; + do { + b= pb[l]; + while (pi[l]--){ + register int k = pi[l]; + + if (b->nbitems>0){ // BamgVertex BamgQuadtreeBox none empty + I2 i2 = b->v[k]->i; + if ( ABS(i-i2.x) v[k]->r); + double dd; + if( (dd= LengthInterpole(Mx(XY), b->v[k]->m(XY))) < seuil ){ + return b->v[k]; + } + } + } + else{ // Pointer BamgQuadtreeBox + register BamgQuadtreeBox *b0=b; + if ((b=b->b[k])){ + hb >>=1 ; // div by 2 + register long iii = ii[l]+I_IJ(k,hb); + register long jjj = jj[l]+J_IJ(k,hb); + + if (INTER_SEG(iii,iii+hb,i-hx,i+hx) && INTER_SEG(jjj,jjj+hb,j-hy,j+hy)){ + pb[++l]= b; + pi[l]= b->nbitems>0 ?(int) b->nbitems : 4 ; + ii[l]= iii; + jj[l]= jjj; + + } + else{ + b=b0; + hb <<=1 ; + } + } + else{ + b=b0; + } + } + } + hb <<= 1; // mul by 2 + } while (l--); + + return 0; + } + /*}}}*/ +} Index: /issm/trunk-jpl/src/c/bamg/BamgQuadtree.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgQuadtree.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgQuadtree.h (revision 15061) @@ -0,0 +1,61 @@ +/*Original code from Frederic Hecht (BAMG v1.01, BamgQuadtree.h)*/ +#ifndef _BAMGQUADTREE_H +#define _BAMGQUADTREE_H + +#include "./include.h" +#include "../classes/Object.h" +class DataSet; + +namespace bamg { + + const int MaxDepth = 30; + const long MaxISize = ( 1L << MaxDepth); // = 2^30 : 010000000000..000 (bitwise operation) + + class BamgVertex; + + class BamgQuadtree{ + + private: + + /*A quadtree box contains a maximum of 4 vertices. 4 other quadtree boxes are + * created if a fifth vertex is added to the same box. A Quadtree box is therefore + * composed of EITHER: + * - up to 4 vertices + * - 4 "sub" quadtree boxes*/ + class BamgQuadtreeBox: public Object{ + public: + int nbitems; // number of current vertices in the box + union{ + BamgQuadtreeBox* b[4]; + BamgVertex* v[4]; + }; + /*Object functions*/ + void Echo() {_error_("not implemented yet"); }; + void DeepEcho() {_error_("not implemented yet"); }; + int Id() {_error_("not implemented yet"); }; + int ObjectEnum() {_error_("not implemented yet"); }; + Object *copy() {_error_("not implemented yet"); }; + }; + + /*BamgQuadtree private Fields*/ + DataSet* boxcontainer; + + public: + + /*BamgQuadtree public Fields*/ + BamgQuadtreeBox* root; + long NbBamgQuadtreeBox; + long NbVertices; + + BamgQuadtree(); + BamgQuadtree(Mesh *t,long nbv=-1); + ~BamgQuadtree(); + + BamgVertex *NearestVertex(Icoor1 i,Icoor1 j); + BamgVertex *NearestVertexWithNormal(Icoor1 i,Icoor1 j); + BamgQuadtreeBox *NewBamgQuadtreeBox(void); + BamgVertex *ToClose(BamgVertex &,double ,Icoor1,Icoor1); + void Add(BamgVertex &w); + }; +} +#endif Index: /issm/trunk-jpl/src/c/bamg/BamgVertex.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgVertex.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgVertex.cpp (revision 15061) @@ -0,0 +1,257 @@ +#include +#include +#include +#include + +#include "../classes/classes.h" +#include "./det.h" + +namespace bamg { + + /*Methods*/ + /*FUNCTION BamgVertex::Echo {{{*/ + + void BamgVertex::Echo(void){ + + _printLine_("Vertex:"); + _printLine_(" integer coordinates i.x: " << i.x << ", i.y: " << i.y); + _printLine_(" Euclidean coordinates r.x: " << r.x << ", r.y: " << r.y); + _printLine_(" ReferenceNumber = " << ReferenceNumber); + m.Echo(); + + return; + } + /*}}}*/ + /*FUNCTION BamgVertex::GetReferenceNumber{{{*/ + int BamgVertex::GetReferenceNumber() const { + return ReferenceNumber; + } + /*}}}*/ + /*FUNCTION BamgVertex::MetricFromHessian{{{*/ + void BamgVertex::MetricFromHessian(const double Hxx,const double Hyx, const double Hyy,const double smin,const double smax,const double s,double err,BamgOpts* bamgopts){ + /*Compute Metric from Hessian*/ + + /*get options*/ + double power=(bamgopts->power); + double anisomax=(bamgopts->anisomax); + double CutOff=bamgopts->cutoff; + double hmin=(bamgopts->hmin); + double hmax=(bamgopts->hmax); + double coef=bamgopts->coeff; + int Metrictype=(bamgopts->Metrictype); + + /*Intermediary*/ + double ci; + + /*compute multiplicative coefficient depending on Metric Type (2/9 because it is 2d)*/ + + //Absolute Error + /* + * 2 1 + *Metric M = --- ------------ Abs(Hessian) + * 9 err * coeff^2 + */ + if (Metrictype==0){ + ci= 2.0/9.0 * 1/(err*coef*coef); + } + + //Relative Error + /* + * 2 1 Abs(Hessian) + *Metric M = --- ------------ ---------------------- + * 9 err * coeff^2 max( |s| , cutoff*max(|s|) ) + * + */ + else if (Metrictype==1){ + ci= 2.0/9.0 * 1/(err*coef*coef) * 1/Max( Abs(s), CutOff*(Max(Abs(smin),Abs(smax)))); + } + + //Rescaled absolute error + /* + * 2 1 Abs(Hessian) + *Metric M = --- ------------ ---------------------- + * 9 err * coeff^2 (smax-smin) + */ + else if (Metrictype==2){ + ci= 2.0/9.0 * 1/(err*coef*coef) * 1/(smax-smin); + } + else{ + _error_("Metrictype " << Metrictype << " not supported yet (use 0,1 or 2(default))"); + } + + //initialize metric Miv with ci*H + Metric Miv(Hxx*ci,Hyx*ci,Hyy*ci); + + //Get eigen values and vectors of Miv + EigenMetric Vp(Miv); + + //move eigen valuse to their absolute values + Vp.Abs(); + + //Apply a power if requested by user + if(power!=1.0) Vp.pow(power); + + //modify eigen values according to hmin and hmax + Vp.Maxh(hmax); + Vp.Minh(hmin); + + //Bound anisotropy by 1/(anisomax)^2 + Vp.BoundAniso2(1/(anisomax*anisomax)); + + //rebuild Metric from Vp + Metric MVp(Vp); + + //Apply Metric to vertex + m.IntersectWith(MVp); + + } + /*}}}*/ + /*FUNCTION BamgVertex::Optim {{{*/ + long BamgVertex::Optim(int i,int koption){ + long ret=0; + if ( t && (IndexInTriangle >= 0 ) && (IndexInTriangle <3) ){ + ret = t->Optim(IndexInTriangle,koption); + if(!i){ + t =0; // for no future optime + IndexInTriangle= 0; + } + } + return ret; + } + /*}}}*/ + /*FUNCTION BamgVertex::Smoothing{{{*/ + double BamgVertex::Smoothing(Mesh &Th,const Mesh &BTh,Triangle* &tstart ,double omega){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/Smoothing)*/ + + register BamgVertex* s=this; + BamgVertex &vP = *s,vPsave=vP; + + register Triangle* tbegin= t , *tria = t , *ttc; + + register int k=0,kk=0,j = EdgesVertexTriangle[IndexInTriangle][0],jc; + R2 P(s->r),PNew(0,0); + do { + k++; + + if (!tria->Hidden(j)){ + BamgVertex &vQ = (*tria)[VerticesOfTriangularEdge[j][0]]; + + R2 Q = vQ,QP(P-Q); + double lQP = LengthInterpole(vP,vQ,QP); + PNew += Q+QP/Max(lQP,1e-20); + kk ++; + } + ttc = tria->TriangleAdj(j); + jc = NextEdge[tria->NuEdgeTriangleAdj(j)]; + tria = ttc; + j = NextEdge[jc]; + if (k>=2000){ + _error_("k>=2000 (Maximum number of iterations reached)"); + } + } while ( tbegin != tria); + if (kk<4) return 0; + PNew = PNew/(double)kk; + R2 Xmove((PNew-P)*omega); + PNew = P+Xmove; + double delta=Norme2_2(Xmove); + + Icoor2 deta[3]; + I2 IBTh = BTh.R2ToI2(PNew); + + tstart=BTh.TriangleFindFromCoord(IBTh,deta,tstart); + + if (tstart->det <0){ // outside + double ba,bb; + AdjacentTriangle edge= CloseBoundaryEdge(IBTh,tstart,ba,bb) ; + tstart = edge; + vP.m= Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1)); + } + else { // inside + double aa[3]; + double s = deta[0]+deta[1]+deta[2]; + aa[0]=deta[0]/s; + aa[1]=deta[1]/s; + aa[2]=deta[2]/s; + vP.m = Metric(aa,(*tstart)[0],(*tstart)[1],(*tstart)[2]); + } + + // recompute the det of the triangle + vP.r = PNew; + + vP.i = Th.R2ToI2(PNew); + + BamgVertex vPnew = vP; + + int ok=1; + int loop=1; + k=0; + while (ok){ + ok =0; + do { + k++; + double detold = tria->det; + tria->det = bamg::det( (*tria)[0],(*tria)[1] ,(*tria)[2]); + if (loop) { + BamgVertex *v0,*v1,*v2,*v3; + if (tria->det<0) ok =1; + else if (tria->Quadrangle(v0,v1,v2,v3)) + { + vP = vPsave; + double qold =QuadQuality(*v0,*v1,*v2,*v3); + vP = vPnew; + double qnew =QuadQuality(*v0,*v1,*v2,*v3); + if (qnewdet < detold/2 ) ok=1; + + } + tria->SetUnMarkUnSwap(0); + tria->SetUnMarkUnSwap(1); + tria->SetUnMarkUnSwap(2); + ttc = tria->TriangleAdj(j); + jc = NextEdge[tria->NuEdgeTriangleAdj(j)]; + tria = ttc; + j = NextEdge[jc]; + if (k>=2000){ + _error_("k>=2000"); + } + }while ( tbegin != tria); + + if (ok && loop) vP=vPsave; // no move + loop=0; + } + return delta; + } + /*}}}*/ + + /*Intermediary*/ + /*FUNCTION QuadQuality{{{*/ + double QuadQuality(const BamgVertex & a,const BamgVertex &b,const BamgVertex &c,const BamgVertex &d) { + /*Original code from Frederic Hecht (BAMG v1.01, MeshQuad.cpp/QuadQuality)*/ + + // calcul de 4 angles -- + R2 A((R2)a),B((R2)b),C((R2)c),D((R2)d); + R2 AB(B-A),BC(C-B),CD(D-C),DA(A-D); + // Move(A),Line(B),Line(C),Line(D),Line(A); + const Metric & Ma = a; + const Metric & Mb = b; + const Metric & Mc = c; + const Metric & Md = d; + + double lAB=Norme2(AB); + double lBC=Norme2(BC); + double lCD=Norme2(CD); + double lDA=Norme2(DA); + AB /= lAB; BC /= lBC; CD /= lCD; DA /= lDA; + // version aniso + double cosDAB= Ma(DA,AB)/(Ma(DA)*Ma(AB)),sinDAB= Det(DA,AB); + double cosABC= Mb(AB,BC)/(Mb(AB)*Mb(BC)),sinABC= Det(AB,BC); + double cosBCD= Mc(BC,CD)/(Mc(BC)*Mc(CD)),sinBCD= Det(BC,CD); + double cosCDA= Md(CD,DA)/(Md(CD)*Md(DA)),sinCDA= Det(CD,DA); + double sinmin=Min(Min(sinDAB,sinABC),Min(sinBCD,sinCDA)); + if (sinmin<=0) return sinmin; + return 1.0-Max(Max(Abs(cosDAB),Abs(cosABC)),Max(Abs(cosBCD),Abs(cosCDA))); + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/BamgVertex.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/BamgVertex.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/BamgVertex.h (revision 15061) @@ -0,0 +1,58 @@ +#ifndef _BAMGVERTEX_H_ +#define _BAMGVERTEX_H_ + +#include "./include.h" +#include "./Metric.h" +#include "./Direction.h" +#include "./BamgOpts.h" + +namespace bamg { + + //classes + class Triangle; + class Mesh; + class VertexOnGeom; + class VertexOnEdge; + + class BamgVertex { + + public: + + /*Fields*/ + I2 i; // integer coordinates + R2 r; // real coordinates + Metric m; + long ReferenceNumber; + Direction DirOfSearch; + short IndexInTriangle; // the vertex number in triangle; varies between 0 and 2 in t + + union { + Triangle *t; // one triangle which is containing the vertex + long color; + BamgVertex *MeshVertexHook; // used in geometry BamgVertex to know the Mesh Vertex associated + VertexOnGeom *GeomEdgeHook; // if IndexInTriangle == 8; // set with Mesh::SetVertexFieldOn() + BamgVertex *BackgroundVertexHook; // if IndexInTriangle == 16 on Background vertex Mesh::SetVertexFieldOnBTh() + VertexOnEdge *BackgroundEdgeHook; // if IndexInTriangle == 32 on Background edge + }; + + /*Operators*/ + operator I2() const {return i;} // Cast operator + operator const R2 & () const {return r;} // Cast operator + operator Metric () const {return m;} // Cast operator + double operator()(R2 x) const { return m(x);} // Get x in the metric m + + /*methods (No constructor and no destructors...)*/ + double Smoothing(Mesh & ,const Mesh & ,Triangle * & ,double =1); + void MetricFromHessian(const double Hxx,const double Hyx, const double Hyy, const double smin,const double smax,const double s,const double err,BamgOpts* bamgopts); + void Echo(); + int GetReferenceNumber() const; + long Optim(int =1,int =0); + + //inline functions + inline void Set(const BamgVertex &rec,const Mesh & ,Mesh & ){*this=rec;} + }; + + //Intermediary + double QuadQuality(const BamgVertex &,const BamgVertex &,const BamgVertex &,const BamgVertex &); +} +#endif Index: /issm/trunk-jpl/src/c/bamg/CMakeLists.txt =================================================================== --- /issm/trunk-jpl/src/c/bamg/CMakeLists.txt (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/CMakeLists.txt (revision 15061) @@ -0,0 +1,31 @@ +# Subdirectories {{{ +# }}} +# Include Directory {{{ +include_directories(AFTER $ENV{ISSM_DIR}/src/c/classes/bamg) +# }}} +# BAMG_SOURCES {{{ +set(BAMG_SOURCES $ENV{ISSM_DIR}/src/c/classes/bamg/AdjacentTriangle.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/BamgGeom.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/BamgMesh.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/BamgOpts.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/BamgQuadtree.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/BamgVertex.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/CrackedEdge.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/Curve.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/Direction.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/Edge.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/EigenMetric.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/GeomEdge.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/Geometry.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/GeomSubDomain.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/GeomVertex.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/ListofIntersectionTriangles.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/Mesh.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/Metric.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/SetOfE4.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/SubDomain.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/Triangle.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/VertexOnEdge.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/VertexOnGeom.cpp + $ENV{ISSM_DIR}/src/c/classes/bamg/VertexOnVertex.cpp PARENT_SCOPE) +# }}} Index: /issm/trunk-jpl/src/c/bamg/CrackedEdge.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/CrackedEdge.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/CrackedEdge.cpp (revision 15061) @@ -0,0 +1,33 @@ +#include +#include +#include +#include + +#include "CrackedEdge.h" + +namespace bamg { + + /*Constructors/Destructors*/ + /*FUNCTION CrackedEdge() {{{*/ + CrackedEdge::CrackedEdge() { + a=NULL; + b=NULL; + E=NULL; + e1=NULL; + e2=NULL; + indexa[0]=-1; + indexa[1]=-1; + indexa[2]=-1; + indexb[0]=-1; + indexb[1]=-1; + indexb[2]=-1; + length=0; + normal.x=0; + normal.y=0; + + } + /*}}}*/ + + /*Methods*/ + +} Index: /issm/trunk-jpl/src/c/bamg/CrackedEdge.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/CrackedEdge.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/CrackedEdge.h (revision 15061) @@ -0,0 +1,31 @@ +#ifndef _CRACKEDEDGE_H_ +#define _CRACKEDEDGE_H_ + +#include "./typedefs.h" + +namespace bamg { + + //classes + class Triangle; + class GeomEdge; + class Edge; + + class CrackedEdge { + + public: + Triangle* a; + Triangle* b; + GeomEdge* E; + Edge* e1; + Edge* e2; + double length; + R2 normal; + long indexa[3]; + long indexb[3]; + + //Constructors + CrackedEdge(); + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/Curve.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/Curve.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Curve.cpp (revision 15061) @@ -0,0 +1,37 @@ +#include +#include +#include +#include + +#include "Curve.h" +#include "Geometry.h" + +namespace bamg { + + /*Constructors/Destructors*/ + /*FUNCTION Curve::Curve(){{{*/ + Curve::Curve(){ + FirstEdge=NULL; + LastEdge=NULL; + FirstVertexIndex=0; + LastVertexIndex=0; + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION Curve::Reverse {{{*/ + void Curve::Reverse() { + /*reverse the direction of the curve */ + Exchange(FirstEdge,LastEdge); + Exchange(FirstVertexIndex,LastVertexIndex); + } + /*}}}*/ + /*FUNCTION Curve::Set {{{*/ + void Curve::Set(const Curve & rec,const Geometry & Gh ,Geometry & GhNew){ + *this = rec; + FirstEdge = GhNew.edges + Gh.GetId(FirstEdge); + LastEdge = GhNew.edges + Gh.GetId(LastEdge); + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/Curve.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/Curve.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Curve.h (revision 15061) @@ -0,0 +1,27 @@ +#ifndef _CURVE_H_ +#define _CURVE_H_ + +#include "../shared/Bamg/shared.h" + +namespace bamg { + + //classes + class GeomEdge; + class Curve; + class Geometry; + + class Curve { + public: + GeomEdge *FirstEdge; //First edge of the curve + GeomEdge *LastEdge; //Last edge of the curve + int FirstVertexIndex; //Last vertex index in the last edge + int LastVertexIndex; //First Vertex index in the first edge + + //Methods + Curve(); + void Reverse(void); + void Set(const Curve & rec,const Geometry & Th ,Geometry & ThNew); + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/Direction.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/Direction.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Direction.cpp (revision 15061) @@ -0,0 +1,36 @@ +#include +#include +#include +#include + +#include "Direction.h" + +namespace bamg { + + /*Constructors/Destructors*/ + /*FUNCTION Direction() {{{*/ + Direction::Direction(): + dir(MaxICoor){ + + }/*}}}*/ + /*FUNCTION Direction(Icoor1 i,Icoor1 j) {{{*/ + Direction::Direction(Icoor1 i,Icoor1 j) { + Icoor2 n2 = 2*(Abs(i)+Abs(j)); + Icoor2 r = MaxICoor* (Icoor2) i; + Icoor1 r1 = (Icoor1) (2*(r/ n2)); // odd number + dir = (j>0) ? r1 : r1+1; // odd-> j>0 even-> j<0 + }/*}}}*/ + + /*Methods*/ + /*FUNCTION Direction::direction{{{*/ + int Direction::direction(Icoor1 i,Icoor1 j) { + int r =1; + if (dir!= MaxICoor) { + Icoor2 x(dir/2),y1(MaxICoor/2-Abs(x)),y(dir%2?-y1:y1); + r = (x*i + y*j) >=0; + } + return r; + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/Direction.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/Direction.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Direction.h (revision 15061) @@ -0,0 +1,20 @@ +#ifndef _DIRECTION_H_ +#define _DIRECTION_H_ + +#include "./include.h" +#include "../shared/Bamg/shared.h" + +namespace bamg { + + class Direction { + private: + Icoor1 dir; + + public: + //Methods + Direction(); + Direction(Icoor1 i,Icoor1 j); + int direction(Icoor1 i,Icoor1 j); + }; +} +#endif Index: /issm/trunk-jpl/src/c/bamg/DoubleAndInt.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/DoubleAndInt.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/DoubleAndInt.h (revision 15061) @@ -0,0 +1,19 @@ +#ifndef _DOUBLEANDINT_H_ +#define _DOUBLEANDINT_H_ + +#include "./include.h" + +namespace bamg { + + class DoubleAndInt { + //class used by Mesh::MakeQuadrangles + + public: + double q; + long i3j; + + //Operators + int operator<(DoubleAndInt a){return q > a.q;} + }; +} +#endif Index: /issm/trunk-jpl/src/c/bamg/Edge.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/Edge.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Edge.cpp (revision 15061) @@ -0,0 +1,55 @@ +#include +#include +#include +#include + +#include "Edge.h" +#include "Mesh.h" +#include "Geometry.h" +#include "../shared/io/Print/Print.h" + +namespace bamg { + + /*Constructors/Destructors*/ + + /*Methods*/ + /*FUNCTION Edge::Set {{{*/ + void Edge::Set(const Mesh & Th ,long i,Mesh & ThNew){ + *this = Th.edges[i]; + v[0] = ThNew.vertices + Th.GetId(v[0]); + v[1] = ThNew.vertices + Th.GetId(v[1]); + if (GeomEdgeHook) + GeomEdgeHook = ThNew.Gh.edges+Th.Gh.GetId(GeomEdgeHook); + if (adj[0]) adj[0] = ThNew.edges + Th.GetId(adj[0]); + if (adj[1]) adj[1] = ThNew.edges + Th.GetId(adj[1]); + } + /*}}}*/ + /*FUNCTION Edge::Echo {{{*/ + void Edge::Echo(void){ + _printLine_("Edge:"); + _printLine_(" pointers towards two vertices: " << v[0] << " " << v[1]); + _printLine_(" ReferenceNumber = " << ReferenceNumber); + _printLine_(" GeomEdgeHook = " << GeomEdgeHook); + _printLine_(" two adjacent edges on the same curve: " << adj[0] << " " << adj[1]); + } + /*}}}*/ + /*FUNCTION Edge::Renumbering{{{*/ + void Edge::Renumbering(BamgVertex *vb,BamgVertex *ve, long *renu){ + + if (v[0] >=vb && v[0] =vb && v[1] +#include +#include +#include + +#include "Metric.h" +#include "../shared/io/Print/Print.h" + +namespace bamg { + + /*Constructor*/ + /*FUNCTION EigenMetric::EigenMetric(const Metric M){{{*/ + EigenMetric::EigenMetric(const Metric& M){ + /*From a metric (a11,a21,a22), get eigen values lambda1 and lambda2 and one eigen vector v*/ + + /*Intermediaries*/ + double a11=M.a11,a21=M.a21,a22=M.a22; + double normM; + double delta,b; + + /*To get the eigen values, we must solve the following equation: + * | a11 - lambda a21 | + * det | | = 0 + * | a21 a22-lambda | + * + * We have to solve the following polynom: + * lamda^2 + ( -a11 -a22)*lambda + (a11*a22-a21*a21) = 0*/ + + /*Compute polynom determinant*/ + b=-a11-a22; + delta=b*b - 4*(a11*a22-a21*a21); + + /*Compute norm of M to avoid round off errors*/ + normM=a11*a11 + a22*a22 + a21*a21; + + /*1: normM too small: eigen values = 0*/ + if(normM<1.e-30){ + lambda1=0; + lambda2=0; + v.x=1; + v.y=0; + } + /*2: delta is small -> double root*/ + else if (delta < 1.e-5*normM){ + lambda1=-b/2; + lambda2=-b/2; + v.x=1; + v.y=0; + } + /*3: general case -> two roots*/ + else{ + delta = sqrt(delta); + lambda1 = (-b-delta)/2.0; + lambda2 = (-b+delta)/2.0; + + /*Now, one must find the eigen vectors. For that we use the following property of the inner product + * = + * Here, M'(M-lambda*Id) is symmetrical, which gives: + * ∀(x,y)∈R²xR² = + * And we have the following: + * if y∈Ker(M'), ∀x∈R² = = 0 + * We have shown that + * Im(M') ⊥ Ker(M') + * + * To find the eigen vectors of M, we only have to find two vectors + * of the image of M' and take their perpendicular as long as they are + * not 0. + * To do that, we take the images (1,0) and (0,1): + * x1 = (a11 - lambda) x2 = a21 + * y1 = a21 y2 = (a22-lambda) + * + * We take the vector that has the larger norm and take its perpendicular.*/ + + double norm1 = (a11-lambda1)*(a11-lambda1) + a21*a21; + double norm2 = a21*a21 + (a22-lambda1)*(a22-lambda1); + + if (norm2 +#include +#include + +#include "../shared/Exceptions/exceptions.h" + +#include "GeomEdge.h" +#include "Geometry.h" + +using namespace std; + +namespace bamg { + + /*Constructor/Destructor*/ + + /*Methods*/ + /*FUNCTION GeomEdge::Cracked{{{*/ + int GeomEdge::Cracked() const { + return type &1; + }/*}}}*/ + /*FUNCTION GeomEdge::F{{{*/ + R2 GeomEdge::F(double theta) const{ + /*Original code from Frederic Hecht (BAMG v1.01, MeshGeom.cpp/F)*/ + // parametrization of the curve edge + + R2 A=v[0]->r,B=v[1]->r; + double ca,cb,cta,ctb; + + //Check that theta is in [0 1] + _assert_(theta>-1e-12 && theta<1+1e-12); + + if (TgA()){ + if (TgB()){ //Hermite interpolation + cb = theta*theta*(3-2*theta); + ca = 1-cb; + cta = (1-theta)*(1-theta)*theta; + ctb = (theta-1)*theta*theta ; + } + else { + double t = theta; + cb = t*t; + ca = 1-cb; + cta= t-cb; + ctb=0; + } + } + else{ + if (TgB()){ + double t = 1-theta; + ca = t*t; + cb = 1-ca; + ctb= -t+ca; + cta=0; + } + else { // lagrange P1 + ca =(1-theta); + cb = theta; + cta=ctb=0; + } + } + return A*ca + B*cb + tg[0]*cta + tg[1]*ctb; + } + /*}}}*/ + /*FUNCTION GeomEdge::Mark{{{*/ + int GeomEdge::Mark() const { + return type &16; + }/*}}}*/ + /*FUNCTION GeomEdge::R1tg{{{*/ + double GeomEdge::R1tg(double theta,R2 & t) const{ + /*Original code from Frederic Hecht (BAMG v1.01, MeshGeom.cpp/R1tg)*/ + // 1/R of radius of cuvature + + R2 A=v[0]->r,B=v[1]->r; + double dca,dcb,dcta,dctb; + double ddca,ddcb,ddcta,ddctb; + double tt = theta*theta; + + //check theta + _assert_(theta>=0 && theta<=1); + + if (TgA()){ + if (TgB()){ + // Tangent A and B provided: + // interpolation d'hermite + dcb = 6*theta*(1-theta); + ddcb = 6*(1-2*theta); + dca = -dcb; + ddca = -ddcb; + dcta = (3*theta - 4)*theta + 1; + ddcta=6*theta-4; + dctb = 3*tt - 2*theta; + ddctb = 6*theta-2; + } + else { + //Tangent A provided but tangent B not provided + // 1-t*t, t-t*t, t*t + double t = theta; + dcb = 2*t; + ddcb = 2; + dca = -dcb; + ddca = -2; + dcta = 1-dcb; + ddcta = -ddcb; + dctb=0; + ddctb=0; + } + } + else{ + if (TgB()){ + //Tangent B provided but tangent A not provided + double t = 1-theta; + dca = -2*t; + ddca = 2; + dcb = -dca; + ddcb = -2; + dctb = 1+dca; + ddctb= ddca; + dcta =0; + ddcta =0; + } + else { + //Neither thangent A nor tangent B provided + // lagrange P1 + t=B-A; + return 0; + } + } + R2 d = A*dca + B*dcb + tg[0]* dcta + tg[1] * dctb; + R2 dd = A*ddca + B*ddcb + tg[0]* ddcta + tg[1] * ddctb; + double d2=(d,d); + double sd2 = sqrt(d2); + t=d; + if(d2>1.0e-20){ + t/=sd2; + return Abs(Det(d,dd))/(d2*sd2); + } + else return 0; + } + /*}}}*/ + /*FUNCTION GeomEdge::Required{{{*/ + int GeomEdge::Required() { + return type &64; + }/*}}}*/ + /*FUNCTION GeomEdge::Set {{{*/ + void GeomEdge::Set(const GeomEdge & rec,const Geometry & Gh ,Geometry & GhNew){ + *this = rec; + v[0] = GhNew.vertices + Gh.GetId(v[0]); + v[1] = GhNew.vertices + Gh.GetId(v[1]); + if (Adj[0]) Adj[0] = GhNew.edges + Gh.GetId(Adj[0]); + if (Adj[1]) Adj[1] = GhNew.edges + Gh.GetId(Adj[1]); + } + /*}}}*/ + /*FUNCTION GeomEdge::SetCracked{{{*/ + void GeomEdge::SetCracked() { + type |= 1;/*=>1st digit to 1*/ + }/*}}}*/ + /*FUNCTION GeomEdge::SetTgA{{{*/ + void GeomEdge::SetTgA() { + type |=4; /*=>2d digit to 1*/ + }/*}}}*/ + /*FUNCTION GeomEdge::SetTgB{{{*/ + void GeomEdge::SetTgB() { + type |=8; /*=> 3d digit to 1*/ + }/*}}}*/ + /*FUNCTION GeomEdge::SetMark{{{*/ + void GeomEdge::SetMark() { + type |=16;/*=> 4th digiy to 1*/ + }/*}}}*/ + /*FUNCTION GeomEdge::SetUnMark{{{*/ + void GeomEdge::SetUnMark() { + type &= 1007 /* 1023-16 = 000111110111 => 4th digit to 0*/; + }/*}}}*/ + /*FUNCTION GeomEdge::SetRequired{{{*/ + void GeomEdge::SetRequired() { + type |= 64;/*=>6th digit to 1*/ + }/*}}}*/ + /*FUNCTION GeomEdge::Tg{{{*/ + int GeomEdge::Tg(int i) const { + return i==0 ? TgA() : TgB(); + }/*}}}*/ + /*FUNCTION GeomEdge::TgA{{{*/ + int GeomEdge::TgA() const { + return type &4; + }/*}}}*/ + /*FUNCTION GeomEdge::TgB{{{*/ + int GeomEdge::TgB() const { + return type &8; + }/*}}}*/ +} Index: /issm/trunk-jpl/src/c/bamg/GeomEdge.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/GeomEdge.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/GeomEdge.h (revision 15061) @@ -0,0 +1,47 @@ +#ifndef _GEOMETRICALEDGE_H_ +#define _GEOMETRICALEDGE_H_ + +#include "./include.h" + +namespace bamg { + + //classes + class GeomVertex; + class Geometry; + + class GeomEdge { + + public: + GeomVertex *v[2]; + long ReferenceNumber; + long CurveNumber; + R2 tg[2]; // the 2 tangentes (tg[0] =0 => no continuity) + GeomEdge *Adj[2]; + int AdjVertexIndex[2]; // for a given vertex, this gives the index of the vertex in the adjacent edge (0 or 1) + int type; + + //Operators + GeomVertex & operator[](int i){return *v[i];}; + const GeomVertex & operator[](int i) const { return *v[i];}; + GeomVertex * operator()(int i){return v[i];}; + + //Methods + R2 F(double theta) const ; // parametrization of the curve edge + double R1tg(double theta,R2 &t) const ; // 1/radius of curvature + tangente + int Tg(int i) const; + int Cracked() const; + int TgA() const; + int TgB() const; + int Mark() const; + int Required(); + void SetCracked(); + void SetTgA(); + void SetTgB(); + void SetMark(); + void SetUnMark(); + void SetRequired(); + void Set(const GeomEdge & rec,const Geometry & Th ,Geometry & ThNew); + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/GeomSubDomain.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/GeomSubDomain.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/GeomSubDomain.cpp (revision 15061) @@ -0,0 +1,20 @@ +#include +#include +#include +#include + +#include "GeomSubDomain.h" +#include "Geometry.h" + +namespace bamg { + + /*Constructors/Destructors*/ + + /*Methods*/ + /*FUNCTION GeomSubDomain::Set {{{*/ + void GeomSubDomain::Set(const GeomSubDomain & rec,const Geometry & Gh ,const Geometry & GhNew){ + *this = rec; + edge = Gh.GetId(edge) + GhNew.edges; + }/*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/GeomSubDomain.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/GeomSubDomain.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/GeomSubDomain.h (revision 15061) @@ -0,0 +1,23 @@ +#ifndef _GEOMETRICALSUBDOMAIN_H_ +#define _GEOMETRICALSUBDOMAIN_H_ + +#include "./include.h" + +namespace bamg { + + //classes + class GeomEdge; + class Geometry; + + class GeomSubDomain { + public: + GeomEdge *edge; + int direction; // -1 or 1 + long ReferenceNumber; + + //Methods + void Set(const GeomSubDomain &,const Geometry & ,const Geometry &); + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/GeomVertex.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/GeomVertex.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/GeomVertex.cpp (revision 15061) @@ -0,0 +1,37 @@ +#include +#include +#include +#include + +#include "GeomVertex.h" +#include "../shared/Exceptions/exceptions.h" + +namespace bamg { + + /*Constructors/Destructors*/ + //See header file + + /*Methods*/ + /*FUNCTION GeomVertex::Corner {{{*/ + int GeomVertex::Corner() const { + return type & 4; + } + /*}}}*/ + /*FUNCTION GeomVertex::Required {{{*/ + int GeomVertex::Required()const { + // a corner is required + return type & 6; + } + /*}}}*/ + /*FUNCTION GeomVertex::SetCorner {{{*/ + void GeomVertex::SetCorner(){ + type |= 4; + } + /*}}}*/ + /*FUNCTION GeomVertex::SetRequired {{{*/ + void GeomVertex::SetRequired(){ + type |= 2; + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/GeomVertex.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/GeomVertex.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/GeomVertex.h (revision 15061) @@ -0,0 +1,30 @@ +#ifndef _GEOMETRICALVERTEX_H_ +#define _GEOMETRICALVERTEX_H_ + +#include "./include.h" +#include "BamgVertex.h" + +namespace bamg { + + class Geometry; + + class GeomVertex : public BamgVertex { + + public: + friend class Geometry; + + int type; + + //Constructors + GeomVertex():type(0){}; + + //Methods + int Corner() const; + int Required()const; + void SetCorner(); + void SetRequired(); + + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/Geometry.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/Geometry.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Geometry.cpp (revision 15061) @@ -0,0 +1,969 @@ +#include +#include +#include +#include + +#include "../classes/classes.h" +#include "../shared/Exceptions/exceptions.h" + +namespace bamg { + + static const Direction NoDirOfSearch=Direction(); + + /*Constructors/Destructors*/ + /*FUNCTION Geometry::Geometry(){{{*/ + Geometry::Geometry(){ + Init(); + } + /*}}}*/ + /*FUNCTION Geometry::Geometry(BamgGeom* bamggeom, BamgOpts* bamgopts){{{*/ + Geometry::Geometry(BamgGeom* bamggeom, BamgOpts* bamgopts){ + Init(); + ReadGeometry(bamggeom,bamgopts); + PostRead(); + } + /*}}}*/ + /*FUNCTION Geometry::Geometry(const Geometry & Gh) (COPY operator){{{*/ + Geometry::Geometry(const Geometry & Gh) { + /*Original code from Frederic Hecht (BAMG v1.01, MeshGeom.cpp/Geometry)*/ + + long i; + *this = Gh; + NbRef =0; + quadtree=0; + vertices = nbv ? new GeomVertex[nbv] : NULL; + edges = nbe ? new GeomEdge[nbe]:NULL; + curves= nbcurves ? new Curve[nbcurves]:NULL; + subdomains = nbsubdomains ? new GeomSubDomain[nbsubdomains]:NULL; + for (i=0;i (BAMG v1.01, MeshGeom.cpp/~Geometry)*/ + if(NbRef>0){ _printString_("Trying to delete geometry and NbRef>0, probably due to an error"); return;} + if(vertices) delete [] vertices; vertices=0; + if(edges) delete [] edges; edges=0; + if(quadtree) delete quadtree; quadtree=0; + if(curves) delete [] curves; curves=0;nbcurves=0; + if(subdomains) delete [] subdomains;subdomains=0; + Init(); + } + /*}}}*/ + + /*IO*/ + /*FUNCTION Geometry::ReadGeometry{{{*/ + void Geometry::ReadGeometry(BamgGeom* bamggeom,BamgOpts* bamgopts){ + + int verbose; + nbv=0; + nbe=0; + nbcurves=0; + + double Hmin = HUGE_VAL;// the infinie value + int i,j,n,i0,i1,i2,i3; + + /*initialize some variables*/ + verbose= bamgopts->verbose; + nbv = bamggeom->VerticesSize[0]; + nbe = bamggeom->EdgesSize[0]; + + //some checks + if (bamggeom->Vertices==NULL) _error_("the domain provided does not contain any vertex"); + if (bamggeom->Edges==NULL) _error_("the domain provided does not contain any edge"); + + //Vertices + if (bamggeom->Vertices){ + if(verbose>5) _printLine_(" processing Vertices"); + if (bamggeom->VerticesSize[1]!=3) _error_("Vertices should have 3 columns"); + vertices = new GeomVertex[nbv]; + for (i=0;iVertices[i*3+0]; + vertices[i].r.y=(double)bamggeom->Vertices[i*3+1]; + vertices[i].ReferenceNumber=(long)bamggeom->Vertices[i*3+2]; + vertices[i].DirOfSearch=NoDirOfSearch; + vertices[i].color =0; + vertices[i].type=0; + } + /*find domain extrema (pmin,pmax) that will define the square box used for by the quadtree*/ + pmin = vertices[0].r; + pmax = vertices[0].r; + for (i=0;iEdges){ + R2 zerovector(0,0); + double* verticeslength=NULL; + + if(verbose>5) _printLine_(" processing Edges"); + if (bamggeom->EdgesSize[1]!=3) _error_("Edges should have 3 columns"); + edges = new GeomEdge[nbe]; + + //initialize verticeslength (sum of the lengths of the edges holding vertex) + verticeslength = new double[nbv]; + for(i=0;iEdges[i*3+0]-1; //-1 for C indexing + i2=(int)bamggeom->Edges[i*3+1]-1; //-1 for C indexing + edges[i].v[0]= vertices + i1; //pointer toward vertex i1 (=&vertices[i1]) + edges[i].v[1]= vertices + i2; //pointer toward vertex i2 + edges[i].ReferenceNumber=(long)bamggeom->Edges[i*3+2]; + + //get length of edge + R2 x12=vertices[i2].r-vertices[i1].r; + double l12=sqrt((x12,x12)); + Hmin=Min(Hmin,l12); + + //initialize other fields + edges[i].tg[0]=zerovector; + edges[i].tg[1]=zerovector; + edges[i].AdjVertexIndex[0] = edges[i].AdjVertexIndex[1] = -1; + edges[i].Adj[0] = edges[i].Adj[1] = NULL; + edges[i].type = 0; + + //Cracked? + if (edges[i].ReferenceNumber!=1) edges[i].SetCracked(); + + //prepare metric + vertices[i1].color++; + vertices[i2].color++; + verticeslength[i1] += l12; + verticeslength[i2] += l12; + } + + // definition the default of the given mesh size + for (i=0;i 0) + vertices[i].m=Metric(verticeslength[i] /(double) vertices[i].color); + else + vertices[i].m=Metric(Hmin); + } + delete [] verticeslength; + + } + else{ + _error_("No edges provided"); + } + + //hVertices + if(bamgopts->hVertices && bamgopts->hVerticesSize[0]==nbv){ + if(verbose>5) _printLine_(" processing hVertices"); + for (i=0;i< nbv;i++){ + if (!xIsNan(bamgopts->hVertices[i])){ + vertices[i].m=Metric((double)bamgopts->hVertices[i]); + } + } + } + + //MetricVertices + if(bamgopts->metric && bamgopts->metric[0]==nbv){ + if(verbose>5) _printLine_(" processing MetricVertices"); + for (i=0;i< nbv;i++) { + vertices[i].m = Metric((double)bamgopts->metric[i*3+0],(double)bamgopts->metric[i*3+1],(double)bamgopts->metric[i*3+2]); + } + } + + //MaxCornerAngle + if (bamgopts->MaxCornerAngle){ + if(verbose>5) _printLine_(" processing MaxCornerAngle"); + MaxCornerAngle=bamgopts->MaxCornerAngle*Pi/180; + } + + //TangentAtEdges + if (bamggeom->TangentAtEdges){ + if(verbose>5) _printString_(" processing TangentAtEdges"); + if (bamggeom->TangentAtEdgesSize[1]!=4) _error_("TangentAtEdges should have 4 columns"); + int n,i,j,k; + R2 tg; + + n=bamggeom->TangentAtEdgesSize[0]; + for (k=0;kTangentAtEdges[k*4+0]-1; //for C indexing + j=(int)bamggeom->TangentAtEdges[k*4+1]-1; //for C indexing + tg.x=bamggeom->TangentAtEdges[k*4+2]; + tg.y=bamggeom->TangentAtEdges[k*4+3]; + if (i<0 || i>=nbe) _error_("TangentAtEdges first index exceeds matrix dimension"); + if (j!=0 && j!=1) _error_("TangentAtEdges second index should be 1 or 2 only"); + edges[i].tg[j] = tg; + } + } + + //Corners + if(bamggeom->Corners){ + if(verbose>5) _printString_(" processing Corners"); + if (bamggeom->CornersSize[1]!=1) _error_("Corners should have 1 column"); + n=bamggeom->CornersSize[0]; + for (i=0;iCorners[i]-1; //for C indexing + if (j>nbv-1 || j<0) _error_("Bad corner definition: should in [0 " << nbv << "]"); + /*Required => at the same time SetRequired and SetCorner*/ + vertices[j].SetCorner(); + vertices[j].SetRequired(); + } + } + + //RequiredVertices + if(bamggeom->RequiredVertices){ + if(verbose>5) _printLine_(" processing RequiredVertices"); + if (bamggeom->RequiredVerticesSize[1]!=1) _error_("RequiredVertices should have 1 column"); + n=bamggeom->RequiredVerticesSize[0]; + for (i=0;iRequiredVertices[i]-1; //for C indexing + if (j>nbv-1 || j<0) _error_("Bad RequiredVerticess definition: should in [0 " << nbv << "]"); + vertices[j].SetRequired(); + } + } + + //RequiredEdges + if(bamggeom->RequiredEdges){ + if(verbose>5) _printLine_(" processing RequiredEdges"); + if (bamggeom->RequiredEdgesSize[1]!=1) _error_("RequiredEdges should have 1 column"); + n=bamggeom->RequiredEdgesSize[0]; + for (i=0;iRequiredEdges[i]-1; //for C indexing + if (j>nbe-1 || j<0) _error_("Bad RequiredEdges definition: should in [0 " << nbe << "]"); + edges[j].SetRequired(); + } + } + + //SubDomain + if(bamggeom->SubDomains){ + if(verbose>5) _printLine_(" processing SubDomains"); + if (bamggeom->SubDomainsSize[1]!=4) _error_("SubDomains should have 4 columns"); + nbsubdomains=bamggeom->SubDomainsSize[0]; + subdomains = new GeomSubDomain[nbsubdomains]; + for (i=0;iSubDomains[i*4+0]; + i1=(int)bamggeom->SubDomains[i*4+1]; + i2=(int)bamggeom->SubDomains[i*4+2]; + i3=(int)bamggeom->SubDomains[i*4+3]; + if (i0!=2) _error_("Bad Subdomain definition: first number should be 2 (for Edges)"); + if (i1>nbe || i1<=0) _error_("Bad Subdomain definition: second number should in [1 " << nbe << "] (edge number)"); + subdomains[i].edge=edges + (i1-1); + subdomains[i].direction = (int) i2; + subdomains[i].ReferenceNumber = i3; + } + } + } + /*}}}*/ + /*FUNCTION Geometry::WriteGeometry{{{*/ + void Geometry::WriteGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts){ + + int verbose; + int nbreq=0; + int nbreqv=0; + int nbtan=0; + int nbcracked=0; + int i,count; + + /*Get options*/ + verbose=bamgopts->verbose; + + /*Vertices*/ + if(verbose>5) _printLine_(" writing Vertices"); + bamggeom->VerticesSize[0]=nbv; + bamggeom->VerticesSize[1]=3; + if (nbv){ + bamggeom->Vertices=xNew(3*nbv); + for (i=0;iVertices[i*3+0]=vertices[i].r.x; + bamggeom->Vertices[i*3+1]=vertices[i].r.y; + bamggeom->Vertices[i*3+2]=vertices[i].GetReferenceNumber(); + + //update counters + if (vertices[i].Required()) nbreqv++; + } + } + + /*Edges*/ + if(verbose>5) _printLine_(" writing Edges"); + bamggeom->EdgesSize[0]=nbe; + bamggeom->EdgesSize[1]=3; + if (nbe){ + bamggeom->Edges=xNew(3*nbe); + for (i=0;iEdges[i*3+0]=GetId(edges[i][0])+1; //back to Matlab indexing + bamggeom->Edges[i*3+1]=GetId(edges[i][1])+1; //back to Matlab indexing + bamggeom->Edges[i*3+2]=(double)edges[i].ReferenceNumber; + + //update counters + if (edges[i].Required()) nbreq++; + if (edges[i].TgA() && edges[i][0].Corner()) nbtan++; + if (edges[i].TgB() && edges[i][1].Corner()) nbtan++; + } + } + + /*RequiredEdges*/ + if(verbose>5) _printLine_(" writing " << nbreq << " RequiredEdges"); + bamggeom->RequiredEdgesSize[0]=nbreq; + bamggeom->RequiredEdgesSize[1]=1; + if (nbreq){ + bamggeom->RequiredEdges=xNew(1*nbreq); + count=0; + for (i=0;iRequiredEdges[count]=i+1; //back to Matlab indexing + count=count+1; + } + } + } + + //No corners + + /*RequiredVertices*/ + if(verbose>5) _printLine_(" writing " << nbreqv << " RequiredVertices"); + bamggeom->RequiredVerticesSize[0]=nbreqv; + bamggeom->RequiredVerticesSize[1]=1; + if (nbreqv){ + bamggeom->RequiredVertices=xNew(1*nbreqv); + count=0; + for (i=0;iRequiredVertices[count]=i+1; //back to Matlab indexing + count=count+1; + } + } + } + + /*SubDomains*/ + if(verbose>5) _printLine_(" writing SubDomains"); + bamggeom->SubDomainsSize[0]=nbsubdomains; + bamggeom->SubDomainsSize[1]=4; + if (nbsubdomains){ + bamggeom->SubDomains=xNew(4*nbsubdomains); + for (i=0;iSubDomains[4*i+0]=2; + bamggeom->SubDomains[4*i+1]=GetId(subdomains[i].edge)+1; //back to Matlab indexing + bamggeom->SubDomains[4*i+2]=subdomains[i].direction; + bamggeom->SubDomains[4*i+3]=subdomains[i].ReferenceNumber; + } + } + + /*TangentAtEdges*/ + if(verbose>5) _printLine_(" writing TangentAtEdges"); + bamggeom->TangentAtEdgesSize[0]=nbtan; + bamggeom->TangentAtEdgesSize[1]=4; + if (nbtan){ + bamggeom->TangentAtEdges=xNew(4*nbtan); + count=0; + for (i=0;iTangentAtEdges[4*i+0]=i+1; //back to Matlab indexing + bamggeom->TangentAtEdges[4*i+1]=1; + bamggeom->TangentAtEdges[4*i+2]=edges[i].tg[0].x; + bamggeom->TangentAtEdges[4*i+3]=edges[i].tg[0].y; + } + if (edges[i].TgB() && edges[i][1].Corner()){ + bamggeom->TangentAtEdges[4*i+0]=i+1; //back to Matlab indexing + bamggeom->TangentAtEdges[4*i+1]=2; + bamggeom->TangentAtEdges[4*i+2]=edges[i].tg[1].x; + bamggeom->TangentAtEdges[4*i+3]=edges[i].tg[1].y; + } + count=count+1; + } + } + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION Geometry::Echo {{{*/ + void Geometry::Echo(void){ + + _printLine_("Geometry:"); + _printLine_(" nbv (number of vertices) : " << nbv); + _printLine_(" nbe (number of edges) : " << nbe); + _printLine_(" nbsubdomains: " << nbsubdomains); + _printLine_(" nbcurves: " << nbcurves); + _printLine_(" vertices: " << vertices); + _printLine_(" edges: " << edges); + _printLine_(" quadtree: " << quadtree); + _printLine_(" subdomains: " << subdomains); + _printLine_(" curves: " << curves); + _printLine_(" pmin (x,y): (" << pmin.x << " " << pmin.y << ")"); + _printLine_(" pmax (x,y): (" << pmax.x << " " << pmax.y << ")"); + _printLine_(" coefIcoor: " << coefIcoor); + _printLine_(" MaxCornerAngle: " << MaxCornerAngle); + + return; + } + /*}}}*/ + /*FUNCTION Geometry::Init{{{*/ + void Geometry::Init(void){ + /*Original code from Frederic Hecht (BAMG v1.01, MeshGeom.cpp/EmptyGeometry)*/ + + NbRef=0; + nbv=0; + nbe=0; + quadtree=NULL; + curves=NULL; + edges=NULL; + vertices=NULL; + nbsubdomains=0; + nbcurves=0; + subdomains=NULL; + MaxCornerAngle = 10*Pi/180; //default is 10 degres + } + /*}}}*/ + /*FUNCTION Geometry::MinimalHmin{{{*/ + double Geometry::MinimalHmin() { + /* coeffIcoor = (2^30-1)/D + * We cannot go beyond hmin = D/2^30 because of the quadtree + * hmin is therefore approximately 2/coeffIcoor */ + return 2.0/coefIcoor; + }/*}}}*/ + /*FUNCTION Geometry::MaximalHmax{{{*/ + double Geometry::MaximalHmax() { + return Max(pmax.x-pmin.x,pmax.y-pmin.y); + }/*}}}*/ + /*FUNCTION Geometry::GetId(const GeomVertex &t){{{*/ + long Geometry::GetId(const GeomVertex & t) const { + return &t - vertices; + }/*}}}*/ + /*FUNCTION Geometry::GetId(const GeomVertex * t){{{*/ + long Geometry::GetId(const GeomVertex * t) const { + return t - vertices; + }/*}}}*/ + /*FUNCTION Geometry::GetId(const GeomEdge & t){{{*/ + long Geometry::GetId(const GeomEdge & t) const { + return &t - edges; + }/*}}}*/ + /*FUNCTION Geometry::GetId(const GeomEdge * t){{{*/ + long Geometry::GetId(const GeomEdge * t) const { + return t - edges; + }/*}}}*/ + /*FUNCTION Geometry::GetId(const Curve * c){{{*/ + long Geometry::GetId(const Curve * c) const { + return c - curves; + }/*}}}*/ + /*FUNCTION Geometry::Containing{{{*/ + GeomEdge* Geometry::Containing(const R2 P, GeomEdge * start) const { + /*Original code from Frederic Hecht (BAMG v1.01, MeshGeom.cpp/Contening)*/ + + GeomEdge* on =start,* pon=0; + // walk with the cos on geometry + int counter=0; + while(pon != on){ + counter++; + _assert_(counter<100); + pon = on; + R2 A= (*on)[0]; + R2 B= (*on)[1]; + R2 AB = B-A; + R2 AP = P-A; + R2 BP = P-B; + if ( (AB,AP) < 0) + on = on->Adj[0]; + else if ( (AB,BP) > 0) + on = on->Adj[1]; + else + return on; + } + return on; + } + /*}}}*/ + /*FUNCTION Geometry::PostRead{{{*/ + void Geometry::PostRead(){ + /*Original code from Frederic Hecht (BAMG v1.01, MeshGeom.cpp/AfterRead)*/ + + long i ,j,k; + long *head_v = new long[nbv]; + long *next_p = new long[2 *nbe]; + float *eangle = new float[nbe]; + double eps = 1e-20; + BamgQuadtree quadtree; // build quadtree to find duplicates + BamgVertex *v0 = vertices; + + k=0; + + //build quadtree for this geometry + for (i=0;i [0 2^30-1[^2 for a quadtree of depth 30*/ + vertices[i].i=R2ToI2(vertices[i].r); + + /*find nearest vertex already present in the quadtree (NULL if empty)*/ + BamgVertex* v=quadtree.NearestVertex(vertices[i].i.x,vertices[i].i.y); + + /*if there is a vertex found that is to close to vertices[i] -> error*/ + if( v && Norme1(v->r - vertices[i].r) < eps ){ + _printLine_("reference numbers: " << v->ReferenceNumber << " " << vertices[i].ReferenceNumber); + _printLine_("Id: " << i+1); + _printLine_("Coords: ["<r.x<<" "<r.y<<"] ["<r - edges[i].v[0]->r; + double lv10=Norme2(v10); + //check that its length is not 0 + if(lv10==0){ + delete [] next_p; + delete [] head_v; + delete [] eangle; + _error_("Length of edge " << i << " is 0"); + } + //compute angle in [-Pi Pi] + eangle[i] = atan2(v10.y,v10.x); + //build chains head_v and next_p + for (j=0;j<2;j++){ + long v=GetId(edges[i].v[j]); + next_p[k]=head_v[v]; + head_v[v]=k++; //post increment: head_v[v]=k; and then k=k+1; + } + } + + //sort head_v by order of increasing edges angle + for (i=0;i=0){ + ord++; + long i1=n/2; // i1 = floor (n/2) -> Edge number + long j1=n%2; // j1 = 1 if n is odd -> Vertex index for this edge (0 or 1) + long* pn=next_p+n; + + //Next vertex index + n=*pn; + + //compute angle between horizontal axis and v0->v1 + float angle = j1 ? OppositeAngle(eangle[i1]): eangle[i1]; + + //exchange if the current edge angle is smaller than the previous one + if (angleold > angle){ + exch=1; + *pn=*po; // next_p[n] = n + 1 + *po=*p; // + *p=n; // next_p[n+1] = n + po=pn; // po now point toward pn (invert next and current) + } + + //else, continue going to the next edge position + else{ // to have : po -> p -> pn + angleold=angle; // update maximum angle + po=p; // po now point toward p (current position) + p=pn; // p now point toward pn (next position) + } + } + } + + // angular test on current vertex to guess whether it is a corner (ord = number of edges holding i) + if(ord==2) { + long n1 = head_v[i]; + long n2 = next_p[n1]; + long i1 = n1/2, i2 = n2/2; // edge number + long j1 = n1%2, j2 = n2%2; // vertex in the edge + float angle1= j1 ? OppositeAngle(eangle[i1]) : eangle[i1]; + float angle2= !j2 ? OppositeAngle(eangle[i2]) : eangle[i2]; + float da12 = Abs(angle2-angle1); + if (( da12 >= MaxCornerAngle ) && (da12 <= 2*Pi -MaxCornerAngle)) { + vertices[i].SetCorner() ; + } + // if the edge type/referencenumber a changing then is SetRequired(); + if (edges[i1].type != edges[i2].type || edges[i1].Required()){ + vertices[i].SetRequired(); + } + if (edges[i1].ReferenceNumber != edges[i2].ReferenceNumber) { + vertices[i].SetRequired(); + } + } + if(ord != 2) { + vertices[i].SetCorner(); + } + + /*close the list around the vertex to have a circular loop*/ + long no=-1, ne = head_v[i]; + while (ne >=0) ne = next_p[no=ne]; + if(no>=0) next_p[no] = head_v[i]; + } + + /*Check that the list makes sense (we have all the time the same vertex) + * and build adjacent edges*/ + k =0; + for (i=0;ir -edges[i].v[0]->r;// AB = vertex0 -> vertex1 + double lAB=Norme2(AB); // Get length of AB + double ltg2[2]={0.0}; // initialize tangent + + //loop over the 2 vertices of the edge + for (j=0;j<2;j++) { + R2 tg =edges[i].tg[j]; + double ltg=Norme2(tg); + + //by default, tangent=[0 0] + if(ltg==0){ + //if the current vertex of the edge is not a corner + if(!edges[i].v[j]->Corner()){ + /*The tangent is set as the vector between the + * previous and next vertices connected to current vertex + * normed by the edge length*/ + tg = edges[i].v[1-j]->r - edges[i].Adj[j]->v[1-edges[i].AdjVertexIndex[j]]->r; + ltg= Norme2(tg); + tg = tg *(lAB/ltg); + ltg= lAB; + } + //else: a Corner no tangent => nothing to do + } + else{ + //tangent has already been computed + tg = tg*(lAB/ltg),ltg=lAB; + } + + ltg2[j] = ltg; + + if ((tg,AB)<0) tg = -tg; + + edges[i].tg[j]=tg; + } + if (ltg2[0]!=0) edges[i].SetTgA(); + if (ltg2[1]!=0) edges[i].SetTgB(); + } + + /* generation of all curves (from corner to corner)*/ + /*We proceed in 2 steps: first allocate, second build*/ + for (int step=0;step<2;step++){ + + //unmark all edges + for (i=0;iSetMark(); + nb_marked_edges++; + e->CurveNumber=nbcurves; + GeomVertex *b=(*e)(k1); + + //break if we have reached the other end of the curve + if (a==b || b->Required()){ + if(curves){ + curves[nbcurves].LastEdge=e; + curves[nbcurves].LastVertexIndex=k1; + } + break; + } + //else: go to next edge (adjacent) + else{ + k0 = e->AdjVertexIndex[k1];// vertex in next edge + e = e->Adj[k1]; // next edge + } + } + nbcurves++; + if(level) a->SetRequired(); + } + } + } + } + _assert_(nb_marked_edges && nbe); + //allocate if first step + if(step==0) curves=new Curve[nbcurves]; + } + + /*clean up*/ + delete [] next_p; + delete [] head_v; + delete [] eangle; + + } + /*}}}*/ + /*FUNCTION Geometry::ProjectOnCurve {{{*/ + GeomEdge* Geometry::ProjectOnCurve(const Edge &e,double s,BamgVertex &V,VertexOnGeom &GV) const { + /*Original code from Frederic Hecht (BAMG v1.01, MeshGeom.cpp/ProjectOnCurve)*/ + /*Add a vertex on an existing geometrical edge according to the metrics of the two vertices constituting the edge*/ + + double save_s=s; + int NbTry=0; + +retry: + + s=save_s; + GeomEdge* on=e.GeomEdgeHook; + if (!on){ + _error_("ProjectOnCurve error message: edge provided should be on geometry"); + } + if (!e[0].GeomEdgeHook || !e[1].GeomEdgeHook){ + _error_("ProjectOnCurve error message: at least one of the vertex of the edge provided is not on geometry"); + } + + //Get the two vertices of the edge + const BamgVertex &v0=e[0]; + const BamgVertex &v1=e[1]; + + //Get position of V0, V1 and vector v0->v1 + R2 V0=v0,V1=v1,V01=V1-V0; + + //Get geometrical vertices corresponding to v0 and v1 + VertexOnGeom vg0=*v0.GeomEdgeHook, vg1=*v1.GeomEdgeHook; + + //build two pointers towrad current geometrical edge + GeomEdge *eg0=on, *eg1=on; + + //Get edge direction and swap v0 and v1 if necessary + R2 Ag=(R2)(*on)[0],Bg=(R2)(*on)[1],AB=Bg-Ag; + int OppositeSens = (V01,AB)<0; + int direction0=0,direction1=1; + if (OppositeSens) s=1-s,Exchange(vg0,vg1),Exchange(V0,V1); + + //Compute metric of new vertex as a linear interpolation of the two others + V.m=Metric(1.0-s,v0,s,v1); + + const int mxe=100; + GeomEdge* ge[mxe+1]; + int directionge[mxe+1]; + double lge[mxe+1]; + int bge=mxe/2,tge=bge; + ge[bge] = e.GeomEdgeHook; + directionge[bge]=1; + + while(eg0!=(GeomEdge*)vg0 && (*eg0)(direction0)!=(GeomVertex*)vg0){ + if (bge<=0) { + if(NbTry) { + _printLine_("Fatal Error: on the class Mesh before call Geometry::ProjectOnCurve"); + _printLine_("That bug might come from:"); + _printLine_(" 1) a mesh edge containing more than " << mxe/2 << " geometrical edges"); + _printLine_(" 2) code bug : be sure that we call Mesh::SetVertexFieldOn() before"); + _printLine_("To solve the problem do a coarsening of the geometrical mesh or change the constant value of mxe (dangerous)"); + _error_("see above"); + } + NbTry++; + goto retry; + } + GeomEdge* tmpge = eg0; + ge[--bge] =eg0 = eg0->Adj[direction0]; + _assert_(bge>=0 && bge<=mxe); + direction0 = 1-( directionge[bge] = tmpge->AdjVertexIndex[direction0]); + } + while (eg1 != (GeomEdge*) vg1 && (*eg1)(direction1) != (GeomVertex*) vg1) { + if(tge>=mxe ) { + _printLine_("WARNING: on the class Mesh before call Geometry::ProjectOnCurve is having issues (isn't it Eric?)"); + NbTry++; + if (NbTry<2) goto retry; + _printLine_("Fatal Error: on the class Mesh before call Geometry::ProjectOnCurve"); + _printLine_("That bug might come from:"); + _printLine_(" 1) a mesh edge contening more than " << mxe/2 << " geometrical edges"); + _printLine_(" 2) code bug : be sure that we call Mesh::SetVertexFieldOn() before"); + _printLine_("To solve the problem do a coarsening of the geometrical mesh or change the constant value of mxe (dangerous)"); + _error_("see above"); + } + GeomEdge* tmpge = eg1; + ge[++tge] =eg1 = eg1->Adj[direction1]; + directionge[tge]= direction1 = 1-tmpge->AdjVertexIndex[direction1]; + _assert_(tge>=0 && tge<=mxe); + } + + if ((*eg0)(direction0)==(GeomVertex*)vg0) + vg0=VertexOnGeom(*(BamgVertex*) vg0,*eg0,direction0); //vg0 = absisce + + if ((*eg1)(direction1)==(GeomVertex*)vg1) + vg1=VertexOnGeom(*(BamgVertex*) vg1,*eg1,direction1); + + double sg; + if (eg0 == eg1) { + register double s0=vg0,s1=vg1; + sg = s0*(1.0-s) + s*s1; + on=eg0; + } + else { + R2 AA=V0,BB; + double s0,s1; + int i=bge; + double ll=0; + for(i=bge;i=0 && i<=mxe); + BB = (*ge[i])[directionge[i]]; + lge[i]=ll += Norme2(AA-BB); + AA=BB ;} + lge[tge]=ll+=Norme2(AA-V1); + // search the geometrical edge + _assert_(s<=1.0); + double ls= s*ll; + on =0; + s0 = vg0; + s1= directionge[bge]; + double l0=0,l1; + i=bge; + while ( (l1=lge[i]) < ls ) { + _assert_(i>=0 && i<=mxe); + i++,s0=1-(s1=directionge[i]),l0=l1; + } + on=ge[i]; + if (i==tge) + s1=vg1; + + s =(ls-l0)/(l1-l0); + sg =s0*(1.0-s)+s*s1; + } + _assert_(on); + V.r= on->F(sg); + GV=VertexOnGeom(V,*on,sg); + return on; + } + /*}}}*/ + /*FUNCTION Geometry::R2ToI2{{{*/ + I2 Geometry::R2ToI2(const R2 & P) const { + /*coefIcoor is the coefficient used for integer coordinates: + * (x-pmin.x) + * Icoor x = (2^30 -1) ------------ + * D + * where D is the longest side of the domain (direction x or y) + * so that (x-pmin.x)/D is in ]0 1[ + * + * coefIcoor = (2^30 -1)/D + */ + return I2( (Icoor1) (coefIcoor*(P.x-pmin.x)) ,(Icoor1) (coefIcoor*(P.y-pmin.y)) ); + }/*}}}*/ + /*FUNCTION Geometry::UnMarkEdges{{{*/ + void Geometry::UnMarkEdges() { + for (int i=0;i +#include +#include +#include + +#include "../classes/classes.h" +#include "./det.h" + +namespace bamg { + + /*Constructors Destructors*/ + /*FUNCTION ListofIntersectionTriangles::ListofIntersectionTriangles{{{*/ + ListofIntersectionTriangles::ListofIntersectionTriangles(int n,int m) + : MaxSize(n), Size(0), len(-1),state(-1),lIntTria(new IntersectionTriangles[n]) , + NbSeg(0), MaxNbSeg(m), lSegsI(new SegInterpolation[m]){ + } + /*}}}*/ + /*FUNCTION ListofIntersectionTriangles::~ListofIntersectionTriangles{{{*/ + ListofIntersectionTriangles::~ListofIntersectionTriangles(){ + if (lIntTria) delete [] lIntTria,lIntTria=0; + if (lSegsI) delete [] lSegsI,lSegsI=0; + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION ListofIntersectionTriangles::Init{{{*/ + void ListofIntersectionTriangles::Init(void){ + state=0; + len=0; + Size=0; + } + /*}}}*/ + /*FUNCTION ListofIntersectionTriangles::Length{{{*/ + double ListofIntersectionTriangles::Length(){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/Length)*/ + + // computation of the length + + // check Size + if (Size<=0){ + _error_("Size<=0"); + } + + Metric Mx,My; + int ii,jj; + R2 x,y,xy; + + SegInterpolation* SegI=lSegsI; + SegI=lSegsI; + lSegsI[NbSeg].last=Size; + int EndSeg=Size; + + y = lIntTria[0].x; + double sxy, s = 0; + lIntTria[0].s =0; + SegI->lBegin=s; + + for (jj=0,ii=1;iilEnd=s; + SegI++; + EndSeg=SegI->last; + SegI->lBegin=s; + } + } + len = s; + SegI->lEnd=s; + + return s; + } + /*}}}*/ + /*FUNCTION ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) {{{*/ + int ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/NewItem)*/ + + register int n; + R2 x(0,0); + if ( d0) x = (*tt)[0].r * d0; + if ( d1) x = x + (*tt)[1].r * d1; + if ( d2) x = x + (*tt)[2].r * d2; + // newer add same point + if(!Size || Norme2_2(lIntTria[Size-1].x-x)) { + if (Size==MaxSize) ReShape(); + lIntTria[Size].t=tt; + lIntTria[Size].bary[0]=d0; + lIntTria[Size].bary[1]=d1; + lIntTria[Size].bary[2]=d2; + lIntTria[Size].x = x; + Metric m0,m1,m2; + register BamgVertex * v; + if ((v=(*tt)(0))) m0 = v->m; + if ((v=(*tt)(1))) m1 = v->m; + if ((v=(*tt)(2))) m2 = v->m; + lIntTria[Size].m = Metric(lIntTria[Size].bary,m0,m1,m2); + n=Size++;} + else n=Size-1; + return n; + } + /*}}}*/ + /*FUNCTION ListofIntersectionTriangles::NewItem(R2 A,const Metric & mm){{{*/ + int ListofIntersectionTriangles::NewItem(R2 A,const Metric & mm) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/NewItem)*/ + + register int n; + if(!Size || Norme2_2(lIntTria[Size-1].x-A)) { + if (Size==MaxSize) ReShape(); + lIntTria[Size].t=0; + lIntTria[Size].x=A; + lIntTria[Size].m=mm; + n=Size++; + } + else n=Size-1; + return n; + } + /*}}}*/ + /*FUNCTION ListofIntersectionTriangles::NewPoints{{{*/ + long ListofIntersectionTriangles::NewPoints(BamgVertex* vertices,long &nbv,long maxnbv){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/NewPoints)*/ + + //If length<1.5, do nothing + double s=Length(); + if (s<1.5) return 0; + + const long nbvold=nbv; + int ii = 1 ; + R2 y,x; + Metric My,Mx ; + double sx =0,sy; + int nbi=Max(2,(int) (s+0.5)); + double sint=s/nbi; + double si =sint; + + int EndSeg=Size; + SegInterpolation* SegI=NULL; + if (NbSeg) SegI=lSegsI,EndSeg=SegI->last; + + for (int k=1;klast; + } + } + + int ii1=ii-1; + x =lIntTria[ii1].x; + sx =lIntTria[ii1].s; + Metric Mx=lIntTria[ii1].m; + y =lIntTria[ii].x; + sy =lIntTria[ii].s; + Metric My=lIntTria[ii].m; + double lxy = sy-sx; + double cy = abscisseInterpole(Mx,My,y-x,(si-sx)/lxy); + + R2 C; + double cx = 1-cy; + C = SegI ? SegI->F(si): x * cx + y *cy; + //C.Echo(); + //x.Echo(); + //y.Echo(); + //_printLine_("cx = " << cx << ", cy=" << cy); + + si += sint; + if ( nbv=MaxNbSeg) { + int mneo= MaxNbSeg; + MaxNbSeg *= 2; + if (verbosity>3){ + _printLine_(" reshape lSegsI from " << mneo << " to " << MaxNbSeg); + } + _assert_(lSegsI && NbSeg3) _printLine_(" ListofIntersectionTriangles ReShape Maxsize " << MaxSize << " -> " << MaxNbSeg); + MaxSize = newsize; + delete [] lIntTria;// remove old + lIntTria = nw; // copy pointer + } + /*}}}*/ + /*FUNCTION ListofIntersectionTriangles::SplitEdge{{{*/ + void ListofIntersectionTriangles::SplitEdge(const Mesh & Bh, const R2 &A,const R2 &B,int nbegin) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/ListofIntersectionTriangles)*/ + + Triangle *tbegin, *t; + + long int verbose=2; + Icoor2 deta[3], deti,detj; + double ba[3]; + int nbt =0,ifirst=-1,ilast; + int i0,i1,i2; + int ocut,i,j,k=-1; + // int OnAVertices =0; + Icoor2 dt[3]; + I2 a = Bh.R2ToI2(A) ,b= Bh.R2ToI2(B);// compute the Icoor a,b + I2 vi,vj; + int iedge =-1;// not a edge + + if(nbegin) {// optimisation + // we suppose knowing the starting triangle + t=tbegin=lIntTria[ilast=(Size-1)].t; + if (tbegin->det>=0) + ifirst = ilast;} + else {// not optimisation + Init(); + t=tbegin = Bh.TriangleFindFromCoord(a,deta); + if( t->det>=0) + ilast=NewItem(t,double(deta[0])/t->det,double(deta[1])/t->det,double(deta[2])/t->det); + else + {// find the nearest boundary edge of the vertex A + // find a edge or such normal projection a the edge IJ is on the edge + // <=> IJ.IA >=0 && IJ.AJ >=0 + ilast=ifirst; + double ba,bb; + AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb); + BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1); + NewItem(A,Metric(ba,v0,bb,v1)); + t=edge; + // test if the point b is in the same side + if (det(v0.i,v1.i,b)>=0) { + AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb); + BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1); + NewItem(A,Metric(ba,v0,bb,v1)); + return; + } + } // find the nearest boundary edge of the vertex A + } // end not optimisation + if (t->det<0) { // outside departure + while (t->det <0) { // intersection boundary edge and a,b, + k=(*t)(0) ? (( (*t)(1) ? ( (*t)(2) ? -1 : 2) : 1 )) : 0; + if (k<0){ + _error_("k<0"); + } + ocut = OppositeEdge[k]; + i=VerticesOfTriangularEdge[ocut][0]; + j=VerticesOfTriangularEdge[ocut][1]; + vi=(*t)[i]; + vj=(*t)[j]; + deti = bamg::det(a,b,vi); + detj = bamg::det(a,b,vj); + if (deti>0) // go to i direction on gamma + ocut = PreviousEdge[ocut]; + else if (detj<=0) // go to j direction on gamma + ocut = NextEdge[ocut]; + AdjacentTriangle tadj =t->Adj(ocut); + t = tadj; + iedge= tadj; + if (t == tbegin) { // + double ba,bb; + long int verbose=2; + AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb); + BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1); + NewItem(A,Metric(ba,v0,bb,v1)); + return; + } + } // end while (t->det <0) + // theoriticaly we have: deti =<0 and detj>0 + + // computation of barycentric coor + // test if the point b is on size on t + // we revert vi,vj because vi,vj is def in Adj triangle + if ( det(vi,vj,b)>=0) { + t=tbegin; + double ba,bb; + AdjacentTriangle edge=CloseBoundaryEdge(b,t,ba,bb); + NewItem(B,Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1))); + return; + } + else + { + k = OppositeVertex[iedge]; + i=VerticesOfTriangularEdge[iedge][0]; + j=VerticesOfTriangularEdge[iedge][1]; + double dij = detj-deti; + if (i+j+k != 0 + 1 +2){ + _error_("i+j+k != 0 + 1 +2"); + } + ba[j] = detj/dij; + ba[i] = -deti/dij; + ba[k] = 0; + ilast=NewItem(t,ba[0],ba[1],ba[2]); } + } // outside departure + + // recherche the intersection of [a,b] with Bh Mesh. + // we know a triangle ta contening the vertex a + // we have 2 case for intersection [a,b] with a edge [A,B] of Bh + // 1) the intersection point is in ]A,B[ + // 2) is A or B + // first version --- + for (;;) { + // t->Draw(); + if (iedge < 0) { + i0 =0;i1=1;i2=2; + dt[0] =bamg::det(a,b,(*t)[0]); + dt[1] =bamg::det(a,b,(*t)[1]); + dt[2] =bamg::det(a,b,(*t)[2]);} + else { + i2 = iedge; + i0 = NextEdge[i2]; + i1 = NextEdge[i0]; + dt[VerticesOfTriangularEdge[iedge][0]] = detj;// we revert i,j because + dt[VerticesOfTriangularEdge[iedge][1]] = deti;// we take the Triangle by the other side + dt[iedge] = det(a,b,(*t)[OppositeVertex[iedge]]);} + + // so we have just to see the transition from - to + of the det0..2 on edge of t + // because we are going from a to b + if ((dt[i=VerticesOfTriangularEdge[i0][0]] < 0) && + ( dt[j=VerticesOfTriangularEdge[i0][1]] > 0)) + ocut =i0; + else if ((dt[i=VerticesOfTriangularEdge[i1][0]] < 0) && + (dt[j=VerticesOfTriangularEdge[i1][1]] > 0)) + ocut =i1; + else if ((dt[i=VerticesOfTriangularEdge[i2][0]] < 0) && + (dt[j=VerticesOfTriangularEdge[i2][1]] > 0)) + ocut =i2; + else if ((dt[i=VerticesOfTriangularEdge[i0][0]] == 0) && + ( dt[j=VerticesOfTriangularEdge[i0][1]] > 0)) + ocut =i0; + else if ((dt[i=VerticesOfTriangularEdge[i1][0]] == 0) && + (dt[j=VerticesOfTriangularEdge[i1][1]] > 0)) + ocut =i1; + else if ((dt[i=VerticesOfTriangularEdge[i2][0]] == 0) && + (dt[j=VerticesOfTriangularEdge[i2][1]] > 0)) + ocut =i2; + else if ((dt[i=VerticesOfTriangularEdge[i0][0]] < 0) && + ( dt[j=VerticesOfTriangularEdge[i0][1]] == 0)) + ocut =i0; + else if ((dt[i=VerticesOfTriangularEdge[i1][0]] < 0) && + (dt[j=VerticesOfTriangularEdge[i1][1]] == 0)) + ocut =i1; + else if ((dt[i=VerticesOfTriangularEdge[i2][0]] < 0) && + (dt[j=VerticesOfTriangularEdge[i2][1]] == 0)) + ocut =i2; + else { // On a edge (2 zero) + k =0; + if (dt[0]) ocut=0,k++; + if (dt[1]) ocut=1,k++; + if (dt[2]) ocut=2,k++; + if(k == 1) { + if (dt[ocut] >0) // triangle upper AB + ocut = NextEdge[ocut]; + i= VerticesOfTriangularEdge[ocut][0]; + j= VerticesOfTriangularEdge[ocut][1]; + } + else { + _error_("Bug Split Edge"); + } + } + + k = OppositeVertex[ocut]; + + Icoor2 detbij = bamg::det((*t)[i],(*t)[j],b); + + if (detbij >= 0) { //we find the triangle contening b + dt[0]=bamg::det((*t)[1],(*t)[2],b); + dt[1]=bamg::det((*t)[2],(*t)[0],b); + dt[2]=bamg::det((*t)[0],(*t)[1],b); + double dd = t->det; + NewItem(t,dt[0]/dd,dt[1]/dd,dt[2]/dd); + return ;} + else { // next triangle by adjacent by edge ocut + deti = dt[i]; + detj = dt[j]; + double dij = detj-deti; + ba[i] = detj/dij; + ba[j] = -deti/dij; + ba[3-i-j ] = 0; + ilast=NewItem(t, ba[0],ba[1],ba[2]); + + AdjacentTriangle ta =t->Adj(ocut); + t = ta; + iedge= ta; + if (t->det <= 0) { + double ba,bb; + AdjacentTriangle edge=CloseBoundaryEdge(b,t,ba,bb); + NewItem(B,Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1))); + return; + } + }// we go outside of omega + } // for(;;) + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/ListofIntersectionTriangles.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/ListofIntersectionTriangles.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/ListofIntersectionTriangles.h (revision 15061) @@ -0,0 +1,73 @@ +#ifndef _LISTOFINTERSECTIONTRIANGLES_H_ +#define _LISTOFINTERSECTIONTRIANGLES_H_ + +#include "./include.h" + +namespace bamg { + + class Triangle; + + class ListofIntersectionTriangles { + + class IntersectionTriangles { + + public: + Triangle *t; + double bary[3]; // use if t != 0 + R2 x; + Metric m; + double s; // curvilinear coordinate + double sp; // length of the previous segment in m + double sn; // length of the next segment in m + }; + + class SegInterpolation { + + public: + GeomEdge *e; + double sBegin ,sEnd; // abscisse of the seg on edge parameter + double lBegin ,lEnd; // length abscisse set in ListofIntersectionTriangles::Length + int last; // last index in ListofIntersectionTriangles for this Sub seg of edge + + //Methods + R2 F(double s){ + double c01=lEnd-lBegin, c0=(lEnd-s)/c01, c1=(s-lBegin)/c01; + if (lBegin>s || s>lEnd){ + _error_("lBegin>s || s>lEnd"); + } + return e->F(sBegin*c0+sEnd*c1); + } + }; + + public: + + int MaxSize; + int Size; + double len; + int state; + IntersectionTriangles *lIntTria; + int NbSeg; + int MaxNbSeg; + SegInterpolation *lSegsI; + + //Constructors/Destructors + ListofIntersectionTriangles(int n=256,int m=16); + ~ListofIntersectionTriangles(); + + //Operators + IntersectionTriangles & operator[](int i) {return lIntTria[i];} + operator int&() {return Size;} + + //Methods + void Init(); + int NewItem(Triangle *tt,double d0,double d1,double d2); + int NewItem(R2 ,const Metric &); + void SplitEdge(const Mesh &,const R2 &,const R2 &,int nbegin=0); + double Length(); + long NewPoints(BamgVertex *,long &nbv,long maxnbv); + void NewSubSeg(GeomEdge *e,double s0,double s1); + void ReShape(); + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/Mesh.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/Mesh.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Mesh.cpp (revision 15061) @@ -0,0 +1,5847 @@ +#include +#include +#include +#include + +#include "../classes/classes.h" +#include "./det.h" + +namespace bamg { + + static const Direction NoDirOfSearch=Direction(); + + /*Constructors/Destructors*/ + /*FUNCTION Mesh::Mesh(BamgGeom* bamggeom,BamgMesh* bamgmesh, BamgOpts* bamgopts){{{*/ + Mesh::Mesh(BamgGeom* bamggeom,BamgMesh* bamgmesh, BamgOpts* bamgopts):Gh(*(new Geometry())),BTh(*this){ + + /*Initialize fields*/ + Init(0); + + /*Read Geometry if provided*/ + if(bamggeom->Edges) { + Gh.ReadGeometry(bamggeom,bamgopts); + Gh.PostRead(); + } + + /*Read background mesh*/ + ReadMesh(bamgmesh,bamgopts); + + /*Build Geometry if not provided*/ + if(bamggeom->Edges==NULL) { + /*Recreate geometry if needed*/ + _printLine_("WARNING: mesh present but no geometry found. Reconstructing..."); + BuildGeometryFromMesh(bamgopts); + Gh.PostRead(); + } + + /*Set integer coordinates*/ + SetIntCoor(); + + /*Fill holes and generate mesh properties*/ + ReconstructExistingMesh(); + } + /*}}}*/ + /*FUNCTION Mesh::Mesh(int* index,double* x,double* y,int nods,int nels){{{*/ + Mesh::Mesh(int* index,double* x,double* y,int nods,int nels):Gh(*(new Geometry())),BTh(*this){ + + Init(0); + ReadMesh(index,x,y,nods,nels); + SetIntCoor(); + ReconstructExistingMesh(); + } + /*}}}*/ + /*FUNCTION Mesh::Mesh(double* x,double* y,int nods){{{*/ + Mesh::Mesh(double* x,double* y,int nods):Gh(*(new Geometry())),BTh(*this){ + Triangulate(x,y,nods); + } + /*}}}*/ + /*FUNCTION Mesh::Mesh(const Mesh & Tho,const int *flag ,const int *bb){{{*/ + Mesh::Mesh(const Mesh & Tho,const int *flag ,const int *bb,BamgOpts* bamgopts) : Gh(*(new Geometry())), BTh(*this) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/Triangles)*/ + + int i,k,itadj; + int kt=0; + int * kk = new int [Tho.nbv]; + long * reft = new long[Tho.nbt]; + long nbInT = Tho.TriangleReferenceList(reft); + long * refv = new long[Tho.nbv]; + + for (i=0;i=0 && flag[i]) + { + const Triangle & t = Tho.triangles[i]; + kt++; + kk[Tho.GetId(t[0])]=1; + kk[Tho.GetId(t[1])]=1; + kk[Tho.GetId(t[2])]=1; + itadj=Tho.GetId(t.TriangleAdj(0)); + if ( reft[itadj] >=0 && !flag[itadj]) + { nbNewBedge++; + refv[Tho.GetId(t[VerticesOfTriangularEdge[0][0]])]=bb[i]; + refv[Tho.GetId(t[VerticesOfTriangularEdge[0][1]])]=bb[i]; + } + itadj=Tho.GetId(t.TriangleAdj(1)); + if ( reft[itadj] >=0 && !flag[itadj]) + { nbNewBedge++; + refv[Tho.GetId(t[VerticesOfTriangularEdge[1][0]])]=bb[i]; + refv[Tho.GetId(t[VerticesOfTriangularEdge[1][1]])]=bb[i];} + itadj=Tho.GetId(t.TriangleAdj(2)); + if ( reft[itadj] >=0 && !flag[itadj]) + { nbNewBedge++; + refv[Tho.GetId(t[VerticesOfTriangularEdge[2][0]])]=bb[i]; + refv[Tho.GetId(t[VerticesOfTriangularEdge[2][1]])]=bb[i];} + } + k=0; + for (i=0;i=0) kk[i]=k++; + } + _printLine_(" number of vertices " << k << ", remove = " << Tho.nbv - k); + _printLine_(" number of triangles " << kt << ", remove = " << nbInT-kt); + _printLine_(" number of New boundary edge " << nbNewBedge); + long imaxnbv =k; + Init(imaxnbv); + for (i=0;i=0) + { + vertices[nbv] = Tho.vertices[i]; + if (!vertices[nbv].GetReferenceNumber()) + vertices[nbv].ReferenceNumber = refv[i]; + nbv++; + } + if (imaxnbv != nbv){ + delete [] kk; + delete [] refv; + _error_("imaxnbv != nbv"); + } + for (i=0;i=0 && flag[i]) + { + const Triangle & t = Tho.triangles[i]; + int i0 = Tho.GetId(t[0]); + int i1 = Tho.GetId(t[1]); + int i2 = Tho.GetId(t[2]); + if (i0<0 || i1<0 || i2<0){ + delete [] refv; + _error_("i0<0 || i1<0 || i2< 0"); + } + if (i0>=Tho.nbv || i1>=Tho.nbv || i2>=Tho.nbv){ + _error_("i0>=Tho.nbv || i1>=Tho.nbv || i2>=Tho.nbv"); + } + triangles[nbt] = Triangle(this,kk[i0],kk[i1],kk[i2]); + triangles[nbt].color = Tho.subdomains[reft[i]].ReferenceNumber; + nbt++; + } + if (kt!=nbt){ + _error_("kt!=nbt"); + } + if (nbt==0 && nbv==0) { + _error_("All triangles have been removed"); + } + delete [] kk; + delete [] reft; + delete [] refv; + //double cutoffradian = 10.0/180.0*Pi; + BuildGeometryFromMesh(bamgopts); + Gh.PostRead(); + SetIntCoor(); + ReconstructExistingMesh(); + + if (!nbsubdomains){ + _error_("nbsubdomains==0"); + } + if (!subdomains[0].head || !subdomains[0].head->link){ + _error_("!subdomains[0].head || !subdomains[0].head->link"); + } + + } + /*}}}*/ + /*FUNCTION Mesh::Mesh(Mesh & Th,Geometry * pGh,Mesh * pBth,long maxnbv_in) COPY{{{*/ + Mesh::Mesh(Mesh & Th,Geometry * pGh,Mesh * pBth,long maxnbv_in) + : Gh(*(pGh?pGh:&Th.Gh)), BTh(*(pBth?pBth:this)) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/Triangles)*/ + Gh.NbRef++; + maxnbv_in = Max(maxnbv_in,Th.nbv); + long i; + // do all the allocation to be sure all the pointer existe + + Init(maxnbv_in);// to make the allocation + // copy of triangles + nbv = Th.nbv; + nbt = Th.nbt; + nbe = Th.nbe; + nbsubdomains = Th.nbsubdomains; + nbtout = Th.nbtout; + nbq = Th.nbq ; + NbVerticesOnGeomVertex = Th.NbVerticesOnGeomVertex; + if(NbVerticesOnGeomVertex) + VerticesOnGeomVertex = new VertexOnGeom[NbVerticesOnGeomVertex]; + NbVerticesOnGeomEdge = Th.NbVerticesOnGeomEdge; + if (NbVerticesOnGeomEdge) + VerticesOnGeomEdge = new VertexOnGeom[NbVerticesOnGeomEdge] ; + if (& BTh == & Th.BTh){ // same background + BTh.NbRef++; + NbVertexOnBThVertex = Th.NbVertexOnBThVertex; + if(NbVertexOnBThVertex) + VertexOnBThVertex = new VertexOnVertex[NbVertexOnBThVertex]; + NbVertexOnBThEdge = Th.NbVertexOnBThEdge; + if(NbVertexOnBThEdge) + VertexOnBThEdge = new VertexOnEdge[NbVertexOnBThEdge]; + } + else { // no add on background mesh + BTh.NbRef++; + NbVertexOnBThVertex=0; + VertexOnBThVertex=0; + NbVertexOnBThEdge=0; + VertexOnBThEdge=0; + } + + if(nbe) + edges = new Edge[nbe]; + if(nbsubdomains) + subdomains = new SubDomain[nbsubdomains]; + pmin = Th.pmin; + pmax = Th.pmax; + coefIcoor = Th.coefIcoor; + for(i=0;iInit(imaxnbv); + TriangulateFromGeom1(bamgopts,keepBackVertices); + } + /*}}}*/ + /*FUNCTION Mesh::Mesh(long maxnbv,Geometry & G,BamgOpts* bamgopts){{{*/ + Mesh::Mesh(long imaxnbv,Geometry & G,BamgOpts* bamgopts):Gh(G),BTh(*this){ + Init(imaxnbv); + TriangulateFromGeom0(bamgopts); + } + /*}}}*/ + /*FUNCTION Mesh::~Mesh(){{{*/ + Mesh::~Mesh() { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/Triangles)*/ + + //if (vertices) delete [] vertices; + if (edges) delete [] edges; + if (triangles) delete [] triangles; + if (quadtree) delete quadtree; + //if (orderedvertices) delete [] orderedvertices; + if (subdomains) delete [] subdomains; + if (VerticesOnGeomEdge) delete [] VerticesOnGeomEdge; + if (VerticesOnGeomVertex) delete [] VerticesOnGeomVertex; + if (VertexOnBThVertex) delete [] VertexOnBThVertex; + if (VertexOnBThEdge) delete [] VertexOnBThEdge; + + if (&Gh) { + if (Gh.NbRef>0) Gh.NbRef--; + else if (Gh.NbRef==0) delete &Gh; + } + if (&BTh && (&BTh != this)) { + if (BTh.NbRef>0) BTh.NbRef--; + else if (BTh.NbRef==0) delete &BTh; + } + Init(0); // set all to zero + } + /*}}}*/ + + /*IO*/ + /*FUNCTION Mesh::ReadMesh(int* index,double* x,double* y,int nods,int nels){{{*/ + void Mesh::ReadMesh(int* index,double* x,double* y,int nods,int nels){ + + double Hmin = HUGE_VAL;// the infinie value + long i1,i2,i3; + long i; + Metric M1(1); + int verbose=0; + bool* nodeflags=NULL; + + nbv=nods; + maxnbv=nbv; + nbt=nels; + + //Vertices + if (verbose) _printLine_("Reading vertices (" << nbv << ")"); + vertices=xNew(nbv); + orderedvertices=xNew(nbv); + for (i=0;i(nbv); + for(i=0;i(nodeflags); + } + /*}}}*/ + /*FUNCTION Mesh::ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts){{{*/ + void Mesh::ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts){ + + int verbose; + double Hmin = HUGE_VAL; // the infinie value + long i1,i2,i3; + long i,j; + Metric M1(1); + + verbose=bamgopts->verbose; + + nbv=bamgmesh->VerticesSize[0]; + maxnbv=nbv; + nbt=bamgmesh->TrianglesSize[0]; + + //Vertices + if(bamgmesh->Vertices){ + if(verbose>5) _printLine_(" processing Vertices"); + + vertices=xNew(nbv); + orderedvertices=xNew(nbv); + + for (i=0;iVertices[i*3+0]; + vertices[i].r.y=bamgmesh->Vertices[i*3+1]; + vertices[i].ReferenceNumber=(long)bamgmesh->Vertices[i*3+2]; + vertices[i].DirOfSearch =NoDirOfSearch; + vertices[i].m=M1; + vertices[i].color=0; + } + maxnbt=2*maxnbv-2; // for filling The Holes and quadrilaterals + } + else{ + if(verbose>5) _error_("no Vertices found in the initial mesh"); + } + + //Triangles + if(bamgmesh->Triangles){ + if(verbose>5) _printLine_(" processing Triangles"); + triangles =new Triangle[maxnbt]; //we cannot allocate only nbt triangles since + //other triangles will be added for each edge + for (i=0;iTriangles[i*4+0]-1; //for C indexing + i2=(long)bamgmesh->Triangles[i*4+1]-1; //for C indexing + i3=(long)bamgmesh->Triangles[i*4+2]-1; //for C indexing + t=Triangle(this,i1,i2,i3); + t.color=(long)bamgmesh->Triangles[i*4+3]; + } + } + else{ + if(verbose>5) _error_("no Triangles found in the initial mesh"); + } + + //Quadrilaterals + if(bamgmesh->Quadrilaterals){ + if(verbose>5) _printLine_(" processing Quadrilaterals"); + long i1,i2,i3,i4; + triangles =new Triangle[nbt]; + for (i=0;iQuadrilateralsSize[0];i++){ + //divide the quad into two triangles + Triangle & t1 = triangles[2*i]; + Triangle & t2 = triangles[2*i+1]; + i1=(long)bamgmesh->Quadrilaterals[i*5+0]-1; //for C indexing + i2=(long)bamgmesh->Quadrilaterals[i*5+1]-1; //for C indexing + i3=(long)bamgmesh->Quadrilaterals[i*5+2]-1; //for C indexing + i4=(long)bamgmesh->Quadrilaterals[i*5+3]-1; //for C indexing + t1=Triangle(this,i1,i2,i3); + t2=Triangle(this,i3,i4,i1); + t1.color=(long)bamgmesh->Quadrilaterals[i*5+4]; + t2.color=(long)bamgmesh->Quadrilaterals[i*5+4]; + t1.SetHidden(OppositeEdge[1]); // two times because the adj was not created + t2.SetHidden(OppositeEdge[1]); + } + } + + //VerticesOnGeomEdge + if(bamgmesh->VerticesOnGeomEdge){ + if(verbose>5) _printLine_(" processing VerticesOnGeomEdge"); + NbVerticesOnGeomEdge=bamgmesh->VerticesOnGeomEdgeSize[0]; + VerticesOnGeomEdge= new VertexOnGeom[NbVerticesOnGeomEdge] ; + for (i=0;iVerticesOnGeomEdge[i*3+0]-1; //for C indexing + i2=(long) bamgmesh->VerticesOnGeomEdge[i*3+1]-1; //for C indexing + s =(double)bamgmesh->VerticesOnGeomEdge[i*3+2]; + VerticesOnGeomEdge[i]=VertexOnGeom(vertices[i1],Gh.edges[i2],s); + } + } + + //VerticesOnGeomVertex + if(bamgmesh->VerticesOnGeomVertexSize[0]){ + if(verbose>5) _printLine_(" processing VerticesOnGeomVertex"); + NbVerticesOnGeomVertex=bamgmesh->VerticesOnGeomVertexSize[0]; + VerticesOnGeomVertex = new VertexOnGeom[NbVerticesOnGeomVertex] ; + for (i=0;iVerticesOnGeomVertex[i*2+0]-1; //for C indexing + i2=(long)bamgmesh->VerticesOnGeomVertex[i*2+1]-1; //for C indexing + VerticesOnGeomVertex[i]=VertexOnGeom(vertices[i1],Gh.vertices[i2]); + } + } + + //Edges + if (bamgmesh->Edges){ + int i1,i2; + double* len=NULL; + + if(verbose>5) _printLine_(" processing Edges"); + nbe=bamgmesh->EdgesSize[0]; + edges= new Edge[nbe]; + //initialize length of each edge (used to provided metric) + len= new double[nbv]; + for(i=0;iEdges[i*3+0]-1; //-1 for C indexing + i2=(int)bamgmesh->Edges[i*3+1]-1; //-1 for C indexing + edges[i].ReferenceNumber=(long)bamgmesh->Edges[i*3+2]; + edges[i].v[0]= vertices +i1; + edges[i].v[1]= vertices +i2; + edges[i].adj[0]=NULL; + edges[i].adj[1]=NULL; + R2 x12=vertices[i2].r-vertices[i1].r; + double l12=sqrt((x12,x12)); + + //prepare metric + vertices[i1].color++; + vertices[i2].color++; + len[i1]+=l12; + len[i2]+=l12; + Hmin = Min(Hmin,l12); + } + + // definition the default of the given mesh size + for (i=0;i0) + vertices[i].m=Metric(len[i]/(double)vertices[i].color); + else + vertices[i].m=Metric(Hmin); + } + delete [] len; + + // construction of edges[].adj + for (i=0;icolor,j0; + if(i0==-1){ + v->color=i*2+j; + } + else if (i0>=0) {// i and i0 edge are adjacent by the vertex v + j0 = i0%2; + i0 = i0/2; + _assert_(v==edges[i0 ].v[j0]); + edges[i ].adj[j ] =edges +i0; + edges[i0].adj[j0] =edges +i ; + v->color = -3; + } + } + } + } + + //EdgeOnGeomEdge + if(bamgmesh->EdgesOnGeomEdge){ + if(verbose>5) _printLine_(" processing EdgesOnGeomEdge"); + int i1,i2,i,j; + i2=bamgmesh->EdgesOnGeomEdgeSize[0]; + for (i1=0;i1EdgesOnGeomEdge[i1*2+0]-1; //C indexing + j=(int)bamgmesh->EdgesOnGeomEdge[i1*2+1]-1; //C indexing + //Check value + if(!(i>=0 && j>=0 && iSubDomains){ + long i3,head,direction; + if(verbose>5) _printLine_(" processing SubDomains"); + nbsubdomains=bamgmesh->SubDomainsSize[0]; + subdomains = new SubDomain [ nbsubdomains ]; + for (i=0;iSubDomains[i*3+0]; + head=(int)bamgmesh->SubDomains[i*3+1]-1;//C indexing + direction=(int)bamgmesh->SubDomains[i*3+2]; + if (i3!=23) _error_("Bad Subdomain definition: first number should be 3"); + if (head<0 || head>=nbt) _error_("Bad Subdomain definition: head should in [1 " << nbt << "] (triangle number)"); + subdomains[i].head = triangles+head; + } + } + + } + /*}}}*/ + /*FUNCTION Mesh::WriteMesh {{{*/ + void Mesh::WriteMesh(BamgMesh* bamgmesh,BamgOpts* bamgopts){ + + /*Intermediary*/ + int i,j,k,num,i1,i2; + long n; + int* head_1=NULL; + int* next_1=NULL; + int* connectivitysize_1=NULL; + int connectivitymax_1=0; + + /*Get options*/ + int verbose=bamgopts->verbose; + + /*Build reft that holds the number the subdomain number of each triangle, and the real numbering of the elements*/ + long* reft = new long[nbt]; + long* numt = new long[nbt]; + long nbInT = TriangleReferenceList(reft); + TriangleIntNumbering(numt); + + /*Chaining algorithm used to generate connectivity tables and other outputs*/ + + //Memory Allocation + head_1=xNew(nbv); + next_1=xNew(3*nbt); + connectivitysize_1=xNew(nbv); + + //Initialization + for (i=0;i=0){ + for (j=0;j<3;j++){ + int v=GetId(triangles[i][j]); //jth vertex of the ith triangle + if (k>3*nbt-1 || k<0) _error_("k = " << k << ", nbt = " << nbt); + next_1[k]=head_1[v]; + if (v>nbv-1 || v<0) _error_("v = " << v << ", nbv = " << nbv); + head_1[v]=k++; + connectivitysize_1[v]+=1; + } + } + } + //Get maximum connectivity + connectivitymax_1=0; + for (i=0;iconnectivitymax_1) connectivitymax_1=connectivitysize_1[i]; + } + + /*OK, now build outputs*/ + + /*Vertices*/ + if(verbose>5) _printLine_(" writing Vertices"); + bamgmesh->VerticesSize[0]=nbv; + bamgmesh->VerticesSize[1]=3; + if (nbv){ + bamgmesh->Vertices=xNew(3*nbv); + for (i=0;iVertices[i*3+0]=vertices[i].r.x; + bamgmesh->Vertices[i*3+1]=vertices[i].r.y; + bamgmesh->Vertices[i*3+2]=vertices[i].GetReferenceNumber(); + } + } + + /*Edges*/ + if(verbose>5) _printLine_(" writing Edges"); + bamgmesh->EdgesSize[0]=nbe; + bamgmesh->EdgesSize[1]=3; + int NumIssmSegments=0; + if (nbe){ + bamgmesh->Edges=xNew(3*nbe); + for (i=0;iEdges[i*3+0]=GetId(edges[i][0])+1; //back to M indexing + bamgmesh->Edges[i*3+1]=GetId(edges[i][1])+1; //back to M indexing + bamgmesh->Edges[i*3+2]=edges[i].ReferenceNumber; + if(edges[i].GeomEdgeHook){ + NumIssmSegments++; + } + } + } + + /*Element edges*/ + if(verbose>5) _printLine_(" writing element edges"); + SetOfEdges4* edge4=new SetOfEdges4(nbt*3,nbv); + double* elemedge=NULL; + elemedge=xNew(3*nbt); + for (i=0;i<3*nbt;i++) elemedge[i]=-2.;//will become -1 + k=0; + for (i=0;i=0){ + for (j=0;j<3;j++) { + i1=GetId(triangles[i][VerticesOfTriangularEdge[j][0]]); + i2=GetId(triangles[i][VerticesOfTriangularEdge[j][1]]); + n =edge4->SortAndFind(i1,i2); + if (n==-1){ + //first time + n=edge4->SortAndAdd(i1,i2); + elemedge[n*2+0]=double(k); + } + else{ + //second time + elemedge[n*2+1]=double(k); + } + } + k++; + } + } + bamgmesh->IssmEdgesSize[0]=edge4->nb(); + bamgmesh->IssmEdgesSize[1]=4; + bamgmesh->IssmEdges=xNew(4*edge4->nb()); + for (i=0;inb();i++){ + /*Invert first two vertices if necessary*/ + bool found=false; + for (j=0;j<3;j++){ + if (triangles[(int)elemedge[2*i+0]](j)==vertices+edge4->i(i)){ + if (triangles[(int)elemedge[2*i+0]]((j+1)%3)==vertices+edge4->j(i)){ + //trigonometric direction + bamgmesh->IssmEdges[i*4+0]=edge4->i(i)+1;// back to M indexing + bamgmesh->IssmEdges[i*4+1]=edge4->j(i)+1;// back to M indexing + } + else{ + bamgmesh->IssmEdges[i*4+0]=edge4->j(i)+1;// back to M indexing + bamgmesh->IssmEdges[i*4+1]=edge4->i(i)+1;// back to M indexing + } + found=true; + break; + } + } + _assert_(found); + bamgmesh->IssmEdges[i*4+2]=elemedge[2*i+0]+1; // back to M indexing + bamgmesh->IssmEdges[i*4+3]=elemedge[2*i+1]+1; // back to M indexing + } + //clean up + delete edge4; + xDelete(elemedge); + + /*IssmSegments*/ + if(verbose>5) _printLine_(" writing IssmSegments"); + bamgmesh->IssmSegmentsSize[0]=NumIssmSegments; + bamgmesh->IssmSegmentsSize[1]=4; + bamgmesh->IssmSegments=xNew(4*NumIssmSegments); + num=0; + for (i=0;iIssmSegments[num*4+0]=GetId(edges[i][0])+1; //back to M indexing + bamgmesh->IssmSegments[num*4+1]=GetId(edges[i][1])+1; //back to M indexing + bamgmesh->IssmSegments[num*4+2]=(int)j/3+1; //back to M indexing + bamgmesh->IssmSegments[num*4+3]=edges[i].ReferenceNumber; + num+=1; + stop=true; + break; + } + if (GetId(triangles[(int)j/3][(int)((k+2)%3)])==i2){ + bamgmesh->IssmSegments[num*4+0]=GetId(edges[i][1])+1; //back to M indexing + bamgmesh->IssmSegments[num*4+1]=GetId(edges[i][0])+1; //back to M indexing + bamgmesh->IssmSegments[num*4+2]=(int)j/3+1; //back to M indexing + bamgmesh->IssmSegments[num*4+3]=edges[i].ReferenceNumber; + num+=1; + stop=true; + break; + } + } + } + if(stop) break; + } + if (!stop){ + _error_("Element holding segment [" << i1+1 << " " << i2+1 << "] not found..."); + } + } + } + + /*Triangles*/ + if(verbose>5) _printLine_(" writing Triangles"); + k=nbInT-nbq*2; + num=0; + bamgmesh->TrianglesSize[0]=k; + bamgmesh->TrianglesSize[1]=4; + if (k){ + bamgmesh->Triangles=xNew(4*k); + for (i=0;i=0 && !( t.Hidden(0) || t.Hidden(1) || t.Hidden(2) )){ + bamgmesh->Triangles[num*4+0]=GetId(t[0])+1; //back to M indexing + bamgmesh->Triangles[num*4+1]=GetId(t[1])+1; //back to M indexing + bamgmesh->Triangles[num*4+2]=GetId(t[2])+1; //back to M indexing + bamgmesh->Triangles[num*4+3]=subdomains[reft[i]].ReferenceNumber; + num=num+1; + } + } + } + + /*Quadrilaterals*/ + if(verbose>5) _printLine_(" writing Quadrilaterals"); + bamgmesh->QuadrilateralsSize[0]=nbq; + bamgmesh->QuadrilateralsSize[1]=5; + if (nbq){ + bamgmesh->Quadrilaterals=xNew(5*nbq); + for (i=0;iQuadrilaterals[i*5+0]=GetId(v0)+1; //back to M indexing + bamgmesh->Quadrilaterals[i*5+1]=GetId(v1)+1; //back to M indexing + bamgmesh->Quadrilaterals[i*5+2]=GetId(v2)+1; //back to M indexing + bamgmesh->Quadrilaterals[i*5+3]=GetId(v3)+1; //back to M indexing + bamgmesh->Quadrilaterals[i*5+4]=subdomains[reft[i]].ReferenceNumber; + } + } + } + + /*SubDomains*/ + if(verbose>5) _printLine_(" writing SubDomains"); + bamgmesh->SubDomainsSize[0]=nbsubdomains; + bamgmesh->SubDomainsSize[1]=4; + if (nbsubdomains){ + bamgmesh->SubDomains=xNew(4*nbsubdomains); + for (i=0;iSubDomains[i*4+0]=3; + bamgmesh->SubDomains[i*4+1]=reft[GetId(subdomains[i].head)]; + bamgmesh->SubDomains[i*4+2]=1; + bamgmesh->SubDomains[i*4+3]=subdomains[i].ReferenceNumber; + } + } + + /*SubDomainsFromGeom*/ + if(verbose>5) _printLine_(" writing SubDomainsFromGeom"); + bamgmesh->SubDomainsFromGeomSize[0]=Gh.nbsubdomains; + bamgmesh->SubDomainsFromGeomSize[1]=4; + if (Gh.nbsubdomains){ + bamgmesh->SubDomainsFromGeom=xNew(4*Gh.nbsubdomains); + for (i=0;iSubDomainsFromGeom[i*4+0]=2; + bamgmesh->SubDomainsFromGeom[i*4+1]=GetId(subdomains[i].edge)+1; //back to Matlab indexing + bamgmesh->SubDomainsFromGeom[i*4+2]=subdomains[i].direction; + bamgmesh->SubDomainsFromGeom[i*4+3]=Gh.subdomains[i].ReferenceNumber; + } + } + + /*VerticesOnGeomVertex*/ + if(verbose>5) _printLine_(" writing VerticesOnGeomVertex"); + bamgmesh->VerticesOnGeomVertexSize[0]=NbVerticesOnGeomVertex; + bamgmesh->VerticesOnGeomVertexSize[1]=2; + if (NbVerticesOnGeomVertex){ + bamgmesh->VerticesOnGeomVertex=xNew(2*NbVerticesOnGeomVertex); + for (i=0;iVerticesOnGeomVertex[i*2+0]=GetId((BamgVertex*)v)+1; //back to Matlab indexing + bamgmesh->VerticesOnGeomVertex[i*2+1]=Gh.GetId((GeomVertex*)v)+1; //back to Matlab indexing + } + } + + /*VertexOnGeomEdge*/ + if(verbose>5) _printLine_(" writing VerticesOnGeomEdge"); + bamgmesh->VerticesOnGeomEdgeSize[0]=NbVerticesOnGeomEdge; + bamgmesh->VerticesOnGeomEdgeSize[1]=3; + if (NbVerticesOnGeomEdge){ + bamgmesh->VerticesOnGeomEdge=xNew(3*NbVerticesOnGeomEdge); + for (i=0;iVerticesOnGeomEdge[i*3+0]=GetId((BamgVertex*)v)+1; //back to Matlab indexing + bamgmesh->VerticesOnGeomEdge[i*3+1]=Gh.GetId((const GeomEdge*)v)+1; //back to Matlab indexing + bamgmesh->VerticesOnGeomEdge[i*3+2]=(double)v; //absisce + } + } + + /*EdgesOnGeomEdge*/ + if(verbose>5) _printLine_(" writing EdgesOnGeomEdge"); + k=0; + for (i=0;iEdgesOnGeomEdgeSize[0]=k; + bamgmesh->EdgesOnGeomEdgeSize[1]=2; + if (k){ + bamgmesh->EdgesOnGeomEdge=xNew(2*(int)k); + int count=0; + for (i=0;iEdgesOnGeomEdge[count*2+0]=(double)i+1; //back to Matlab indexing + bamgmesh->EdgesOnGeomEdge[count*2+1]=(double)Gh.GetId(edges[i].GeomEdgeHook)+1; //back to Matlab indexing + count=count+1; + } + } + } + + /*Element Connectivity*/ + if(verbose>5) _printLine_(" writing Element connectivity"); + bamgmesh->ElementConnectivitySize[0]=nbt-nbtout; + bamgmesh->ElementConnectivitySize[1]=3; + bamgmesh->ElementConnectivity=xNew(3*(nbt-nbtout)); + for (i=0;i<3*(nbt-nbtout);i++) bamgmesh->ElementConnectivity[i]=NAN; + num=0; + for (i=0;i=0){ + for (j=0;j<3;j++){ + k=GetId(triangles[i].TriangleAdj(j)); + if (reft[k]>=0){ + _assert_(3*num+j<3*(nbt-nbtout)); + bamgmesh->ElementConnectivity[3*num+j]=k+1; // back to Matlab indexing + } + } + num+=1; + } + } + + /*ElementNodal Connectivity*/ + if(verbose>5) _printLine_(" writing Nodal element connectivity"); + bamgmesh->NodalElementConnectivitySize[0]=nbv; + bamgmesh->NodalElementConnectivitySize[1]=connectivitymax_1; + bamgmesh->NodalElementConnectivity=xNew(connectivitymax_1*nbv); + for (i=0;iNodalElementConnectivity[i]=NAN; + for (i=0;iNodalElementConnectivity[connectivitymax_1*i+k]=floor((double)j/3)+1; + k++; + } + } + + /*Nodal Connectivity*/ + if(verbose>5) _printLine_(" writing Nodal connectivity"); + //chaining algorithm (again...) + int* head_2=NULL; + int* next_2=NULL; + int* connectivitysize_2=NULL; + int connectivitymax_2=0; + i1=bamgmesh->IssmEdgesSize[0]; + i2=bamgmesh->IssmEdgesSize[1]; + head_2=xNew(nbv); + next_2=xNew(2*i1); + connectivitysize_2=xNew(nbv); + //Initialization + for (i=0;iIssmEdges[i*i2+j]-1; //back to C indexing + if (k>2*i1-1 || k<0) _error_("Index exceed matrix dimensions (k=" << k << " not in [0 " << 2*i1-1 << "]"); + next_2[k]=head_2[v]; + if (v>nbv-1 || v<0) _error_("Index exceed matrix dimensions (v=" << v << " not in [0 " << nbv-1 << "])"); + head_2[v]=k++; + connectivitysize_2[v]+=1; + } + } + //Get maximum connectivity + for (i=0;iconnectivitymax_2) connectivitymax_2=connectivitysize_2[i]; + } + //Build output + connectivitymax_2++;//add last column for size + bamgmesh->NodalConnectivitySize[0]=nbv; + bamgmesh->NodalConnectivitySize[1]=connectivitymax_2; + bamgmesh->NodalConnectivity=xNew(connectivitymax_2*nbv); + for (i=0;iNodalConnectivity[i]=0; + for (i=0;iIssmEdges[int(j/2)*i2+0]; + if (i+1==num){ //carefull, ElementEdge is in M indexing + //i is the first vertex of the edge, it is therefore connected to the second vertex + bamgmesh->NodalConnectivity[connectivitymax_2*i+k]=bamgmesh->IssmEdges[int(j/2)*i2+1]; + } + else{ + bamgmesh->NodalConnectivity[connectivitymax_2*i+k]=num; + } + k++; + } + bamgmesh->NodalConnectivity[connectivitymax_2*(i+1)-1]=k; + } + + /*Cracked vertices*/ + if(verbose>5) _printLine_(" writing Cracked vertices"); + bamgmesh->CrackedVerticesSize[0]=NbCrackedVertices; + bamgmesh->CrackedVerticesSize[1]=2; + if (NbCrackedVertices){ + bamgmesh->CrackedVertices=xNew(2*NbCrackedVertices); + for (i=0;iCrackedVertices[i*2+0]=CrackedVertices[i*2+0]+1; //M indexing + bamgmesh->CrackedVertices[i*2+1]=CrackedVertices[i*2+1]+1; //M indexing + } + } + + /*Cracked vertices*/ + if(verbose>5) _printLine_(" writing Cracked vertices"); + bamgmesh->CrackedEdgesSize[0]=NbCrackedEdges; + bamgmesh->CrackedEdgesSize[1]=4; + if (NbCrackedEdges){ + bamgmesh->CrackedEdges=xNew(2*NbCrackedEdges); + for (i=0;iCrackedEdges[i*2+0]=0;//CrackedEdges[i]->+1; //M indexing + bamgmesh->CrackedEdges[i*2+1]=0;//CrackedEdges[i]-]->+1; //M indexing + } + } + + //clean up + xDelete(connectivitysize_1); + xDelete(head_1); + xDelete(next_1); + xDelete(connectivitysize_2); + xDelete(head_2); + xDelete(next_2); + delete [] reft; + delete [] numt; + } + /*}}}*/ + /*FUNCTION Mesh::ReadMetric{{{*/ + void Mesh::ReadMetric(const BamgOpts* bamgopts) { + + /*Intermediary*/ + int i,j; + + if(bamgopts->verbose>3) _printLine_(" processing metric"); + double hmin = Max(bamgopts->hmin,MinimalHmin()); + double hmax = Min(bamgopts->hmax,MaximalHmax()); + double coef = bamgopts->coeff; + + //for now we only use j==3 + j=3; + + for (i=0;imetric[i]; + vertices[i].m=Metric(Max(hmin,Min(hmax, h*coef))); + } + else if (j==3){ + //do not erase metric computed by hVertices + if (vertices[i].m.a11==1 && vertices[i].m.a21==0 && vertices[i].m.a22==1){ + double a,b,c; + a=bamgopts->metric[i*3+0]; + b=bamgopts->metric[i*3+1]; + c=bamgopts->metric[i*3+2]; + Metric M(a,b,c); + EigenMetric Vp(M/coef); + + Vp.Maxh(hmax); + Vp.Minh(hmin); + vertices[i].m = Vp; + } + } + } + } + /*}}}*/ + /*FUNCTION Mesh::WriteMetric{{{*/ + void Mesh::WriteMetric(BamgOpts* bamgopts) { + int i; + xDelete(bamgopts->metric); + bamgopts->metric=xNew(3*nbv); + for (i=0;imetric[i*3+0]=vertices[i].m.a11; + bamgopts->metric[i*3+1]=vertices[i].m.a21; + bamgopts->metric[i*3+2]=vertices[i].m.a22; + } + } + /*}}}*/ + /*FUNCTION Mesh::WriteIndex{{{*/ + void Mesh::WriteIndex(int** pindex,int* pnels){ + + /*Intermediary*/ + int i,k; + + /*output*/ + int* index=NULL; + int num=0; + + /*Get number of triangles*/ + k=0; + for (i=0;i0) k++; + } + + if (k){ + index=xNew(3*k); + for (i=0;i0 && !(t.Hidden(0)||t.Hidden(1) || t.Hidden(2) )){ + //if(t.Anisotropy()<2 & t.Length()<1.e+5){ + index[num*3+0]=GetId(t[0])+1; //back to M indexing + index[num*3+1]=GetId(t[1])+1; //back to M indexing + index[num*3+2]=GetId(t[2])+1; //back to M indexing + num=num+1; + //} + } + } + } + + /*Assign output pointers*/ + *pindex=index; + *pnels=num; + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION Mesh::AddGeometryMetric{{{*/ + void Mesh::AddGeometryMetric(BamgOpts* bamgopts){ + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/IntersectGeomMetric)*/ + + /*Get options*/ + int verbose=bamgopts->verbose; + double anisomax =bamgopts->anisomax; + double errg =bamgopts->errg; + + double ss[2]={0.00001,0.99999}; + double errC = 2*sqrt(2*errg); + double hmax = Gh.MaximalHmax(); + double hmin = Gh.MinimalHmin(); + + //check that hmax is positive + if (hmax<=0){ + _error_("hmax<=0"); + } + + //errC cannot be higher than 1 + if (errC>1) errC=1; + + //Set all vertices to "on" + SetVertexFieldOn(); + + //loop over all the vertices on edges + for (int i=0;iR1tg(s,tg); + double ht=hmax; + // err relative to the length of the edge + if (R1>1.0e-20) { + ht = Min(Max(errC/R1,hmin),hmax); + } + double hn=Min(hmax,ht*anisomax); + + if (ht<=0 || hn<=0){ + _error_("ht<=0 || hn<=0"); + } + EigenMetric Vp(1/(ht*ht),1/(hn*hn),tg); + Metric MVp(Vp); + edges[i][j].m.IntersectWith(MVp); + } + } + // the problem is for the vertex on vertex + } + /*}}}*/ + /*FUNCTION Mesh::AddMetric{{{*/ + void Mesh::AddMetric(BamgOpts* bamgopts){ + // Hessiantype = 0 => H is computed using double P2 projection + // Hessiantype = 1 => H is computed with green formula + + /*Options*/ + int Hessiantype=bamgopts->Hessiantype; + + if (Hessiantype==0){ + BuildMetric0(bamgopts); + } + else if (Hessiantype==1){ + BuildMetric1(bamgopts); + } + else{ + _error_("Hessiantype " << Hessiantype << " not supported yet (1->use Green formula, 0-> double P2 projection)"); + } + } + /*}}}*/ + /*FUNCTION Mesh::AddVertex{{{*/ + void Mesh::AddVertex( BamgVertex &s,Triangle* t, Icoor2* det3) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/Add)*/ + // ------------------------------- + // s2 + // ! + // /|\ ! + // / | \ ! + // / | \ ! + // tt1 / | \ tt0 ! + // / |s \ ! + // / . \ ! + // / . ` \ ! + // / . ` \ ! + // ---------------- ! + // s0 tt2 s1 + //------------------------------- + + /*Intermediaries*/ + Triangle* tt[3]; //the three triangles + Icoor2 det3local[3]; //three determinants (integer) + int nbzerodet =0; //number of zeros in det3 + int izerodet=-1; //egde containing the vertex s + int iedge; + + /*three vertices of t*/ + BamgVertex &s0=(*t)[0]; + BamgVertex &s1=(*t)[1]; + BamgVertex &s2=(*t)[2]; + + //determinant of t + Icoor2 detOld=t->det; + + /* infvertexindex = index of the infinite vertex (NULL) + if no infinite vertex (NULL) infvertexindex=-1 + else if v_i is infinite, infvertexindex=i*/ + int infvertexindex = &s0 ? (( &s1 ? ( &s2 ? -1 : 2) : 1 )) : 0; + + //some checks + if (( infvertexindex <0 ) && (detOld <0) || ( infvertexindex >=0 ) && (detOld >0) ){ + _error_("inconsistent configuration (Contact ISSM developers)"); + } + + // if det3 does not exist, build it + if (!det3){ + //allocate + det3 = det3local; + //if no infinite vertex + if (infvertexindex<0 ) { + det3[0]=bamg::det(s ,s1,s2); + det3[1]=bamg::det(s0,s ,s2); + det3[2]=bamg::det(s0,s1,s );} + else { + // one of &s1 &s2 &s0 is NULL + det3[0]= &s0 ? -1 : bamg::det(s ,s1,s2) ; + det3[1]= &s1 ? -1 : bamg::det(s0,s ,s2) ; + det3[2]= &s2 ? -1 : bamg::det(s0,s1,s ) ; + } + } + + if (!det3[0]) izerodet=0,nbzerodet++; + if (!det3[1]) izerodet=1,nbzerodet++; + if (!det3[2]) izerodet=2,nbzerodet++; + + //if nbzerodet>0, point s is on an egde or on a vertex + if (nbzerodet>0){ + /*s is on an edge*/ + if (nbzerodet==1) { + iedge = OppositeEdge[izerodet]; + AdjacentTriangle ta = t->Adj(iedge); + + /*if the point is one the boundary + add the point in outside part */ + if (t->det>=0){ // inside triangle + if (((Triangle*)ta)->det<0 ) { + // add in outside triangle + AddVertex(s,( Triangle *)ta); + return; + } + } + } + else{ + _error_("Cannot add a vertex more than once. Check duplicates"); + } + } + + // remove de MarkUnSwap edge + t->SetUnMarkUnSwap(0); + t->SetUnMarkUnSwap(1); + t->SetUnMarkUnSwap(2); + + tt[0]= t; + tt[1]= &triangles[nbt++]; + tt[2]= &triangles[nbt++]; + + if (nbt>maxnbt) _error_("Not enough triangles"); + + *tt[1]=*tt[2]=*t; + tt[0]->link=tt[1]; + tt[1]->link=tt[2]; + + (*tt[0])(OppositeVertex[0])=&s; + (*tt[1])(OppositeVertex[1])=&s; + (*tt[2])(OppositeVertex[2])=&s; + + tt[0]->det=det3[0]; + tt[1]->det=det3[1]; + tt[2]->det=det3[2]; + + // update adj des triangles externe + tt[0]->SetAdjAdj(0); + tt[1]->SetAdjAdj(1); + tt[2]->SetAdjAdj(2); + // update des adj des 3 triangle interne + const int i0 = 0; + const int i1= NextEdge[i0]; + const int i2 = PreviousEdge[i0]; + + tt[i0]->SetAdj2(i2,tt[i2],i0); + tt[i1]->SetAdj2(i0,tt[i0],i1); + tt[i2]->SetAdj2(i1,tt[i1],i2); + + tt[0]->SetSingleVertexToTriangleConnectivity(); + tt[1]->SetSingleVertexToTriangleConnectivity(); + tt[2]->SetSingleVertexToTriangleConnectivity(); + + // swap if the point s is on a edge + if(izerodet>=0) { + int rswap=tt[izerodet]->swap(iedge); + + if (!rswap) { + _error_("swap the point s is on a edge"); + } + } + } + /*}}}*/ + /*FUNCTION Mesh::BoundAnisotropy{{{*/ + void Mesh::BoundAnisotropy(double anisomax,double hminaniso) { + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/BoundAnisotropy)*/ + + long int verbose=0; + double lminaniso = 1/ (Max(hminaniso*hminaniso,1e-100)); + + //display info + if (verbose > 1) _printLine_(" BoundAnisotropy by " << anisomax); + + double h1=1.e30,h2=1e-30; + double coef = 1./(anisomax*anisomax); + double hn1=1.e30,hn2=1e-30,rnx =1.e-30,rx=0; + + //loop over all vertices + for (int i=0;i2){ + h1 =Min(h1,Vp.lmin()); + h2 =Max(h2,Vp.lmax()); + hn1=Min(hn1,Vp.lmin()); + hn2=Max(hn2,Vp.lmax()); + rx =Max(rx,Vp.Aniso2()); + rnx= Max(rnx,Vp.Aniso2()); + } + } + + //display info + if (verbose>2){ + _printLine_(" input: Hmin = " << pow(h2,-0.5) << ", Hmax = " << pow(h1,-0.5) << ", factor of anisotropy max = " << pow(rx,0.5)); + _printLine_(" output: Hmin = " << pow(hn2,-0.5) << ", Hmax = " << pow(hn1,-0.5)<< ", factor of anisotropy max = " < (BAMG v1.01, MeshGeom.cpp/ConsGeometry)*/ + + /*Reconstruct Geometry from Mesh*/ + + /*Intermediary*/ + int i,j,k,kk,it,jt; + int verbose=0; + double cutoffradian=10*Pi/180; + + /*Recover options*/ + if (bamgopts){ + verbose=bamgopts->verbose; + cutoffradian=bamgopts->MaxCornerAngle*Pi/180; + } + + //display info + if (verbose>1) _printLine_(" construction of the geometry from the 2d mesh"); + + //check that the mesh is not empty + if (nbt<=0 || nbv <=0 ) { + _error_("nbt or nbv is negative (Mesh empty?)"); + } + + //Gh is the geometry of the mesh (this), initialize MaxCornerAngle + if (cutoffradian>=0) Gh.MaxCornerAngle = cutoffradian; + + /*Construction of the edges*/ + + //initialize st and edge4 + SetOfEdges4* edge4= new SetOfEdges4(nbt*3,nbv); + long* st = new long[nbt*3]; + + //initialize st as -1 (chaining algorithm) + for (i=0;iSortAndAdd(GetId(edges[i][0]),GetId(edges[i][1])); + } + //check that there is no double edge + if (nbe != edge4->nb()){ + delete [] st; + _error_("Some Double edge in the mesh, the number is " << nbe << ", nbe4=" << edge4->nb()); + } + //keep nbe in nbeold + long nbeold = nbe; + + //Go through the triangles and ass the edges in edge4 if they are not there yet + for (i=0;iSortAndAdd(GetId(triangles[i][VerticesOfTriangularEdge[j][0]]), GetId(triangles[i][VerticesOfTriangularEdge[j][1]])); + long invisible = triangles[i].Hidden(j); + + //if st[k] has not been changed yet, add 3*i+j (= vertex position in the index) + if(st[k]==-1) st[k]=3*i+j; + + //else st[k]>=0 -> the edge already exist, check + else if(st[k]>=0) { + //check that it is not an edge on boundary (should not already exist) + if (triangles[i].TriangleAdj(j) || triangles[st[k]/3].TriangleAdj((int) (st[k]%3))){ + _error_("problem in Geometry reconstruction: an edge on boundary is duplicated (double element?)"); + } + //OK, the element is not on boundary, is belongs to 2 triangles -> build Adjacent triangles list + triangles[i].SetAdj2(j,triangles + st[k] / 3,(int) (st[k]%3)); + if (invisible) triangles[i].SetHidden(j); + // if k < nbe mark the edge as on Boundary (Locked) + if (knb(); // the total number of edges + delete edge4; edge4=NULL; + + //display info + if(verbose>5) { + _printLine_(" info on Mesh:"); + _printLine_(" - number of vertices = " << nbv); + _printLine_(" - number of triangles = " << nbt); + _printLine_(" - number of given edges = " << nbe); + _printLine_(" - number of all edges = " << nbedges); + _printLine_(" - Euler number 1 - nb of holes = " << nbt-nbedges+nbv); + } + + // check consistency of edge[].adj and geometrical required vertices + k=0; kk=0; + for (i=0;i=0) + kk++; + } + + /*Constructions of edges*/ + + k += kk; + kk=0; + if (k) { + nbe = k; + Edge* edgessave=edges; + edges = new Edge[nbe]; + k =0; + + //display info + if(verbose>4) _printLine_(" Construction of the edges " << nbe); + + for (i=0;i=0){ + it = st[i]/3; + j = (int) (st[i]%3); + add=k++; + } + if (add>=0 && add < nbe){ + edges[add].v[0] = &triangles[it][VerticesOfTriangularEdge[j][0]]; + edges[add].v[1] = &triangles[it][VerticesOfTriangularEdge[j][1]]; + edges[add].GeomEdgeHook=NULL; + //if already existed + if (iGetReferenceNumber(),edges[add].v[1]->GetReferenceNumber()); + } + } + + //check that we have been through all edges + if (k!=nbe){ + _error_("problem in edge construction process: k!=nbe (should not happen)"); + } + //delete edgessave + if (edgessave) delete [] edgessave; + } + + /*Color the vertices*/ + + //initialize color of all vertices as 0 + for (i=0;icolor++; + } + + //change the color: if a vertex belongs to 2 edges -1, else -2 + for (i=0;icolor; + long j0; + + //if color<0 (first time), no adjacent edge + if(i0<0) edges[i].adj[j]=NULL; + + //if color=-1 (corner),change the vertex color as 2*i+j (position of the vertex in edges) + if(i0==-1) v->color=i*2+j; + + //if color>=0 (i and i0 edge are adjacent by the vertex v) + else if (i0>=0) { + //get position of v in edges back + j0 = i0%2; //column in edges + i0 = i0/2; //line in edges + + //check that we have the correct vertex + if (v!=edges[i0 ].v[j0]){ + _error_("v!=edges[i0 ].v[j0]: this should not happen as the vertex belongs to this edge"); + } + + //Add adjacence + edges[i ].adj[j ]=edges +i0; + edges[i0].adj[j0]=edges +i ; + + //change color to -3 + v->color = -3; + } + } + } + + /*Reconstruct subdomains info*/ + + //check that nbsubdomains is empty + if (nbsubdomains){ + _error_("nbsubdomains should be 0"); + } + nbsubdomains=0; + + //color the subdomains + long* colorT= new long[nbt]; + Triangle *tt,*t; + + //initialize the color of each triangle as -1 + for (it=0;it0){ + if( (j=st[level]++)<3 ){ + t = &triangles[st[level-1]]; + tt=t->TriangleAdj((int)j); + + //color the adjacent triangle + if ( ! t->Locked(j) && tt && (colorT[jt = GetId(tt)] == -1) && ( tt->color==kolor)) { + colorT[jt]=nbsubdomains; + st[++level]=jt; + st[++level]=0; + k++; + } + } + else level-=2; + } + nbsubdomains++; + } + } + if (verbose> 3) _printLine_(" The Number of sub domain = " << nbsubdomains); + + //build subdomains + long isd; + subdomains = new SubDomain[nbsubdomains]; + + //initialize subdomains[isd].head as 0 + for (isd=0;isdcolor != triangles[it].color) && !subdomains[isd=colorT[it]].head){ + subdomains[isd].head = triangles+it; + subdomains[isd].ReferenceNumber = triangles[it].color; + subdomains[isd].direction = j; // hack + subdomains[isd].edge = 0; + k++; + } + } + } + //check that we have been through all subdomains + if (k!= nbsubdomains){ + delete [] colorT; + _error_("k!= nbsubdomains"); + } + //delete colorT and st + delete [] colorT; + delete [] st; + + /*Reconstruct Geometry Gh*/ + + //build colorV -1 for all vertex and 0 for the vertices belonging to edges + long* colorV = new long[nbv]; + for (i=0;i3) _printLine_(" number of vertices = " << Gh.nbv << "\n number of edges = " << Gh.nbe); + NbVerticesOnGeomVertex = Gh.nbv; + VerticesOnGeomVertex = new VertexOnGeom[NbVerticesOnGeomVertex]; + NbVerticesOnGeomEdge =0; + VerticesOnGeomEdge =0; + + //Build VertexOnGeom + for (i=0;i=0){ + BamgVertex & v = Gh.vertices[j]; + v = vertices[i]; + v.color =0; + VerticesOnGeomVertex[j] = VertexOnGeom(vertices[i], Gh.vertices[j]); + } + } + + //Buid pmin and pmax of Gh (extrema coordinates) + Gh.pmin = Gh.vertices[0].r; + Gh.pmax = Gh.vertices[0].r; + // recherche des extrema des vertices pmin,pmax + for (i=0;iSetRequired(); + Gh.edges[i].v[1]->SetRequired(); + Gh.edges[i].SetRequired(); + } + + R2 x12 = Gh.vertices[j0].r-Gh.vertices[j1].r; + double l12=Norme2(x12); + hmin = Min(hmin,l12); + + Gh.vertices[j1].color++; + Gh.vertices[j0].color++; + + len[j0]+= l12; + len[j1] += l12; + hmin = Min(hmin,l12); + Gh.edges[i].ReferenceNumber = edges[i].ReferenceNumber; + + k = edge4->SortAndAdd(i0,i1); + if (k != i){ + delete [] len; + delete [] colorV; + _error_("problem in Edge4 construction: k != i"); + } + } + + //Build metric for all vertices of Gh + for (i=0;i 0) + Gh.vertices[i].m= Metric(len[i] /(double) Gh.vertices[i].color); + else + Gh.vertices[i].m= Metric(hmin); + } + //delete len + delete [] len; + + //Build Gh.subdomains + for (i=0;iSortAndFind(i0,i1); + if(k>=0){ + subdomains[i].direction = (vertices + i0 == edges[k].v[0]) ? 1 : -1; + subdomains[i].edge = edges+k; + Gh.subdomains[i].edge = Gh.edges + k; + Gh.subdomains[i].direction = subdomains[i].direction; + Gh.subdomains[i].ReferenceNumber = subdomains[i].ReferenceNumber; + } + else + _error_("%i should be >=0"); + } + + delete edge4; + delete [] colorV; + + //unset adj + for (i=0;iverbose; + + /*Get and process fields*/ + s=bamgopts->field; + nbsol=bamgopts->fieldSize[1]; + + /*Check size*/ + if (bamgopts->fieldSize[0] != nbv) _error_("'field' should have " << nbv << " rows"); + + //initialization of some variables + double* ss=(double*)s; + double sA,sB,sC; + double* detT = new double[nbt]; + double* sumareas = new double[nbv]; + double* alpha= new double[nbt*3]; + double* beta = new double[nbt*3]; + double* dx_elem = new double[nbt]; + double* dy_elem = new double[nbt]; + double* dx_vertex = new double[nbv]; + double* dy_vertex = new double[nbv]; + double* dxdx_elem = new double[nbt]; + double* dxdy_elem = new double[nbt]; + double* dydy_elem = new double[nbt]; + double* dxdx_vertex= new double[nbv]; + double* dxdy_vertex= new double[nbv]; + double* dydy_vertex= new double[nbv]; + + //display infos + if(verbose>1) { + _printLine_(" Construction of Metric: number of field: " << nbsol << " (nbt=" << nbt << ", nbv=" << nbv << ")"); + } + + //first, build the chains that will be used for the Hessian computation, as weel as the area of each element + int* head_s=NULL; + head_s=xNew(nbv); + int* next_p=NULL; + next_p=xNew(3*nbt); + int p=0; + //initialization + for(i=0;i2) _printLine_(" Solution " << nusol << ", Min = " << smin << ", Max = " << smax << ", Delta = " << sdelta); + + //skip constant field + if (sdelta < 1.0e-10*Max(absmax,1e-20)){ + _printLine_(" Solution " << nusol << " is constant, skipping..."); + continue; + } + + //initialize the hessian and gradient matrices + for ( iv=0,k=0; iverr[nusol],bamgopts); + } + + }//for all solutions + + //clean up + xDelete(head_s); + xDelete(next_p); + delete [] detT; + delete [] alpha; + delete [] beta; + delete [] sumareas; + delete [] dx_elem; + delete [] dy_elem; + delete [] dx_vertex; + delete [] dy_vertex; + delete [] dxdx_elem; + delete [] dxdy_elem; + delete [] dydy_elem; + delete [] dxdx_vertex; + delete [] dxdy_vertex; + delete [] dydy_vertex; + } + /*}}}*/ + /*FUNCTION Mesh::BuildMetric1 (Green formula){{{*/ + void Mesh::BuildMetric1(BamgOpts* bamgopts){ + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/IntersectConsMetric)*/ + + /*Options*/ + double* s=NULL; + long nbsol; + int NbJacobi; + int verbose; + + /*Recover options*/ + verbose=bamgopts->verbose; + NbJacobi=bamgopts->nbjacobi; + + /*Get and process fields*/ + s=bamgopts->field; + nbsol=bamgopts->fieldSize[1]; + + /*Check size*/ + if (bamgopts->fieldSize[0] != nbv) _error_("'field' should have " << nbv << " rows"); + + //initialization of some variables + long i,k,iA,iB,iC,iv; + R2 O(0,0); + double* ss=(double*)s; + double sA,sB,sC; + double* detT = new double[nbt]; + double* Mmass= new double[nbv]; + double* Mmassxx= new double[nbv]; + double* dxdx= new double[nbv]; + double* dxdy= new double[nbv]; + double* dydy= new double[nbv]; + double* workT= new double[nbt]; + double* workV= new double[nbv]; + int* OnBoundary = new int[nbv]; + + //display infos + if(verbose>1) { + _printLine_(" Construction of Metric: number of field: " << nbsol << " (nbt=" << nbt << ", nbv=" << nbv << ")"); + } + + //initialize Mmass, OnBoundary and Massxx by zero + for (iv=0;ivlink){ + //mark the two vertices of the edge as OnBoundary + OnBoundary[GetId(t[VerticesOfTriangularEdge[j][0]])]=1; + OnBoundary[GetId(t[VerticesOfTriangularEdge[j][1]])]=1; + nbb++; + } + } + + //number of vertices on boundary for current triangle t + workT[i] = nbb; + + //Build Mmass Mmass[i] = Mmass[i] + Area/3 + Mmass[iA] += dett; + Mmass[iB] += dett; + Mmass[iC] += dett; + + //Build Massxx = Mmass + Mmassxx[iA] += dett; + Mmassxx[iB] += dett; + Mmassxx[iC] += dett; + } + + //else: the triangle is a boundary triangle -> workT=-1 + else workT[i]=-1; + } + + //for all Solution + for (int nusol=0;nusol2) _printLine_(" Solution " << nusol << ", Min = " << smin << ", Max = " << smax << ", Delta = " << sdelta << ", number of fields = " << nbsol); + + //skip constant field + if (sdelta < 1.0e-10*Max(absmax,1e-20) ){ + if (verbose>2) _printLine_(" Solution " << nusol << " is constant, skipping..."); + continue; + } + + //pointer toward ss that is also a pointer toward s (solutions) + double* sf=ss; + + //initialize the hessian matrix + for ( iv=0,k=0; iv normal = 0 + if ( !tBC || !tBC->link ) nBC=O; + if ( !tCA || !tCA->link ) nCA=O; + if ( !tAB || !tAB->link ) nAB=O; + + // remark we forgot a 1/2 because + // int_{edge} w_i = 1/2 if i is in edge + // 0 if not + // if we don't take the boundary + dxdx[iA] += ( nCA.x + nAB.x ) *Grads.x; + dxdx[iB] += ( nAB.x + nBC.x ) *Grads.x; + dxdx[iC] += ( nBC.x + nCA.x ) *Grads.x; + + //warning optimization (1) the division by 2 is done on the metric construction + dxdy[iA] += (( nCA.y + nAB.y ) *Grads.x + ( nCA.x + nAB.x ) *Grads.y) ; + dxdy[iB] += (( nAB.y + nBC.y ) *Grads.x + ( nAB.x + nBC.x ) *Grads.y) ; + dxdy[iC] += (( nBC.y + nCA.y ) *Grads.x + ( nBC.x + nCA.x ) *Grads.y) ; + + dydy[iA] += ( nCA.y + nAB.y ) *Grads.y; + dydy[iB] += ( nAB.y + nBC.y ) *Grads.y; + dydy[iC] += ( nBC.y + nCA.y ) *Grads.y; + + } // for real all triangles + } + + long kk=0; + for ( iv=0,k=0 ; iv0){ + dxdx[iv] /= 2*Mmassxx[iv]; + // warning optimization (1) on term dxdy[iv]*ci/2 + dxdy[iv] /= 4*Mmassxx[iv]; + dydy[iv] /= 2*Mmassxx[iv]; + // Compute the matrix with abs(eigen value) + Metric M(dxdx[iv], dxdy[iv], dydy[iv]); + EigenMetric Vp(M); + Vp.Abs(); + M = Vp; + dxdx[iv] = M.a11; + dxdy[iv] = M.a21; + dydy[iv] = M.a22; + } + else kk++; + } + + // correction of second derivative + // by a laplacien + double* d2[3] = {dxdx, dxdy, dydy}; + double* dd; + for (int xy = 0;xy<3;xy++) { + dd = d2[xy]; + // do leat 2 iteration for boundary problem + for (int ijacobi=0;ijacobi0)+(Mmassxx[iB]>0)+(Mmassxx[iC]>0)),1.); + workT[i] = (dd[iA]+dd[iB]+dd[iC])/cc; + } + for (iv=0;iverr[nusol],bamgopts); + } + + }// end for all solution + + delete [] detT; + delete [] Mmass; + delete [] dxdx; + delete [] dxdy; + delete [] dydy; + delete [] workT; + delete [] workV; + delete [] Mmassxx; + delete [] OnBoundary; + + } + /*}}}*/ + /*FUNCTION Mesh::CrackMesh{{{*/ + void Mesh::CrackMesh(BamgOpts* bamgopts) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/CrackMesh)*/ + + /*Intermediary*/ + int i,j,k,num,count; + int i1,i2; + int j1,j2; + + /*Options*/ + int verbose=bamgopts->verbose; + + // computed the number of cracked edge + for (k=i=0;iCracked()) k++; + } + + //Return if no edge is cracked + if(k==0) return; + if (verbose>4) _printLine_(" number of Cracked Edges = " << k); + + //Initialize Cracked edge + NbCrackedEdges=k; + CrackedEdges=new CrackedEdge[k]; + + //Compute number of Cracked Vertices + k=0; + NbCrackedVertices=0; + + int* splitvertex=new int[nbv]; + for (i=0;iCracked()){ + + //Fill edges fields of CrackedEdges + CrackedEdges[k ].E =edges[i].GeomEdgeHook; + CrackedEdges[k++].e1=&edges[i]; + + //Get number of the two vertices on the edge + i1=GetId(edges[i][0]); + i2=GetId(edges[i][1]); + _assert_(i1>=0 && i1=0 && i24) _printLine_(" number of Cracked Vertices = " << NbCrackedVertices); + if (NbCrackedVertices){ + CrackedVertices=xNew(2*NbCrackedVertices); + num=0; + for (i=0;i to renumber + CrackedEdges[i].b=ta.t; + CrackedEdges[i].length=Norme2((*ta.t)[j1].r-(*ta.t)[j2].r); + CrackedEdges[i].normal=Orthogonal((*ta.t)[j1].r-(*ta.t)[j2].r); + } + Edgeflags[i]++; + break; + } + } + //_printLine_(element_renu[GetId(ta.t)] << " -> " << GetId((*ta.t)[0])+1 << " " << GetId((*ta.t)[1])+1 << " " << GetId((*ta.t)[2])+1 << ", edge [" << i1 << "->" << j1 << " " << i2 << "->" << j2 << "]"); + ta = Next(ta).Adj(); + if (count++>50) _error_("Maximum number of iteration exceeded"); + }while ((tbegin != ta)); + } + + //Check EdgeFlag + for(i=0;i (BAMG v1.01, Mesh2.cpp/ForceBoundary)*/ + + long int verbose=2; + int k=0; + int nbfe=0,nbswp=0,Nbswap=0; + + //display + if (verbose > 2) _printLine_(" ForceBoundary nb of edge: " << nbe); + + //check that there is no triangle with 0 determinant + for (int t = 0; t < nbt; t++){ + if (!triangles[t].det) k++; + } + if (k!=0) { + _error_("there is " << k << " triangles of mes = 0"); + } + + //Force Edges + AdjacentTriangle ta(0,0); + for (int i = 0; i < nbe; i++){ + + //Force edge i + nbswp = ForceEdge(edges[i][0],edges[i][1],ta); + if (nbswp<0) k++; + else Nbswap += nbswp; + + if (nbswp) nbfe++; + if ( nbswp < 0 && k < 5){ + _error_("Missing Edge " << i << ", v0=" << GetId(edges[i][0]) << ",v1=" << GetId(edges[i][1])); + } + } + + if (k!=0) { + _error_("There are " << k << " lost edges, the boundary might be crossing"); + } + for (int j=0;j 3) _printLine_(" number of inforced edge = " << nbfe << ", number of swap= " << Nbswap); + } + /*}}}*/ + /*FUNCTION Mesh::FindSubDomain{{{*/ + void Mesh::FindSubDomain(int OutSide) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/FindSubDomain)*/ + + long int verbose=0; + + if (verbose >2){ + if (OutSide) _printLine_(" Find all external sub-domain"); + else _printLine_(" Find all internal sub-domain"); + } + short * HeapArete = new short[nbt]; + Triangle ** HeapTriangle = new Triangle* [nbt]; + Triangle *t,*t1; + long k,it; + + for (int itt=0;ittlink = t ; // sd forme d'un triangle cicular link + + HeapTriangle[i] =t ; + HeapArete[i] = 3; + + while (i >= 0) // boucle sur la pile + { while ( HeapArete[i]--) // boucle sur les 3 aretes + { + int na = HeapArete[i]; + Triangle * tc = HeapTriangle[i]; // triangle courant + if( ! tc->Locked(na)) // arete non frontiere + { + Triangle * ta = tc->TriangleAdj(na) ; // næ triangle adjacent + if (ta->link == 0 ) // non deja chainer => on enpile + { + i++; + ta->link = t->link ; // on chaine les triangles + t->link = ta ; // d'un meme sous domaine + HeapArete[i] = 3; // pour les 3 triangles adjacents + HeapTriangle[i] = ta; + }} + } // deplie fin de boucle sur les 3 adjacences + i--; + } + } + } + + // supression de tous les sous domaine infini <=> contient le sommet NULL + it =0; + nbtout = 0; + while (itlink; + t1->link=0; + } + } + } + it++;} // end while (itlink; + mark[it]=k; + subdomains[k].head = t1; + do { + mark[GetId(t)]=k; + t=t->link; + } while (t!=t1); + mark[it]=k++;} + // else if(mark[it] == -2 ) triangles[it].Draw(999); + it++;} // end white (it=0 && subdomains[kl].ReferenceNumber <0 && kr >=0 && subdomains[kr].ReferenceNumber>=0) + nbk--,subdomains[kr].ReferenceNumber=subdomains[kl].ReferenceNumber-1; + if (kr >=0 && subdomains[kr].ReferenceNumber <0 && kl >=0 && subdomains[kl].ReferenceNumber>=0) + nbk--,subdomains[kl].ReferenceNumber=subdomains[kr].ReferenceNumber-1; + if(kr<0 && kl >=0 && subdomains[kl].ReferenceNumber>=0) + nbk--,subdomains[kl].ReferenceNumber=-1; + if(kl<0 && kr >=0 && subdomains[kr].ReferenceNumber>=0) + nbk--,subdomains[kr].ReferenceNumber=-1; + } + } + long j=0; + for ( i=0;ilink; + t1->link=0; + }//while (t) + } + if(verbose>4) _printLine_(" Number of removes subdomains (OutSideMesh) = " << nbsubdomains-j); + nbsubdomains=j; + } + + delete [] mark; + + } + else + { // find the head for all sub domaine + if (Gh.nbsubdomains != nbsubdomains && subdomains) + delete [] subdomains, subdomains=0; + if (! subdomains ) + subdomains = new SubDomain[ Gh.nbsubdomains]; + nbsubdomains =Gh.nbsubdomains; + long err=0; + CreateSingleVertexToTriangleConnectivity(); + long * mark = new long[nbt]; + Edge **GeomEdgetoEdge = MakeGeomEdgeToEdge(); + + for (it=0;itt; + int direction = Gh.subdomains[i].direction; + // test if ge and e is in the same direction + if (((eg[0].r-eg[1].r),(e[0].r-e[1].r))<0) direction = -direction ; + subdomains[i].direction = direction; + subdomains[i].edge = &e; + _assert_(t && direction); + + AdjacentTriangle ta(t,EdgesVertexTriangle[v0->IndexInTriangle][0]);// previous edges + + while (1) { + _assert_(v0==ta.EdgeVertex(1)); + if (ta.EdgeVertex(0) == v1) { // ok we find the edge + if (direction>0) + subdomains[i].head=t=Adj(ta); + else + subdomains[i].head=t=ta; + if(t= triangles+nbt || t->det < 0 || t->link == 0) { + _error_("bad definition of SubSomain " << i); + } + long it = GetId(t); + if (mark[it] >=0) { + break; + } + if(i != inew) + Exchange(subdomains[i],subdomains[inew]); + inew++; + Triangle *tt=t; + long kkk=0; + do + { + kkk++; + if (mark[GetId(tt)]>=0){ + _error_("mark[GetId(tt)]>=0"); + } + mark[GetId(tt)]=i; + tt=tt->link; + } while (tt!=t); + break; + } + ta = Previous(Adj(ta)); + if(t == (Triangle *) ta) { + _error_("bad definition of SubSomain " << i); + } + } + } + + if (inew < nbsubdomains) { + if (verbose>5) _printLine_("WARNING: " << nbsubdomains-inew << " SubDomains are being removed"); + nbsubdomains=inew;} + + for (it=0;it (BAMG v1.01, Mesh2.cpp/PreInit)*/ + + /* initialize random seed: */ + srand(19999999); + + /*Initialize fields*/ + NbRef=0; + quadtree=NULL; + nbv=0; + nbt=0; + nbe=0; + edges=NULL; + nbq=0; + nbsubdomains=0; + subdomains=NULL; + maxnbv=maxnbv_in; + maxnbt=2 *maxnbv_in-2; + NbVertexOnBThVertex=0; + VertexOnBThVertex=NULL; + NbVertexOnBThEdge=0; + VertexOnBThEdge=NULL; + NbCrackedVertices=0; + CrackedVertices =NULL; + NbCrackedEdges =0; + CrackedEdges =NULL; + NbVerticesOnGeomVertex=0; + VerticesOnGeomVertex=NULL; + NbVerticesOnGeomEdge=0; + VerticesOnGeomEdge=NULL; + + /*Allocate if maxnbv_in>0*/ + if (maxnbv_in) { + vertices=new BamgVertex[maxnbv]; + _assert_(vertices); + orderedvertices=new (BamgVertex* [maxnbv]); + _assert_(orderedvertices); + triangles=new Triangle[maxnbt]; + _assert_(triangles); + } + else { + vertices=NULL; + orderedvertices=NULL; + triangles=NULL; + maxnbt=0; + } + } + /*}}}*/ + /*FUNCTION Mesh::Insert{{{*/ + void Mesh::Insert() { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/Insert)*/ + + /*Insert points in the existing Geometry*/ + + //Intermediary + int i; + + /*Get options*/ + long int verbose=2; + + //Display info + if (verbose>2) _printLine_(" Insert initial " << nbv << " vertices"); + + //Compute integer coordinates for the existing vertices + SetIntCoor(); + + /*Now we want to build a list (orderedvertices) of the vertices in a random + * order. To do so, we use the following method: + * + * From an initial k0 in [0 nbv[ random (vertex number) + * the next k (vertex number) is computed using a big + * prime number (PN>>nbv) following: + * + * k_{i+1} = k_i + PN [nbv] + * + * let's show that: + * + * for all j in [0 nbv[, ∃! i in [0 nbv[ such that k_i=j + * + * Let's assume that there are 2 distinct j1 and j2 such that + * k_j1 = k_j2 + * + * This means that + * + * k0+j1*PN = k0+j2*PN [nbv] + * (j1-j2)*PN =0 [nbv] + * since PN is a prime number larger than nbv, and nbv!=1 + * j1-j2=0 [nbv] + * BUT + * j1 and j2 are in [0 nbv[ which is impossible. + * + * We hence have built a random list of nbv elements of + * [0 nbv[ all distincts*/ + + //Get Prime number + const long PrimeNumber= BigPrimeNumber(nbv); + int k0=rand()%nbv; + + //Build orderedvertices + for (i=0; ii,orderedvertices[1]->i,orderedvertices[i]->i)==0;){ + //if i is higher than nbv, it means that all the determinants are 0, + //all vertices are aligned! + if (++i>=nbv) _error_("all the vertices are aligned"); + } + // exchange i et 2 in "orderedvertices" so that + // the first 3 vertices are not aligned (real triangle) + Exchange(orderedvertices[2], orderedvertices[i]); + + /*Take the first edge formed by the first two vertices and build + * the initial simple mesh from this edge and 2 boundary triangles*/ + + BamgVertex *v0=orderedvertices[0], *v1=orderedvertices[1]; + + nbt = 2; + triangles[0](0) = NULL;//infinite vertex + triangles[0](1) = v0; + triangles[0](2) = v1; + triangles[1](0) = NULL;//infinite vertex + triangles[1](2) = v0; + triangles[1](1) = v1; + + //Build adjacence + const int e0 = OppositeEdge[0]; + const int e1 = NextEdge[e0]; + const int e2 = PreviousEdge[e0]; + triangles[0].SetAdj2(e0, &triangles[1] ,e0); + triangles[0].SetAdj2(e1, &triangles[1] ,e2); + triangles[0].SetAdj2(e2, &triangles[1] ,e1); + + triangles[0].det = -1; //boundary triangle: det = -1 + triangles[1].det = -1; //boundary triangle: det = -1 + + triangles[0].SetSingleVertexToTriangleConnectivity(); + triangles[1].SetSingleVertexToTriangleConnectivity(); + + triangles[0].link=&triangles[1]; + triangles[1].link=&triangles[0]; + + //build quadtree + if (!quadtree) quadtree = new BamgQuadtree(this,0); + quadtree->Add(*v0); + quadtree->Add(*v1); + + /*Now, add the vertices One by One*/ + long NbSwap=0; + if (verbose>3) _printLine_(" Begining of insertion process..."); + + for (int icount=2; icounti,det3); //(newvertex->i = integer coordinates) + + //Add newvertex to the quadtree + quadtree->Add(*newvertex); + + //Add newvertex to the existing mesh + AddVertex(*newvertex,tcvi,det3); + + //Make the mesh Delaunay around newvertex by swaping the edges + NbSwap += newvertex->Optim(1,0); + } + + //Display info + if (verbose>3) { + _printLine_(" NbSwap of insertion: " << NbSwap); + _printLine_(" NbSwap/nbv: " << NbSwap/nbv); + } + +#ifdef NBLOOPOPTIM + + k0 = rand()%nbv ; + for (int is4=0; is4Optim(0,0); + if (verbose>3) { + _printLine_(" Optim Loop: " << Nbloop); + _printLine_(" NbSwap/nbv: " << NbSwap/nbv); + } + if(!NbSwap) break; + } + CreateSingleVertexToTriangleConnectivity(); + // because we break the TriangleContainingTheVertex +#endif + } + /*}}}*/ + /*FUNCTION Mesh::InsertNewPoints{{{*/ + long Mesh::InsertNewPoints(long nbvold,long & NbTSwap) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/InsertNewPoints)*/ + + long int verbose=0; + double seuil= 1.414/2 ;// for two close point + long i; + long NbSwap=0; + Icoor2 det3[3]; + + //number of new points + const long nbvnew=nbv-nbvold; + + //display info if required + if (verbose>5) _printLine_(" Try to Insert " << nbvnew << " new points"); + + //return if no new points + if (!nbvnew) return 0; + + /*construction of a random order*/ + const long PrimeNumber= BigPrimeNumber(nbv) ; + //remainder of the division of rand() by nbvnew + long k3 = rand()%nbvnew; + //loop over the new points + for (int is3=0; is3ReferenceNumber=i; + } + + // for all the new point + long iv=nbvold; + for (i=nbvold;iToClose(vi,seuil,hi,hj)){ + // a good new point + BamgVertex &vj = vertices[iv]; + long j=vj.ReferenceNumber; + if (&vj!=orderedvertices[j]){ + _error_("&vj!= orderedvertices[j]"); + } + if(i!=j){ + Exchange(vi,vj); + Exchange(orderedvertices[j],orderedvertices[i]); + } + vj.ReferenceNumber=0; + Triangle *tcvj=TriangleFindFromCoord(vj.i,det3); + if (tcvj && !tcvj->link){ + tcvj->Echo(); + _error_("problem inserting point in InsertNewPoints (tcvj=" << tcvj << " and tcvj->link=" << tcvj->link << ")"); + } + quadtree->Add(vj); + AddVertex(vj,tcvj,det3); + NbSwap += vj.Optim(1); + iv++; + } + } + if (verbose>3) { + _printLine_(" number of new points: " << iv); + _printLine_(" number of to close (?) points: " << nbv-iv); + _printLine_(" number of swap after: " << NbSwap); + } + nbv = iv; + + for (i=nbvold;i3) _printLine_(" NbSwap=" << NbSwap); + + NbTSwap += NbSwap ; + return nbv-nbvold; + } + /*}}}*/ + /*FUNCTION Mesh::isCracked{{{*/ + int Mesh::isCracked() const { + return NbCrackedVertices != 0; + } + /*}}}*/ + /*FUNCTION Mesh::MakeGeomEdgeToEdge{{{*/ + Edge** Mesh::MakeGeomEdgeToEdge() { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/MakeGeomEdgeToEdge)*/ + + if (!Gh.nbe){ + _error_("!Gh.nbe"); + } + Edge **e= new (Edge* [Gh.nbe]); + + long i; + for ( i=0;iGeomEdgeHook; + e[Gh.GetId(GeomEdgeHook)] = ei; + } + for ( i=0;iGeomEdgeHook; + int j= ii; + while (!(*GeomEdgeHook)[j].Required()) { + Adj(GeomEdgeHook,j); // next geom edge + j=1-j; + if (e[Gh.GetId(GeomEdgeHook)]) break; // optimisation + e[Gh.GetId(GeomEdgeHook)] = ei; + } + } + + int kk=0; + for ( i=0;i (BAMG v1.01, Mesh2.cpp/MakeQuadrangles)*/ + + long int verbose=0; + + if (verbose>2) _printLine_("MakeQuadrangles costheta = " << costheta); + + if (costheta >1) { + if (verbose>5) _printLine_(" do nothing: costheta > 1"); + } + + long nbqq = (nbt*3)/2; + DoubleAndInt *qq = new DoubleAndInt[nbqq]; + + long i,ij; + int j; + long k=0; + for (i=0;i=costheta) + qq[k++].i3j=i*3+j; + // sort qq + HeapSort(qq,k); + + long kk=0; + for (ij=0;ij=costheta) + triangles[i].SetHidden(j),kk++; + } + nbq = kk; + if (verbose>2){ + _printLine_(" number of quadrilaterals = " << nbq); + _printLine_(" number of triangles = " << nbt-nbtout- nbq*2); + _printLine_(" number of outside triangles = " << nbtout); + } + delete [] qq; + } + /*}}}*/ + /*FUNCTION Mesh::MakeBamgQuadtree{{{*/ + void Mesh::MakeBamgQuadtree() { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/MakeBamgQuadtree)*/ + + long int verbose=0; + if ( !quadtree ) quadtree = new BamgQuadtree(this); + + } + /*}}}*/ + /*FUNCTION Mesh::MaxinalHmax{{{*/ + double Mesh::MaximalHmax() { + return Max(pmax.x-pmin.x,pmax.y-pmin.y); + } + /*}}}*/ + /*FUNCTION Mesh::MaxSubDivision{{{*/ + void Mesh::MaxSubDivision(double maxsubdiv) { + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/MaxSubDivision)*/ + + long int verbose=0; + + const double maxsubdiv2 = maxsubdiv*maxsubdiv; + if(verbose>1) _printLine_(" Limit the subdivision of a edges in the new mesh by " << maxsubdiv); + // for all the edges + // if the len of the edge is to long + long it,nbchange=0; + double lmax=0; + for (it=0;it maxsubdiv2){ + R2 AC = M.Orthogonal(AB);// the ortogonal vector of AB in M + double lc = M(AC,AC); + D2xD2 Rt(AB,AC);// Rt.x = AB , Rt.y = AC; + D2xD2 Rt1(Rt.inv()); + D2xD2 D(maxsubdiv2,0,0,lc); + D2xD2 MM = Rt1*D*Rt1.t(); + v0.m = M = Metric(MM.x.x,MM.y.x,MM.y.y); + nbchange++; + } + M = v1; + l = M(AB,AB); + lmax = Max(lmax,l); + if(l> maxsubdiv2){ + R2 AC = M.Orthogonal(AB);// the ortogonal vector of AB in M + double lc = M(AC,AC); + D2xD2 Rt(AB,AC);// Rt.x = AB , Rt.y = AC; + D2xD2 Rt1(Rt.inv()); + D2xD2 D(maxsubdiv2,0,0,lc); + D2xD2 MM = Rt1*D*Rt1.t(); + v1.m = M = Metric(MM.x.x,MM.y.x,MM.y.y); + nbchange++; + } + } + } + } + if(verbose>3){ + _printLine_(" number of metric changes = " << nbchange << ", maximum number of subdivision of a edges before change = " << pow(lmax,0.5)); + } + } + /*}}}*/ + /*FUNCTION Mesh::MetricAt{{{*/ + Metric Mesh::MetricAt(const R2 & A) const { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/MetricAt)*/ + + I2 a = R2ToI2(A); + Icoor2 deta[3]; + Triangle * t =TriangleFindFromCoord(a,deta); + if (t->det <0) { // outside + double ba,bb; + AdjacentTriangle edge= CloseBoundaryEdge(a,t,ba,bb) ; + return Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1));} + else { // inside + double aa[3]; + double s = deta[0]+deta[1]+deta[2]; + aa[0]=deta[0]/s; + aa[1]=deta[1]/s; + aa[2]=deta[2]/s; + return Metric(aa,(*t)[0],(*t)[1],(*t)[2]); + } + } + /*}}}*/ + /*FUNCTION Mesh::MininalHmin{{{*/ + double Mesh::MinimalHmin() { + return 2.0/coefIcoor; + } + /*}}}*/ +/*FUNCTION Mesh::NearestVertex{{{*/ +BamgVertex* Mesh::NearestVertex(Icoor1 i,Icoor1 j) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/NearestVertex)*/ + return quadtree->NearestVertex(i,j); +} +/*}}}*/ + /*FUNCTION Mesh::NewPoints{{{*/ + void Mesh::NewPoints(Mesh & Bh,BamgOpts* bamgopts,int KeepVertices){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/NewPoints)*/ + + int i,j,k; + long NbTSwap=0; + long nbtold=nbt; + long nbvold=nbv; + long Headt=0; + long next_t; + long* first_np_or_next_t=new long[maxnbt]; + Triangle* t=NULL; + + /*Recover options*/ + int verbose=bamgopts->verbose; + + /*First, insert old points if requested*/ + if (KeepVertices && (&Bh != this) && (nbv+Bh.nbv< maxnbv)){ + if (verbose>5) _printLine_(" Inserting initial mesh points"); + for (i=0;i5) _printLine_(" Big loop"); + do { + /*Update variables*/ + iter++; + nbtold=nbt; + nbvold=nbv; + + /*We test all triangles*/ + i=Headt; + next_t=-first_np_or_next_t[i]; + for(t=&triangles[i];i=nbt ){ + _error_("Index problem in NewPoints (i=" << i << " not in [0 " << nbt-1 << "])"); + } + //change first_np_or_next_t[i] + first_np_or_next_t[i] = iter; + + //Loop over the edges of t + for(j=0;j<3;j++){ + AdjacentTriangle tj(t,j); + BamgVertex &vA = *tj.EdgeVertex(0); + BamgVertex &vB = *tj.EdgeVertex(1); + + //if t is a boundary triangle, or tj locked, continue + if (!t->link) continue; + if (t->det <0) continue; + if (t->Locked(j)) continue; + + AdjacentTriangle tadjj = t->Adj(j); + Triangle* ta=tadjj; + + //if the adjacent triangle is a boundary triangle, continur + if (ta->det<0) continue; + + R2 A=vA; + R2 B=vB; + k=GetId(ta); + + //if this edge has already been done, go to next edge of triangle + if(first_np_or_next_t[k]==iter) continue; + + lIntTria.SplitEdge(Bh,A,B); + lIntTria.NewPoints(vertices,nbv,maxnbv); + } // end loop for each edge + }// for triangle + + if (!InsertNewPoints(nbvold,NbTSwap)) break; + for (i=nbtold;it, EdgesVertexTriangle[s->IndexInTriangle][1]); + Triangle* tbegin= (Triangle*) ta; + long kt; + do { + kt = GetId((Triangle*) ta); + if (first_np_or_next_t[kt]>0){ + first_np_or_next_t[kt]=-Headt; + Headt=kt; + } + if (ta.EdgeVertex(0)!=s){ + _error_("ta.EdgeVertex(0)!=s"); + } + ta = Next(Adj(ta)); + } while ( (tbegin != (Triangle*) ta)); + } + + } while (nbv!=nbvold); + + delete [] first_np_or_next_t; + + long NbSwapf =0,NbSwp; + + NbSwp = NbSwapf; + for (i=0;i (BAMG v1.01, MeshQuad.cpp/ProjectOnCurve)*/ + + void *pA=0,*pB=0; + double tA=0,tB=0; + R2 A=vA,B=vB; + BamgVertex * pvA=&vA, * pvB=&vB; + if (vA.IndexInTriangle == IsVertexOnVertex){ + pA=vA.BackgroundVertexHook; + } + else if (vA.IndexInTriangle == IsVertexOnEdge){ + pA=vA.BackgroundEdgeHook->be; + tA=vA.BackgroundEdgeHook->abcisse; + } + else { + _error_("ProjectOnCurve On BamgVertex " << BTh.GetId(vA) << " forget call to SetVertexFieldOnBTh"); + } + + if (vB.IndexInTriangle == IsVertexOnVertex){ + pB=vB.BackgroundVertexHook; + } + else if(vB.IndexInTriangle == IsVertexOnEdge){ + pB=vB.BackgroundEdgeHook->be; + tB=vB.BackgroundEdgeHook->abcisse; + } + else { + _error_("ProjectOnCurve On BamgVertex " << BTh.GetId(vB) << " forget call to SetVertexFieldOnBTh"); + } + Edge * e = &BhAB; + if (!pA || !pB || !e){ + _error_("!pA || !pB || !e"); + } + // be carefull the back ground edge e is on same geom edge + // of the initiale edge def by the 2 vertex A B; + //check Is a background Mesh; + if (e=BTh.edges+BTh.nbe){ + _error_("e=BTh.edges+BTh.nbe"); + } + // walk on BTh edge + //not finish ProjectOnCurve with BackGround Mesh); + // 1 first find a back ground edge contening the vertex A + // 2 walk n back gound boundary to find the final vertex B + + if( vA.IndexInTriangle == IsVertexOnEdge) + { // find the start edge + e = vA.BackgroundEdgeHook->be; + + } + else if (vB.IndexInTriangle == IsVertexOnEdge) + { + theta = 1-theta; + Exchange(tA,tB); + Exchange(pA,pB); + Exchange(pvA,pvB); + Exchange(A,B); + e = vB.BackgroundEdgeHook->be; + + } + else{ // do the search by walking + _error_("case not supported yet"); + } + + // find the direction of walking with direction of edge and pA,PB; + R2 AB=B-A; + + double cosE01AB = (( (R2) (*e)[1] - (R2) (*e)[0] ) , AB); + int kkk=0; + int direction = (cosE01AB>0) ? 1 : 0; + + // double l=0; // length of the edge AB + double abscisse = -1; + + for (int step=0;step<2;step++){ + // 2 times algo: + // 1 for computing the length l + // 2 for find the vertex + int iii; + BamgVertex *v0=pvA,*v1; + Edge *neee,*eee; + double lg =0; // length of the curve + double te0; + // we suppose take the curve's abcisse + for ( eee=e,iii=direction,te0=tA; + eee && ((( void*) eee) != pB) && (( void*) (v1=&((*eee)[iii]))) != pB ; + neee = eee->adj[iii],iii = 1-neee->Intersection(*eee),eee = neee,v0=v1,te0=1-iii ) { + + kkk=kkk+1; + _assert_(kkk<100); + _assert_(eee); + double lg0 = lg; + double dp = LengthInterpole(v0->m,v1->m,(R2) *v1 - (R2) *v0); + lg += dp; + if (step && abscisse <= lg) { // ok we find the geom edge + double sss = (abscisse-lg0)/dp; + double thetab = te0*(1-sss)+ sss*iii; + _assert_(thetab>=0 && thetab<=1); + BR = VertexOnEdge(&R,eee,thetab); + return Gh.ProjectOnCurve(*eee,thetab,R,GR); + } + } + // we find the end + if (v1 != pvB){ + if (( void*) v1 == pB) + tB = iii; + + double lg0 = lg; + _assert_(eee); + v1 = pvB; + double dp = LengthInterpole(v0->m,v1->m,(R2) *v1 - (R2) *v0); + lg += dp; + abscisse = lg*theta; + if (abscisse <= lg && abscisse >= lg0 ) // small optimisation we know the lenght because end + { // ok we find the geom edge + double sss = (abscisse-lg0)/dp; + double thetab = te0*(1-sss)+ sss*tB; + _assert_(thetab>=0 && thetab<=1); + BR = VertexOnEdge(&R,eee,thetab); + return Gh.ProjectOnCurve(*eee,thetab,R,GR); + } + } + abscisse = lg*theta; + + } + _error_("Big bug..."); + return 0; // just for the compiler + } + /*}}}*/ +/*FUNCTION Mesh::ReconstructExistingMesh{{{*/ +void Mesh::ReconstructExistingMesh(){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/FillHoleInMesh)*/ + + /*This routine reconstruct an existing mesh to make it CONVEX: + * -all the holes are filled + * -concave boundaries are filled + * A convex mesh is required for a lot of operations. This is why every mesh + * goes through this process. + * This routine also generates mesh properties such as adjencies,... + */ + + /*Intermediary*/ + int verbose=0; + + // generation of the integer coordinate + + // find extrema coordinates of vertices pmin,pmax + long i; + if(verbose>2) _printLine_(" Reconstruct mesh of " << nbv << " vertices"); + + //initialize orderedvertices + _assert_(orderedvertices); + for (i=0;iSortAndAdd(GetId(edges[i][0]),GetId(edges[i][1]))); + } + if (kk != nbe){ + _error_("There are " << kk-nbe << " double edges in the mesh"); + } + + //Add edges of all triangles in existing mesh + long* st = new long[nbt*3]; + for (i=0;iSortAndAdd(GetId(triangles[i][VerticesOfTriangularEdge[j][0]]),GetId(triangles[i][VerticesOfTriangularEdge[j][1]])); + + long invisible=triangles[i].Hidden(j); + + //If the edge has not been added to st, add it + if(st[k]==-1) st[k]=3*i+j; + + //If the edge already exists, add adjacency + else if(st[k]>=0) { + _assert_(!triangles[i].TriangleAdj(j)); + _assert_(!triangles[st[k]/3].TriangleAdj((int) (st[k]%3))); + + triangles[i].SetAdj2(j,triangles+st[k]/3,(int)(st[k]%3)); + if (invisible) triangles[i].SetHidden(j); + if (k5) { + _printLine_(" info of Mesh:"); + _printLine_(" - number of vertices = " << nbv << " "); + _printLine_(" - number of triangles = " << nbt << " "); + _printLine_(" - number of given edges = " << nbe << " "); + _printLine_(" - number of all edges = " << edge4->nb()); + _printLine_(" - Euler number 1 - nb of holes = " << nbt-edge4->nb()+nbv); + } + + //check the consistency of edge[].adj and the geometrical required vertex + long k=0; + for (i=0;inb();i++){ + if (st[i]>=0){ // edge alone + if (ii(i); + orderedvertices[i0] = vertices+i0; + long i1=edge4->j(i); + orderedvertices[i1] = vertices+i1; + } + else { + k=k+1; + if (k<10) { + //print only 10 edges + _printLine_("Lost boundary edges " << i << " : " << edge4->i(i) << " " << edge4->j(i)); + } + else if (k==10){ + _printLine_("Other lost boundary edges not shown..."); + } + } + } + } + if(k) { + _error_(k << " boundary edges (from the geometry) are not defined as mesh edges"); + } + + /* mesh generation with boundary points*/ + long nbvb=0; + for (i=0;ii,orderedvertices[1]->i,orderedvertices[i]->i)==0;) + if (++i>=nbvb) { + _error_("ReconstructExistingMesh: All the vertices are aligned"); + } + //Move this vertex (i) to the 2d position in orderedvertices + Exchange(orderedvertices[2], orderedvertices[i]); + + /*Reconstruct mesh beginning with 2 triangles*/ + BamgVertex * v0=orderedvertices[0], *v1=orderedvertices[1]; + + triangles[0](0) = NULL; // Infinite vertex + triangles[0](1) = v0; + triangles[0](2) = v1; + + triangles[1](0) = NULL;// Infinite vertex + triangles[1](2) = v0; + triangles[1](1) = v1; + const int e0 = OppositeEdge[0]; + const int e1 = NextEdge[e0]; + const int e2 = PreviousEdge[e0]; + triangles[0].SetAdj2(e0, &triangles[1] ,e0); + triangles[0].SetAdj2(e1, &triangles[1] ,e2); + triangles[0].SetAdj2(e2, &triangles[1] ,e1); + + triangles[0].det = -1; // boundary triangles + triangles[1].det = -1; // boundary triangles + + triangles[0].SetSingleVertexToTriangleConnectivity(); + triangles[1].SetSingleVertexToTriangleConnectivity(); + + triangles[0].link=&triangles[1]; + triangles[1].link=&triangles[0]; + + if (!quadtree) delete quadtree; //ReInitialise; + quadtree = new BamgQuadtree(this,0); + quadtree->Add(*v0); + quadtree->Add(*v1); + + // vertices are added one by one + long NbSwap=0; + for (int icount=2; icounti,det3); + quadtree->Add(*vi); + AddVertex(*vi,tcvi,det3); + NbSwap += vi->Optim(1,1); + } + + //enforce the boundary + AdjacentTriangle ta(0,0); + long nbloss = 0,knbe=0; + for ( i = 0; i < nbe; i++){ + if (st[i] >=0){ //edge alone => on border + BamgVertex &a=edges[i][0], &b=edges[i][1]; + if (a.t && b.t){ + knbe++; + if (ForceEdge(a,b,ta)<0) nbloss++; + } + } + } + if(nbloss) { + _error_("we lost " << nbloss << " existing edges other " << knbe); + } + + FindSubDomain(1); + // remove all the hole + // remove all the good sub domain + long krm =0; + for (i=0;iSortAndAdd(v0?GetId(v0):nbv,v1? GetId(v1):nbv); + + _assert_(st[k]>=0); + tta.SetAdj2(ja,savetriangles + st[k] / 3,(int) (st[k]%3)); + ta.SetLock(); + st[k]=-2-st[k]; + } + } + } + } + long NbTfillHoll =0; + for (i=0;i=0) { + savetriangles[savenbt]=triangles[i]; + savetriangles[savenbt].link=0; + savenbt++; + } + } + // gestion of the adj + k =0; + Triangle * tmax = triangles + nbt; + for (i=0;i= triangles && ta < tmax){ + ta= savetriangles + ta->color; + ti.SetAdj2(j,ta,aa); + if(lck) ti.SetLocked(j); + } + } + } + + // restore triangles; + nbt=savenbt; + maxnbt=savemaxnbt; + delete [] triangles; + delete [] subdomains; + triangles = savetriangles; + subdomains = savesubdomains; + if (k) { + _error_("number of triangles edges alone = " << k); + } + FindSubDomain(); + + delete edge4; + delete [] st; + for (i=0;iAdd(vertices[i]); + + SetVertexFieldOn(); + + /*Check requirements consistency*/ + for (i=0;iIsRequiredVertex()){ + _printLine_("ReconstructExistingMesh error message: problem with the edge number " << i+1 << ": [" << GetId(edges[i][0])+1 << " " << GetId(edges[i][1])+1 << "]"); + _printLine_("This edge is on geometrical edge number " << Gh.GetId(edges[i].GeomEdgeHook)+1); + if (edges[i][j].GeomEdgeHook->OnGeomVertex()) + _printLine_("the vertex number " << GetId(edges[i][j])+1 << " of this edge is a geometric BamgVertex number " << Gh.GetId(edges[i][j].GeomEdgeHook->gv)+1); + else if (edges[i][j].GeomEdgeHook->OnGeomEdge()) + _printLine_("the vertex number " << GetId(edges[i][j])+1 << " of this edge is a geometric Edge number " << Gh.GetId(edges[i][j].GeomEdgeHook->ge)+1); + else + _printLine_("Its pointer is " << edges[i][j].GeomEdgeHook); + + _printLine_("This edge is on geometry and has no adjacent edge (open curve) and one of the tip is not required"); + _error_("See above (might be cryptic...)"); + } + } + } + } + } +} +/*}}}*/ + /*FUNCTION Mesh::TrianglesRenumberBySubDomain{{{*/ + void Mesh::TrianglesRenumberBySubDomain(bool justcompress){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/ReNumberingTheTriangleBySubDomain)*/ + + long int verbose=0; + long *renu= new long[nbt]; + register Triangle *t0,*t,*te=triangles+nbt; + register long k=0,it,i,j; + + for ( it=0;it= nbt ){ + _error_("kt<0 || kt >= nbt"); + } + if (renu[kt]!=-1){ + _error_("renu[kt]!=-1"); + } + renu[kt]=k++; + } + while (t0 != (t=t->link)); + } + // take is same numbering if possible + if(justcompress) + for ( k=0,it=0;it=0 ) + renu[it]=k++; + + // put the outside triangles at the end + for ( it=0;it= 0) // a new sub cycle + { + i=it; + Triangle ti=triangles[i],tj; + while ( (j=renu[i]) >= 0) + { // i is old, and j is new + renu[i] = -1; // mark + tj = triangles[j]; // save new + triangles[j]= ti; // new <- old + i=j; // next + ti = tj; + } + } + delete [] renu; + + } + /*}}}*/ + /*FUNCTION Mesh::VerticesRenumber{{{*/ + void Mesh::VerticesRenumber(long * renu) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/ReNumberingVertex)*/ + + // warning be carfull because pointer + // from on mesh to over mesh + // -- so do ReNumbering at the beginning + BamgVertex * ve = vertices+nbv; + long it,ie,i; + + _printLine_("renumbering triangles"); + for ( it=0;it=vertices && v < ve) + VerticesOnGeomVertex[i].meshvertex=vertices+renu[GetId(v)]; + } + + _printLine_("renumbering vertices on edge"); + for (i=0;i< NbVerticesOnGeomEdge;i++) + { + BamgVertex *v =VerticesOnGeomEdge[i].meshvertex; + if (v>=vertices && v < ve) + VerticesOnGeomEdge[i].meshvertex=vertices+renu[GetId(v)]; + } + + _printLine_("renumbering vertices on Bth vertex"); + for (i=0;i< NbVertexOnBThVertex;i++) + { + BamgVertex *v=VertexOnBThVertex[i].v; + if (v>=vertices && v < ve) + VertexOnBThVertex[i].v=vertices+renu[GetId(v)]; + } + + for (i=0;i< NbVertexOnBThEdge;i++) + { + BamgVertex *v=VertexOnBThEdge[i].v; + if (v>=vertices && v < ve) + VertexOnBThEdge[i].v=vertices+renu[GetId(v)]; + } + + // move the Vertices without a copy of the array + // be carefull not trivial code + long j; + for ( it=0;it= 0) // a new sub cycle + { + i=it; + BamgVertex ti=vertices[i],tj; + while ( (j=renu[i]) >= 0){ + // i is old, and j is new + renu[i] = -1-renu[i]; // mark + tj = vertices[j]; // save new + vertices[j]= ti; // new <- old + i=j; // next + ti = tj; + } + } + if (quadtree){ + delete quadtree; + quadtree = new BamgQuadtree(this); + } + + for ( it=0;it (BAMG v1.01, Mesh2.cpp/SetIntCoor)*/ + + /*Set integer coordinate for existing vertices*/ + + //Get extrema coordinates of the existing vertices + pmin = vertices[0].r; + pmax = vertices[0].r; + long i; + for (i=0;i*/ + + const double sqrt32=sqrt(3.)*0.5; + const double aireKh=sqrt32*0.5; + D2 Beq(1,0),Heq(0.5,sqrt32); + D2xD2 Br(D2xD2(Beq,Heq).t()); + D2xD2 B1r(Br.inv()); + double gammamn=1e100,hmin=1e100; + double gammamx=0,hmax=0; + double beta=1e100; + double beta0=0; + double alpha2=0; + double area=0,Marea=0; + // double cf= double(coefIcoor); + // double cf2= 6.*cf*cf; + int nt=0; + for (int it=0;it (BAMG v1.01, Mesh2.cpp/SmoothingVertex)*/ + + long int verbose=0; + // if quatree exist remove it end reconstruct + if (quadtree) delete quadtree; + quadtree=0; + CreateSingleVertexToTriangleConnectivity(); + Triangle vide; // a triangle to mark the boundary vertex + Triangle ** tstart= new Triangle* [nbv]; + long i,j,k; + // attention si Background == Triangle alors on ne peut pas utiliser la rechech rapide + if ( this == & BTh) + for ( i=0;i2) _printLine_(" SmoothingVertex: nb Iteration = " << nbiter << ", Omega=" << omega); + for (k=0;k3) _printLine_(" move max = " << pow(delta,0.5) << ", iteration = " << k << ", nb of swap = " << NbSwap); + } + + delete [] tstart; + if (quadtree) quadtree= new BamgQuadtree(this); +} +/*}}}*/ +/*FUNCTION Mesh::SmoothMetric{{{*/ +void Mesh::SmoothMetric(double raisonmax) { + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/SmoothMetric)*/ + + long int verbose=0; + + if(raisonmax<1.1) return; + if(verbose > 1) _printLine_(" Mesh::SmoothMetric raisonmax = " << raisonmax); + CreateSingleVertexToTriangleConnectivity(); + long i,j,kch,kk,ip; + long *first_np_or_next_t0 = new long[nbv]; + long *first_np_or_next_t1 = new long[nbv]; + long Head0 =0,Head1=-1; + double logseuil= log(raisonmax); + + for(i=0;i=0&& kk++<100) { + kch=0; + for (i=Head0;i>=0;i=first_np_or_next_t0[ip=i],first_np_or_next_t0[ip]=-1) { + // pour tous les triangles autour du sommet s + register Triangle* t= vertices[i].t; + if (!t){ + _error_("!t"); + } + BamgVertex & vi = vertices[i]; + AdjacentTriangle ta(t,EdgesVertexTriangle[vertices[i].IndexInTriangle][0]); + BamgVertex *pvj0 = ta.EdgeVertex(0); + while (1) { + ta=Previous(Adj(ta)); + if (vertices+i != ta.EdgeVertex(1)){ + _error_("vertices+i != ta.EdgeVertex(1)"); + } + BamgVertex & vj = *(ta.EdgeVertex(0)); + if ( &vj ) { + j= &vj-vertices; + if (j<0 || j >= nbv){ + _error_("j<0 || j >= nbv"); + } + R2 Aij = (R2) vj - (R2) vi; + double ll = Norme2(Aij); + if (0) { + double hi = ll/vi.m(Aij); + double hj = ll/vj.m(Aij); + if(hi < hj) + { + double dh=(hj-hi)/ll; + if (dh>logseuil) { + vj.m.IntersectWith(vi.m/(1 +logseuil*ll/hi)); + if(first_np_or_next_t1[j]<0) + kch++,first_np_or_next_t1[j]=Head1,Head1=j; + } + } + } + else + { + double li = vi.m(Aij); + if( vj.m.IntersectWith(vi.m/(1 +logseuil*li)) ) + if(first_np_or_next_t1[j]<0) // if the metrix change + kch++,first_np_or_next_t1[j]=Head1,Head1=j; + } + } + if ( &vj == pvj0 ) break; + } + } + Head0 = Head1; + Head1 = -1; + Exchange(first_np_or_next_t0,first_np_or_next_t1); + } + if(verbose>2) _printLine_(" number of iterations = " << kch); + delete [] first_np_or_next_t0; + delete [] first_np_or_next_t1; +} +/*}}}*/ + /*FUNCTION Mesh::SplitElement{{{*/ + int Mesh::SplitElement(int choice){ + /*Original code from Frederic Hecht (BAMG v1.01, MeshQuad.cpp/SplitElement)*/ + + long int verbose=0; + + Direction NoDirOfSearch; + const int withBackground = &BTh != this && &BTh; + + TrianglesRenumberBySubDomain(); + //int nswap =0; + const long nfortria( choice ? 4 : 6); + if(withBackground) + { + BTh.SetVertexFieldOn(); + SetVertexFieldOnBTh(); + } + else + BTh.SetVertexFieldOn(); + + long newnbt=0,newnbv=0; + long * kedge = 0; + long newnbq=nbq; + long * ksplit= 0, * ksplitarray=0; + long kkk=0; + int ret =0; + if (maxnbvSortAndAdd(GetId(edges[i][0]),GetId(edges[i][1]))); + if (ong) // a geometrical edges + { + if (withBackground){ + // walk on back ground mesh + // newVertexOnBThEdge[ibe++] = VertexOnEdge(vertices[k],bedge,absicsseonBedge); + // a faire -- difficile + // the first PB is to now a background edge between the 2 vertices + if (!edgesGtoB){ + _error_("!edgesGtoB"); + } + ong= ProjectOnCurve(*edgesGtoB[Gh.GetId(edges[i].GeomEdgeHook)], + edges[i][0],edges[i][1],0.5,vertices[k], + newVertexOnBThEdge[kvb], + newVerticesOnGeomEdge[kvg++]); + vertices[k].ReferenceNumber= edges[i].ReferenceNumber; + vertices[k].DirOfSearch = NoDirOfSearch; + ; + // get the Info on background mesh + double s = newVertexOnBThEdge[kvb]; + BamgVertex & bv0 = newVertexOnBThEdge[kvb][0]; + BamgVertex & bv1 = newVertexOnBThEdge[kvb][1]; + // compute the metrix of the new points + vertices[k].m = Metric(1-s,bv0,s,bv1); + kvb++; + } + else + { + ong=Gh.ProjectOnCurve(edges[i], + 0.5,vertices[k],newVerticesOnGeomEdge[kvg++]); + // vertices[k].i = R2ToI2( vertices[k].r); + vertices[k].ReferenceNumber = edges[i].ReferenceNumber; + vertices[k].DirOfSearch = NoDirOfSearch; + vertices[k].m = Metric(0.5,edges[i][0],0.5,edges[i][1]); + } + } + else // straigth line edge --- + { + vertices[k].r = ((R2) edges[i][0] + (R2) edges[i][1] )*0.5; + vertices[k].m = Metric(0.5,edges[i][0],0.5,edges[i][1]); + vertices[k].GeomEdgeHook = 0; + } + //vertices[k].i = R2ToI2( vertices[k].r); + R2 AB = vertices[k].r; + R2 AA = (A+AB)*0.5; + R2 BB = (AB+B)*0.5; + vertices[k].ReferenceNumber = edges[i].ReferenceNumber; + vertices[k].DirOfSearch = NoDirOfSearch; + + newedges[ie].GeomEdgeHook = Gh.Containing(AA,ong); + newedges[ie++].v[1]=vertices+k; + + newedges[ie]=edges[i]; + newedges[ie].adj[0]=newedges + ie -1; + newedges[ie].adj[1]=newedges+(edges[i].adj[1]-edges) ; + newedges[ie].GeomEdgeHook = Gh.Containing(BB,ong); + newedges[ie++].v[0]=vertices+k; + k++; + } + if (edgesGtoB) delete [] edgesGtoB; + edgesGtoB=0; + + newnbv=k; + newNbVerticesOnGeomEdge=kvg; + if (newnbv> maxnbv) goto Error;// bug + + nbv = k; + + kedge = new long[3*nbt+1]; + ksplitarray = new long[nbt+1]; + ksplit = ksplitarray +1; // because ksplit[-1] == ksplitarray[0] + + for (i=0;i<3*nbt;i++) + kedge[i]=-1; + + // + + for (i=0;i= lastT) + t.SetAdj2(j,0,0);// unset adj + const BamgVertex & v0 = t[VerticesOfTriangularEdge[j][0]]; + const BamgVertex & v1 = t[VerticesOfTriangularEdge[j][1]]; + long ke =edge4->SortAndFind(GetId(v0),GetId(v1)); + if (ke>0) + { + long ii = GetId(tt); + int jj = ta; + long ks = ke + nbvold; + kedge[3*i+j] = ks; + if (ii=0){ + // warning PB roundoff error + if (t.link && ( (aa=Area2( A.r , t[1].r , t[2].r )) < 0.0 + || (bb=Area2( t[0].r , A.r , t[2].r )) < 0.0 + || (cc=Area2( t[0].r , t[1].r , A.r )) < 0.0)){ + _printLine_(ke + nbvold << " not in triangle " << i << " In= " << !!t.link << " " << aa << " " << bb << " " << cc << " " << dd); + _error_("Number of triangles with P2 interpolation Problem"); + } + } + else { + if (tt.link && ( (aa=Area2( A.r , tt[1].r , tt[2].r )) < 0 + || (bb=Area2( tt[0].r , A.r , tt[2].r )) < 0 + || (cc=Area2( tt[0].r , tt[1].r , A.r )) < 0)){ + _printLine_(ke + nbvold << " not in triangle " << ii << " In= " << !!tt.link << " " << aa << " " << bb << " " << cc << " " << dd); + _error_("Number of triangles with P2 interpolation Problem"); + } + } + } + } + } + + for (i=0;iSortAndFind(GetId(v0),GetId(v1)); + if (ke<0) // new + { + if (&tt) // internal triangles all the boundary + { // new internal edges + long ii = GetId(tt); + int jj = ta; + + kedge[3*i+j]=k;// save the vertex number + kedge[3*ii+jj]=k; + if (k=0 + kedge[3*i+j]=nbvold+ke; + kkk[nbsplitedge++]=j;// previously splited + } + } + else + kkk[nbsplitedge++]=j;// previously splited + + } + if (nbinvisible>=2){ + _error_("nbinvisible>=2"); + } + switch (nbsplitedge) { + case 0: ksplit[i]=10; newnbt++; break; // nosplit + case 1: ksplit[i]=20+kkk[0];newnbt += 2; break; // split in 2 + case 2: ksplit[i]=30+3-kkk[0]-kkk[1];newnbt += 3; break; // split in 3 + case 3: + if (nbinvisible) ksplit[i]=40+invisibleedge,newnbt += 4; + else ksplit[i]=10*nfortria,newnbt+=nfortria; + break; + } + if (ksplit[i]<40){ + _error_("ksplit[i]<40"); + } + } + // now do the element split + newnbq = 4*nbq; + nbv = k; + kkk = nbt; + ksplit[-1] = nbt; + // look on old true triangles + + for (i=0;i=7 || kk<=0){ + _error_("kk>=7 || kk<=0"); + } + + // def the numbering k (edge) i vertex + int k0 = ke; + int k1 = NextEdge[k0]; + int k2 = PreviousEdge[k0]; + int i0 = OppositeVertex[k0]; + int i1 = OppositeVertex[k1]; + int i2 = OppositeVertex[k2]; + + Triangle &t0=triangles[i]; + BamgVertex * v0=t0(i0); + BamgVertex * v1=t0(i1); + BamgVertex * v2=t0(i2); + + if (nbmkadj>=10){ + _error_("nbmkadj>=10"); + } + // -------------------------- + AdjacentTriangle ta0(t0.Adj(i0)),ta1(t0.Adj(i1)),ta2(t0.Adj(i2)); + // save the flag Hidden + int hid[]={t0.Hidden(0),t0.Hidden(1),t0.Hidden(2)}; + // un set all adj -- save Hidden flag -- + t0.SetAdj2(0,0,hid[0]); + t0.SetAdj2(1,0,hid[1]); + t0.SetAdj2(2,0,hid[2]); + // -- remake + switch (kk) { + case 1: break;// nothing + case 2: // + { + Triangle &t1=triangles[kkk++]; + t1=t0; + if (kedge[3*i+i0]<0){ + _error_("kedge[3*i+i0]<0"); + } + BamgVertex * v3 = vertices + kedge[3*i+k0]; + + t0(i2) = v3; + t1(i1) = v3; + t0.SetAllFlag(k2,0); + t1.SetAllFlag(k1,0); + } + break; + case 3: // + { + Triangle &t1=triangles[kkk++]; + Triangle &t2=triangles[kkk++]; + t2=t1=t0; + if (kedge[3*i+k1]<0){ + _error_("kedge[3*i+k1]<0"); + } + if (kedge[3*i+k2]<0){ + _error_("kedge[3*i+k2]<0"); + } + + BamgVertex * v01 = vertices + kedge[3*i+k2]; + BamgVertex * v02 = vertices + kedge[3*i+k1]; + t0(i1) = v01; + t0(i2) = v02; + t1(i2) = v02; + t1(i0) = v01; + t2(i0) = v02; + t0.SetAllFlag(k0,0); + t1.SetAllFlag(k1,0); + t1.SetAllFlag(k0,0); + t2.SetAllFlag(k2,0); + } + break; + case 4: // + case 6: // split in 4 + { + Triangle &t1=triangles[kkk++]; + Triangle &t2=triangles[kkk++]; + Triangle &t3=triangles[kkk++]; + t3=t2=t1=t0; + if (kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0){ + _error_("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0"); + } + BamgVertex * v12 = vertices + kedge[3*i+k0]; + BamgVertex * v02 = vertices + kedge[3*i+k1]; + BamgVertex * v01 = vertices + kedge[3*i+k2]; + t0(i1) = v01; + t0(i2) = v02; + t0.SetAllFlag(k0,hid[k0]); + + t1(i0) = v01; + t1(i2) = v12; + t0.SetAllFlag(k1,hid[k1]); + + t2(i0) = v02; + t2(i1) = v12; + t2.SetAllFlag(k2,hid[k2]); + + t3(i0) = v12; + t3(i1) = v02; + t3(i2) = v01; + + t3.SetAllFlag(0,hid[0]); + t3.SetAllFlag(1,hid[1]); + t3.SetAllFlag(2,hid[2]); + + if ( kk == 6) + { + + Triangle &t4=triangles[kkk++]; + Triangle &t5=triangles[kkk++]; + + t4 = t3; + t5 = t3; + + t0.SetHidden(k0); + t1.SetHidden(k1); + t2.SetHidden(k2); + t3.SetHidden(0); + t4.SetHidden(1); + t5.SetHidden(2); + + if (nbv < maxnbv ) + { + vertices[nbv].r = ((R2) *v01 + (R2) *v12 + (R2) *v02 ) / 3.0; + vertices[nbv].ReferenceNumber =0; + vertices[nbv].DirOfSearch =NoDirOfSearch; + //vertices[nbv].i = R2ToI2(vertices[nbv].r); + double a3[]={1./3.,1./3.,1./3.}; + vertices[nbv].m = Metric(a3,v0->m,v1->m,v2->m); + BamgVertex * vc = vertices +nbv++; + t3(i0) = vc; + t4(i1) = vc; + t5(i2) = vc; + + } + else + goto Error; + } + + } + break; + } + + // save all the new triangles + mkadj[nbmkadj++]=i; + long jj; + if (t0.link) + for (jj=nbt;jj13){// 13 = 6 + 4 + + _error_("nbmkadj>13"); + } + + if (kk==6) newnbq+=3; + for (jj=ksplit[i-1];jj= maxnbt) goto Error; // bug + if (nbv>= maxnbv) goto Error; // bug + // generation of the new triangles + + SetIntCoor("In SplitElement"); + + CreateSingleVertexToTriangleConnectivity(); + if(withBackground) + BTh.CreateSingleVertexToTriangleConnectivity(); + + delete [] edges; + edges = newedges; + nbe = newnbe; + nbq = newnbq; + + for (i=0;i2){ + _printLine_(" number of quadrilaterals = " << nbq); + _printLine_(" number of triangles = " << nbt-nbtout- nbq*2); + _printLine_(" number of outside triangles = " << nbtout); + } + + return 0; //ok + +Error: + nbv = nbvold; + nbt = nbtold; + nbtout = nbtoutold; + // cleaning memory --- + delete [] newedges; + if (ksplitarray) delete [] ksplitarray; + if (kedge) delete [] kedge; + if (newVerticesOnGeomEdge) delete [] newVerticesOnGeomEdge; + if (edge4) delete edge4; + if(newVertexOnBThEdge) delete [] newVertexOnBThEdge; + + return ret; // ok + } + /*}}}*/ +/*FUNCTION Mesh::SplitInternalEdgeWithBorderVertices{{{*/ +long Mesh::SplitInternalEdgeWithBorderVertices(){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/SplitInternalEdgeWithBorderVertices)*/ + + long NbSplitEdge=0; + SetVertexFieldOn(); + long it; + long nbvold=nbv; + long int verbose=2; + for (it=0;itlink) { + _printLine_("problem inserting point in SplitInternalEdgeWithBorderVertices (tcvj && !tcvj->link)"); + } + + quadtree->Add(vi); + if (!tcvi || tcvi->det<0){// internal + _error_("!tcvi || tcvi->det < 0"); + } + AddVertex(vi,tcvi,det3); + NbSwap += vi.Optim(1); + iv++; + } + if (verbose>3) { + _printLine_(" number of points: " << iv); + _printLine_(" number of swap to split internal edges with border vertices: " << NbSwap); + nbv = iv; + } + } + if (NbSplitEdge>nbv-nbvold) _printLine_("WARNING: not enough vertices to split all internal edges, we lost " << NbSplitEdge - ( nbv-nbvold) << " edges..."); + if (verbose>2) _printLine_("SplitInternalEdgeWithBorderVertices: Number of splited edge " << NbSplitEdge); + + return NbSplitEdge; +} +/*}}}*/ +/*FUNCTION Mesh::ToI2{{{*/ +I2 Mesh::R2ToI2(const R2 & P) const { + return I2( (Icoor1) (coefIcoor*(P.x-pmin.x)),(Icoor1) (coefIcoor*(P.y-pmin.y)) ); +} +/*}}}*/ +/*FUNCTION Mesh::ToR2{{{*/ +R2 Mesh::I2ToR2(const I2 & P) const { + return R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y); +} +/*}}}*/ +/*FUNCTION Mesh::TriangleFindFromCoord{{{*/ +Triangle * Mesh::TriangleFindFromCoord(const I2 & B,Icoor2 det3[3], Triangle *tstart) const { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/FindTriangleContening)*/ + + Triangle * t=0; + int j,jp,jn,jj; + int counter; + + /*Get starting triangle. Take tsart if provided*/ + if (tstart) t=tstart; + + /*Else find the closest Triangle using the quadtree*/ + else { + + /*Check that the quadtree does exist*/ + if (!quadtree) _error_("no starting triangle provided and no quadtree available"); + + /*Call NearestVertex*/ + BamgVertex *a = quadtree->NearestVertex(B.x,B.y) ; + + /*Check output (Vertex a)*/ + if (!a) _error_("problem while trying to find nearest vertex from a given point. No output found"); + if (!a->t) _error_("no triangle is associated to vertex number " << GetId(a)+1 << " (orphan?)"); + _assert_(a>=vertices && at; + _assert_(t>=triangles && tdet < 0){ + + /*Get a real vertex from this triangle (k0)*/ + int k0=(*t)(0)?(((*t)(1)?((*t)(2)?-1:2):1)):0; + _assert_(k0>=0);// k0 the NULL vertex + int k1=NextVertex[k0],k2=PreviousVertex[k0]; + det3[k0]=det(B,(*t)[k1],(*t)[k2]); + det3[k1]=det3[k2]=-1; + if (det3[k0] > 0) // outside B + return t; + t = t->TriangleAdj(OppositeEdge[k0]); + counter++; + _assert_(counter<2); + } + + jj=0; + detop = det(*(*t)(VerticesOfTriangularEdge[jj][0]),*(*t)(VerticesOfTriangularEdge[jj][1]),B); + + while(t->det>0) { + + /*Increase counter*/ + if (++counter>=10000) _error_("Maximum number of iteration reached (threshold = " << counter << ")."); + + j= OppositeVertex[jj]; + det3[j] = detop; //det(*b,*s1,*s2); + jn = NextVertex[j]; + jp = PreviousVertex[j]; + det3[jp]= det(*(*t)(j),*(*t)(jn),B); + det3[jn] = t->det-det3[j] -det3[jp]; + + // count the number k of det3 <0 + int k=0,ii[3]; + if (det3[0] < 0 ) ii[k++]=0; + if (det3[1] < 0 ) ii[k++]=1; + if (det3[2] < 0 ) ii[k++]=2; + // 0 => ok + // 1 => go in way 1 + // 2 => two way go in way 1 or 2 randomly + + if (k==0) break; + if (k==2 && BinaryRand()) Exchange(ii[0],ii[1]); + _assert_(k<3); + AdjacentTriangle t1 = t->Adj(jj=ii[0]); + if ((t1.det() < 0 ) && (k == 2)) + t1 = t->Adj(jj=ii[1]); + t=t1; + j=t1;// for optimisation we now the -det[OppositeVertex[j]]; + detop = -det3[OppositeVertex[jj]]; + jj = j; + } + + if (t->det<0) // outside triangle + det3[0]=det3[1]=det3[2]=-1,det3[OppositeVertex[jj]]=detop; + return t; +} +/*}}}*/ +/*FUNCTION Mesh::TriangleIntNumbering{{{*/ +void Mesh::TriangleIntNumbering(long* renumbering){ + + long num=0; + for (int i=0;i0) renumbering[i]=num++; + else renumbering[i]=-1; + } + return; +} +/*}}}*/ +/*FUNCTION Mesh::TriangleReferenceList{{{*/ +long Mesh::TriangleReferenceList(long* reft) const { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/ConsRefTriangle)*/ + + long int verbose=0; + register Triangle *t0,*t; + register long k=0, num; + + //initialize all triangles as -1 (outside) + for (int it=0;it=0 && numlink)); + //stop when all triangles of subdomains have been tagged + + } + return k; +} +/*}}}*/ +/*FUNCTION Mesh::Triangulate{{{*/ +void Mesh::Triangulate(double* x,double* y,int nods){ + + int verbose=0; + int i; + Metric M1(1); + + /*Initialize mesh*/ + Init(nods);//this resets nbv to 0 + nbv=nods; + + //Vertices + if(verbose) _printLine_("Reading vertices (" << nbv << ")"); + for (i=0;i (BAMG v1.01, Mesh2.cpp/GeomToTriangles0)*/ + /*Generate mesh from geometry*/ + + /*Intermediaries*/ + int i,k; + int nbcurves = 0; + int NbNewPoints,NbEdgeCurve; + double lcurve,lstep,s; + const int MaxSubEdge = 10; + + R2 AB; + GeomVertex *a, *b; + BamgVertex *va,*vb; + GeomEdge *e; + + // add a ref to GH to make sure that it is not destroyed by mistake + Gh.NbRef++; + + /*Get options*/ + int verbose=bamgopts->verbose; + + //build background mesh flag (1 if background, else 0) + bool background=(&BTh != this); + + /*Build VerticesOnGeomVertex*/ + + //Compute the number of geometrical vertices that we are going to use to mesh + for (i=0;i= maxnbv) _error_("too many vertices on geometry: " << NbVerticesOnGeomVertex << " >= " << maxnbv); + _assert_(nbv==0); + //Build VerticesOnGeomVertex + for (i=0;ibeginning of a new curve)*/ + if (!ei.Mark() && ei[j].Required()){ + + long nbvend=0; + Edge* PreviousNewEdge=NULL; + lstep = -1; + + /*If Edge is required (do that only once for the 2 vertices)*/ + if(ei.Required()){ + if (j==0){ + //do not create internal points if required (take it as is) + if(step==0) nbe++; + else{ + e=&ei; + a=ei(0); + b=ei(1); + + //check that edges has been allocated + _assert_(edges); + edges[nbe].v[0]=a->MeshVertexHook; + edges[nbe].v[1]=b->MeshVertexHook;; + edges[nbe].ReferenceNumber = e->ReferenceNumber; + edges[nbe].GeomEdgeHook = e; + edges[nbe].adj[0] = 0; + edges[nbe].adj[1] = 0; + nbe++; + } + } + } + + /*If Edge is not required: we are on a curve*/ + else { + for (int kstep=0;kstep<=step;kstep++){ + //kstep=0, compute number of edges (discretize curve) + //kstep=1 create the points and edge + PreviousNewEdge=0; + NbNewPoints=0; + NbEdgeCurve=0; + if (nbvend>=maxnbv) _error_("maximum number of vertices too low! Check the domain outline or increase maxnbv"); + lcurve =0; + s = lstep; //-1 initially, then length of each sub edge + + /*reminder: i = edge number, j=[0;1] vertex index in edge*/ + k=j; // k = vertex index in edge (0 or 1) + e=&ei; // e = reference of current edge + a=ei(k); // a = pointer toward the kth vertex of the current edge + va = a->MeshVertexHook; // va = pointer toward mesh vertex associated + e->SetMark(); // Mark edge + + /*Loop until we reach the end of the curve*/ + for(;;){ + k = 1-k; // other vertx index of the curve + b = (*e)(k); // b = pointer toward the other vertex of the current edge + AB= b->r - a->r; // AB = vector of the current edge + Metric MA = background ? BTh.MetricAt(a->r) :a->m ; //Get metric associated to A + Metric MB = background ? BTh.MetricAt(b->r) :b->m ; //Get metric associated to B + double ledge = (MA(AB) + MB(AB))/2; //Get edge length in metric + + /* We are now creating the mesh edges from the geometrical edge selected above. + * The edge will be divided according to the metric previously computed and cannot + * be divided more than 10 times (MaxSubEdge). */ + + //By default, there is only one subedge that is the geometrical edge itself + int NbSubEdge = 1; + + //initialize lSubEdge, holding the length of each subedge (cannot be higher than 10) + double lSubEdge[MaxSubEdge]; + + //Build Subedges according to the edge length + if (ledge < 1.5){ + //if ledge < 1.5 (between one and 2), take the edge as is + lSubEdge[0] = ledge; + } + //else, divide the edge + else { + //compute number of subedges (division of the edge), Maximum is 10 + NbSubEdge = Min( MaxSubEdge, (int) (ledge +0.5)); + /*Now, we are going to divide the edge according to the metric. + * Get segment by sement along the edge. + * Build lSubEdge, which holds the distance between the first vertex + * of the edge and the next point on the edge according to the + * discretization (each SubEdge is AB)*/ + R2 A,B; + A=a->r; + Metric MAs=MA,MBs; + ledge=0; + double x =0, xstep= 1./NbSubEdge; + for (int kk=0; kk < NbSubEdge; kk++,A=B,MAs=MBs ) { + x += xstep; + B = e->F(k ? x : 1-x); + MBs= background ? BTh.MetricAt(B) : Metric(1-x,MA,x,MB); + AB = A-B; + lSubEdge[kk]=(ledge+=(MAs(AB)+MBs(AB))/2); + } + } + + double lcurveb = lcurve+ledge; + + /*Now, create corresponding points*/ + while(s>=lcurve && s<=lcurveb && nbv1){ + if (ss < (llk=lSubEdge[kkk=(kk0+kk1)/2])) + kk1=kkk,ll1=llk; + else + kk0=kkk,ll0=llk; + } + _assert_(kk1!=kk0); + + /*Curvilinear coordinate in [0 1] of ss in current edge*/ + // WARNING: This is what we would do + // ssa = (ss-ll0)/(ll1-ll0); + // aa = (kk0+ssa)/NbSubEdge + // This is what Bamg does: + double sbb = (ss-ll0)/(ll1-ll0); + /*Curvilinear coordinate in [0 1] of ss in current curve*/ + double bb = (kk1+sbb)/NbSubEdge; + double aa = 1-bb; + + // new vertex on edge + vb = &vertices[nbv++]; + vb->m = Metric(aa,a->m,bb,b->m); + vb->ReferenceNumber = e->ReferenceNumber; + vb->DirOfSearch =NoDirOfSearch; + double abcisse = k ? bb : aa; + vb->r = e->F(abcisse); + VerticesOnGeomEdge[NbVerticesOnGeomEdge++]= VertexOnGeom(*vb,*e,abcisse); + + // to take into account the direction of the edge + s += lstep; + edges[nbe].v[0]=va; + edges[nbe].v[1]=vb; + edges[nbe].ReferenceNumber =e->ReferenceNumber; + edges[nbe].GeomEdgeHook = e; + edges[nbe].adj[0] = PreviousNewEdge; + if(PreviousNewEdge) PreviousNewEdge->adj[1]=&edges[nbe]; + PreviousNewEdge=edges+nbe; + nbe++; + va = vb; + } + + /*We just added one edge to the curve: Go to the next one*/ + lcurve = lcurveb; + e->SetMark(); + a=b; + + /*If b is required, we are on a new curve->break*/ + if (b->Required()) break; + int kprev=k; + k = e->AdjVertexIndex[kprev];// next vertices + e = e->Adj[kprev]; + _assert_(e); + }// for(;;) + vb = b->MeshVertexHook; + + /*Number of edges in the last disretized curve*/ + NbEdgeCurve = Max((long) (lcurve +0.5), (long) 1); + /*Number of internal vertices in the last disretized curve*/ + NbNewPoints = NbEdgeCurve-1; + if(!kstep){ + NbVerticesOnGeomEdge0 += NbNewPoints; + nbcurves++; + } + nbvend=nbv+NbNewPoints; + lstep = lcurve / NbEdgeCurve; //approximately one + }// end of curve -- + if (edges) { // last edges of the curves + edges[nbe].v[0]=va; + edges[nbe].v[1]=vb; + edges[nbe].ReferenceNumber = e->ReferenceNumber; + edges[nbe].GeomEdgeHook = e; + edges[nbe].adj[0] = PreviousNewEdge; + edges[nbe].adj[1] = 0; + if(PreviousNewEdge) PreviousNewEdge->adj[1] = & edges[nbe]; + nbe++; + } + else nbe += NbEdgeCurve; + } // end on curve --- + } + } + } // for (i=0;i4) _printLine_(" -- current number of vertices = " << nbv); + if (verbose>3) _printLine_(" Creating initial Constrained Delaunay Triangulation..."); + if (verbose>3) _printLine_(" Inserting boundary points"); + Insert(); + + //Force the boundary + if (verbose>3) _printLine_(" Forcing boundaries"); + ForceBoundary(); + + //Extract SubDomains + if (verbose>3) _printLine_(" Extracting subdomains"); + FindSubDomain(); + + if (verbose>3) _printLine_(" Inserting internal points"); + NewPoints(*this,bamgopts,0) ; + if (verbose>4) _printLine_(" -- current number of vertices = " << nbv); + } + /*}}}*/ + /*FUNCTION Mesh::TriangulateFromGeom1{{{*/ + void Mesh::TriangulateFromGeom1(BamgOpts* bamgopts,int KeepVertices){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/GeomToTriangles1)*/ + + /*Get options*/ + int verbose=bamgopts->verbose; + + Gh.NbRef++;// add a ref to Gh + + /************************************************************************* + * method in 2 steps + * 1 - compute the number of new edges to allocate + * 2 - construct the edges + * remark: + * in this part we suppose to have a background mesh with the same geometry + * + * To construct the discretization of the new mesh we have to + * rediscretize the boundary of background Mesh + * because we have only the pointeur from the background mesh to the geometry. + * We need the abcisse of the background mesh vertices on geometry + * so a vertex is + * 0 on GeomVertex ; + * 1 on GeomEdge + abcisse + * 2 internal + *************************************************************************/ + + //Check that background mesh and current mesh do have the same geometry + _assert_(&BTh.Gh==&Gh); + BTh.NbRef++; // add a ref to BackGround Mesh + + //Initialize new mesh + BTh.SetVertexFieldOn(); + int* bcurve = new int[Gh.nbcurves]; // + + /* There are 2 ways to make the loop + * 1) on the geometry + * 2) on the background mesh + * if you do the loop on geometry, we don't have the pointeur on background, + * and if you do the loop in background we have the pointeur on geometry + * so do the walk on background */ + + NbVerticesOnGeomVertex=0; + NbVerticesOnGeomEdge=0; + + /*STEP 1 copy of Required vertices*/ + + int i; + for (i=0;i= maxnbv){ + _error_("too many vertices on geometry: " << NbVerticesOnGeomVertex << " >= " << maxnbv); + } + + VerticesOnGeomVertex = new VertexOnGeom[ NbVerticesOnGeomVertex]; + VertexOnBThVertex = new VertexOnVertex[NbVerticesOnGeomVertex]; + + //At this point there is NO vertex but vertices should have been allocated by Init + _assert_(vertices); + for (i=0;i Th + VerticesOnGeomVertex[nbv]= VertexOnGeom(vertices[nbv],Gh[i]); + nbv++; + } + else Gh[i].MeshVertexHook=0; + } + for (i=0;iMeshVertexHook); // use of Geom -> Th + VertexOnBThVertex[NbVertexOnBThVertex++]=VertexOnVertex(gv->MeshVertexHook,bv); + gv->MeshVertexHook->m = bv->m; // for taking the metric of the background mesh + } + } + _assert_(NbVertexOnBThVertex==NbVerticesOnGeomVertex); /*This might be due to MaxCornerAngle too small*/ + + /*STEP 2: reseed boundary edges*/ + + // find the begining of the curve in BTh + Gh.UnMarkEdges(); + int bfind=0; + for (int i=0;iIsRequiredVertex()){ + + /*Get curve number*/ + int nc=ei.GeomEdgeHook->CurveNumber; + + //_printLine_("Dealing with curve number " << nc); + //_printLine_("edge on geometry is same as GhCurve? " << (ei.GeomEdgeHook==Gh.curves[nc].FirstEdge || ei.GeomEdgeHook==Gh.curves[nc].LastEdge)?"yes":"no"); + //if(ei.GeomEdgeHook==Gh.curves[nc].FirstEdge || ei.GeomEdgeHook==Gh.curves[nc].LastEdge){ + // _printLine_("Do we have the right extremity? curve first vertex -> " << ((GeomVertex *)*ei[je].GeomEdgeHook==&(*Gh.curves[nc].FirstEdge)[Gh.curves[nc].FirstVertexIndex])?"yes":"no"); + // _printLine_("Do we have the right extremity? curve last vertex -> " << ((GeomVertex *)*ei[je].GeomEdgeHook==&(*Gh.curves[nc].LastEdge)[Gh.curves[nc].LastVertexIndex])?"yes":"no"); + //} + //BUG FIX from original bamg + /*Check that we are on the same edge and right vertex (0 or 1) */ + if(ei.GeomEdgeHook==Gh.curves[nc].FirstEdge && (GeomVertex *)*ei[je].GeomEdgeHook==&(*Gh.curves[nc].FirstEdge)[Gh.curves[nc].FirstVertexIndex]){ + bcurve[nc]=iedge*2+je; + bfind++; + } + else if ((ei.GeomEdgeHook==Gh.curves[nc].LastEdge && (GeomVertex *)*ei[je].GeomEdgeHook==&(*Gh.curves[nc].LastEdge)[Gh.curves[nc].LastVertexIndex]) && bcurve[nc]==-1){ + bcurve[nc]=iedge*2+je; + bfind++; + } + } + } + } + if (bfind!=Gh.nbcurves){ + delete [] bcurve; + _error_("problem generating number of curves (" << Gh.nbcurves << " found in the geometry but " << bfind << " curve found in the mesh)"); + } + + // method in 2 + 1 step + // 0.0) compute the length and the number of vertex to do allocation + // 1.0) recompute the length + // 1.1) compute the vertex + + long nbex=0,NbVerticesOnGeomEdgex=0; + for (int step=0; step <2;step++){ + + long NbOfNewPoints=0; + long NbOfNewEdge=0; + long iedge; + Gh.UnMarkEdges(); + double L=0; + + /*Go through all geometrical curve*/ + for (int icurve=0;icurveGeomEdgeHook; + + double sNew=Lstep;// abscisse of the new points (phase==1) + L=0;// length of the curve + long i=0;// index of new points on the curve + register GeomVertex * GA0 = *(*peequi)[k0equi].GeomEdgeHook; + BamgVertex *A0; + A0 = GA0->MeshVertexHook; // the vertex in new mesh + BamgVertex *A1; + VertexOnGeom *GA1; + Edge* PreviousNewEdge = 0; + + // New Curve phase + _assert_(A0-vertices>=0 && A0-verticesRequired()){ + GeomVertex *GA1 = *(*peequi)[1-k0equi].GeomEdgeHook; + A1 = GA1->MeshVertexHook; // + } + else { + for(;;){ + Edge &ee=*pe; + Edge &eeequi=*peequi; + k1 = 1-k0; // next vertex of the edge + k1equi= 1 - k0equi; + _assert_(pe && ee.GeomEdgeHook); + ee.GeomEdgeHook->SetMark(); + BamgVertex & v0=ee[0], & v1=ee[1]; + R2 AB=(R2)v1-(R2)v0; + double L0=L,LAB; + LAB=LengthInterpole(v0.m,v1.m,AB); + L+= LAB; + + if (phase){ + // computation of the new points for the given curve + while ((i!=NbCreatePointOnCurve) && sNew<=L) { + + //some checks + _assert_(sNew>=L0); + _assert_(LAB); + _assert_(vertices && nbv=1.000000001){ + _error_("Problem creating point on a boundary: se=" << se << " should be in [0 1]"); + } + se = abscisseInterpole(v0.m,v1.m,AB,se,1); + if (se<0 || se>1){ + _error_("Problem creating point on a boundary: se=" << se << " should be in [0 1]"); + } + se = k1 ? se : 1. - se; + se = k1==k1equi ? se : 1. - se; + VertexOnBThEdge[NbVerticesOnGeomEdge++] = VertexOnEdge(A1,&eeequi,se); // save + ongequi=Gh.ProjectOnCurve(eeequi,se,*A1,*GA1); + A1->ReferenceNumber = eeequi.ReferenceNumber; + A1->DirOfSearch =NoDirOfSearch; + e->GeomEdgeHook = ongequi; + e->v[0]=A0; + e->v[1]=A1; + e->ReferenceNumber = eeequi.ReferenceNumber; + e->adj[0]=PreviousNewEdge; + + if (PreviousNewEdge) PreviousNewEdge->adj[1]=e; + PreviousNewEdge=e; + A0=A1; + sNew += Lstep; + if (++i== NbCreatePointOnCurve) break; + } + } + + //some checks + _assert_(ee.GeomEdgeHook->CurveNumber==ei.GeomEdgeHook->CurveNumber); + if (ee[k1].GeomEdgeHook->IsRequiredVertex()) { + _assert_(eeequi[k1equi].GeomEdgeHook->IsRequiredVertex()); + register GeomVertex * GA1 = *eeequi[k1equi].GeomEdgeHook; + A1=GA1->MeshVertexHook;// the vertex in new mesh + _assert_(A1-vertices>=0 && A1-vertices= " << maxnbv); + } + edges = new Edge[NbOfNewEdge]; + nbex = NbOfNewEdge; + if(NbOfNewPoints) { + VerticesOnGeomEdge = new VertexOnGeom[NbOfNewPoints]; + NbVertexOnBThEdge = NbOfNewPoints; + VertexOnBThEdge = new VertexOnEdge[NbOfNewPoints]; + NbVerticesOnGeomEdgex = NbOfNewPoints; + } + NbOfNewPoints =0; + NbOfNewEdge = 0; + } + } + _assert_(nbe!=0); + delete [] bcurve; + + //Insert points inside existing triangles + if (verbose>4) _printLine_(" -- current number of vertices = " << nbv); + if (verbose>3) _printLine_(" Creating initial Constrained Delaunay Triangulation..."); + if (verbose>3) _printLine_(" Inserting boundary points"); + Insert(); + + //Force the boundary + if (verbose>3) _printLine_(" Forcing boundaries"); + ForceBoundary(); + + //Extract SubDomains + if (verbose>3) _printLine_(" Extracting subdomains"); + FindSubDomain(); + + if (verbose>3) _printLine_(" Inserting internal points"); + NewPoints(BTh,bamgopts,KeepVertices) ; + if (verbose>4) _printLine_(" -- current number of vertices = " << nbv); + } + /*}}}*/ + + /*Intermediary*/ + /*FUNCTION CloseBoundaryEdge{{{*/ + AdjacentTriangle CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdge)*/ + + int k=(*t)(0) ? (( (*t)(1) ? ( (*t)(2) ? -1 : 2) : 1 )) : 0; + int dir=0; + if (k<0){ + _error_("k<0"); + } + int kkk=0; + Icoor2 IJ_IA,IJ_AJ; + AdjacentTriangle edge(t,OppositeEdge[k]); + for (;;edge = dir >0 ? Next(Adj(Next(edge))) : Previous(Adj(Previous(edge)))) { + kkk++; + if (kkk>=1000){ + _error_("kkk>=1000"); + } + BamgVertex &vI = *edge.EdgeVertex(0); + BamgVertex &vJ = *edge.EdgeVertex(1); + I2 I=vI, J=vJ, IJ= J-I; + IJ_IA = (IJ ,(A-I)); + if (IJ_IA<0) { + if (dir>0) {a=1;b=0;return edge;}// change of signe => I + else {dir=-1; + continue;}};// go in direction i + IJ_AJ = (IJ ,(J-A)); + if (IJ_AJ<0) { + if(dir<0) {a=0;b=1;return edge;} + else {dir = 1; + continue;}}// go in direction j + double IJ2 = IJ_IA + IJ_AJ; + if (IJ2==0){ + _error_("IJ2==0"); + } + a= IJ_AJ/IJ2; + b= IJ_IA/IJ2; + return edge; + } + } + /*}}}*/ +/*FUNCTION ForceEdge{{{*/ +int ForceEdge(BamgVertex &a, BamgVertex & b,AdjacentTriangle & taret) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/ForceEdge)*/ + + int NbSwap =0; + if (!a.t || !b.t){ // the 2 vertex is in a mesh + _error_("!a.t || !b.t"); + } + int k=0; + taret=AdjacentTriangle(0,0); // erreur + + AdjacentTriangle tta(a.t,EdgesVertexTriangle[a.IndexInTriangle][0]); + BamgVertex *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2; + // we turn around a in the direct direction + + Icoor2 det2 = v2 ? det(*v2,a,b): -1 , det1; + if(v2) // normal case + det2 = det(*v2,a,b); + else { // no chance infini vertex try the next + tta= Previous(Adj(tta)); + v2 = tta.EdgeVertex(0); + vbegin =v2; + if (!v2){ + _error_("!v2"); + } + det2 = det(*v2,a,b); + } + + while (v2 != &b) { + AdjacentTriangle tc = Previous(Adj(tta)); + v1 = v2; + v2 = tc.EdgeVertex(0); + det1 = det2; + det2 = v2 ? det(*v2,a,b): det2; + + if((det1 < 0) && (det2 >0)) { + // try to force the edge + BamgVertex * va = &a, *vb = &b; + tc = Previous(tc); + if (!v1 || !v2){ + _error_("!v1 || !v2"); + } + Icoor2 detss = 0,l=0,ks; + while ((ks=SwapForForcingEdge( va, vb, tc, detss, det1,det2,NbSwap))) + if(l++ > 10000000) { + _error_("Loop in forcing Egde, nb de swap=" << NbSwap << ", nb of try swap (" << l << ") too big"); + } + BamgVertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1); + if (( aa == &a ) && (bb == &b) || (bb == &a ) && (aa == &b)) { + tc.SetLock(); + a.Optim(1,0); + b.Optim(1,0); + taret = tc; + return NbSwap; + } + else + { + taret = tc; + return -2; // error boundary is crossing + } + } + tta = tc; + k++; + if (k>=2000){ + _error_("k>=2000"); + } + if ( vbegin == v2 ) return -1;// error + } + + tta.SetLock(); + taret=tta; + a.Optim(1,0); + b.Optim(1,0); + return NbSwap; +} +/*}}}*/ +/*FUNCTION swap{{{*/ +void swap(Triangle *t1,short a1, Triangle *t2,short a2, BamgVertex *s1,BamgVertex *s2,Icoor2 det1,Icoor2 det2){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/swap)*/ + // -------------------------------------------------------------- + // short a2=aa[a];// les 2 numero de l arete dans les 2 triangles + // + // sb sb + // / | \ / \ ! + // as1/ | \ /a2 \ ! + // / | \ / t2 \ ! + // s1 /t1 | t2 \s2 --> s1 /___as2___\s2 ! + // \ a1|a2 / \ as1 / + // \ | / \ t1 / + // \ | / as2 \ a1/ + // \ | / \ / + // sa sa + // ------------------------------------------------------------- + int as1 = NextEdge[a1]; + int as2 = NextEdge[a2]; + int ap1 = PreviousEdge[a1]; + int ap2 = PreviousEdge[a2]; + (*t1)(VerticesOfTriangularEdge[a1][1]) = s2 ; // avant sb + (*t2)(VerticesOfTriangularEdge[a2][1]) = s1 ; // avant sa + // mise a jour des 2 adjacences externes + AdjacentTriangle taas1 = t1->Adj(as1), + taas2 = t2->Adj(as2), + tas1(t1,as1), tas2(t2,as2), + ta1(t1,a1),ta2(t2,a2); + // externe haut gauche + taas1.SetAdj2(ta2, taas1.GetAllFlag_UnSwap()); + // externe bas droite + taas2.SetAdj2(ta1, taas2.GetAllFlag_UnSwap()); + // remove the Mark UnMarkSwap + t1->SetUnMarkUnSwap(ap1); + t2->SetUnMarkUnSwap(ap2); + // interne + tas1.SetAdj2(tas2); + + t1->det = det1; + t2->det = det2; + + t1->SetSingleVertexToTriangleConnectivity(); + t2->SetSingleVertexToTriangleConnectivity(); +} // end swap +/*}}}*/ + /*FUNCTION SwapForForcingEdge{{{*/ + int SwapForForcingEdge(BamgVertex * & pva ,BamgVertex * & pvb ,AdjacentTriangle & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/SwapForForcingEdge)*/ + // l'arete ta coupe l'arete pva pvb + // de cas apres le swap sa coupe toujours + // on cherche l'arete suivante + // on suppose que detsa >0 et detsb <0 + // attention la routine echange pva et pvb + + if(tt1.Locked()) return 0; // frontiere croise + + AdjacentTriangle tt2 = Adj(tt1); + Triangle *t1=tt1,*t2=tt2;// les 2 triangles adjacent + short a1=tt1,a2=tt2;// les 2 numero de l arete dans les 2 triangles + if ( a1<0 || a1>=3 ){ + _error_("a1<0 || a1>=3"); + } + + BamgVertex & sa= (* t1)[VerticesOfTriangularEdge[a1][0]]; + BamgVertex & s1= (*t1)[OppositeVertex[a1]]; + BamgVertex & s2= (*t2)[OppositeVertex[a2]]; + + Icoor2 dets2 = det(*pva,*pvb,s2); + Icoor2 det1=t1->det , det2=t2->det ; + Icoor2 detT = det1+det2; + if ((det1<=0 ) || (det2<=0)){ + _error_("(det1<=0 ) || (det2<=0)"); + } + if ( (detsa>=0) || (detsb<=0) ){ // [a,b] cut infinite line va,bb + _error_("(detsa>=0) || (detsb<=0)"); + } + Icoor2 ndet1 = bamg::det(s1,sa,s2); + Icoor2 ndet2 = detT - ndet1; + + int ToSwap =0; //pas de swap + if ((ndet1 >0) && (ndet2 >0)) + { // on peut swaper + if ((dets1 <=0 && dets2 <=0) || (dets2 >=0 && detsb >=0)) + ToSwap =1; + else // swap alleatoire + if (BinaryRand()) + ToSwap =2; + } + if (ToSwap) NbSwap++, + bamg::swap(t1,a1,t2,a2,&s1,&s2,ndet1,ndet2); + + int ret=1; + + if (dets2 < 0) {// haut + dets1 = ToSwap ? dets1 : detsa ; + detsa = dets2; + tt1 = Previous(tt2) ;} + else if (dets2 > 0){// bas + dets1 = ToSwap ? dets1 : detsb ; + detsb = dets2; + //xxxx tt1 = ToSwap ? tt1 : Next(tt2); + if(!ToSwap) tt1 = Next(tt2); + } + else { // changement de direction + ret = -1; + Exchange(pva,pvb); + Exchange(detsa,detsb); + Exchange(dets1,dets2); + Exchange(tt1,tt2); + dets1=-dets1; + dets2=-dets2; + detsa=-detsa; + detsb=-detsb; + + if (ToSwap) + if (dets2 < 0) {// haut + dets1 = (ToSwap ? dets1 : detsa) ; + detsa = dets2; + tt1 = Previous(tt2) ;} + else if (dets2 > 0){// bas + dets1 = (ToSwap ? dets1 : detsb) ; + detsb = dets2; + if(!ToSwap) tt1 = Next(tt2); + } + else {// on a fin ??? + tt1 = Next(tt2); + ret =0;} + + } + return ret; + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/Mesh.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/Mesh.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Mesh.h (revision 15061) @@ -0,0 +1,193 @@ +#ifndef _MESH_H_ +#define _MESH_H_ + +#include "./include.h" +#include "./BamgOpts.h" +#include "./BamgMesh.h" +#include "./BamgGeom.h" +#include "./Triangle.h" +#include "./VertexOnGeom.h" +#include "./VertexOnVertex.h" +#include "./VertexOnEdge.h" +#include "./ListofIntersectionTriangles.h" + +namespace bamg { + + //classes + class Geometry; + class CrackedEdge; + class BamgQuadtree; + class SubDomain; + + class Mesh { + + public: + + Geometry & Gh; // Geometry + Mesh & BTh; // Background Mesh Bth== *this =>no background + BamgVertex *vertices; + Triangle *triangles; + Edge *edges; + BamgQuadtree *quadtree; + BamgVertex **orderedvertices; + SubDomain *subdomains; + long NbRef; // counter of ref on the this class if 0 we can delete + long maxnbv,maxnbt; // nombre max de sommets , de triangles + long nbv,nbt,nbe,nbq; // nb of vertices, of triangles, of edges and quadrilaterals + long nbsubdomains; + long nbtout; // Nb of oudeside triangle + + R2 pmin,pmax; // extrema + double coefIcoor; // coef to integer Icoor1; + ListofIntersectionTriangles lIntTria; + + long NbVerticesOnGeomVertex; + VertexOnGeom *VerticesOnGeomVertex; + long NbVerticesOnGeomEdge; + VertexOnGeom *VerticesOnGeomEdge; + long NbVertexOnBThVertex; + VertexOnVertex *VertexOnBThVertex; + long NbVertexOnBThEdge; + VertexOnEdge *VertexOnBThEdge; + long NbCrackedVertices; + long *CrackedVertices; + long NbCrackedEdges; + CrackedEdge *CrackedEdges; + + //Constructors/Destructors + Mesh(BamgGeom* bamggeom,BamgMesh* bamgmesh,BamgOpts* bamgopts); + Mesh(int* index,double* x,double* y,int nods,int nels);/*MeshConvert*/ + Mesh(double* x,double* y,int nods); /*BamgTriangulate*/ + Mesh(Mesh &,Geometry * pGh=0,Mesh* pBTh=0,long maxnbv_in=0 ); //copy operator + Mesh(const Mesh &,const int *flag,const int *bb,BamgOpts* bamgopts); // truncature + Mesh(long maxnbv,Mesh & BT,BamgOpts* bamgopts,int keepBackVertices=1); + Mesh(long maxnbv,Geometry & G,BamgOpts* bamgopts); + ~Mesh(); + + //Operators + const BamgVertex &operator[](long i) const { return vertices[i]; }; + BamgVertex &operator[](long i) { return vertices[i]; }; + const Triangle &operator()(long i) const { return triangles[i]; }; + Triangle &operator()(long i) { return triangles[i]; }; + + //Methods + void SetIntCoor(const char * from =0); + double MinimalHmin(); + double MaximalHmax(); + I2 R2ToI2(const R2 & P) const; + R2 I2ToR2(const I2 & P) const; + void AddVertex(BamgVertex & s,Triangle * t,Icoor2 * =0) ; + void Insert(); + void Echo(void); + void ForceBoundary(); + void FindSubDomain(int OutSide=0); + long TriangleReferenceList(long*) const; + void TriangleIntNumbering(long* renumbering); + void ShowHistogram() const; + void CrackMesh(BamgOpts* bamgopts); + void ShowRegulaty() const; + void SmoothMetric(double raisonmax) ; + void BoundAnisotropy(double anisomax,double hminaniso= 1e-100) ; + void MaxSubDivision(double maxsubdiv); + Edge** MakeGeomEdgeToEdge(); + long SplitInternalEdgeWithBorderVertices(); + void MakeQuadrangles(double costheta); + int SplitElement(int choice); + void MakeBamgQuadtree(); + void NewPoints(Mesh &,BamgOpts* bamgopts,int KeepVertices=1); + long InsertNewPoints(long nbvold,long & NbTSwap) ; + void TrianglesRenumberBySubDomain(bool justcompress=false); + void VerticesRenumber(long * renu); + void SmoothingVertex(int =3,double=0.3); + Metric MetricAt (const R2 &) const; + GeomEdge* ProjectOnCurve( Edge & AB, BamgVertex & A, BamgVertex & B,double theta, BamgVertex & R,VertexOnEdge & BR,VertexOnGeom & GR); + long GetId(const Triangle & t) const; + long GetId(const Triangle * t) const; + long GetId(const BamgVertex & t) const; + long GetId(const BamgVertex * t) const; + long GetId(const Edge & t) const; + long GetId(const Edge * t) const; + BamgVertex* NearestVertex(Icoor1 i,Icoor1 j) ; + Triangle* TriangleFindFromCoord(const I2 & ,Icoor2 [3],Triangle *tstart=0) const; + void ReadMesh(int* index,double* x,double* y,int nods,int nels); + void ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts); + void WriteMesh(BamgMesh* bamgmesh,BamgOpts* bamgopts); + void ReadMetric(const BamgOpts* bamgopts); + void WriteMetric(BamgOpts* bamgopts); + void WriteIndex(int** pindex,int* pnels); + void AddMetric(BamgOpts* bamgopts); + void BuildMetric0(BamgOpts* bamgopts); + void BuildMetric1(BamgOpts* bamgopts); + void AddGeometryMetric(BamgOpts* bamgopts); + int isCracked() const; + void BuildGeometryFromMesh(BamgOpts* bamgopts=NULL); + void ReconstructExistingMesh(); + + //Inline methods + inline void CreateSingleVertexToTriangleConnectivity(){ + for (int i=0;iAdjVertexIndex[i];on=on->Adj[j]; + } + inline double qualite(const BamgVertex &va,const BamgVertex &vb,const BamgVertex &vc){ + double ret; + I2 ia=va,ib=vb,ic=vc; + I2 ab=ib-ia,bc=ic-ib,ac=ic-ia; + Icoor2 deta=Det(ab,ac); + if (deta <=0) ret = -1; + else { + double a = sqrt((double) (ac,ac)), + b = sqrt((double) (bc,bc)), + c = sqrt((double) (ab,ab)), + p = a+b+c; + double h= Max(Max(a,b),c),ro=deta/p; + ret = ro/h; + } + return ret; + } + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/Metric.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/Metric.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Metric.cpp (revision 15061) @@ -0,0 +1,353 @@ +#include +#include +#include + +#include "Metric.h" +#include "../shared/Exceptions/exceptions.h" +#include "../shared/io/Print/Print.h" + +using namespace std; + +namespace bamg { + + SaveMetricInterpole LastMetricInterpole; + + /*Constructor/Destructor*/ + /*FUNCTION Metric::Metric(double a){{{*/ + Metric::Metric(double a): a11(1/(a*a)),a21(0),a22(1/(a*a)){ + + }/*}}}*/ + /*FUNCTION Metric::Metric(double a,double b,double c){{{*/ + Metric::Metric(double a,double b,double c) :a11(a),a21(b),a22(c){ + + }/*}}}*/ + /*FUNCTION Metric::Metric(const double a[3],const Metric& m0, const Metric& m1,const Metric& m2 ){{{*/ + Metric::Metric(const double a[3],const Metric& m0, const Metric& m1,const Metric& m2 ){ + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/Metric)*/ + + Metric mab(a[0]*m0.a11 + a[1]*m1.a11 + a[2]*m2.a11, + a[0]*m0.a21 + a[1]*m1.a21 + a[2]*m2.a21, + a[0]*m0.a22 + a[1]*m1.a22 + a[2]*m2.a22); + + EigenMetric vab(mab); + + R2 v1(vab.v.x,vab.v.y); + R2 v2(-v1.y,v1.x); + + double h1 = a[0] / m0(v1) + a[1] / m1(v1) + a[2] / m2(v1); + double h2 = a[0] / m0(v2) + a[1] / m1(v2) + a[2] / m2(v2); + + vab.lambda1 = 1 / (h1*h1); + vab.lambda2 = 1 / (h2*h2); + *this = vab; + } + /*}}}*/ + /*FUNCTION Metric::Metric(double a,const Metric& ma, double b,const Metric& mb){{{*/ + Metric::Metric(double a,const Metric& ma, double b,const Metric& mb) { + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/EigenMetric)*/ + + /*Compute metric (linear combination of ma and mb)*/ + Metric mab(a*ma.a11+b*mb.a11,a*ma.a21+b*mb.a21,a*ma.a22+b*mb.a22); + + /*Get Eigen values and vectors*/ + EigenMetric vab(mab); + R2 v1(vab.v.x,vab.v.y); + R2 v2(-v1.y,v1.x); + + /*Modify eigen values (a+b=1)*/ + double h1 = a/ma(v1) + b/mb(v1); + double h2 = a/ma(v2) + b/mb(v2); + vab.lambda1 = 1/(h1*h1); + vab.lambda2 = 1/(h2*h2); + *this=vab; + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION Metric::det{{{*/ + double Metric::det() const { + return a11*a22-a21*a21; + } /*}}}*/ + /*FUNCTION Metric::Echo {{{*/ + void Metric::Echo(void){ + + _printLine_("Metric:"); + _printLine_(" [a11 a21 a22]: [" << a11 << " " << a21 << " " << a22 << "]"); + + return; + } + /*}}}*/ + /*FUNCTION Metric::IntersectWith{{{*/ + int Metric::IntersectWith(const Metric& M2) { + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/IntersectWith)*/ + + /*Get a new metric from an existing metric (M1=this) + * and a new metric given in input M2 using a + * Simultaneous Matrix Reduction: + * If M1 and M2 are 2 metrics, we must build N=M1^-1 M2 (Alauzet2003 p16) + * the eigen vectors of N form a matrix P + * The new metric M = M1 inter M2 is then given by: + * + * -T [ max(lambda1, mu1) 0 ] -1 + * M = P [ ] P + * [ 0 max(lambda2, mu2)] + * + * where lambdai and mui can be computed using Rayleigh formula: + * lambdai = vi' M1 vi + * with vi eigen vectors of N (columns of P) + */ + + int change=0; + Metric &M1=*this; + D2xD2 P; + + //Get P, eigen vectors of N=inv(M1) M2 + SimultaneousMatrixReduction(*this,M2,P); + + //extract the eigen vectors of P (columns) + R2 v1(P.x.x,P.y.x); + R2 v2(P.x.y,P.y.y); + + //compute lambdai mui + double lambda1=M1(v1,v1); + double lambda2=M1(v2,v2); + double mu1=M2(v1,v1); + double mu2=M2(v2,v2); + + //check where any change needs to be done on M1 + if ( lambda1 < mu1 ) change=1,lambda1=mu1; + if ( lambda2 < mu2 ) change=1,lambda2=mu2; + + //update M1 if necessary + if (change) { + D2xD2 invP(P.inv()); + D2xD2 D(lambda1,0,0,lambda2); + D2xD2 M(invP.t()*D*invP); + a11=M.x.x; + a21=0.5*(M.x.y+M.y.x); + a22=M.y.y; + } + return change; + } + /*}}}*/ + /*FUNCTION Metric::mul{{{*/ + R2 Metric::mul(const R2 x)const { + return R2(a11*x.x+a21*x.y,a21*x.x+a22*x.y); + }/*}}}*/ + + /*Intermediary*/ + /*FUNCTION LengthInterpole{{{*/ + double LengthInterpole(const Metric& Ma,const Metric& Mb, R2 AB) { + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/LengthInterpole)*/ + + double k=1./2.; + int level=0; + static int kkk=0; + static Metric Ms1[32],Ms2[32]; + static double lMs1[32],lMs2[32]; + static double K[32]; + double l=0,sss=0; + Ms1[level]=Ma; + Ms2[level]=Mb; + double sa = Ma(AB); + double sb = Mb(AB); + lMs1[level]=sa; + lMs2[level]=sb; + K[level]=k; + level++; + int i=0; + double * L= LastMetricInterpole.L, *S = LastMetricInterpole.S; + double sstop = 0.1; // Max(0.6,(sa+sb)/5000); + while (level) { + level--; + Metric M1=Ms1[level]; + Metric M2=Ms2[level]; + k=K[level]; + double s1= lMs1[level]; + double s2= lMs2[level]; + + double s= (s1+s2)*k; + if( s > sstop && level < 30 && i < 500-level ) { + Metric Mi(0.5,M1,0.5,M2); + double si = Mi(AB); + if( Abs((s1+s2)-(si+si)) > s1*0.001) + { + k=k/2; + // we begin by the end to walk in the correct direction from a to b + // due to the stack + Ms1[level]=Mi; + Ms2[level]=M2; + lMs1[level]=si; + lMs2[level]=s2; + K[level]=k; + level++; + Ms1[level]=M1; + Ms2[level]=Mi; + lMs1[level]=s1; + lMs2[level]=si; + K[level]=k; + level++; + } + else + L[i]= l += s,S[i]=sss+=k,i++; + } + else + L[i]= l += s,S[i]=sss+=k,i++; + } + // warning for optimisation S is in [0:0.5] not in [0:1] + if (i>=512){ + _error_("i>=512"); + } + LastMetricInterpole.lab=l; + LastMetricInterpole.opt=i; + if (i>200 && kkk++<10) _printLine_("WARNING: LengthInterpole: ( i=" << i << " l=" << l << " sss=" << sss << " ) " << sstop); + return l; + } + /*}}}*/ + /*FUNCTION SimultaneousMatrixReduction{{{*/ + void SimultaneousMatrixReduction( Metric M1, Metric M2, D2xD2 &V) { + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/ReductionSimultanee)*/ + + /*In this routine we must return a matrix V that is composed of the + * eigen vectors of N=inv(M1) M2. + * Instead of looking at N directly, we are going to use the fact that + * M1 and M2 are symmetrical, positive definite. + * The eigen values of N are given by solving + * inv(M1) M2 V = lambda V + * which is equivalent to + * M2 V = lambda M1 V + * and we will hence solve + * (M2 - lambda M1) V = 0 + */ + + //M1 and M2 components + double a11=M1.a11,a21=M1.a21,a22=M1.a22; + double b11=M2.a11,b21=M2.a21,b22=M2.a22; + + /*To get the eigen values, we solve the following problem: + * det(M2-lambda M1) = 0 + * (b11 - lambda a11)(b22-lambda a22) - (b21-lambda a21)^2 + * and we have the following trinome: + * a lambda^2 + b lambda + c =0 + * with: + * a = a11 a22 - a21 a21 (=det(M1)) + * b = -a11 b22 -b11 a22 + 2 b21 a21 + * c = b11 b22 - b21 b21 (=det(M2)) + * */ + const double a= a11*a22 - a21*a21; + const double b=-a11*b22 - b11*a22+2*b21*a21; + const double c=-b21*b21 + b11*b22; + const double bb=b*b,ac=a*c; + const double delta= bb-4*ac; + + // first, case of a double root if: + // - all the terms are very small (a??) + // - or : delta is very small + if ( (bb + Abs(ac) < 1.0e-34 ) || (delta < 1.0e-6*bb) ){ + //all vectors are eigen vectors -> choose 1,0 and 0,1 + V= D2xD2(1,0,0,1); + } + + //general case: two distinct roots: lambda1 and lambda2 + else { + + /*Compute eigen values*/ + const double delta2 = sqrt(delta); + double lambda[2]; + lambda[0]= (-b - delta2)/(2*a); + lambda[1]= (-b + delta2)/(2*a); + + /*compute eigen vectors*/ + double vp[2][2]; + double v0,v1,v2; + double s0,s1; + + for(int i=0;i<2;i++){ + /*Now, one must find the eigen vectors. For that we use the + * following property of the inner product + * (Ax,b) = transp(b) Ax = transp(x) transp(A) b + * = (transp(A) b ,x) + * Here we are dealing with A= M2 - lambda M1 which is symmetrical: + * for all (x,y) in R2 + * ((M2 - lambda M1)x,y)=((M2 - lambda M1)y,x) + * If y is in Ker(M2 - lambda M1): + * for all x in R2 + * ((M2 - lambda M1)y,x)=0 + * This shows that: + * Ker(M2 - lambda M1) is orthogonal to Im(M2 - lambda M1) + * To find the eigen vectors, we only have to find two vectors + * of the image and take their perpendicular as long as they are + * not 0. + * To do that, we take (1,0) and (0,1) and take the larger norm*/ + + //compute V = M2 - lambdai M1 + v0 = b11 - lambda[i]*a11; + v1 = b21 - lambda[i]*a21; + v2 = b22 - lambda[i]*a22; + + // compute s1=norm(V(1,0)) and s0=norm(V(0,1)) + s0 = v0*v0 + v1*v1; + s1 = v1*v1 + v2*v2; + + //compute vp1 = (vp1x,vp1y) + if(s1 < s0){ + s0=sqrt(s0); + vp[0][i]= v1/s0; + vp[1][i]= - v0/s0; + } + else{ + s1=sqrt(s1); + vp[0][i]= v2/s1; + vp[1][i]= - v1/s1; + } + } + + //compute V from vp + V=D2xD2(vp[0][0],vp[0][1],vp[1][0],vp[1][1]); + } + } + /*}}}*/ + /*FUNCTION abscisseInterpole{{{*/ + double abscisseInterpole(const Metric& Ma,const Metric& Mb, R2 AB,double s,int optim) { + /*Original code from Frederic Hecht (BAMG v1.01, Metric.cpp/abscisseInterpole)*/ + + if(!optim) LengthInterpole(Ma,Mb,AB); + double l = s* LastMetricInterpole.lab,r; + int j=LastMetricInterpole.opt-1; + + double * L= LastMetricInterpole.L, *S = LastMetricInterpole.S; + // warning for optimisation S is the abcisse in [0:0.5] + // and L is le lenght + if(l<=L[0]){ + r=2*S[0]*l/L[0]; + } + else if (l>=L[j]){ + r=1; + } + else{ + int i=0; + while (j-i>1){ + int k; + k= (i+j)/2; + if(l<=L[k]){ + j=k;// l<=L[j] + } + else{ + i=k; // L[i]1 || r<0){ + _error_("r>1 || r<0"); + } + return r ; + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/Metric.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/Metric.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Metric.h (revision 15061) @@ -0,0 +1,138 @@ +#ifndef _METRIC_H +#define _METRIC_H + +#include "./include.h" +#include "../shared/Bamg/shared.h" +#include "R2.h" +#include + +namespace bamg { + + typedef P2 D2; + typedef P2xP2 D2xD2; + + class Metric; + class EigenMetric; + + class Metric{ + + public: + + //fields + double a11,a21,a22; + + //friends + friend class EigenMetric; + + //functions + Metric():a11(0),a21(0),a22(0){}; + Metric(const EigenMetric&); + Metric(double a); + Metric(double a,double b,double c); + Metric( double a,const Metric& ma, double b,const Metric& mb); + Metric(const double a[3],const Metric& m0,const Metric& m1,const Metric& m2 ); + void Echo(); + R2 mul(const R2 x)const; + double det() const; + int IntersectWith(const Metric& M2); + inline void Box(double &hx,double &hy) const; + + /*The following functions must remain the the header file because it is called before Metric + * is compiled by other classes*/ + R2 Orthogonal(const R2 x){ return R2(-(a21*x.x+a22*x.y),a11*x.x+a21*x.y); } + R2 Orthogonal(const I2 x){ return R2(-(a21*x.x+a22*x.y),a11*x.x+a21*x.y); } + + //operators + Metric operator*(double c) const {double c2=c*c;return Metric(a11*c2,a21*c2,a22*c2);} + Metric operator/(double c) const {double c2=1/(c*c);return Metric(a11*c2,a21*c2,a22*c2);} + operator D2xD2(){ return D2xD2(a11,a21,a21,a22);} + double operator()(R2 x) const { return sqrt(x.x*x.x*a11+2*x.x*x.y*a21+x.y*x.y*a22);}; // length of x in metric sqrt() + double operator()(R2 x,R2 y) const { return x.x*y.x*a11+(x.x*x.y+x.y*y.x)*a21+x.y*y.y*a22;}; + + }; + + class EigenMetric{ + public: + + //fields + double lambda1,lambda2; + D2 v; + + //friends + friend class Metric; + + //functions + EigenMetric(const Metric& ); + EigenMetric(double r1,double r2,const D2& vp1); + void Echo(); + void Abs(); + void pow(double p); + void Min(double a); + void Max(double a); + void Minh(double h); + void Maxh(double h); + void Isotrope(); + double hmin() const; + double hmax() const; + double lmax() const; + double lmin() const; + double Aniso2() const; + double Aniso() const; + void BoundAniso(const double c); + inline void BoundAniso2(const double coef); + + //operators + void operator *=(double coef){ lambda1*=coef;lambda2*=coef;} + }; + + class SaveMetricInterpole { + friend double LengthInterpole(const Metric& Ma,const Metric& Mb, R2 AB); + friend double abscisseInterpole(const Metric& Ma ,const Metric& Mb, R2 ,double s,int optim); + public: + int opt; + double lab; + double L[1024],S[1024]; + }; + + extern SaveMetricInterpole LastMetricInterpole; // for optimization + //Functions + void SimultaneousMatrixReduction( Metric M1, Metric M2,D2xD2 &V); + double LengthInterpole(const Metric& Ma,const Metric& Mb, R2 AB); + double abscisseInterpole(const Metric& Ma,const Metric& Mb, R2 AB,double s,int optim=0); + + //inlines + inline void EigenMetric::BoundAniso2(const double coef){ + if (coef<=1.00000000001){ + if (lambda1 < lambda2) + lambda1 = bamg::Max(lambda1,lambda2*coef); + else + lambda2 = bamg::Max(lambda2,lambda1*coef); + } + else{ //TO BE CHECKED + if (lambda1 > lambda2) + lambda1 = bamg::Min(lambda1,lambda2*coef); + else + lambda2 = bamg::Min(lambda2,lambda1*coef); + } + } + inline Metric::Metric(const EigenMetric& M) { + double v00=M.v.x*M.v.x; + double v11=M.v.y*M.v.y; + double v01=M.v.x*M.v.y; + a11=v00*M.lambda1+v11*M.lambda2; + a21=v01*(M.lambda1-M.lambda2); + a22=v00*M.lambda2+v11*M.lambda1; + } + inline void Metric::Box(double &hx,double &hy) const { + double d= a11*a22-a21*a21; + hx = sqrt(a22/d); + hy = sqrt(a11/d); + } + inline double LengthInterpole(double la,double lb) { + return ( Abs(la - lb) < 1.0e-6*Max3(la,lb,1.0e-20) ) ? (la+lb)/2 : la*lb*log(la/lb)/(la-lb); + } + inline double abscisseInterpole(double la,double lb,double lab,double s){ + return ( Abs(la - lb) <1.0e-6*Max3(la,lb,1.0e-20)) ? s : (exp(s*lab*(la-lb)/(la*lb))-1)*lb/(la-lb); + } +} +#endif Index: /issm/trunk-jpl/src/c/bamg/R2.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/R2.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/R2.h (revision 15061) @@ -0,0 +1,100 @@ +/*Original code from Frederic Hecht (BAMG v1.01, R2.h)*/ +#ifndef _R2_H +#define _R2_H + +#include + +namespace bamg { + + template class P2{ + + public: + + //fields + R x,y; + + //functions + P2 () :x(0),y(0) {}; + P2 (R a,R b) :x(a),y(b) {} + P2 (P2 A,P2 B) : x(B.x-A.x),y(B.y-A.y) {} + void Echo(){ + printf("Member of P2:\n"); + printf(" x: %g or %i\n",x,x); + printf(" y: %g or %i\n",y,y); + } + //operators + RR operator,(const P2 & cc) const {return (RR) x* (RR) cc.x+(RR) y* (RR) cc.y;} //scalar product + P2 operator+(const P2 & cc) const {return P2(x+cc.x,y+cc.y);} + P2 operator-(const P2 & cc) const {return P2(x-cc.x,y-cc.y);} + P2 operator-() const{return P2(-x,-y);} + P2 operator*(R cc) const {return P2(x*cc,y*cc);} + P2 operator/(R cc) const {return P2(x/cc,y/cc);} + P2 operator+=(const P2 & cc) {x += cc.x;y += cc.y;return *this;} + P2 operator/=(const R r) {x /= r;y /= r;return *this;} + P2 operator*=(const R r) {x *= r;y *= r;return *this;} + P2 operator-=(const P2 & cc) {x -= cc.x;y -= cc.y;return *this;} + + }; + + template class P2xP2{ + + public: + + //fields + P2 x,y; + + //functions + P2xP2 (): x(),y() {} + P2xP2 (P2 a,P2 b): x(a),y(b) {} + P2xP2 (P2 a,P2 b,P2 c ): x(b-a),y(c-a) {} + P2xP2 (R xx,R xy,R yx,R yy) :x(xx,xy),y(yx,yy) {} + void Echo(){ + printf("Member of P2xP2:\n"); + printf(" x.x: %g x.y: %g\n",x.x,x.y); + printf(" y.x: %g y.x: %g\n",y.x,y.y); + } + RR det() const {return (RR) x.x* (RR) y.y - (RR) x.y * (RR) y.x;} + P2xP2 inv() const{ + RR d = (*this).det(); + return P2xP2((R)( y.y /d) ,(R)(-x.y/d),(R)( -y.x/d) ,(R)( x.x/d) ); + }; + P2xP2 t() {return P2xP2(x.x,y.x,x.y,y.y);} //transposer + P2 tx() {return P2(x.x,y.x);} + P2 ty() {return P2(x.y,y.y);} + //Operators + P2 operator*(const P2& c) const {return P2(x.x*c.x + x.y*c.y, y.x*c.x + y.y*c.y);} + P2xP2 operator*(P2xP2 c) const{ + return P2xP2(x.x*c.x.x + x.y*c.y.x, + x.x*c.x.y + x.y*c.y.y, + y.x*c.x.x + y.y*c.y.x, + y.x*c.x.y + y.y*c.y.y); + } + }; + + //inline functions + template + inline RR Det(const P2 x,const P2 y) { + return (RR) x.x * (RR) y.y - (RR) x.y * (RR) y.x ; + } + template + inline RR Area2 (const P2 a,const P2 b,const P2 c) { + return Det(b-a,c-a) ; + } + template + inline R Norme1 (const P2 x) { + return (Abs(x.x)+Abs(x.y)) ; + } + template + inline RR Norme2_2 (const P2 x) { + return (RR)x.x*(RR)x.x + (RR)x.y*(RR)x.y ; + } + template + inline RR Norme2 (const P2 x) { + return sqrt((RR)x.x*(RR)x.x + (RR)x.y*(RR)x.y) ; + } + template + inline P2 Orthogonal (const P2 x) { + return P2(-x.y,x.x); + } +} +#endif Index: /issm/trunk-jpl/src/c/bamg/SetOfE4.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/SetOfE4.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/SetOfE4.cpp (revision 15061) @@ -0,0 +1,120 @@ +#include "../classes/classes.h" + +using namespace std; +namespace bamg { + + /*Constructor*/ + /*FUNCTION SetOfEdges4::SetOfEdges4(long mmx,long nnx){{{*/ + SetOfEdges4::SetOfEdges4(long mmx,long nnx){ + /*Original code from Frederic Hecht (BAMG v1.01, SetOfEdges4.cpp/SetOfEdges4)*/ + + /*Intermediary*/ + int i; + + //initialize fields + nx =nnx; //number of vertices + nbax =mmx; // 3 * number of triangles + NbOfEdges=0; + head = new long [nx]; + Edges= new IntEdge[nbax]; + + //initialize head (-1 everywhere) + i=nx; + while(i--) head[i]=-1; + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION SetOfEdges4::add{{{*/ + long SetOfEdges4::add(long ii,long jj) { + /*Original code from Frederic Hecht (BAMG v1.01, SetOfEdges4.cpp/add)*/ + + /*Intermediary*/ + int h,n; + + //get n from h (usually h=ii) + _assert_(head); + n=head[h=Abs(ii)%nx]; + + //go through the existing edges that holds h (=ii) and check that + //the edge ii jj is not already in Edge + while (n >= 0){ + + //if the edge ii jj is already in Edges, return n + if (ii == Edges[n].i && jj == Edges[n].j) return n; + + //else go to next edge that holds ii + else n = Edges[n].next; + } + + //check that nbax <=NbOfEdges + if (nbax <=NbOfEdges ) { + _error_("SetOfEdges4::add overflow: NbOfEdges=" << NbOfEdges << " > nbax=" << nbax); + } + + //update chain + Edges[NbOfEdges].i=ii; + Edges[NbOfEdges].j=jj; + Edges[NbOfEdges].next= head[h]; + head[h] = NbOfEdges; + return NbOfEdges ++; + } + /*}}}*/ + /*FUNCTION SetOfEdges4::find {{{*/ + long SetOfEdges4::find(long ii,long jj) { + /*Original code from Frederic Hecht (BAMG v1.01, SetOfEdges4.cpp/find)*/ + + /*Intermediary*/ + int n; + + //check that head is not empty + _assert_(head); + + //get n from h (usually h=ii) + n=head[Abs(ii)%nx]; + + //go through the existing edges that holds h (=ii) and return position in Edge + while (n >= 0){ + + //if the edge ii jj is already in Edges, return n + if (ii == Edges[n].i && jj == Edges[n].j) return n; + + //else go to next edge that holds ii + else n = Edges[n].next; + } + + //if we reach this point, the edge does not exist return -1 + return -1; + } + /*}}}*/ + /*FUNCTION SetOfEdges4::i{{{*/ + long SetOfEdges4::i(long k){ + return Edges[k].i; + } + /*}}}*/ + /*FUNCTION SetOfEdges4::j{{{*/ + long SetOfEdges4::j(long k){ + return Edges[k].j; + } + /*}}}*/ + /*FUNCTION SetOfEdges4::nb{{{*/ + long SetOfEdges4::nb(){ + return NbOfEdges; + } + /*}}}*/ + /*FUNCTION SetOfEdges4::newarete{{{*/ + long SetOfEdges4::newarete(long k){ + return NbOfEdges == k+1; + } + /*}}}*/ + /*FUNCTION SetOfEdges4::SortAndAdd{{{*/ + long SetOfEdges4::SortAndAdd (long ii,long jj) { + return ii <=jj ? add (ii,jj) : add (jj,ii) ; + } + /*}}}*/ + /*FUNCTION SetOfEdges4::SortAndFind{{{*/ + long SetOfEdges4::SortAndFind (long ii,long jj) { + return ii <=jj ? find (ii,jj) : find (jj,ii) ; + } + /*}}}*/ +} Index: /issm/trunk-jpl/src/c/bamg/SetOfE4.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/SetOfE4.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/SetOfE4.h (revision 15061) @@ -0,0 +1,42 @@ +#ifndef _SetOfEdge4_h +#define _SetOfEdge4_h + +namespace bamg { + + class SetOfEdges4; + + class IntEdge{ + friend class SetOfEdges4; + public: + long i,j; + long next; + }; + + class SetOfEdges4 { + + private: + long nx,nbax,NbOfEdges; + long* head; + IntEdge* Edges; + + public: + + // Constructors + SetOfEdges4(long ,long);// nb Edges mx , nb de sommet + ~SetOfEdges4() {delete [] head; delete [] Edges;} + + //operators + IntEdge & operator[](long k){return Edges[k];} + + //Methods + long add (long ii,long jj); + long SortAndAdd (long ii,long jj); + long nb(); + long find (long ii,long jj); + long SortAndFind (long ii,long jj); + long i(long k); + long j(long k); + long newarete(long k); + }; +} +#endif Index: /issm/trunk-jpl/src/c/bamg/SubDomain.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/SubDomain.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/SubDomain.cpp (revision 15061) @@ -0,0 +1,28 @@ +#include +#include +#include +#include + +#include "SubDomain.h" +#include "Mesh.h" + +namespace bamg { + + /*Constructors/Destructors*/ + + /*Methods*/ + /*FUNCTION SubDomain::Set {{{*/ + void SubDomain::Set(const Mesh & Th ,long i,Mesh & ThNew){ + *this = Th.subdomains[i]; + if ( head-Th.triangles<0 || head-Th.triangles>=Th.nbt){ + _error_("head-Th.triangles<0 || head-Th.triangles>=Th.nbt"); + } + head = ThNew.triangles + Th.GetId(head) ; + if (edge-Th.edges<0 || edge-Th.edges>=Th.nbe);{ + _error_("edge-Th.edges<0 || edge-Th.edges>=Th.nbe"); + } + edge = ThNew.edges+ Th.GetId(edge); + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/SubDomain.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/SubDomain.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/SubDomain.h (revision 15061) @@ -0,0 +1,27 @@ +#ifndef _SUBDOMAIN_H_ +#define _SUBDOMAIN_H_ + +#include "./include.h" +#include "./Edge.h" + +namespace bamg { + + //classes + class Triangle; + class Mesh; + + class SubDomain { + + public: + + Triangle *head; + long ReferenceNumber; + int direction; // -1 or 1 + Edge *edge; // to geometrical + + //Methods + void Set(const Mesh &,long,Mesh &); + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/Triangle.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/Triangle.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Triangle.cpp (revision 15061) @@ -0,0 +1,491 @@ +#include +#include +#include +#include + +#include "../classes/classes.h" +#include "./det.h" + +namespace bamg { + + /*Constructors/Destructors*/ + /*FUNCTION Triangle(){{{*/ + Triangle::Triangle(void){ + + } + /*}}}*/ + /*FUNCTION Triangle(Mesh *Th,long i,long j,long k) {{{*/ + Triangle::Triangle(Mesh *Th,long i,long j,long k) { + BamgVertex *v=Th->vertices; + long nbv = Th->nbv; + if (i<0 || j<0 || k<0){ + _error_("i<0 || j<0 || k<0"); + } + if (i>=nbv || j>=nbv || k>=nbv){ + _error_("i>=nbv || j>=nbv || k>=nbv"); + } + vertices[0]=v+i; + vertices[1]=v+j; + vertices[2]=v+k; + adj[0]=adj[1]=adj[2]=0; + AdjEdgeIndex[0]=AdjEdgeIndex[1]=AdjEdgeIndex[2]=0; + det=0; + } + /*}}}*/ + /*FUNCTION Triangle(BamgVertex *v0,BamgVertex *v1,BamgVertex *v2) {{{*/ + Triangle::Triangle(BamgVertex *v0,BamgVertex *v1,BamgVertex *v2){ + vertices[0]=v0; + vertices[1]=v1; + vertices[2]=v2; + adj[0]=adj[1]=adj[2]=0; + AdjEdgeIndex[0]=AdjEdgeIndex[1]=AdjEdgeIndex[2]=0; + if (v0) det=0; + else { + det=-1; + link=NULL;}; + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION Triangle::Adj{{{*/ + AdjacentTriangle Triangle::Adj(int i) const { + return AdjacentTriangle(adj[i],AdjEdgeIndex[i]&3); + };/*}}}*/ + /*FUNCTION Triangle::Anisotropy{{{*/ + double Triangle::Anisotropy() const{ + + double lmin,lmax; + + /*Get three vertices A,B and C*/ + R2 A=*this->vertices[0]; + R2 B=*this->vertices[1]; + R2 C=*this->vertices[2]; + + /*Compute edges*/ + R2 e1=B-A; + R2 e2=C-A; + R2 e3=B-C; + + /*Compute edge length*/ + double l1=Norme2(e1); + double l2=Norme2(e2); + double l3=Norme2(e3); + + lmin=l1; + lmin=min(lmin,l2); + lmin=min(lmin,l3); + lmax=l1; + lmax=max(lmax,l2); + lmax=max(lmax,l3); + + return lmax/lmin; + };/*}}}*/ + /*FUNCTION Triangle::Length{{{*/ + double Triangle::Length() const{ + + double l; + + /*Get three vertices A,B and C*/ + R2 A=*this->vertices[0]; + R2 B=*this->vertices[1]; + R2 C=*this->vertices[2]; + + /*Compute edges*/ + R2 e1=B-A; + R2 e2=C-A; + R2 e3=B-C; + + /*Compute edge length*/ + l=Norme2(e1); + l=max(l,Norme2(e2)); + l=max(l,Norme2(e3)); + + return l; + };/*}}}*/ + /*FUNCTION Triangle::Echo {{{*/ + void Triangle::Echo(void){ + + int i; + + _printLine_("Triangle:"); + _printLine_(" vertices pointer towards three vertices"); + _printLine_(" vertices[0] vertices[1] vertices[2] = " << vertices[0] << " " << vertices[1] << " " << vertices[2]); + _printLine_(" adj pointer towards three adjacent triangles"); + _printLine_(" adj[0] adj[1] adj[2] = " << adj[0] << " " << adj[1] << " " << adj[2]); + _printLine_(" det (integer triangle determinant) = " << det); + if (link){ + _printLine_(" link (pointer toward duplicate triangle)= " << link); + } + else{ + _printLine_(" color = " << color); + } + + _printLine_("\nThree vertices:"); + for(i=0;i<3;i++){ + if (vertices[i]){ + vertices[i]->Echo(); + } + else{ + _printLine_(" vertex " << i+1 << " does not exist"); + } + } + + return; + } + /*}}}*/ + /*FUNCTION Triangle::FindBoundaryEdge{{{*/ + AdjacentTriangle Triangle::FindBoundaryEdge(int i) const{ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/FindBoundaryEdge)*/ + + /*Intermediary*/ + Triangle* ttc=NULL; + int k,j,jc; + + // call current triangle t + Triangle* t = (Triangle*)this; + + //is the current triangle inside or outside? + int outside=!link ; + + // EdgesVertexTriangle[3][2] = {{1,2},{2,0},{0,1}}; + // initialize j as the first vertex of the ith edge + j=EdgesVertexTriangle[i][0]; + + //Loop over the adjacent triangle of t + k=0; + do{ + //keep track of outside + int outsidep = outside; + //increment k + k++; + //Get ttc, adjacent triangle of t with respect to vertex j + ttc = t->adj[j]; + //is the current triangle inside or outside? + outside = !ttc->link; + //if both previous triangle are outside, return + if (outside+outsidep == 1) return AdjacentTriangle(t,j); + + //update t and j + t = ttc; + //NextEdge[3] = {1,2,0}; + jc = NextEdge[t->AdjEdgeIndex[j]&3]; + j = NextEdge[jc]; + + //check number of iterations + if (k>=2000){ + _error_("too many iteration in Triangle::FindBoundaryEdge (k>=2000)"); + } + } while (this!= t); + //not found, return empty triangle + return AdjacentTriangle(NULL,0); + } + /*}}}*/ + /*FUNCTION Triangle::GetAllflag{{{*/ + int Triangle::GetAllflag(int a){ + return AdjEdgeIndex[a] & 1020; + }/*}}}*/ + /*FUNCTION Triangle::Hidden{{{*/ + int Triangle::Hidden(int a)const { + return AdjEdgeIndex[a]&16; + } /*}}}*/ + /*FUNCTION Triangle::Locked{{{*/ + int Triangle::Locked(int a)const { + return AdjEdgeIndex[a]&4; + } /*}}}*/ + /*FUNCTION Triangle::NuEdgeTriangleAdj{{{*/ + short Triangle::NuEdgeTriangleAdj(int i) const { + /*Number of the adjacent edge in adj tria (make sure it is between 0 and 2*/ + return AdjEdgeIndex[i&3]&3; + }/*}}}*/ + /*FUNCTION Triangle::Optim{{{*/ + long Triangle::Optim(short i,int koption) { + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/Optim)*/ + + // turn around (positive direction) + Triangle *t=this; + long NbSwap =0; + int k = 0; + int j = OppositeEdge[i]; + int jp= PreviousEdge[j]; + + // initialize tp, jp the previous triangle & edge + Triangle *tp=adj[jp]; + jp = AdjEdgeIndex[jp]&3; + do { + while (t->swap(j,koption)){ + if (k>=20000) _error_("k>=20000"); + NbSwap++; + k++; + t= tp->adj[jp]; // set unchange t qnd j for previous triangles + j= NextEdge[tp->AdjEdgeIndex[jp]&3]; + } + // end on this Triangle + tp = t; + jp = NextEdge[j]; + + t= tp->adj[jp]; // set unchange t qnd j for previous triangles + j= NextEdge[tp->AdjEdgeIndex[jp]&3]; + + } while( t != this); + return NbSwap; + } + /*}}}*/ + /*FUNCTION Triangle::Quadrangle {{{*/ + Triangle* Triangle::Quadrangle(BamgVertex * & v0,BamgVertex * & v1,BamgVertex * & v2,BamgVertex * & v3) const{ + // return the other triangle of the quad if a quad or 0 if not a quat + Triangle * t =0; + if (link) { + int a=-1; + if (AdjEdgeIndex[0] & 16 ) a=0; + if (AdjEdgeIndex[1] & 16 ) a=1; + if (AdjEdgeIndex[2] & 16 ) a=2; + if (a>=0) { + t = adj[a]; + // if (t-this<0) return 0; + v2 = vertices[VerticesOfTriangularEdge[a][0]]; + v0 = vertices[VerticesOfTriangularEdge[a][1]]; + v1 = vertices[OppositeEdge[a]]; + v3 = t->vertices[OppositeEdge[AdjEdgeIndex[a]&3]]; + } + } + return t; + } + /*}}}*/ + /*FUNCTION Triangle::QualityQuad {{{*/ + double Triangle::QualityQuad(int a,int option) const{ + double q; + if (!link || AdjEdgeIndex[a] &4) + q= -1; + else { + Triangle * t = adj[a]; + if (t-this<0) q= -1;// because we do 2 times + else if (!t->link ) q= -1; + else if (AdjEdgeIndex[0] & 16 || AdjEdgeIndex[1] & 16 || AdjEdgeIndex[2] & 16 || t->AdjEdgeIndex[0] & 16 || t->AdjEdgeIndex[1] & 16 || t->AdjEdgeIndex[2] & 16 ) + q= -1; + else if(option){ + const BamgVertex & v2 = *vertices[VerticesOfTriangularEdge[a][0]]; + const BamgVertex & v0 = *vertices[VerticesOfTriangularEdge[a][1]]; + const BamgVertex & v1 = *vertices[OppositeEdge[a]]; + const BamgVertex & v3 = * t->vertices[OppositeEdge[AdjEdgeIndex[a]&3]]; + q = QuadQuality(v0,v1,v2,v3); // do the float part + } + else q= 1; + } + return q; + } + /*}}}*/ + /*FUNCTION Triangle::Renumbering(Triangle *tb,Triangle *te, long *renu){{{*/ + void Triangle::Renumbering(Triangle *tb,Triangle *te, long *renu){ + + if (link >=tb && link =tb && adj[0] =tb && adj[1] =tb && adj[2] =vb && vertices[0] =vb && vertices[1] =vb && vertices[2] = Th.triangles && link < Th.triangles + Th.nbt) + link = ThNew.triangles + Th.GetId(link); + } + /*}}}*/ + /*FUNCTION Triangle::SetAdjAdj{{{*/ + void Triangle::SetAdjAdj(short a){ + // Copy all the mark + a &= 3; + register Triangle *tt=adj[a]; + AdjEdgeIndex [a] &= 55; // remove MarkUnSwap + register short aatt = AdjEdgeIndex[a] & 3; + if(tt){ + tt->adj[aatt]=this; + tt->AdjEdgeIndex[aatt]=a + (AdjEdgeIndex[a] & 60 ) ; + } + }/*}}}*/ + /*FUNCTION Triangle::SetAdj2{{{*/ + void Triangle::SetAdj2(short a,Triangle *t,short aat){ + /*For current triangle: + * - a is the index of the edge were the adjency is set (in [0 2]) + * - t is the adjacent triangle + * - aat is the index of the same edge in the adjacent triangle*/ + adj[a]=t; + AdjEdgeIndex[a]=aat; + if(t){ //if t!=NULL add adjacent triangle to t (this) + t->adj[aat]=this; + t->AdjEdgeIndex[aat]=a; + } + }/*}}}*/ + /*FUNCTION Triangle::SetAllFlag{{{*/ + void Triangle::SetAllFlag(int a,int f){ + AdjEdgeIndex[a] = (AdjEdgeIndex[a] &3) + (1020 & f); + }/*}}}*/ + /*FUNCTION Triangle::SetDet{{{*/ + void Triangle::SetDet() { + if(vertices[0] && vertices[1] && vertices[2]) det = bamg::det(*vertices[0],*vertices[1],*vertices[2]); + else det = -1; + }/*}}}*/ + /*FUNCTION Triangle::SetHidden{{{*/ + void Triangle::SetHidden(int a){ + //Get Adjacent Triangle number a + register Triangle* t = adj[a]; + //if it exist + //C|=D -> C=(C|D) bitwise inclusive OR + if(t) t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] |=16; + AdjEdgeIndex[a] |= 16; + }/*}}}*/ + /*FUNCTION Triangle::SetLocked{{{*/ + void Triangle::SetLocked(int a){ + //mark the edge as on Boundary + register Triangle * t = adj[a]; + t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] |=4; + AdjEdgeIndex[a] |= 4; + }/*}}}*/ + /*FUNCTION Triangle::SetMarkUnSwap{{{*/ + void Triangle::SetMarkUnSwap(int a){ + register Triangle * t = adj[a]; + t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] |=8; + AdjEdgeIndex[a] |=8 ; + }/*}}}*/ + /*FUNCTION Triangle::SetSingleVertexToTriangleConnectivity{{{*/ + void Triangle::SetSingleVertexToTriangleConnectivity() { + if (vertices[0]) (vertices[0]->t=this,vertices[0]->IndexInTriangle=0); + if (vertices[1]) (vertices[1]->t=this,vertices[1]->IndexInTriangle=1); + if (vertices[2]) (vertices[2]->t=this,vertices[2]->IndexInTriangle=2); + }/*}}}*/ + /*FUNCTION Triangle::SetUnMarkUnSwap{{{*/ + void Triangle::SetUnMarkUnSwap(int a){ + register Triangle * t = adj[a]; + t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] &=55; // 23 + 32 + AdjEdgeIndex[a] &=55 ; + }/*}}}*/ + /*FUNCTION Triangle::swap{{{*/ + int Triangle::swap(short a,int koption){ + /*Original code from Frederic Hecht (BAMG v1.01, Mesh2.cpp/swap)*/ + + if(a/4 !=0) return 0;// arete lock or MarkUnSwap + + register Triangle *t1=this,*t2=adj[a];// les 2 triangles adjacent + register short a1=a,a2=AdjEdgeIndex[a];// les 2 numero de l arete dans les 2 triangles + if(a2/4 !=0) return 0; // arete lock or MarkUnSwap + + register BamgVertex *sa=t1->vertices[VerticesOfTriangularEdge[a1][0]]; + register BamgVertex *sb=t1->vertices[VerticesOfTriangularEdge[a1][1]]; + register BamgVertex *s1=t1->vertices[OppositeVertex[a1]]; + register BamgVertex *s2=t2->vertices[OppositeVertex[a2]]; + + Icoor2 det1=t1->det , det2=t2->det ; + Icoor2 detT = det1+det2; + Icoor2 detA = Abs(det1) + Abs(det2); + Icoor2 detMin = Min(det1,det2); + + int OnSwap = 0; + // si 2 triangle infini (bord) => detT = -2; + if (sa == 0) {// les deux triangles sont frontieres + det2=bamg::det(s2->i,sb->i,s1->i); + OnSwap = det2 >0;} + else if (sb == 0) { // les deux triangles sont frontieres + det1=bamg::det(s1->i,sa->i,s2->i); + OnSwap = det1 >0;} + else if(( s1 != 0) && (s2 != 0) ) { + det1 = bamg::det(s1->i,sa->i,s2->i); + det2 = detT - det1; + OnSwap = (Abs(det1) + Abs(det2)) < detA; + + Icoor2 detMinNew=Min(det1,det2); + // if (detMin<0 && (Abs(det1) + Abs(det2) == detA)) OnSwap=BinaryRand();// just for test + if (! OnSwap &&(detMinNew>0)) { + OnSwap = detMin ==0; + if (! OnSwap) { + int kopt = koption; + while (1) + if(kopt) { + // critere de Delaunay pure isotrope + register Icoor2 xb1 = sb->i.x - s1->i.x, + x21 = s2->i.x - s1->i.x, + yb1 = sb->i.y - s1->i.y, + y21 = s2->i.y - s1->i.y, + xba = sb->i.x - sa->i.x, + x2a = s2->i.x - sa->i.x, + yba = sb->i.y - sa->i.y, + y2a = s2->i.y - sa->i.y; + register double + cosb12 = double(xb1*x21 + yb1*y21), + cosba2 = double(xba*x2a + yba*y2a) , + sinb12 = double(det2), + sinba2 = double(t2->det); + + // angle b12 > angle ba2 => cotg(angle b12) < cotg(angle ba2) + OnSwap = ((double) cosb12 * (double) sinba2) < ((double) cosba2 * (double) sinb12); + break; + } + else { + // critere de Delaunay anisotrope + double som; + I2 AB=(I2) *sb - (I2) *sa; + I2 MAB2=((I2) *sb + (I2) *sa); + R2 MAB(MAB2.x*0.5,MAB2.y*0.5); + I2 A1=(I2) *s1 - (I2) *sa; + I2 D = (I2) * s1 - (I2) * sb ; + R2 S2(s2->i.x,s2->i.y); + R2 S1(s1->i.x,s1->i.y); + { + Metric M=s1->m; + R2 ABo = M.Orthogonal(AB); + R2 A1o = M.Orthogonal(A1); + // (A+B)+ x ABo = (S1+B)/2+ y A1 + // ABo x - A1o y = (S1+B)/2-(A+B)/2 = (S1-B)/2 = D/2 + double dd = Abs(ABo.x*A1o.y)+Abs(ABo.y*A1o.x); + double d = (ABo.x*A1o.y - ABo.y*A1o.x)*2; // because D/2 + if (Abs(d) > dd*1.e-3) { + R2 C(MAB+ABo*((D.x*A1o.y - D.y*A1o.x)/d)); + som = M(C - S2)/M(C - S1); + } else + {kopt=1;continue;} + + } + { + Metric M=s2->m; + R2 ABo = M.Orthogonal(AB); + R2 A1o = M.Orthogonal(A1); + // (A+B)+ x ABo = (S1+B)/2+ y A1 + // ABo x - A1o y = (S1+B)/2-(A+B)/2 = (S1-B)/2 = D/2 + double dd = Abs(ABo.x*A1o.y)+Abs(ABo.y*A1o.x); + double d = (ABo.x*A1o.y - ABo.y*A1o.x)*2; // because D/2 + if(Abs(d) > dd*1.e-3) { + R2 C(MAB+ABo*((D.x*A1o.y - D.y*A1o.x)/d)); + som += M(C - S2)/M(C - S1); + } else + {kopt=1;continue;} + } + OnSwap = som < 2; + break; + } + + } // OnSwap + } // (! OnSwap &&(det1 > 0) && (det2 > 0) ) + } + if( OnSwap ) + bamg::swap(t1,a1,t2,a2,s1,s2,det1,det2); + else { + t1->SetMarkUnSwap(a1); + } + return OnSwap; + } + /*}}}*/ + /*FUNCTION Triangle::TriangleAdj{{{*/ + Triangle* Triangle::TriangleAdj(int i) const { + return adj[i&3]; + }/*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/Triangle.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/Triangle.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/Triangle.h (revision 15061) @@ -0,0 +1,76 @@ +#ifndef _TRIANGLE_H_ +#define _TRIANGLE_H_ + +#include "./include.h" +#include "AdjacentTriangle.h" + +namespace bamg { + + //classes + class Mesh; + class BamgVertex; + class Triangle; + + class Triangle { + + friend class AdjacentTriangle; + + private: + BamgVertex *vertices[3]; // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer + Triangle *adj[3]; // 3 pointers toward the adjacent triangles + short AdjEdgeIndex[3]; // edge id in the adjacent triangles. The edge number 1 is the edge number AdjEdgeIndex[1] in the Adjacent triangle 1 + + public: + Icoor2 det; //Integer determinant (twice its area) + union { + Triangle *link; + long color; + }; + + //Constructors/Destructors + Triangle(); + Triangle(Mesh *Th,long i,long j,long k); + Triangle(BamgVertex *v0,BamgVertex *v1,BamgVertex *v2); + + //Operators + const BamgVertex & operator[](int i) const {return *vertices[i];}; + BamgVertex & operator[](int i) {return *vertices[i];}; + const BamgVertex * operator()(int i) const {return vertices[i];}; + BamgVertex * & operator()(int i) {return vertices[i];}; + + //Methods + void Echo(); + double Anisotropy() const; + double Length() const; + int swap(short a1,int=0); + long Optim(short a,int =0); + int Locked(int a)const; + int Hidden(int a)const; + int GetAllflag(int a); + void SetAllFlag(int a,int f); + double QualityQuad(int a,int option=1) const; + short NuEdgeTriangleAdj(int i) const; + AdjacentTriangle FindBoundaryEdge(int i) const; + AdjacentTriangle Adj(int i) const; + Triangle *TriangleAdj(int i) const; + Triangle *Quadrangle(BamgVertex *& v0,BamgVertex *& v1,BamgVertex *& v2,BamgVertex *& v3) const; + void Renumbering(Triangle *tb,Triangle *te, long *renu); + void Renumbering(BamgVertex *vb,BamgVertex *ve, long *renu); + void SetAdjAdj(short a); + void SetAdj2(short a,Triangle *t,short aat); + void SetSingleVertexToTriangleConnectivity(); + void SetHidden(int a); + void SetLocked(int a); + void SetMarkUnSwap(int a); + void SetUnMarkUnSwap(int a); + void SetDet(); + + //Inline methods + double qualite() ; + void Set(const Triangle &,const Mesh &,Mesh &); + int In(BamgVertex *v) const { return vertices[0]==v || vertices[1]==v || vertices[2]==v ;} + + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/VertexOnEdge.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/VertexOnEdge.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/VertexOnEdge.cpp (revision 15061) @@ -0,0 +1,25 @@ +#include +#include +#include +#include + +#include "VertexOnEdge.h" +#include "Mesh.h" + +namespace bamg { + + /*Methods*/ + /*FUNCTION VertexOnEdge::Set {{{*/ + void VertexOnEdge::Set(const Mesh & Th ,long i,Mesh & ThNew){ + *this = Th.VertexOnBThEdge[i]; + v = ThNew.vertices + Th.GetId(v); + } + /*}}}*/ + /*FUNCTION VertexOnEdge::SetOnBTh{{{*/ + void VertexOnEdge::SetOnBTh(){ + v->BackgroundEdgeHook=this; + v->IndexInTriangle=IsVertexOnEdge; + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/VertexOnEdge.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/VertexOnEdge.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/VertexOnEdge.h (revision 15061) @@ -0,0 +1,36 @@ +#ifndef _VERTEXONEDGE_H_ +#define _VERTEXONEDGE_H_ + +#include "./include.h" +#include "./Edge.h" + +namespace bamg { + + //classes + class Mesh; + class BamgVertex; + + class VertexOnEdge { + + public: + BamgVertex* v; + Edge* be; + double abcisse; + + //Constructors + VertexOnEdge(BamgVertex * w, Edge *bw,double s) :v(w),be(bw),abcisse(s) {}; + VertexOnEdge(){}; + + //Operators + operator double () const { return abcisse;} + operator BamgVertex* () const { return v;} + operator Edge* () const { return be;} + BamgVertex & operator[](int i) const { return (*be)[i];} + + //Methods + void SetOnBTh(); + void Set(const Mesh &,long,Mesh &); + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/VertexOnGeom.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/VertexOnGeom.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/VertexOnGeom.cpp (revision 15061) @@ -0,0 +1,70 @@ +#include +#include +#include +#include + +#include "VertexOnGeom.h" +#include "Mesh.h" +#include "Geometry.h" + +namespace bamg { + + /*Constructors/Destructors*/ + /*FUNCTION VertexOnGeom::VertexOnGeom(){{{*/ + VertexOnGeom::VertexOnGeom(){ + meshvertex=NULL; + curvilincoord=0; + gv=0; + } + /*}}}*/ + /*FUNCTION VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomVertex &g){{{*/ + VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomVertex &g){ + meshvertex=&m; + curvilincoord=-1; + gv=&g; + } + /*}}}*/ + /*FUNCTION VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomEdge &g,double s){{{*/ + VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomEdge &g,double s){ + meshvertex=&m; + curvilincoord=s; + ge=&g; + } + /*}}}*/ + + /*Methods*/ + /*FUNCTION VertexOnGeom::Set {{{*/ + void VertexOnGeom::Set(const VertexOnGeom & rec,const Mesh & Th ,Mesh & ThNew){ + *this = rec; + meshvertex = ThNew.vertices + Th.GetId(meshvertex); + if (gv) + if (curvilincoord < 0 ) + gv = ThNew.Gh.vertices + Th.Gh.GetId(gv); + else + ge = ThNew.Gh.edges + Th.Gh.GetId(ge); + + } + /*}}}*/ + /*FUNCTION VertexOnGeom::OnGeomVertex{{{*/ + int VertexOnGeom::OnGeomVertex()const{ + return this? curvilincoord <0 :0; + } + /*}}}*/ + /*FUNCTION VertexOnGeom::OnGeomEdge{{{*/ + int VertexOnGeom::OnGeomEdge() const{ + return this? curvilincoord >=0 :0; + } + /*}}}*/ + /*FUNCTION VertexOnGeom::IsRequiredVertex{{{*/ + int VertexOnGeom::IsRequiredVertex() { + return this? ((curvilincoord<0 ? (gv?gv->Required():0):0 )) : 0; + } + /*}}}*/ + /*FUNCTION VertexOnGeom::SetOn{{{*/ + void VertexOnGeom::SetOn(){ + meshvertex->GeomEdgeHook=this; + meshvertex->IndexInTriangle=IsVertexOnGeom; + } + /*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/VertexOnGeom.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/VertexOnGeom.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/VertexOnGeom.h (revision 15061) @@ -0,0 +1,46 @@ +#ifndef _VERTEXONGEOM_H_ +#define _VERTEXONGEOM_H_ + +#include "./include.h" +#include "./GeomVertex.h" + +namespace bamg { + + //classes + class Mesh; + class BamgVertex; + class GeomEdge; + + class VertexOnGeom{ + + public: + + BamgVertex* meshvertex; + double curvilincoord; + union{ + GeomVertex* gv; // if curvilincoord <0; + GeomEdge* ge; // if curvilincoord in [0..1] + }; + + //Constructors/Destructors + VertexOnGeom(); + VertexOnGeom(BamgVertex & m,GeomVertex &g); + VertexOnGeom(BamgVertex & m,GeomEdge &g,double s); + + //Operators + operator BamgVertex*() const {return meshvertex;} + operator GeomVertex * () const {return gv;} + operator GeomEdge * () const {return ge;} + operator const double & () const {return curvilincoord;} + + //Methods + int OnGeomVertex()const; + int OnGeomEdge() const; + int IsRequiredVertex(); + void SetOn(); + + //Inline methods + void Set(const VertexOnGeom&,const Mesh &,Mesh &); + }; +} +#endif Index: /issm/trunk-jpl/src/c/bamg/VertexOnVertex.cpp =================================================================== --- /issm/trunk-jpl/src/c/bamg/VertexOnVertex.cpp (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/VertexOnVertex.cpp (revision 15061) @@ -0,0 +1,34 @@ +#include +#include +#include +#include + +#include "VertexOnVertex.h" +#include "Mesh.h" + +namespace bamg { + + /*Constructors/Destructors*/ + /*FUNCTION VertexOnVertex::VertexOnVertex(){{{*/ + VertexOnVertex::VertexOnVertex() { + v=NULL; + bv=NULL; + };/*}}}*/ + /*FUNCTION VertexOnVertex::VertexOnVertex(BamgVertex * w,BamgVertex *bw){{{*/ + VertexOnVertex::VertexOnVertex(BamgVertex * w,BamgVertex *bw) :v(w),bv(bw){ + + }/*}}}*/ + + /*Methods*/ + /*FUNCTION VertexOnVertex::Set{{{*/ + void VertexOnVertex::Set(const Mesh &Th ,long i,Mesh &ThNew) { + *this = Th.VertexOnBThVertex[i]; + v = ThNew.vertices + Th.GetId(v); + } + /*}}}*/ + /*FUNCTION VertexOnVertex::SetOnBTh{{{*/ + void VertexOnVertex::SetOnBTh(){ + v->BackgroundVertexHook=bv;v->IndexInTriangle=IsVertexOnVertex; + }/*}}}*/ + +} Index: /issm/trunk-jpl/src/c/bamg/VertexOnVertex.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/VertexOnVertex.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/VertexOnVertex.h (revision 15061) @@ -0,0 +1,28 @@ +#ifndef _VERTEXONVERTEX_H_ +#define _VERTEXONVERTEX_H_ + +#include "./include.h" +#include "./BamgVertex.h" + +namespace bamg { + + //classes + class Mesh; + + class VertexOnVertex { + + public: + BamgVertex* v; + BamgVertex* bv; + + //Constructors + VertexOnVertex(); + VertexOnVertex(BamgVertex * w,BamgVertex *bw); + + //Methods + void SetOnBTh(); + void Set(const Mesh &,long,Mesh &); + }; + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/bamgobjects.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/bamgobjects.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/bamgobjects.h (revision 15061) @@ -0,0 +1,34 @@ +/* \file bamgobjects.h + * \brief: prototype header for all bamg related objects. + */ + +#ifndef BAMG_OBJECTS_H_ +#define BAMG_OBJECTS_H_ + +/*Bamg: */ +#include "./BamgOpts.h" +#include "./BamgGeom.h" +#include "./BamgMesh.h" +#include "./Metric.h" +#include "./DoubleAndInt.h" +#include "./Direction.h" +#include "./BamgVertex.h" +#include "./AdjacentTriangle.h" +#include "./Edge.h" +#include "./GeomVertex.h" +#include "./GeomEdge.h" +#include "./Curve.h" +#include "./Triangle.h" +#include "./ListofIntersectionTriangles.h" +#include "./GeomSubDomain.h" +#include "./SubDomain.h" +#include "./VertexOnGeom.h" +#include "./VertexOnVertex.h" +#include "./VertexOnEdge.h" +#include "./CrackedEdge.h" +#include "./Mesh.h" +#include "./Geometry.h" +#include "./BamgQuadtree.h" +#include "./SetOfE4.h" + +#endif Index: /issm/trunk-jpl/src/c/bamg/det.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/det.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/det.h (revision 15061) @@ -0,0 +1,15 @@ +#ifndef _BAMGDET_H_ +#define _BAMGDET_H_ + +#include "./include.h" + +namespace bamg { + + Icoor2 inline det(const I2 &a,const I2 & b,const I2 &c){ + Icoor2 bax = b.x - a.x ,bay = b.y - a.y; + Icoor2 cax = c.x - a.x ,cay = c.y - a.y; + return bax*cay - bay*cax; + } + +} +#endif Index: /issm/trunk-jpl/src/c/bamg/include.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/include.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/include.h (revision 15061) @@ -0,0 +1,11 @@ +/*!\file: include.h + * \brief prototypes for include.h + */ + +#ifndef _INCLUDE2_H_ +#define _INCLUDE2_H_ + +#include "./macros.h" +#include "./typedefs.h" + +#endif //ifndef _INCLUDE2_H_ Index: /issm/trunk-jpl/src/c/bamg/macros.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/macros.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/macros.h (revision 15061) @@ -0,0 +1,24 @@ +#ifndef _BAMGMACROS_H +#define _BAMGMACROS_H + +#include "./typedefs.h" + +namespace bamg { + + const double Pi =3.141592653589793238462643383279502884197169399375105820974944592308; + const float fPi=3.141592653589793238462643383279502884197169399375105820974944592308; + const int IsVertexOnGeom = 8; + const int IsVertexOnVertex = 16; + const int IsVertexOnEdge = 32; + static const short VerticesOfTriangularEdge[3][2] = {{1,2},{2,0},{0,1}}; + static const short EdgesVertexTriangle[3][2] = {{1,2},{2,0},{0,1}}; + static const short OppositeVertex[3] = {0,1,2}; + static const short OppositeEdge[3] = {0,1,2}; + static const short NextEdge[3] = {1,2,0}; + static const short PreviousEdge[3] = {2,0,1}; + static const short NextVertex[3] = {1,2,0}; + static const short PreviousVertex[3] = {2,0,1}; + const Icoor1 MaxICoor = 1073741823; // 2^30-1 =111...111 (29 times one) +} + +#endif Index: /issm/trunk-jpl/src/c/bamg/typedefs.h =================================================================== --- /issm/trunk-jpl/src/c/bamg/typedefs.h (revision 15061) +++ /issm/trunk-jpl/src/c/bamg/typedefs.h (revision 15061) @@ -0,0 +1,17 @@ +#ifndef _BAMGTYPEDEFS_H +#define _BAMGTYPEDEFS_H + +#include "./R2.h" + +namespace bamg { + + /*Integer coordinates types*/ + typedef int Icoor1; + typedef long Icoor2; + + /*I2 and R2*/ + typedef P2 I2; + typedef P2 R2; +} + +#endif Index: /issm/trunk-jpl/src/c/classes/classes.h =================================================================== --- /issm/trunk-jpl/src/c/classes/classes.h (revision 15060) +++ /issm/trunk-jpl/src/c/classes/classes.h (revision 15061) @@ -140,7 +140,4 @@ #include "./matrix/matrixobjects.h" -/*bamg: */ -#include "./bamg/bamgobjects.h" - /*gauss: */ #include "./gauss/gaussobjects.h" Index: /issm/trunk-jpl/src/c/modules/BamgConvertMeshx/BamgConvertMeshx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/BamgConvertMeshx/BamgConvertMeshx.cpp (revision 15060) +++ /issm/trunk-jpl/src/c/modules/BamgConvertMeshx/BamgConvertMeshx.cpp (revision 15061) @@ -6,5 +6,5 @@ #include "../../shared/shared.h" #include "../../toolkits/toolkits.h" -#include "../../classes/bamg/bamgobjects.h" +#include "../../bamg/bamgobjects.h" using namespace bamg; Index: /issm/trunk-jpl/src/c/modules/Bamgx/Bamgx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/Bamgx/Bamgx.cpp (revision 15060) +++ /issm/trunk-jpl/src/c/modules/Bamgx/Bamgx.cpp (revision 15061) @@ -3,5 +3,5 @@ */ #include "./Bamgx.h" -#include "../../classes/bamg/bamgobjects.h" +#include "../../bamg/bamgobjects.h" #include "../../shared/shared.h" #include "../../toolkits/toolkits.h" Index: /issm/trunk-jpl/src/c/modules/Bamgx/Bamgx.h =================================================================== --- /issm/trunk-jpl/src/c/modules/Bamgx/Bamgx.h (revision 15060) +++ /issm/trunk-jpl/src/c/modules/Bamgx/Bamgx.h (revision 15061) @@ -6,5 +6,5 @@ #define _BAMGX_H -#include "../../classes/bamg/bamgobjects.h" +#include "../../bamg/bamgobjects.h" /* local prototypes: */ Index: /issm/trunk-jpl/src/wrappers/matlab/io/matlabio.h =================================================================== --- /issm/trunk-jpl/src/wrappers/matlab/io/matlabio.h (revision 15060) +++ /issm/trunk-jpl/src/wrappers/matlab/io/matlabio.h (revision 15061) @@ -13,4 +13,5 @@ #include "../include/matlabincludes.h" +#include "../../c/bamg/bamgobjects.h" #include "../../c/classes/classes.h" #include "../../c/toolkits/toolkits.h" Index: /issm/trunk-jpl/src/wrappers/python/io/pythonio.h =================================================================== --- /issm/trunk-jpl/src/wrappers/python/io/pythonio.h (revision 15060) +++ /issm/trunk-jpl/src/wrappers/python/io/pythonio.h (revision 15061) @@ -13,4 +13,5 @@ #include "../include/pythonincludes.h" +#include "../../c/bamg/bamgobjects.h" #include "../../c/classes/classes.h"