Changeset 3335


Ignore:
Timestamp:
03/25/10 15:45:46 (15 years ago)
Author:
Mathieu Morlighem
Message:

Added ISSMASSERT for ISSM assertion (used in bug detection-> development only)

Location:
issm/trunk/src/c
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r3332 r3335  
    22#include <string.h>
    33#include <cmath>
    4 #include <assert.h>
    54
    65#include "GeometricalEdge.h"
    … …  
    2524
    2625                //check theta
    27                 assert(theta>=0 && theta<=1);
     26                ISSMASSERT(theta>=0 && theta<=1);
    2827
    2928                if (TgA()){

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

    r3332 r3335  
    33#include <cmath>
    44#include <ctime>
    5 #include <assert.h>
    65
    76#include "GeometricalVertex.h"
    … …  
    4746        GeometricalVertex* GeometricalVertex::The(){
    4847                // return a unique vertex
    49                 assert(link);
     48                ISSMASSERT(link);
    5049                return link;
    5150        }/*}}}*/

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

    r3332 r3335  
    33#include <cmath>
    44#include <ctime>
    5 #include <assert.h>
    65
    76#include "BamgObjects.h"
    … …  
    735734                                 }
    736735                         }
    737                         assert(nbgem && nbe);
     736                        ISSMASSERT(nbgem && nbe);
    738737                        if(step==0){
    739738                                curves = new Curve[NbOfCurves];
    … …  
    894893                        GeometricalEdge* tmpge = eg0;
    895894                        ge[--bge] =eg0 = eg0->Adj[sens0];
    896                         assert(bge>=0 && bge<=mxe);
     895                        ISSMASSERT(bge>=0 && bge<=mxe);
    897896                        sens0 = 1-( sensge[bge] = tmpge->DirAdj[sens0]);
    898897                }
    … …  
    912911                        ge[++tge] =eg1 = eg1->Adj[sens1];
    913912                        sensge[tge]= sens1 = 1-tmpge->DirAdj[sens1];
    914                         assert(tge>=0 && tge<=mxe);
     913                        ISSMASSERT(tge>=0 && tge<=mxe);
    915914                }
    916915
    … …  
    934933                        double ll=0;
    935934                        for(i=bge;i<tge;i++){
    936                                 assert(i>=0 && i<=mxe);
     935                                ISSMASSERT(i>=0 && i<=mxe);
    937936                                BB =  (*ge[i])[sensge[i]];
    938937                                lge[i]=ll += Norme2(AA-BB);
    … …  
    962961                                sg =s0*(1.0-s)+s*s1;   
    963962                }
    964                 assert(on);
     963                ISSMASSERT(on);
    965964                V.r= on->F(sg);
    966965                GV=VertexOnGeom(V,*on,sg);

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

    r3332 r3335  
    1 #include <assert.h>
    21#include "BamgObjects.h"
    32
    … …  
    3534
    3635                //check that head is not empty
    37                 assert(head);
     36                ISSMASSERT(head);
    3837
    3938                //get n from h (usually h=ii)
    … …  
    6261
    6362                //get n from h (usually h=ii)
    64                 assert(head);
     63                ISSMASSERT(head);
    6564                n=head[h=Abs(ii)%nx];
    6665

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

    r3332 r3335  
    33#include <cmath>
    44#include <ctime>
    5 #include <assert.h>
    65
    76#include "BamgObjects.h"
    … …  
    459458                                                j0 = i0%2;
    460459                                                i0 = i0/2;
    461                                                 assert(v==edges[i0 ].v[j0]);
     460                                                ISSMASSERT(v==edges[i0 ].v[j0]);
    462461                                                edges[i ].adj[j ] =edges +i0;
    463462                                                edges[i0].adj[j0] =edges +i ;
    … …  
    759758                        for (i=0;i<NbVerticesOnGeomVertex;i++){
    760759                                VertexOnGeom &v=VerticesOnGeomVertex[i];
    761                                 assert(v.OnGeomVertex());
     760                                ISSMASSERT(v.OnGeomVertex());
    762761                                bamgmesh->VerticesOnGeometricVertex[i*2+0]=Number((Vertex*)v)+1; //back to Matlab indexing
    763762                                bamgmesh->VerticesOnGeometricVertex[i*2+1]=Gh.Number((GeometricalVertex*)v)+1; //back to Matlab indexing
    … …  
    814813                                        k=Number(triangles[i].TriangleAdj(j));
    815814                                        if (reft[k]>=0){
    816                                                 assert(3*num+j<3*(nbt-NbOutT));
     815                                                ISSMASSERT(3*num+j<3*(nbt-NbOutT));
    817816                                                bamgmesh->ElementConnectivity[3*num+j]=k+1; // back to Matlab indexing
    818817                                        }
    … …  
    831830                        k=0;
    832831                        for(j=head_1[i];j!=-1;j=next_1[j]){
    833                                 assert(connectivitymax_1*i+k < connectivitymax_1*nbv);
     832                                ISSMASSERT(connectivitymax_1*i+k < connectivitymax_1*nbv);
    834833                                bamgmesh->NodalElementConnectivity[connectivitymax_1*i+k]=floor(j/3)+1;
    835834                                k++;
    … …  
    876875                        k=0;
    877876                        for(j=head_2[i];j!=-1;j=next_2[j]){
    878                                 assert(connectivitymax_2*i+k < connectivitymax_2*nbv);
     877                                ISSMASSERT(connectivitymax_2*i+k < connectivitymax_2*nbv);
    879878                                num=(int)bamgmesh->ElementEdges[int(j/2)*i2+0];
    880879                                if (i+1==num){ //carefull, ElementEdge is in M indexing
    … …  
    22112210                                i1=Number(edges[i][0]);
    22122211                                i2=Number(edges[i][1]);
    2213                                 assert(i1>=0 && i1<nbv && i2>=0 && i2<nbv);
     2212                                ISSMASSERT(i1>=0 && i1<nbv && i2>=0 && i2<nbv);
    22142213                                splitvertex[i1]++;
    22152214                                splitvertex[i2]++;
    … …  
    22252224                        }
    22262225                }
    2227                 assert(k==NbCrackedEdges);
     2226                ISSMASSERT(k==NbCrackedEdges);
    22282227
    22292228                //Add new vertices
    … …  
    22392238                                }
    22402239                        }
    2241                         assert(num==NbCrackedVertices);
     2240                        ISSMASSERT(num==NbCrackedVertices);
    22422241                }
    22432242                delete [] splitvertex;
    … …  
    22572256                        Triangle* tbegin=vertices[i1].t;
    22582257                        k=vertices[i1].vint;//local number of i in triangle tbegin
    2259                         assert(Number((*tbegin)[k])==Number(vertices[i1]));
     2258                        ISSMASSERT(Number((*tbegin)[k])==Number(vertices[i1]));
    22602259
    22612260                        //Now, we are going to go through the adjacent triangle that hold i1 till
    … …  
    22832282                                                if (Edgeflags[i]==0){
    22842283                                                        //first element
    2285                                                         CrackedEdges[k].a=ta.t;
    2286                                                         CrackedEdges[k].length=Norme2((*ta.t)[j1].r-(*ta.t)[j2].r);
    2287                                                         CrackedEdges[k].normal=Orthogonal((*ta.t)[j1].r-(*ta.t)[j2].r);
     2284                                                        CrackedEdges[i].a=ta.t;
     2285                                                        CrackedEdges[i].length=Norme2((*ta.t)[j1].r-(*ta.t)[j2].r);
     2286                                                        CrackedEdges[i].normal=Orthogonal((*ta.t)[j1].r-(*ta.t)[j2].r);
    22882287                                                }
    22892288                                                else{
    22902289                                                        //Second element -> to renumber
    2291                                                         CrackedEdges[k].b=ta.t;
    2292                                                         CrackedEdges[k].length=Norme2((*ta.t)[j1].r-(*ta.t)[j2].r);
    2293                                                         CrackedEdges[k].normal=Orthogonal((*ta.t)[j1].r-(*ta.t)[j2].r);
     2290                                                        CrackedEdges[i].b=ta.t;
     2291                                                        CrackedEdges[i].length=Norme2((*ta.t)[j1].r-(*ta.t)[j2].r);
     2292                                                        CrackedEdges[i].normal=Orthogonal((*ta.t)[j1].r-(*ta.t)[j2].r);
    22942293                                                }
    22952294                                                Edgeflags[i]++;
    … …  
    30563055
    30573056                //Check that background mesh and current mesh do have the same geometry
    3058                 assert(&BTh.Gh==&Gh);
     3057                ISSMASSERT(&BTh.Gh==&Gh);
    30593058                BTh.NbRef++; // add a ref to BackGround Mesh
    30603059
    … …  
    30883087
    30893088                //At this point there is NO vertex but vertices should be have been allocated by PreInit
    3090                 assert(vertices);
     3089                ISSMASSERT(vertices);
    30913090                for (i=0;i<Gh.nbv;i++){
    30923091                        if (Gh[i].Required()) {//Gh vertices Required
    … …  
    31043103                                GeometricalVertex* gv=vog;
    31053104                                Vertex *bv = vog;
    3106                                 assert(gv->to); // use of Geom -> Th
     3105                                ISSMASSERT(gv->to); // use of Geom -> Th
    31073106                                VertexOnBThVertex[NbVertexOnBThVertex++]=VertexOnVertex(gv->to,bv);
    31083107                                gv->to->m = bv->m; // for taking the metrix of the background mesh
    31093108                        }
    31103109                }
    3111                 assert(NbVertexOnBThVertex==NbVerticesOnGeomVertex);
     3110                ISSMASSERT(NbVertexOnBThVertex==NbVerticesOnGeomVertex);
    31123111
    31133112                /*STEP 2: reseed bounday edges*/
    … …  
    31973196
    31983197                                                // New Curve phase
    3199                                                 assert(A0-vertices>=0 && A0-vertices<nbv);
     3198                                                ISSMASSERT(A0-vertices>=0 && A0-vertices<nbv);
    32003199                                                if(ongequi->Required()){
    32013200                                                        GeometricalVertex *GA1 = *(*peequi)[1-k0equi].onGeometry;
    … …  
    32083207                                                                k1 = 1-k0; // next vertex of the edge
    32093208                                                                k1equi= 1 - k0equi;
    3210                                                                 assert(pe && ee.onGeometry);
     3209                                                                ISSMASSERT(pe && ee.onGeometry);
    32113210                                                                ee.onGeometry->SetMark();
    32123211                                                                Vertex & v0=ee[0], & v1=ee[1];
    … …  
    32213220
    32223221                                                                                //some checks
    3223                                                                                 assert(sNew>=L0);
    3224                                                                                 assert(LAB);
    3225                                                                                 assert(vertices && nbv<nbvx);
    3226                                                                                 assert(edges && nbe<nbex);
    3227                                                                                 assert(VerticesOnGeomEdge && NbVerticesOnGeomEdge<NbVerticesOnGeomEdgex);
     3222                                                                                ISSMASSERT(sNew>=L0);
     3223                                                                                ISSMASSERT(LAB);
     3224                                                                                ISSMASSERT(vertices && nbv<nbvx);
     3225                                                                                ISSMASSERT(edges && nbe<nbex);
     3226                                                                                ISSMASSERT(VerticesOnGeomEdge && NbVerticesOnGeomEdge<NbVerticesOnGeomEdgex);
    32283227
    32293228                                                                                // new vertex on edge
    … …  
    32603259
    32613260                                                                //some checks
    3262                                                                 assert(ee.onGeometry->CurveNumber==ei.onGeometry->CurveNumber);
     3261                                                                ISSMASSERT(ee.onGeometry->CurveNumber==ei.onGeometry->CurveNumber);
    32633262                                                                if (ee[k1].onGeometry->IsRequiredVertex()) {
    3264                                                                         assert(eeequi[k1equi].onGeometry->IsRequiredVertex());
     3263                                                                        ISSMASSERT(eeequi[k1equi].onGeometry->IsRequiredVertex());
    32653264                                                                        register GeometricalVertex * GA1 = *eeequi[k1equi].onGeometry;
    32663265                                                                        A1=GA1->to;// the vertex in new mesh
    3267                                                                         assert(A1-vertices>=0 && A1-vertices<nbv);
     3266                                                                        ISSMASSERT(A1-vertices>=0 && A1-vertices<nbv);
    32683267                                                                        break;
    32693268                                                                }
    … …  
    32903289                                                        PreviousNewEdge = e;
    32913290
    3292                                                         assert(i==NbCreatePointOnCurve);
     3291                                                        ISSMASSERT(i==NbCreatePointOnCurve);
    32933292                                                }
    32943293                                        } //  end loop on equi curve
    … …  
    33253324                        }
    33263325                }
    3327                 assert(nbe!=0);
     3326                ISSMASSERT(nbe!=0);
    33283327                delete [] bcurve;
    33293328
    … …  
    40934092
    40944093        //initialize ordre
    4095         assert(ordre);
     4094        ISSMASSERT(ordre);
    40964095        for (i=0;i<nbv;i++) ordre[i]=0;
    40974096
    … …  
    41274126                        //If the edge already exists, add adjacency
    41284127                        else if(st[k]>=0) {
    4129                                 assert(!triangles[i].TriangleAdj(j));
    4130                                 assert(!triangles[st[k]/3].TriangleAdj((int) (st[k]%3)));
     4128                                ISSMASSERT(!triangles[i].TriangleAdj(j));
     4129                                ISSMASSERT(!triangles[st[k]/3].TriangleAdj((int) (st[k]%3)));
    41314130
    41324131                                triangles[i].SetAdj2(j,triangles+st[k]/3,(int)(st[k]%3));
    … …  
    42874286                                        long k =edge4->SortAndAdd(v0?Number(v0):nbv,v1? Number(v1):nbv);
    42884287
    4289                                         assert(st[k]>=0);
     4288                                        ISSMASSERT(st[k]>=0);
    42904289                                        tta.SetAdj2(ja,savetriangles + st[k] / 3,(int) (st[k]%3));
    42914290                                        ta.SetLock();
    … …  
    43054304                }
    43064305        }
    4307         assert(savenbt+NbTfillHoll<=savenbtx);
     4306        ISSMASSERT(savenbt+NbTfillHoll<=savenbtx);
    43084307
    43094308        // copy of the outside triangles in saveTriangles

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

    r3329 r3335  
    1818#endif
    1919
     20/*Assertion macro*/
     21#define ISSMASSERT(statement)\
     22  if (!(statement)) ISSMERROR(exprintf("Assertion %s failed, please report bug to an ISSM developer",#statement))
     23
    2024/*The following macros hide the error exception handling in a matlab module. Just put
    2125 * MODULEBOOT(); and MODULEEND(); at the beginning and end of a module, and c++ exceptions
    2226 * will be trapped. Really nifty!*/
    23 
    2427#ifdef _SERIAL_
    2528
    … …  
    5154                return 1;\
    5255        }
    53 
    5456#endif
    5557

  • issm/trunk/src/c/io/WriteData.cpp

    r3332 r3335  
    1616
    1717#include <mex.h>
    18 #include <assert.h>
    1918
    2019/*Several prototypes for WriteData, according to type: */
    … …  
    211210        fnames[++i] = "CrackedVertices";          fsize[i][0]=bm->CrackedVerticesSize[0];           fsize[i][1]=bm->CrackedVerticesSize[1];          fpointer[i]=&bm->CrackedVertices;
    212211        fnames[++i] = "CrackedEdges";             fsize[i][0]=bm->CrackedEdgesSize[0];              fsize[i][1]=bm->CrackedEdgesSize[1];             fpointer[i]=&bm->CrackedEdges;
    213         assert(i==numfields-1);
     212        ISSMASSERT(i==numfields-1);
    214213
    215214        /*Initialize Matlab structure*/
    … …  
    255254        fnames[++i] = "CrackedEdges";    fsize[i][0]=bg->CrackedEdgesSize[0];    fsize[i][1]=bg->CrackedEdgesSize[1];    fpointer[i]=&bg->CrackedEdges;
    256255        fnames[++i] = "SubDomains";      fsize[i][0]=bg->SubDomainsSize[0];      fsize[i][1]=bg->SubDomainsSize[1];      fpointer[i]=&bg->SubDomains;
    257         assert(i==numfields-1);
     256        ISSMASSERT(i==numfields-1);
    258257
    259258        /*Initialize Matlab structure*/

  • issm/trunk/src/c/shared/TriMesh/TriMeshUtils.cpp

    r3332 r3335  
    44
    55#include <stdio.h>
    6 #include <assert.h>
    76
    87#include "./trimesh.h"
    9 
     8#include "../Exceptions/exceptions.h"
    109#include "../Alloc/alloc.h"
     10#include "../../include/macros.h"
    1111
    1212int IsGridOnRift(int* riftsegments, int nriftsegs, int grid){
    … …  
    968968                /*Using the order vector, and the riftsegments_copy and riftspairs_copy, reorder the segments and the pairs: */
    969969                for (j=0;j<numsegs;j++){
    970                         assert(order[j]<numsegs);
     970                        ISSMASSERT(order[j]<numsegs);
    971971                        *(riftsegments_copy+3*j+0)=*(riftsegments+3*order[j]+0);
    972972                        *(riftsegments_copy+3*j+1)=*(riftsegments+3*order[j]+1);
Note: See TracChangeset for help on using the changeset viewer.