← Back to branch summary

~ubuntu-branches/debian/squeeze/gmsh/squeeze

« back to all changes in this revision

Viewing changes to Mesh/meshGFaceBDS.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Christophe Prud'homme, Christophe Prud'homme
  • Date: 2009-09-27 17:36:40 UTC
  • mfrom: (1.2.9 upstream) (8.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090927173640-oxyhzt0eadjfrlwz
[Christophe Prud'homme]
* New upstream release
  + solver code refactoring
  + better IDE integration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Mesh/meshGFaceBDS.cpp
5
5
 
6
6
#include <stdlib.h>
7
7
#include "GmshMessage.h"
8
 
#include "GmshPredicates.h"
 
8
#include "robustPredicates.h"
9
9
#include "meshGFace.h"
10
10
#include "meshGFaceOptimize.h"
11
11
#include "BackgroundMesh.h"
319
319
  double op2x[3] = {op[1]->X, op[1]->Y, op[1]->Z};
320
320
  double fourth[3];
321
321
  fourthPoint(p1x, p2x, op1x, fourth);
322
 
  double result = gmsh::insphere(p1x, p2x, op1x, fourth, op2x) * 
323
 
    gmsh::orient3d(p1x, p2x, op1x, fourth);  
 
322
  double result = robustPredicates::insphere(p1x, p2x, op1x, fourth, op2x) * 
 
323
    robustPredicates::orient3d(p1x, p2x, op1x, fourth);  
324
324
  return result > 0.;
325
325
}
326
326
 
425
425
  }  
426
426
}
427
427
 
428
 
void gmshDelaunayizeBDS(GFace *gf, BDS_Mesh &m, int &nb_swap)
 
428
void delaunayizeBDS(GFace *gf, BDS_Mesh &m, int &nb_swap)
429
429
{
430
430
  nb_swap = 0;
431
431
  std::set<swapquad> configs;
640
640
  }
641
641
}
642
642
 
643
 
void gmshRefineMeshBDS(GFace *gf, BDS_Mesh &m, const int NIT, 
644
 
                       const bool computeNodalSizeField,
645
 
                       std::map<MVertex*, BDS_Point*> *recoverMapInv)
 
643
void refineMeshBDS(GFace *gf, BDS_Mesh &m, const int NIT, 
 
644
                   const bool computeNodalSizeField,
 
645
                   std::map<MVertex*, BDS_Point*> *recoverMapInv)
646
646
{
647
647
  int IT = 0;
648
648
  int MAXNP = m.MAXPOINTNUMBER;
833
833
// if not do not allow p1 v and p2 v, split them
834
834
// if p1 p2 exists and it is internal, split it
835
835
 
836
 
int gmshSolveInvalidPeriodic(GFace *gf, BDS_Mesh &m, 
837
 
                             std::map<BDS_Point*, MVertex*> *recoverMap)
 
836
int solveInvalidPeriodic(GFace *gf, BDS_Mesh &m, 
 
837
                         std::map<BDS_Point*, MVertex*> *recoverMap)
838
838
{
839
839
  std::set<BDS_Edge*> toSplit;
840
840
  invalidEdgesPeriodic(m, recoverMap, toSplit);
862
862
  return toSplit.size();
863
863
}
864
864
 
865
 
void gmshOptimizeMeshBDS(GFace *gf, BDS_Mesh &m, const int NIT, 
866
 
                         std::map<BDS_Point*,MVertex*> *recoverMap=0)
 
865
void optimizeMeshBDS(GFace *gf, BDS_Mesh &m, const int NIT, 
 
866
                     std::map<BDS_Point*,MVertex*> *recoverMap=0)
867
867
{
868
868
  int nb_swap;
869
 
  gmshDelaunayizeBDS(gf, m, nb_swap);
 
869
  delaunayizeBDS(gf, m, nb_swap);
870
870
 
871
871
  for (int ITER = 0; ITER < 3; ITER++){
872
872
    for (int KK = 0; KK < 4; KK++){
887
887
  }
888
888
  
889
889
  if (recoverMap){
890
 
    while(gmshSolveInvalidPeriodic(gf, m, recoverMap)){
 
890
    while(solveInvalidPeriodic(gf, m, recoverMap)){
891
891
    }  
892
892
  }
893
893
}
898
898
{
899
899
  m.split_face(f, v);
900
900
  int nb_swap = 0;
901
 
  gmshDelaunayizeBDS(gf, m, nb_swap);
 
901
  delaunayizeBDS(gf, m, nb_swap);
902
902
}
903
903
 
904
904
// build the BDS from a list of GFace
936
936
  return m;
937
937
}
938
938
 
939
 
void gmshCollapseSmallEdges(GModel &gm)
 
939
void collapseSmallEdges(GModel &gm)
940
940
{
941
941
  return;
942
942
  // gm.renumberMeshVertices(true);