Changeset 3325


Ignore:
Timestamp:
03/24/10 09:37:10 (15 years ago)
Author:
Mathieu Morlighem
Message:

removed not needed Crack objects

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

Legend:

Unmodified
Added
Removed
  • issm/trunk/src/c/Bamgx/objects/CrackedEdge.cpp

    r3263 r3325  
    1414
    1515        /*Methods*/
    16         /*FUNCTION CrackedEdge::Crack {{{1*/
    17         void CrackedEdge::Crack() {
    18                 a.Crack();
    19                 b.Crack();
    20         }
    21         /*}}}*/
    22         /*FUNCTION CrackedEdge::UnCrack {{{1*/
    23         void CrackedEdge::UnCrack() {
    24                 a.UnCrack();
    25                 b.UnCrack();
    26         }
    27         /*}}}*/
    28         /*FUNCTION {{{1*/
    29         void CrackedEdge::Set(){
    30                 a.Set();
    31                 b.Set();}
    32         /*}}}*/
    3316
    3417}
  • issm/trunk/src/c/Bamgx/objects/CrackedEdge.h

    r3280 r3325  
    2121        class CrackedEdge {
    2222
    23                 friend class Triangles;
    24 
    25                 class CrackedTriangle {
    26                         friend class Triangles;
    27                         friend class CrackedEdge;
    28                         Triangle* t; // edge of triangle t
    29                         int i;       //  edge number of in triangle
    30                         Edge *edge;  // the  2 edge
    31                         Vertex *New[2]; // new vertex number
    32 
    33                         //Constructors
    34                         CrackedTriangle() : t(0),i(0),edge(0) { New[0]=New[1]=0;}
    35                         CrackedTriangle(Edge * a) : t(0),i(0),edge(a) { New[0]=New[1]=0;}
    36 
    37                         //Methods
    38                         void Crack();
    39                         void UnCrack();
    40                         void Set();
    41                 };
    42 
    43                 public: 
    44                         CrackedTriangle a,b;
     23                        Triangle a,b;
    4524
    4625                        //Constructors
    4726                        CrackedEdge() :a(),b() {}
    48                         CrackedEdge(Edge * start, long  i,long j) : a(start+i),b(start+j) {};
    49                         CrackedEdge(Edge * e0, Edge * e1 ) : a(e0),b(e1) {};
    5027
    5128                        //Methods
    52                         void Crack();
    53                         void UnCrack();
    54                         void Set();
    5529        };
    56 
    57         /*Intermediary*/
    58         inline TriangleAdjacent FindTriangleAdjacent(Edge &E){
    59                 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
    60 
    61                 Vertex * a = E.v[0];
    62                 Vertex * b = E.v[1];
    63 
    64                 Triangle * t = a->t;
    65                 int i = a->vint;
    66                 TriangleAdjacent ta(t,EdgesVertexTriangle[i][0]); // Previous edge
    67                 if (!t || i<0 || i>=3){
    68                         throw ErrorException(__FUNCT__,exprintf("!t || i<0 !! i>=3"));
    69                 }
    70                 if ( a!=(*t)(i)){
    71                         throw ErrorException(__FUNCT__,exprintf("a!=(*t)(i)"));
    72                 }
    73                 int k=0;
    74                 do { // turn around vertex in direct sens (trigo)
    75                         k++;
    76                         if (k>=20000){
    77                                 throw ErrorException(__FUNCT__,exprintf("k>=20000"));
    78                         }
    79                         //  in no crack => ta.EdgeVertex(1) == a otherwise ???
    80                         if (ta.EdgeVertex(1) ==  a && ta.EdgeVertex(0) ==  b) return ta; // find
    81                         ta = ta.Adj();
    82                         if (ta.EdgeVertex(0) ==  a && ta.EdgeVertex(1) ==  b) return ta; // find
    83                         --ta;
    84                 } while (t != (Triangle *)ta);
    85                 throw ErrorException(__FUNCT__,exprintf("FindTriangleAdjacent: triangle not found"));
    86                 return TriangleAdjacent(0,0);//for compiler
    87         }
    88         inline Vertex* TheVertex(Vertex * a){// for remove crak in mesh
    89                 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
    90 
    91                 // give a unique vertex with smallest number
    92                 // in case on crack in mesh
    93                 Vertex * r(a), *rr;
    94                 Triangle * t = a->t;
    95                 int i = a->vint;
    96                 TriangleAdjacent ta(t,EdgesVertexTriangle[i][0]); // Previous edge
    97                 if (!t || i<0 || i>=3){
    98                         throw ErrorException(__FUNCT__,exprintf("!t || i<0 !! i>=3"));
    99                 }
    100                 if ( a!=(*t)(i)){
    101                         throw ErrorException(__FUNCT__,exprintf("a!=(*t)(i)"));
    102                 }
    103                 int k=0;
    104                 do { // turn around vertex in direct sens (trigo)
    105                         k++;
    106                         if (k>=20000){
    107                                 throw ErrorException(__FUNCT__,exprintf("k>=20000"));
    108                         }
    109                         //  in no crack => ta.EdgeVertex(1) == a
    110                         if ((rr=ta.EdgeVertex(0)) < r) r = rr;
    111                         ta = ta.Adj();
    112                         if ((rr=ta.EdgeVertex(1)) < r) r =rr;
    113                         --ta;
    114                 } while (t != (Triangle*) ta); 
    115                 return r;
    116         }
    11730
    11831}
  • issm/trunk/src/c/Bamgx/objects/CrackedTriangle.cpp

    r3263 r3325  
    1414
    1515        /*Methods*/
    16         /*FUNCTION CrackedEdge::CrackedTriangle::Crack{{{1*/
    17         void CrackedEdge::CrackedTriangle::Crack(){
    18                 Triangle & T(*t);
    19                 int i0=VerticesOfTriangularEdge[i][0];
    20                 int i1=VerticesOfTriangularEdge[i][0];
    21                 if (!New[0] && !New[1]){
    22                         throw ErrorException(__FUNCT__,exprintf("!New[0] && !New[1]"));
    23                 }
    24                 T(i0) = New[0];
    25                 T(i1) = New[1];
    26         }
    27         /*}}}*/
    28         /*FUNCTION CrackedEdge::CrackedTriangle::UnCrack {{{1*/
    29         void CrackedEdge::CrackedTriangle::UnCrack(){
    30                 Triangle & T(*t);
    31                 int i0=VerticesOfTriangularEdge[i][0];
    32                 int i1=VerticesOfTriangularEdge[i][0];
    33                 if (!New[0] && !New[1]){
    34                         throw ErrorException(__FUNCT__,exprintf("!New[0] && !New[1]"));
    35                 }
    36                 T(i0) = TheVertex(T(i0));
    37                 T(i1) = TheVertex(T(i1));
    38         }
    39         /*}}}*/
    40         /*FUNCTION CrackedEdge::CrackedTriangle::Set {{{1*/
    41         void CrackedEdge::CrackedTriangle::Set(){
    42                 TriangleAdjacent ta( FindTriangleAdjacent(*edge));
    43                 t = ta;
    44                 i = ta;
    45 
    46                 New[0] = ta.EdgeVertex(0);
    47                 New[1] = ta.EdgeVertex(1);
    48                 // warning the ref
    49         }
    50         /*}}}*/
    5116
    5217}
  • issm/trunk/src/c/Bamgx/objects/Geometry.cpp

    r3322 r3325  
    182182                }
    183183
    184                 //CrackedEdges
    185                 if (bamggeom->CrackedEdges){
    186                         if(verbose>5) printf("      processing CrackedEdges\n");
    187                         for (i=0;i<bamggeom->CrackedEdgesSize[0];i++){
    188                                 throw ErrorException(__FUNCT__,exprintf("Not implemented yet"));
    189                         }
    190                 }
    191                 else{
    192                         if(verbose>5) printf("      no CrackedEdges found\n");
    193                 }
    194 
    195184                //hVertices
    196185                if(bamggeom->hVertices){
     
    202191                        }
    203192                }
    204                 else{
    205                         if(verbose>5) printf("      no hVertices found\n");
    206                 }
    207193
    208194                //MetricVertices
     
    212198                                vertices[i].m = Metric((double)bamggeom->MetricVertices[i*3+0],(double)bamggeom->MetricVertices[i*3+1],(double)bamggeom->MetricVertices[i*3+2]);
    213199                        }
    214                 }
    215                 else{
    216                         if(verbose>5) printf("      no MetricVertices found\n");
    217200                }
    218201
     
    229212                        }
    230213                }
    231                 else{
    232                         if(verbose>5) printf("      no h1h2VpVertices found\n");
    233                 }
    234214
    235215                //MaximalAngleOfCorner
     
    237217                        if(verbose>5) printf("      processing MaximalAngleOfCorner\n");
    238218                        MaximalAngleOfCorner=bamgopts->MaximalAngleOfCorner*Pi/180;
    239                 }
    240                 else{
    241                         if(verbose>5) printf("      no MaximalAngleOfCorner found\n");
    242219                }
    243220
     
    260237                                edges[i].tg[j] = tg;
    261238                        }
    262                 }
    263                 else{
    264                         if(verbose>5) printf("      no TangentAtEdges found\n");
    265239                }
    266240
     
    278252                                vertices[j].SetRequired();  }
    279253                }
    280                 else{
    281                         if(verbose>5) printf("      no Corners found\n");
    282                 }
    283254
    284255                //RequiredVertices
     
    294265                                vertices[j].SetRequired();  }
    295266                }
    296                 else{
    297                         if(verbose>5) printf("      no RequiredVertices found\n");
    298                 }
    299267
    300268                //RequiredEdges
     
    310278                                edges[j].SetRequired(); 
    311279                        }
    312                 }
    313                 else{
    314                         if(verbose>5) printf("      no RequiredEdges found\n");
    315280                }
    316281
     
    334299                        }
    335300                }
    336                 else{
    337                         if(verbose>5) printf("      no SubDomains found\n");
    338                 }
    339301        }
    340302        /*}}}1*/
     
    384346                                //update counters
    385347                                if (edges[i].Required()) nbreq++;
    386                                 if (edges[i].Cracked()){
    387                                         if (i<=Number(edges[i].link)) nbcracked++;
    388                                 }
    389348                                if (edges[i].TgA() && edges[i][0].Corner()) nbtan++;
    390349                                if (edges[i].TgB() && edges[i][1].Corner()) nbtan++;
    391                         }
    392                 }
    393 
    394                 /*CrackedEdges*/
    395                 if(verbose>5) printf("      writing CrackedEdges\n");
    396                 bamggeom->CrackedEdgesSize[0]=nbcracked;
    397                 bamggeom->CrackedEdgesSize[1]=2;
    398                 if (nbcracked){
    399                         bamggeom->CrackedEdges=(double*)xmalloc(2*nbcracked*sizeof(double));
    400                         count=0;
    401                         for (i=0;i<nbe;i++){
    402                                 if (edges[i].Cracked()){
    403                                         if (i<=Number(edges[i].link)){
    404                                                 bamggeom->CrackedEdges[count*2+0]=i+1;                     //back to Matlab indexing
    405                                                 bamggeom->CrackedEdges[count*2+1]=Number(edges[i].link)+1; //back to Matlab indexing
    406                                                 count=count+1;
    407                                         }
    408                                 }
    409350                        }
    410351                }
     
    543484                        }
    544485                        throw ErrorException(__FUNCT__,exprintf("See above"));
    545                 }
    546 
    547                 //  verification of cracked edge (to be completed)
    548                 for (i=0;i<nbe;i++){
    549                         if (edges[i].Cracked() ) {
    550                                 //    verification of crack
    551                                 GeometricalEdge & e1=edges[i];
    552                                 GeometricalEdge & e2=*e1.link;
    553                                 if ( e1[0].The() == e2[0].The() && e1[1].The() == e2[1].The() )
    554                                   {
    555                                         //nothing
    556                                   }
    557                                 else
    558                                  if ( e1[0].The() == e2[1].The() && e1[1].The() == e2[0].The() )
    559                                         {
    560                                          //nothing
    561                                         }
    562                                  else {
    563                                          throw ErrorException(__FUNCT__,exprintf("Cracked edges with no same vertex"));
    564                                  }
    565                         }
    566486                }
    567487
  • issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.cpp

    r3263 r3325  
    2727        }
    2828        /*}}}*/
    29         /*FUNCTION TriangleAdjacent::Cracked {{{1*/
    30         int  TriangleAdjacent::Cracked() const {
    31                 return t->TriaAdjSharedEdge[a] & 32;
    32         }
    33         /*}}}*/
    3429        /*FUNCTION TriangleAdjacent::GetAllFlag_UnSwap {{{1*/
    3530        int  TriangleAdjacent::GetAllFlag_UnSwap() const {
     
    4136        void TriangleAdjacent::SetLock(){
    4237                t->SetLocked(a);
    43         }
    44         /*}}}*/
    45         /*FUNCTION TriangleAdjacent::SetCracked {{{1*/
    46         void TriangleAdjacent::SetCracked() {
    47                 t->SetCracked(a);
    4838        }
    4939        /*}}}*/
  • issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h

    r3280 r3325  
    3838                        int  Locked() const;
    3939                        int  MarkUnSwap() const;
    40                         int  Cracked() const;
    4140                        int  GetAllFlag_UnSwap() const;
    4241                        void SetLock();
    43                         void SetCracked();
    4442                        void SetAdj2(const TriangleAdjacent &ta, int l=0);
    4543                        int  swap();
  • issm/trunk/src/c/Bamgx/objects/Triangles.cpp

    r3323 r3325  
    481481                else{
    482482                        if(verbose>5) printf("      no Edges found\n");
    483                 }
    484 
    485                 //CrackedEdges
    486                 if(bamgmesh->CrackedEdges){
    487                         if(verbose>5) printf("      processing CrackedEdges\n");
    488                         NbCrackedEdges=bamgmesh->CrackedEdgesSize[0];
    489                         CrackedEdges=new CrackedEdge[NbCrackedEdges];
    490                         for (i=0;i<NbCrackedEdges;i++){
    491                                 //CrackedEdges[i].a.edge=bamgmesh->CrackedEdges[i*2+0]-1; //C indexing
    492                                 //CrackedEdges[i].b.edge=bamgmesh->CrackedEdges[i*1+0]-1; //C indexing
    493                                 throw ErrorException(__FUNCT__,exprintf("not implemented yet"));
    494                         }
    495                 }
    496                 else{
    497                         if(verbose>5) printf("      no CrackedEdges found\n");
    498483                }
    499484
     
    718703                }
    719704
    720                 /*CrackedEdges*/
    721                 if(verbose>5) printf("      writing CrackedEdges\n");
    722                 bamgmesh->CrackedEdgesSize[0]=NbCrackedEdges;
    723                 bamgmesh->CrackedEdgesSize[1]=2;
    724                 if (NbCrackedEdges){
    725                         bamgmesh->CrackedEdges=(double*)xmalloc(2*NbCrackedEdges*sizeof(double));
    726                         for (i=0;i<NbCrackedEdges;i++){
    727                                 bamgmesh->CrackedEdges[i*2+0]=Number(CrackedEdges[i].a.edge)+1; //back to M indexing
    728                                 bamgmesh->CrackedEdges[i*2+1]=Number(CrackedEdges[i].b.edge)+1; //back to M indexing
    729                         }
    730                 }
    731 
    732705                /*Triangles*/
    733706                if(verbose>5) printf("      writing Triangles\n");
     
    21932166        }
    21942167        /*}}}1*/
    2195                 /*FUNCTION Triangles::Crack{{{1*/
    2196                 int  Triangles::Crack() {
    2197                         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Crack)*/
    2198                         if (NbCrackedEdges!=0 && NbCrackedVertices<=0);{
    2199                                 throw ErrorException(__FUNCT__,exprintf("NbCrackedEdges!=0 && NbCrackedVertices<=0"));
    2200                         }
    2201                         for (int i=0;i<NbCrackedEdges;i++) CrackedEdges[i].Crack();
    2202                         return NbCrackedEdges;
    2203                 }
    2204                 /*}}}1*/
    2205                 /*FUNCTION Triangles::CrackMesh{{{1*/
    2206                 int Triangles::CrackMesh() {
    2207                         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CrackMesh)*/
    2208 
    2209                         int verbosity=0;
    2210                         int i,k;
    2211                         //  computed the number of cracked edge
    2212                         for (k=i=0;i<nbe;i++)
    2213                          if(edges[i].onGeometry->Cracked()) k++;
    2214                         if( k==0) return 0;
    2215                         printf("      number of Cracked Edges = %i\n",k);
    2216                         NbCrackedEdges =k;
    2217                         CrackedEdges = new  CrackedEdge[k];
    2218                         //  new edge
    2219                         Edge * e = new Edge[ nbe + k];
    2220 
    2221                         // copy
    2222                         for (i=0;i<nbe;i++)
    2223                          e[i] = edges[i];
    2224                         delete edges;
    2225                         edges = e;
    2226 
    2227                         const int  nbe0  = nbe;
    2228                         for (k=i=0;i<nbe0;i++) // on double les arete cracked
    2229                          if(edges[i].onGeometry->Cracked())
    2230                                 {
    2231                                  e[nbe] = e[i];
    2232                                  //  return the edge
    2233                                  e[nbe].v[0] =  e[i].v[1];
    2234                                  e[nbe].v[1] =  e[i].v[0];
    2235                                  e[nbe].onGeometry = e[i].onGeometry->link ; // faux
    2236                                  CrackedEdges[k++]=CrackedEdge(edges,i,nbe);
    2237                                  nbe++;
    2238                                 }
    2239                         ReMakeTriangleContainingTheVertex() ;
    2240                         // 
    2241                         int nbcrakev  =0;
    2242                         Vertex *vlast = vertices + nbv;
    2243                         Vertex *vend = vertices + nbvx; // end of array
    2244                         for (int iv=0;iv<nbv;iv++) // vertex
    2245                           {
    2246                                 Vertex & v= vertices[iv];
    2247                                 Vertex * vv = & v; 
    2248                                 int kk=0; // nb cracked
    2249                                 int kc=0;
    2250                                 int kkk =0; // nb triangle  with same number
    2251                                 Triangle * tbegin = v.t;
    2252                                 int i  = v.vint;       
    2253                                 if (!tbegin || (i<0) || (i>=3)){
    2254                                         throw ErrorException(__FUNCT__,exprintf("!tbegin || (i<0) || (i>=3)"));
    2255                                 }
    2256                                 // turn around the vertex v
    2257                                 TriangleAdjacent ta(tbegin,EdgesVertexTriangle[i][0]);// previous edge
    2258                                 int k=0;
    2259                                 do {
    2260                                         int kv = VerticesOfTriangularEdge[ta][1];
    2261                                         k++;
    2262                                         Triangle * tt (ta);
    2263                                         if ( ta.Cracked() )
    2264                                           {   
    2265                                                 TriangleAdjacent tta=(ta.Adj());
    2266                                                 if (!tta.Cracked()){
    2267                                                         throw ErrorException(__FUNCT__,exprintf("!tta.Cracked()"));
    2268                                                 }
    2269                                                 if ( kk == 0) tbegin=ta,kkk=0;  //  begin by a cracked edge  => restart               
    2270                                                 if (  kkk ) { kc =1;vv = vlast++;  kkk = 0; } // new vertex if use
    2271                                                 kk++;// number of cracked edge view                 
    2272                                           }
    2273                                         if ( tt->link ) { // if good triangles store the value
    2274                                                 int it = Number(tt);
    2275                                                 if (it>=nt){
    2276                                                         throw ErrorException(__FUNCT__,exprintf("(it>=nt)"));
    2277                                                 }
    2278                                                 (*tt)(kv)= vv; //   Change the vertex of triangle
    2279                                                 if(vv<vend) {*vv= v;vv->ReferenceNumber=iv;} // copy the vertex value + store the old vertex number in ref
    2280                                                 //        tt->SetTriangleContainingTheVertex();
    2281                                                 kkk++;
    2282                                         } else if (kk) { // crack + boundary
    2283                                                 if (  kkk ) { kc =1;vv = vlast++;  kkk = 0; } // new vertex if use
    2284                                         }
    2285 
    2286                                         ta = Next(ta).Adj();
    2287                                 } while ( (tbegin != ta));
    2288                                 if (!k){
    2289                                         throw ErrorException(__FUNCT__,exprintf("!k"));
    2290                                 }
    2291                                 if (kc)  nbcrakev++;
    2292                           }
    2293 
    2294                         if ( nbcrakev )
    2295                          for (int iec =0;iec < NbCrackedEdges; iec ++)
    2296                           CrackedEdges[iec].Set();
    2297 
    2298                         //  set the ref
    2299                         NbCrackedVertices =   nbcrakev;
    2300                         // int nbvo = nbv;
    2301                         nbv = vlast - vertices;
    2302                         int nbnewv =  nbv - nbv; // nb of new vrtices
    2303                         if (nbcrakev && verbosity > 1 ) printf("      number of Cracked vertices = %i, number of created vertices = %i\n",nbcrakev,nbnewv);
    2304                         // all the new vertices are on geometry
    2305                         if (nbnewv)
    2306                           { //
    2307                                 long n = nbnewv+NbVerticesOnGeomVertex;
    2308                                 long i,j,k;
    2309                                 VertexOnGeom * vog = new VertexOnGeom[n];
    2310                                 for ( i =0; i<NbVerticesOnGeomVertex;i++)
    2311                                  vog[i]=VerticesOnGeomVertex[i];
    2312                                 delete [] VerticesOnGeomVertex;
    2313                                 VerticesOnGeomVertex = vog;
    2314                                 // loop on cracked edge
    2315                                 Vertex * LastOld = vertices + nbv - nbnewv;
    2316                                 for (int iec =0;iec < NbCrackedEdges; iec ++)
    2317                                  for (k=0;k<2;k++)
    2318                                         {
    2319                                          Edge & e = *( k ? CrackedEdges[iec].a.edge : CrackedEdges[iec].b.edge);
    2320                                          for (j=0;j<2;j++)
    2321                                                 {
    2322                                                  Vertex * v = e(j);
    2323                                                  if ( v >=  LastOld)
    2324                                                         { // a new vertex
    2325                                                          long old = v->ReferenceNumber ; // the old same vertex
    2326                                                          long i  = ( v - LastOld);
    2327                                                          //  if the old is on vertex => warning
    2328                                                          // else the old is on edge => ok
    2329                                                          vog[i] = vog[old];
    2330                                                          //                 vog[i].mv = v;
    2331                                                          //g[i].ge = ;
    2332                                                          //og[i].abcisse = ;
    2333                                                         }
    2334 
    2335                                                 }
    2336                                         }
    2337 
    2338                                 NbVerticesOnGeomVertex = n;
    2339                           }
    2340                         SetVertexFieldOn();
    2341 
    2342                         if (vlast >= vend) { 
    2343                                 throw ErrorException(__FUNCT__,exprintf("Not enougth vertices: to crack the mesh we need %i vertices",nbv));
    2344                         }
    2345                         return  NbCrackedVertices;
    2346                 }
    2347                 /*}}}1*/
    23482168        /*FUNCTION Triangles::ForceBoundary{{{1*/
    23492169                void Triangles::ForceBoundary() {
     
    23812201                                        throw ErrorException(__FUNCT__,exprintf("Missing Edge %i, v0=%i,v1=%i",i,Number(edges[i][0]),Number(edges[i][1])));
    23822202                                }
    2383                                 if ( nbswp >=0 && edges[i].onGeometry->Cracked())
    2384                                  ta.SetCracked();
    23852203                        }
    23862204
     
    39283746        NbVertexOnBThVertex=0;
    39293747        NbVertexOnBThEdge=0;
    3930         VertexOnBThVertex=0;
    3931         VertexOnBThEdge=0;
     3748        VertexOnBThVertex=NULL;
     3749        VertexOnBThEdge=NULL;
    39323750
    39333751        NbCrackedVertices=0;
    3934         NbCrackedEdges =0;
    3935         CrackedEdges  =0
     3752        NbCrackedEdges   =0;
     3753        CrackedEdges     =NULL
    39363754        nbe = 0;
    39373755
     
    39513769        }
    39523770        else {
    3953                 vertices=0;
    3954                 ordre=0;
    3955                 triangles=0;
     3771                vertices=NULL;
     3772                ordre=NULL;
     3773                triangles=NULL;
    39563774                nbtx=0;
    39573775        }
    39583776
    3959         quadtree=0;
    3960         edges=0;
    3961         VerticesOnGeomVertex=0;
    3962         VerticesOnGeomEdge=0;
     3777        quadtree=NULL;
     3778        edges=NULL;
     3779        VerticesOnGeomVertex=NULL;
     3780        VerticesOnGeomEdge=NULL;
    39633781        NbVerticesOnGeomVertex=0;
    39643782        NbVerticesOnGeomEdge=0;
    3965         subdomains=0;
     3783        subdomains=NULL;
    39663784        NbSubDomains=0;
    39673785}
     
    54675285}
    54685286/*}}}1*/
    5469 /*FUNCTION Triangles::UnCrack{{{1*/
    5470 int Triangles::UnCrack() {
    5471         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/UnCrack)*/
    5472 
    5473         if (NbCrackedEdges!=0 && NbCrackedVertices<=0);{
    5474                 throw ErrorException(__FUNCT__,exprintf("NbCrackedEdges ==0 || NbCrackedVertices >0"));
    5475         }
    5476         for (int i=0;i<NbCrackedEdges;i++)
    5477          CrackedEdges[i].UnCrack();
    5478         return NbCrackedEdges;
    5479 }
    5480 /*}}}1*/
    54815287
    54825288        /*Intermediary*/
  • issm/trunk/src/c/Bamgx/objects/Triangles.h

    r3301 r3325  
    5959                        long NbCrackedVertices;
    6060                        long NbCrackedEdges;
    61                         CrackedEdge *CrackedEdges;
     61                        CrackedEdge* CrackedEdges;
    6262                        R2 pmin,pmax;    // extrema
    6363                        double coefIcoor; // coef to integer Icoor1;
     
    143143                        void AddGeometryMetric(BamgOpts* bamgopts);
    144144                        int  isCracked() const {return NbCrackedVertices != 0;}
    145                         int  Crack();
    146                         int  UnCrack();
    147145                        void BuildGeometryFromMesh(BamgOpts* bamgopts=NULL);
    148146                        void ReconstructExistingMesh();
    149                         int  CrackMesh();
    150147
    151148                        //Inline methods
Note: See TracChangeset for help on using the changeset viewer.