Changeset 3329

Timestamp:

03/24/10 15:20:31 (15 years ago)

Author:

Mathieu Morlighem

Message:

Added macro for error exceptions-> ISSMERROR

Location:

issm/trunk/src/c

Files:

• Bamgx/Bamgx.cpp (modified) (1 diff)
• Bamgx/objects/CrackedEdge.cpp (modified) (1 diff)
• Bamgx/objects/CrackedEdge.h (modified) (1 diff)
• Bamgx/objects/Geometry.cpp (modified) (3 diffs)
• Bamgx/objects/Triangles.cpp (modified) (7 diffs)
• Bamgx/objects/Triangles.h (modified) (3 diffs)
• include/macros.h (modified) (2 diffs)
• objects/BamgOpts.cpp (modified) (2 diffs)
• objects/BamgOpts.h (modified) (1 diff)
• shared/Exceptions/Exceptions.cpp (modified) (3 diffs)
• shared/Exceptions/exceptions.h (modified) (2 diffs)

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

@@ -74 +74 @@
                 //Renumbering
                 Th.ReNumberingTheTriangleBySubDomain();
+
+                //Crack mesh if requested
+                if(bamgopts->Crack) Th.CrackMesh(bamgopts);
 
                 //Build output

issm/trunk/src/c/Bamgx/objects/CrackedEdge.cpp

@@ -12 +12 @@
 
         /*Constructors/Destructors*/
+        /*FUNCTION CrackedEdge() {{{1*/
+        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*/

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

@@ -21 +21 @@
         class CrackedEdge {
 
-                        Triangle a,b; 
+                public:
+                        Triangle* a;
+                        Triangle* b; 
+                        GeometricalEdge* E;
+                        Edge* e1;
+                        Edge* e2;
+                        double length;
+                        R2     normal;
+                        long   indexa[3];
+                        long   indexb[3];
 
                         //Constructors
-                        CrackedEdge() :a(),b() {}
-
-                        //Methods
+                        CrackedEdge();
         };
 

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

@@ -6 +6 @@
 
 #include "BamgObjects.h"
-
-#undef __FUNCT__ 
-#define __FUNCT__ "Geometry"
 
 namespace bamg {
@@ -84 +81 @@
                 //some checks
                 if (bamggeom->Vertices==NULL){
-                        throw ErrorException(__FUNCT__,exprintf("the domain provided does not contain any vertex"));
+                        ISSMERROR("the domain provided does not contain any vertex");
                 }
                 if (bamggeom->Edges==NULL){
@@ -161 +158 @@
                                 edges[i].Adj[0] = edges[i].Adj[1] = 0;
                                 edges[i].flag = 0;
+
+                                //Cracked?
+                                if (edges[i].ref!=1){
+                                        edges[i].SetCracked();
+                                }
 
                                 //prepare metric

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

@@ -234 +234 @@
                 if(edges)     delete [] edges;
                 if(triangles) delete [] triangles;
-                if(quadtree)  delete  quadtree;
+                if(quadtree)  delete quadtree;
                 //if(ordre)     delete [] ordre; //TEST  crash if not commented
                 if( subdomains) delete []  subdomains;
@@ -532 +532 @@
                 BamgMeshInit(bamgmesh);
 
-                /*Build reft that holds the number the subdomain number of each triangle*/
+                /*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*/
@@ -890 +892 @@
                 }
 
+                /*Cracked vertices*/
+                if(verbose>5) printf("      writing Cracked vertices\n");
+                bamgmesh->CrackedVerticesSize[0]=NbCrackedVertices;
+                bamgmesh->CrackedVerticesSize[1]=2;
+                if (NbCrackedVertices){
+                        bamgmesh->CrackedVertices=(double*)xmalloc(2*NbCrackedVertices*sizeof(double));
+                        for (i=0;i<NbCrackedVertices;i++){
+                                bamgmesh->CrackedVertices[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) printf("      writing Cracked vertices\n");
+                bamgmesh->CrackedEdgesSize[0]=NbCrackedEdges;
+                bamgmesh->CrackedEdgesSize[1]=4;
+                if (NbCrackedEdges){
+                        bamgmesh->CrackedEdges=(double*)xmalloc(2*NbCrackedEdges*sizeof(double));
+                        for (i=0;i<NbCrackedEdges;i++){
+                                bamgmesh->CrackedEdges[i*2+0]=0;//CrackedEdges[i]->+1; //M indexing
+                                bamgmesh->CrackedEdges[i*2+1]=0;//CrackedEdges[i]-]->+1; //M indexing
+                        }
+                }
+
                 //clean up
                 xfree((void**)&connectivitysize_1);
@@ -898 +924 @@
                 xfree((void**)&next_2);
                 delete [] reft;
+                delete [] numt;
         }
         /*}}}1*/
@@ -2142 +2169 @@
                 delete [] Mmassxx;
                 delete []  OnBoundary;
+
+        }
+        /*}}}1*/
+        /*FUNCTION Triangles::CrackMesh{{{1*/
+        void Triangles::CrackMesh(BamgOpts* bamgopts) {
+                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (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;i<nbe;i++){
+                        if(edges[i].onGeometry->Cracked()) k++;
+                }
+
+                //Return if no edge is cracked
+                if(k==0) return;
+                if (verbose>4) printf("      number of Cracked Edges = %i\n",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;i<nbv;i++) splitvertex[i]=0;
+
+                for (i=0;i<nbe;i++){
+                        if(edges[i].onGeometry->Cracked()){
+
+                                //Fill edges fields of CrackedEdges
+                                CrackedEdges[k  ].E =edges[i].onGeometry;
+                                CrackedEdges[k++].e1=&edges[i];
+
+                                //Get number of the two vertices on the edge
+                                i1=Number(edges[i][0]);
+                                i2=Number(edges[i][1]);
+                                assert(i1>=0 && i1<nbv && i2>=0 && i2<nbv);
+                                splitvertex[i1]++;
+                                splitvertex[i2]++;
+
+                                //If the vertex has already been flagged once, it is a cracked vertex (tip otherwise)
+                                if (splitvertex[i1]==2) NbCrackedVertices++;
+                                if (splitvertex[i2]==2) NbCrackedVertices++;
+
+                                //The vertex cannot be marked more than twice
+                                if (splitvertex[i1]==3 || splitvertex[i2]==3){
+                                        throw ErrorException(__FUNCT__,exprintf("Crossing rifts not supported yet"));
+                                }
+                        }
+                }
+                assert(k==NbCrackedEdges);
+
+                //Add new vertices
+                if (verbose>4) printf("      number of Cracked Vertices = %i\n",NbCrackedVertices);
+                if (NbCrackedVertices){
+                        CrackedVertices=(long*)xmalloc(2*NbCrackedVertices*sizeof(double));
+                        num=0;
+                        for (i=0;i<nbv;i++){
+                                if (splitvertex[i]==2){
+                                        CrackedVertices[num*2+0]=i;      //index of first vertex
+                                        CrackedVertices[num*2+1]=nbv+num;//index of new vertex
+                                        num++;
+                                }
+                        }
+                        assert(num==NbCrackedVertices);
+                }
+                delete [] splitvertex;
+
+                //Now, find the triangles that hold a cracked edge
+                ReMakeTriangleContainingTheVertex();
+
+                long* Edgeflags=new long[NbCrackedEdges];
+                for(i=0;i<NbCrackedEdges;i++) Edgeflags[i]=0;
+
+                for(i=0;i<NbCrackedEdges;i++){
+                        //Get the numbers of the 2 vertices of the crren cracked edge
+                        i1=Number((*CrackedEdges[i].e1)[0]);
+                        i2=Number((*CrackedEdges[i].e1)[1]);
+
+                        //find a triangle holding the vertex i1 (first vertex of the ith cracked edge)
+                        Triangle* tbegin=vertices[i1].t;
+                        k=vertices[i1].vint;//local number of i in triangle tbegin
+                        assert(Number((*tbegin)[k])==Number(vertices[i1]));
+
+                        //Now, we are going to go through the adjacent triangle that hold i1 till
+                        //we find one that has the cracked edge
+                        TriangleAdjacent ta(tbegin,EdgesVertexTriangle[k][0]);
+                        count=0;
+                        do {
+                                for(j=0;j<3;j++){
+                                        //Find the position of i1 in the triangle index
+                                        if (Number((*ta.t)[j])==i1){
+                                                j1=j;
+                                                break;
+                                        }
+                                }
+                                for(j=0;j<3;j++){
+                                        //Check wether i2 is also in the triangle index
+                                        if (Number((*ta.t)[j])==i2){
+                                                j2=j;
+                                                //Invert j1 and j2 if necessary
+                                                if ((j1+1)%3==j2){
+                                                        int j3=j1;
+                                                        j1=j2;
+                                                        j2=j3;
+                                                }
+                                                if (Edgeflags[i]==0){
+                                                        //first element
+                                                        CrackedEdges[k].a=ta.t;
+                                                        CrackedEdges[k].length=Norme2((*ta.t)[j1].r-(*ta.t)[j2].r);
+                                                        CrackedEdges[k].normal=Orthogonal((*ta.t)[j1].r-(*ta.t)[j2].r);
+                                                }
+                                                else{
+                                                        //Second element -> to renumber
+                                                        CrackedEdges[k].b=ta.t;
+                                                        CrackedEdges[k].length=Norme2((*ta.t)[j1].r-(*ta.t)[j2].r);
+                                                        CrackedEdges[k].normal=Orthogonal((*ta.t)[j1].r-(*ta.t)[j2].r);
+                                                }
+                                                Edgeflags[i]++;
+                                                break;
+                                        }
+                                }
+                                //printf("%i -> %i %i %i, edge [%i->%i %i->%i]\n",element_renu[Number(ta.t)],Number((*ta.t)[0])+1,Number((*ta.t)[1])+1,Number((*ta.t)[2])+1,i1,j1,i2,j2);
+                                ta = Next(ta).Adj(); 
+                                if (count++>50) throw ErrorException(__FUNCT__,exprintf("Maximum number of iteration exceeded"));
+                        }while ((tbegin != ta)); 
+                }
+
+                //Check EdgeFlag
+                for(i=0;i<NbCrackedEdges;i++){
+                        if (Edgeflags[i]!=2){
+                                throw ErrorException(__FUNCT__,exprintf("A problem occured: at least one crack edge (number %i) does not belong to 2 elements",i+1));
+                        }
+                }
+                delete [] Edgeflags;
+
+                //Reset Vertex to On
+                SetVertexFieldOn();
 
         }
@@ -3725 +3899 @@
 
         NbCrackedVertices=0;
+        CrackedVertices  =NULL;  
         NbCrackedEdges   =0;
         CrackedEdges     =NULL;  
@@ -5260 +5435 @@
 }
 /*}}}1*/
+/*FUNCTION Triangles::TriangleIntNumbering{{{1*/
+void Triangles::TriangleIntNumbering(long* renumbering){
+
+        long num=0;
+        for (int i=0;i<nbt;i++){
+                if (triangles[i].det>0) renumbering[i]=num++;
+                else renumbering[i]=-1;
+        }
+        return;   
+}
+/*}}}1*/
 
         /*Intermediary*/

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

@@ -58 +58 @@
                         VertexOnEdge *VertexOnBThEdge;
                         long NbCrackedVertices;
+                        long* CrackedVertices;
                         long NbCrackedEdges;
                         CrackedEdge* CrackedEdges;
@@ -104 +105 @@
                         void ForceBoundary();
                         void FindSubDomain(int OutSide=0);
-                        long TriangleReferenceList(long *) const;
+                        long TriangleReferenceList(long*) const;
+                        void TriangleIntNumbering(long* renumbering);
                         void ShowHistogram() const;
+                        void CrackMesh(BamgOpts* bamgopts);
                         void ShowRegulaty() const;
                         void SmoothMetric(double raisonmax) ;
@@ -128 +131 @@
                         long Number(const Edge & t) const  { return &t - edges;}
                         long Number(const Edge * t) const  { return t - edges;}
-                        long Number2(const Triangle * t) const  {
-                                return t - triangles;
-                        }
+                        long Number2(const Triangle * t) const  { return t - triangles; }
                         Vertex* NearestVertex(Icoor1 i,Icoor1 j) ;
                         Triangle* FindTriangleContaining(const I2 & ,Icoor2 [3],Triangle *tstart=0) const;

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

@@ -8 +8 @@
 /*Printing macro: */
 #define _printf_(...) PrintfFunction(__VA_ARGS__)
+
+/*Error exception macro*/
+#ifdef _INTEL_WIN_
+#define ISSMERROR(error_string)\
+  throw ErrorException(error_string)
+#else
+#define ISSMERROR(error_string)\
+  throw ErrorException(__FILE__,__func__,__LINE__,error_string)
+#endif
 
 /*The following macros hide the error exception handling in a matlab module. Just put 
@@ -21 +30 @@
         catch(ErrorException &exception){\
                 exception.Report(); \
-                mexErrMsgTxt(" "); \
+                mexErrMsgTxt(""); \
         }\
         catch (exception& e) {\

issm/trunk/src/c/objects/BamgOpts.cpp

@@ -11 +11 @@
         bamgopts->Metrictype=0;
         bamgopts->KeepVertices=0;
+        bamgopts->Crack=0;
         bamgopts->maxsubdiv=0;
         bamgopts->power=0;
@@ -41 +42 @@
         if (bamgopts->coef==0) throw ErrorException(__FUNCT__,exprintf("'coef' should be positive"));
         if (bamgopts->maxsubdiv<=1) throw ErrorException(__FUNCT__,exprintf("'maxsubdiv' should be >1"));
+        if (bamgopts->Crack!=0  && bamgopts->Crack!=1) throw ErrorException(__FUNCT__,exprintf("'Crack' supported options are 0 and 1"));
         if (bamgopts->Hessiantype!=0  && bamgopts->Hessiantype!=1) throw ErrorException(__FUNCT__,exprintf("'Hessiantype' supported options are 0 and 1"));
         if (bamgopts->Metrictype!=0   && bamgopts->Metrictype!=1 && bamgopts->Metrictype!=2) throw ErrorException(__FUNCT__,exprintf("'Metrictype' supported options are 0, 1 and 2"));

issm/trunk/src/c/objects/BamgOpts.h

@@ -11 +11 @@
         int     maxnbv;
         double  MaximalAngleOfCorner;
+        int     Crack;
         int     Hessiantype;
         int     Metrictype;

issm/trunk/src/c/shared/Exceptions/Exceptions.cpp

@@ -2 +2 @@
  * \brief: implementation of the exceptions.
  */
-
 
 #include "../shared.h"
@@ -10 +9 @@
 
         what_str=what_arg;
+        file_name="";
         function_name=what_function;
+        file_line=0;
+}
+
+ErrorException::ErrorException(string what_arg){
+
+        what_str=what_arg;
+        file_name="";
+        function_name="";
+        file_line=0;
+}
+
+ErrorException::ErrorException(string what_file,string what_function,int what_line,string what_arg){
+
+        what_str=what_arg;
+        file_name=what_file;
+        function_name=what_function;
+        file_line=what_line;
 }
 
@@ -22 +39 @@
 void ErrorException::Report(){
 
-        _printf_("%s%s%s",function_name.c_str()," error message: ",what());
+        if (function_name==""){
+                _printf_("%s%s"," error message: ",what());
+        }
+        else if (file_line==0){
+                _printf_("%s%s%s",function_name.c_str()," error message: ",what());
+        }
+        else{
+                _printf_("\n%s%s%s%i\n","??? Error using ==> ",file_name.c_str()," at ",file_line);
+                _printf_("%s%s%s\n\n",function_name.c_str()," error message: ",what());
+        }
         return;
 }
-
-

issm/trunk/src/c/shared/Exceptions/exceptions.h

@@ -17 +17 @@
 class ErrorException: public exception {
         
-        string what_str;
-        string function_name;
+        string   what_str;
+        string   function_name;
+        string   file_name;
+        int      file_line;
 
         public:
 
-        ErrorException(const string &what_function,const string &what_arg);
+        ErrorException(const string &what_function,const string &what_arg);//default
+        ErrorException(const string &what_arg); //for windows
+        ErrorException(string what_file,string what_function,int what_line,string what_arg);//UNIX
         ~ErrorException() throw();
 
@@ -29 +33 @@
         void Report();
 
-
 };
-        
 
 char* exprintf(char* format,...);