diff --git a/Mesh/BDS.cpp b/Mesh/BDS.cpp
index 8cbaef737b8a7749367bad3bda807b98a69ea2f0..3d2a5e81777b7ae8a3d09f2fb63f19f8a6ac6afd 100644
--- a/Mesh/BDS.cpp
+++ b/Mesh/BDS.cpp
@@ -700,9 +700,9 @@ bool BDS_Mesh::split_edge(BDS_Edge *e, BDS_Point *mid)
e->oppositeof(op);
int CHECK1 = -1, CHECK2 = -1;
-
- if (p1->iD == CHECK1 && p2->iD == CHECK2)
- printf("coucou %d %d %d %d\n",p1->iD,p2->iD,op[0]->iD,op[1]->iD);
+
+ if(p1->iD == CHECK1 && p2->iD == CHECK2)
+ printf("coucou %d %d %d %d\n", p1->iD, p2->iD, op[0]->iD, op[1]->iD);
double ori0 = fabs(surface_triangle_param(p2, p1, op[0])) +
fabs(surface_triangle_param(p2, p1, op[1]));
@@ -718,8 +718,8 @@ bool BDS_Mesh::split_edge(BDS_Edge *e, BDS_Point *mid)
// return false;
}
- if (p1->iD == CHECK1 && p2->iD == CHECK2)
- printf("coucou 2 %d %d %d %d\n",p1->iD,p2->iD,op[0]->iD,op[1]->iD);
+ if(p1->iD == CHECK1 && p2->iD == CHECK2)
+ printf("coucou 2 %d %d %d %d\n", p1->iD, p2->iD, op[0]->iD, op[1]->iD);
BDS_Point *pts1[4];
e->faces(0)->getNodes(pts1);
@@ -833,14 +833,17 @@ bool BDS_SwapEdgeTestQuality::operator()(BDS_Point *_p1, BDS_Point *_p2,
{
if(!testSmallTriangles) return true;
- // AVOID CREATING POINTS WITH 2 NEIGHBORING TRIANGLES
+ // AVOID CREATING POINTS WITH 2 NEIGHBORING TRIANGLES
// std::vector<BDS_Face*> f1 = p1->getTriangles();
// std::vector<BDS_Face*> f2 = p2->getTriangles();
- if (_p1->g && _p1->g->classif_degree == 2 && _p1->edges.size() <= 4)return false;
- if (_p2->g && _p2->g->classif_degree == 2 && _p2->edges.size() <= 4)return false;
- if (_p1->g && _p1->g->classif_degree < 2 && _p1->edges.size() <= 3)return false;
- if (_p2->g && _p2->g->classif_degree < 2 && _p2->edges.size() <= 3)return false;
-
+ if(_p1->g && _p1->g->classif_degree == 2 && _p1->edges.size() <= 4)
+ return false;
+ if(_p2->g && _p2->g->classif_degree == 2 && _p2->edges.size() <= 4)
+ return false;
+ if(_p1->g && _p1->g->classif_degree < 2 && _p1->edges.size() <= 3)
+ return false;
+ if(_p2->g && _p2->g->classif_degree < 2 && _p2->edges.size() <= 3)
+ return false;
double s1 = fabs(surface_triangle_param(_p1, _p2, _q1));
double s2 = fabs(surface_triangle_param(_p1, _p2, _q2));
@@ -944,11 +947,11 @@ bool BDS_SwapEdgeTestQuality::operator()(BDS_Point *_p1, BDS_Point *_p2,
bool BDS_SwapEdgeTestNormals::operator()(BDS_Point *_p1, BDS_Point *_p2,
BDS_Point *_q1, BDS_Point *_q2) const
{
-
- // if (_p1->g && _p1->g->classif_degree == 2 && _p1->edges.size() <= 4)return false;
- // if (_p2->g && _p2->g->classif_degree == 2 && _p2->edges.size() <= 4)return false;
- // if (_p1->g && _p1->g->classif_degree < 2 && _p1->edges.size() <= 3)return false;
- // if (_p2->g && _p2->g->classif_degree < 2 && _p2->edges.size() <= 3)return false;
+ // if (_p1->g && _p1->g->classif_degree == 2 && _p1->edges.size() <= 4)return
+ // false; if (_p2->g && _p2->g->classif_degree == 2 && _p2->edges.size() <=
+ // 4)return false; if (_p1->g && _p1->g->classif_degree < 2 &&
+ // _p1->edges.size() <= 3)return false; if (_p2->g && _p2->g->classif_degree
+ // < 2 && _p2->edges.size() <= 3)return false;
double s1 = fabs(surface_triangle_param(_p1, _p2, _q1));
double s2 = fabs(surface_triangle_param(_p1, _p2, _q2));
@@ -973,9 +976,8 @@ bool BDS_SwapEdgeTestNormals::operator()(BDS_Point *_p1, BDS_Point *_p2,
double qb1 = qmTriangle::gamma(_op1, _op2, _op3);
double qb2 = qmTriangle::gamma(_oq1, _oq2, _oq3);
- double mina = std::min(qa1, qa2);
- double minb = std::min(qb1, qb2);
-
+ //double mina = std::min(qa1, qa2);
+ //double minb = std::min(qb1, qb2);
// if(minb > 5 * mina) return true;
double OLD = std::min(_ori * qa1 * _COS_N(_p1, _p2, _p3, gf),
@@ -1248,25 +1250,28 @@ bool BDS_Mesh::collapse_edge_parametric(BDS_Edge *e, BDS_Point *p, bool force)
if(e->g->classif_degree == 2 && p->g != e->g) return false;
}
- if (!force){
- for (size_t i = 0 ; i < e->p1->edges.size(); i ++){
- for (size_t j = 0 ; j < e->p2->edges.size(); j ++){
- BDS_Point *p1 = e->p1->edges[i]->p1 == e->p1 ? e->p1->edges[i]->p2 : e->p1->edges[i]->p1;
- BDS_Point *p2 = e->p2->edges[j]->p1 == e->p2 ? e->p2->edges[j]->p2 : e->p2->edges[j]->p1;
- if (p1->_periodicCounterpart == p2)return false;
+ if(!force) {
+ for(size_t i = 0; i < e->p1->edges.size(); i++) {
+ for(size_t j = 0; j < e->p2->edges.size(); j++) {
+ BDS_Point *p1 = e->p1->edges[i]->p1 == e->p1 ? e->p1->edges[i]->p2 :
+ e->p1->edges[i]->p1;
+ BDS_Point *p2 = e->p2->edges[j]->p1 == e->p2 ? e->p2->edges[j]->p2 :
+ e->p2->edges[j]->p1;
+ if(p1->_periodicCounterpart == p2) return false;
}
}
}
-
if(e->numfaces() == 2) {
BDS_Point *oface[2];
e->oppositeof(oface);
- for (size_t i = 0; i < oface[0]->edges.size();i++){
- if ( oface[0]->edges[i]->p1 == oface[0] &&
- oface[0]->edges[i]->p2 == oface[1] )return false;
- if ( oface[0]->edges[i]->p1 == oface[1] &&
- oface[0]->edges[i]->p2 == oface[0] )return false;
+ for(size_t i = 0; i < oface[0]->edges.size(); i++) {
+ if(oface[0]->edges[i]->p1 == oface[0] &&
+ oface[0]->edges[i]->p2 == oface[1])
+ return false;
+ if(oface[0]->edges[i]->p1 == oface[1] &&
+ oface[0]->edges[i]->p2 == oface[0])
+ return false;
}
if(!force && oface[0]->g && oface[0]->g->classif_degree == 2 &&
oface[0]->edges.size() <= 4)
@@ -1281,7 +1286,7 @@ bool BDS_Mesh::collapse_edge_parametric(BDS_Edge *e, BDS_Point *p, bool force)
oface[1]->edges.size() <= 3)
return false;
}
-
+
std::vector<BDS_Face *> t = p->getTriangles();
BDS_Point *o = e->othervertex(p);
diff --git a/Mesh/BDS.h b/Mesh/BDS.h
index 80629527827b13431e8780ddcd406056a6d8756c..199e6074b76cb70f870d0f1f254c663e99b44222 100644
--- a/Mesh/BDS.h
+++ b/Mesh/BDS.h
@@ -157,8 +157,8 @@ public:
std::vector<BDS_Face *> getTriangles() const;
BDS_Point(int id, double x = 0, double y = 0, double z = 0)
: _lcBGM(1.e22), _lcPTS(1.e22), X(x), Y(y), Z(z), u(0), v(0),
- config_modified(true), degenerated(false),
- _periodicCounterpart(NULL), iD(id), g(0)
+ config_modified(true), degenerated(false), _periodicCounterpart(NULL),
+ iD(id), g(0)
{
}
};
diff --git a/Mesh/BGMBase.cpp b/Mesh/BGMBase.cpp
index 1c8926a5c958edc0a46b35fba071dc00e7fde172..98ea3f06b411b793765642a3b911193799c34de9 100644
--- a/Mesh/BGMBase.cpp
+++ b/Mesh/BGMBase.cpp
@@ -16,53 +16,57 @@ void BGMBase::export_scalar(const std::string &filename,
const DoubleStorageType &_whatToPrint) const
{
FILE *f = Fopen(filename.c_str(), "w");
- if(!f){
+ if(!f) {
Msg::Error("Could not open file '%s'", filename.c_str());
return;
}
- fprintf(f,"View \"Background Mesh\"{\n");
+ fprintf(f, "View \"Background Mesh\"{\n");
const MElement *elem;
int nvertex;
int type;
- for(unsigned int i=0;i<getNumMeshElements();i++){
+ for(unsigned int i = 0; i < getNumMeshElements(); i++) {
elem = getElement(i);
nvertex = elem->getNumVertices();
type = elem->getType();
const char *s = 0;
- switch(type){
- case TYPE_PNT: s = "SP"; break;
- case TYPE_LIN: s = "SL"; break;
- case TYPE_TRI: s = "ST"; break;
- case TYPE_QUA: s = "SQ"; break;
- case TYPE_TET: s = "SS"; break;
- case TYPE_HEX: s = "SH"; break;
- case TYPE_PRI: s = "SI"; break;
- case TYPE_PYR: s = "SY"; break;
- default: throw;
+ switch(type) {
+ case TYPE_PNT: s = "SP"; break;
+ case TYPE_LIN: s = "SL"; break;
+ case TYPE_TRI: s = "ST"; break;
+ case TYPE_QUA: s = "SQ"; break;
+ case TYPE_TET: s = "SS"; break;
+ case TYPE_HEX: s = "SH"; break;
+ case TYPE_PRI: s = "SI"; break;
+ case TYPE_PYR: s = "SY"; break;
+ default: throw;
}
- fprintf(f,"%s(",s);
+ fprintf(f, "%s(", s);
const MVertex *v;
std::vector<double> values(nvertex);
- for (int iv=0;iv<nvertex;iv++){
+ for(int iv = 0; iv < nvertex; iv++) {
v = elem->getVertex(iv);
- values[iv] = get_nodal_value(v,_whatToPrint);
- //GPoint p = gf->point(SPoint2(v->x(),v->y()));
+ values[iv] = get_nodal_value(v, _whatToPrint);
+ // GPoint p = gf->point(SPoint2(v->x(),v->y()));
GPoint p = get_GPoint_from_MVertex(v);
- fprintf(f,"%g,%g,%g",p.x(),p.y(),p.z());
- if (iv!=nvertex-1) fprintf(f,",");
- else fprintf(f,"){");
+ fprintf(f, "%g,%g,%g", p.x(), p.y(), p.z());
+ if(iv != nvertex - 1)
+ fprintf(f, ",");
+ else
+ fprintf(f, "){");
}
- for (int iv=0;iv<nvertex;iv++){
- fprintf(f,"%g",values[iv]);
- if (iv!=nvertex-1) fprintf(f,",");
- else fprintf(f,"};\n");
+ for(int iv = 0; iv < nvertex; iv++) {
+ fprintf(f, "%g", values[iv]);
+ if(iv != nvertex - 1)
+ fprintf(f, ",");
+ else
+ fprintf(f, "};\n");
}
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
fclose(f);
}
@@ -70,101 +74,102 @@ void BGMBase::export_vector(const std::string &filename,
const VectorStorageType &_whatToPrint) const
{
FILE *f = Fopen(filename.c_str(), "w");
- if(!f){
+ if(!f) {
Msg::Error("Could not open file '%s'", filename.c_str());
return;
}
- fprintf(f,"View \"Background Mesh\"{\n");
+ fprintf(f, "View \"Background Mesh\"{\n");
const MElement *elem;
int nvertex;
int type;
- for(unsigned int i=0;i<getNumMeshElements();i++){
+ for(unsigned int i = 0; i < getNumMeshElements(); i++) {
elem = getElement(i);
nvertex = elem->getNumVertices();
type = elem->getType();
const char *s = 0;
- switch(type){
- case TYPE_PNT: s = "VP"; break;
- case TYPE_LIN: s = "VL"; break;
- case TYPE_TRI: s = "VT"; break;
- case TYPE_QUA: s = "VQ"; break;
- case TYPE_TET: s = "VS"; break;
- case TYPE_HEX: s = "VH"; break;
- case TYPE_PRI: s = "VI"; break;
- case TYPE_PYR: s = "VY"; break;
- default: throw;
+ switch(type) {
+ case TYPE_PNT: s = "VP"; break;
+ case TYPE_LIN: s = "VL"; break;
+ case TYPE_TRI: s = "VT"; break;
+ case TYPE_QUA: s = "VQ"; break;
+ case TYPE_TET: s = "VS"; break;
+ case TYPE_HEX: s = "VH"; break;
+ case TYPE_PRI: s = "VI"; break;
+ case TYPE_PYR: s = "VY"; break;
+ default: throw;
}
- fprintf(f,"%s(",s);
+ fprintf(f, "%s(", s);
const MVertex *v;
- std::vector<double> values(nvertex*3);
- for (int iv=0;iv<nvertex;iv++){
+ std::vector<double> values(nvertex * 3);
+ for(int iv = 0; iv < nvertex; iv++) {
v = elem->getVertex(iv);
- std::vector<double> temp = get_nodal_value(v,_whatToPrint);
- for (int j=0;j<3;j++)
- values[iv*3+j] = temp[j];
+ std::vector<double> temp = get_nodal_value(v, _whatToPrint);
+ for(int j = 0; j < 3; j++) values[iv * 3 + j] = temp[j];
GPoint p = get_GPoint_from_MVertex(v);
- fprintf(f,"%g,%g,%g",p.x(),p.y(),p.z());
- if (iv!=nvertex-1) fprintf(f,",");
- else fprintf(f,"){");
+ fprintf(f, "%g,%g,%g", p.x(), p.y(), p.z());
+ if(iv != nvertex - 1)
+ fprintf(f, ",");
+ else
+ fprintf(f, "){");
}
- for (int iv=0;iv<nvertex;iv++){
- for (int j=0;j<3;j++){
- fprintf(f,"%g",values[iv*3+j]);
- if (!((iv==nvertex-1)&&(j==2))) fprintf(f,",");
- else fprintf(f,"};\n");
+ for(int iv = 0; iv < nvertex; iv++) {
+ for(int j = 0; j < 3; j++) {
+ fprintf(f, "%g", values[iv * 3 + j]);
+ if(!((iv == nvertex - 1) && (j == 2)))
+ fprintf(f, ",");
+ else
+ fprintf(f, "};\n");
}
}
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
fclose(f);
}
-
-void BGMBase::export_tensor_as_vectors(const std::string &filename,
- const TensorStorageType &_whatToPrint) const
+void BGMBase::export_tensor_as_vectors(
+ const std::string &filename, const TensorStorageType &_whatToPrint) const
{
FILE *f = Fopen(filename.c_str(), "w");
- if(!f){
+ if(!f) {
Msg::Error("Could not open file '%s'", filename.c_str());
return;
}
- fprintf(f,"View \"Background Mesh\"{\n");
+ fprintf(f, "View \"Background Mesh\"{\n");
TensorStorageType::const_iterator it = _whatToPrint.begin();
const char *s = "VP";
- for (;it!=_whatToPrint.end();it++){// for all vertices
- GPoint p = get_GPoint_from_MVertex( it->first);
- for (int i=0;i<3;i++){
- fprintf(f,"%s(%g,%g,%g){%g,%g,%g};\n",s,p.x(),p.y(),p.z(),
- (it->second)(0,i),(it->second)(1,i),(it->second)(2,i));
- fprintf(f,"%s(%g,%g,%g){%g,%g,%g};\n",s,p.x(),p.y(),p.z(),
- -(it->second)(0,i),-(it->second)(1,i),-(it->second)(2,i));
+ for(; it != _whatToPrint.end(); it++) { // for all vertices
+ GPoint p = get_GPoint_from_MVertex(it->first);
+ for(int i = 0; i < 3; i++) {
+ fprintf(f, "%s(%g,%g,%g){%g,%g,%g};\n", s, p.x(), p.y(), p.z(),
+ (it->second)(0, i), (it->second)(1, i), (it->second)(2, i));
+ fprintf(f, "%s(%g,%g,%g){%g,%g,%g};\n", s, p.x(), p.y(), p.z(),
+ -(it->second)(0, i), -(it->second)(1, i), -(it->second)(2, i));
}
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
fclose(f);
}
-BGMBase::BGMBase(int dim,GEntity *_gf):octree(NULL),gf(_gf), DIM(dim), order(1)
+BGMBase::BGMBase(int dim, GEntity *_gf)
+ : octree(NULL), gf(_gf), DIM(dim), order(1)
{
}
-BGMBase::~BGMBase()
-{
-}
+BGMBase::~BGMBase() {}
-bool BGMBase::inDomain (double u, double v, double w)
+bool BGMBase::inDomain(double u, double v, double w)
{
return (findElement(u, v, w) != NULL);
}
-const MElement* BGMBase::findElement(double u, double v, double w, bool strict)
+const MElement *BGMBase::findElement(double u, double v, double w, bool strict)
{
return (getOctree()->find(u, v, w, DIM, strict));
}
@@ -173,20 +178,20 @@ std::vector<double> BGMBase::get_field_value(double u, double v, double w,
const VectorStorageType &data)
{
// TODO C++11 remove const_cast and enforce const-correctness otherwise
- MElement *e = const_cast<MElement*>(findElement(u, v, w ));
+ MElement *e = const_cast<MElement *>(findElement(u, v, w));
- if (!e) return std::vector<double>(3,-1000.);
+ if(!e) return std::vector<double>(3, -1000.);
- std::vector<std::vector<double> > val = get_nodal_values(e,data);
- std::vector<double> element_uvw = get_element_uvw_from_xyz(e,u,v,w);
+ std::vector<std::vector<double> > val = get_nodal_values(e, data);
+ std::vector<double> element_uvw = get_element_uvw_from_xyz(e, u, v, w);
std::vector<double> res(3);
- for (int j=0;j<3;j++) {
+ for(int j = 0; j < 3; j++) {
std::vector<double> values(e->getNumVertices());
- for (std::size_t i=0;i<e->getNumVertices();i++){
- values[i]=val[i][j];
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) {
+ values[i] = val[i][j];
}
res[j] = e->interpolate(&values[0], element_uvw[0], element_uvw[1],
element_uvw[2], 1, order);
@@ -198,13 +203,12 @@ double BGMBase::get_field_value(double u, double v, double w,
const DoubleStorageType &data)
{
// TODO C++11 Remove const_cast
- MElement *e = const_cast<MElement*>(findElement(u, v, w));
- if (!e) return -1000.;
- std::vector<double> val = get_nodal_values(e,data);
- std::vector<double> element_uvw = get_element_uvw_from_xyz(e,u,v,w);
+ MElement *e = const_cast<MElement *>(findElement(u, v, w));
+ if(!e) return -1000.;
+ std::vector<double> val = get_nodal_values(e, data);
+ std::vector<double> element_uvw = get_element_uvw_from_xyz(e, u, v, w);
std::vector<double> values(e->getNumVertices());
- for (std::size_t i=0;i<e->getNumVertices();i++)
- values[i]=val[i];
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) values[i] = val[i];
return e->interpolate(&values[0], element_uvw[0], element_uvw[1],
element_uvw[2], 1, order);
@@ -212,29 +216,27 @@ double BGMBase::get_field_value(double u, double v, double w,
double BGMBase::size(double u, double v, double w)
{
- return get_field_value(u,v,w,sizeField);
+ return get_field_value(u, v, w, sizeField);
}
-double BGMBase::size(const MVertex *v)
-{
- return get_nodal_value(v,sizeField);
-}
+double BGMBase::size(const MVertex *v) { return get_nodal_value(v, sizeField); }
-std::vector<double> BGMBase::get_nodal_value(const MVertex *v,
- const VectorStorageType &data) const
+std::vector<double>
+BGMBase::get_nodal_value(const MVertex *v, const VectorStorageType &data) const
{
VectorStorageType::const_iterator itfind = data.find(v);
- if (itfind==data.end()){
+ if(itfind == data.end()) {
Msg::Error("Unknown vertex %d in BGMBase::get_nodal_value", v->getNum());
- return std::vector<double>(3,0.);
+ return std::vector<double>(3, 0.);
}
return itfind->second;
}
-double BGMBase::get_nodal_value(const MVertex *v,const DoubleStorageType &data) const
+double BGMBase::get_nodal_value(const MVertex *v,
+ const DoubleStorageType &data) const
{
DoubleStorageType::const_iterator itfind = data.find(v);
- if (itfind==data.end()){
+ if(itfind == data.end()) {
Msg::Error("Unknown vertex %d in BGMBase::get_nodal_value", v->getNum());
return 0.;
}
@@ -242,31 +244,34 @@ double BGMBase::get_nodal_value(const MVertex *v,const DoubleStorageType &data)
}
std::vector<std::vector<double> >
-BGMBase::get_nodal_values(const MElement *e,const VectorStorageType &data) const
+BGMBase::get_nodal_values(const MElement *e,
+ const VectorStorageType &data) const
{
std::vector<std::vector<double> > res(e->getNumVertices());
- for (std::size_t i=0;i<e->getNumVertices();i++){
- VectorStorageType::const_iterator itfind = data.find(const_cast<MVertex*>(e->getVertex(i)));
- for (int j=0;j<3;j++)
- res[i].push_back((itfind->second)[j]);
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) {
+ VectorStorageType::const_iterator itfind =
+ data.find(const_cast<MVertex *>(e->getVertex(i)));
+ for(int j = 0; j < 3; j++) res[i].push_back((itfind->second)[j]);
}
return res;
}
-std::vector<double> BGMBase::get_nodal_values(const MElement *element,
- const DoubleStorageType &data) const
+std::vector<double>
+BGMBase::get_nodal_values(const MElement *element,
+ const DoubleStorageType &data) const
{
- std::vector<double> res(element->getNumVertices(),0.);
+ std::vector<double> res(element->getNumVertices(), 0.);
- for (std::size_t i=0;i<element->getNumVertices();i++)
- //res[i] = (data.find(const_cast<MVertex*>(e->getVertex(i))))->second;
+ for(std::size_t i = 0; i < element->getNumVertices(); i++)
+ // res[i] = (data.find(const_cast<MVertex*>(e->getVertex(i))))->second;
res[i] = data.find(element->getVertex(i))->second;
return res;
}
-std::vector<double> BGMBase::get_element_uvw_from_xyz (const MElement *e, double x,
- double y, double z) const
+std::vector<double> BGMBase::get_element_uvw_from_xyz(const MElement *e,
+ double x, double y,
+ double z) const
{
std::vector<double> res(3);
@@ -276,20 +281,17 @@ std::vector<double> BGMBase::get_element_uvw_from_xyz (const MElement *e, double
return res;
}
-std::set<MVertex*> BGMBase::get_vertices_of_maximum_dim(int dim)
+std::set<MVertex *> BGMBase::get_vertices_of_maximum_dim(int dim)
{
- std::set<MVertex*> bnd_vertices;
- for(unsigned int i=0;i<gf->getNumMeshElements();i++){
- MElement* element = gf->getMeshElement(i);
- for(std::size_t j=0;j<element->getNumVertices();j++){
+ std::set<MVertex *> bnd_vertices;
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
+ MElement *element = gf->getMeshElement(i);
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
MVertex *vertex = element->getVertex(j);
- if (vertex->onWhat()->dim() <= dim)bnd_vertices.insert(vertex);
+ if(vertex->onWhat()->dim() <= dim) bnd_vertices.insert(vertex);
}
}
return bnd_vertices;
}
-GEntity* BGMBase::getBackgroundGEntity()
-{
- return gf;
-}
+GEntity *BGMBase::getBackgroundGEntity() { return gf; }
diff --git a/Mesh/BGMBase.h b/Mesh/BGMBase.h
index 97f5d57969833e2ca2707eaa020d37d1210af9d0..b2b04ca6720f64f3327eca3f9bffbef102930324 100644
--- a/Mesh/BGMBase.h
+++ b/Mesh/BGMBase.h
@@ -6,7 +6,6 @@
#ifndef _BACKGROUND_MESH_BASE_H_
#define _BACKGROUND_MESH_BASE_H_
-
#include <string>
#include <map>
#include <vector>
@@ -19,7 +18,6 @@
//#include <tr1/unordered_map>
//#include <tr1/unordered_set>
-
class MElementOctree;
class GFace;
class GRegion;
@@ -30,68 +28,84 @@ class MElement;
class MVertex;
class GEntity;
-class BGMBase{
- public:
- typedef MVertex const* const hash_key_ptr;
-// typedef tr1::unordered_map<hash_key_ptr, STensor3 > TensorStorageType;
-// typedef tr1::unordered_map<hash_key_ptr, double > DoubleStorageType;
-// typedef tr1::unordered_map<hash_key_ptr, vector<double> > VectorStorageType;
- typedef std::map<hash_key_ptr, STensor3 > TensorStorageType;
- typedef std::map<hash_key_ptr, double > DoubleStorageType;
- typedef std::map<hash_key_ptr, std::vector<double> > VectorStorageType;
-
- protected:
- mutable MElementOctree *octree;
- GEntity *gf;
-
-
- DoubleStorageType sizeField; // an attached size field
-
-
- int DIM,order;
-
- virtual void export_scalar(const std::string &filename, const DoubleStorageType&) const;
- virtual void export_vector(const std::string &filename, const VectorStorageType&) const;
- virtual void export_tensor_as_vectors(const std::string &filename, const TensorStorageType &_whatToPrint)const;
-
- virtual void propagateValues(DoubleStorageType &dirichlet, simpleFunction<double> &eval_diffusivity, bool in_parametric_plane = false)=0;
- virtual void computeSizeField()=0;
- virtual GPoint get_GPoint_from_MVertex(const MVertex *) const=0;
- virtual const MElement* getElement(unsigned int i)const=0;
- virtual unsigned int getNumMeshElements()const=0;
-
- virtual std::vector<double> get_nodal_values(const MElement *e,const DoubleStorageType &data)const;
- virtual std::vector<std::vector<double> > get_nodal_values(const MElement *e,const VectorStorageType &data)const;
-
- virtual std::vector<double> get_nodal_value(const MVertex *v,const VectorStorageType &data)const;
- virtual double get_nodal_value(const MVertex *v,const DoubleStorageType &data)const;
-
- virtual std::vector<double> get_element_uvw_from_xyz (const MElement *e, double x, double y,double z) const;
-
- virtual double get_field_value(double u, double v, double w, const DoubleStorageType &data);
- virtual std::vector<double> get_field_value(double u, double v, double w, const VectorStorageType &data);
-
-
- public:
- BGMBase(int dim,GEntity *_gf);
- ~BGMBase();
-
- virtual MElementOctree* getOctree()=0;
-
- virtual GEntity* getBackgroundGEntity();
-
- virtual double size(double u, double v, double w=0.);// get the size field, element interpolation
- virtual double size(const MVertex *v);// get the nodal size field
-
- virtual bool inDomain (double u, double v, double w=0.);
-
- virtual inline void exportSizeField(const std::string &filename) const{export_scalar(filename,sizeField);};
-
- // warning: these are "3D", "real" vertices, not copies in a parametric domain
- virtual std::set<MVertex*> get_vertices_of_maximum_dim(int dim);
- virtual const MElement* findElement(double u, double v, double w=0.,bool strict=true);
-
+class BGMBase {
+public:
+ typedef MVertex const *const hash_key_ptr;
+ // typedef tr1::unordered_map<hash_key_ptr, STensor3 > TensorStorageType;
+ // typedef tr1::unordered_map<hash_key_ptr, double > DoubleStorageType;
+ // typedef tr1::unordered_map<hash_key_ptr, vector<double> >
+ // VectorStorageType;
+ typedef std::map<hash_key_ptr, STensor3> TensorStorageType;
+ typedef std::map<hash_key_ptr, double> DoubleStorageType;
+ typedef std::map<hash_key_ptr, std::vector<double> > VectorStorageType;
+
+protected:
+ mutable MElementOctree *octree;
+ GEntity *gf;
+
+ DoubleStorageType sizeField; // an attached size field
+
+ int DIM, order;
+
+ virtual void export_scalar(const std::string &filename,
+ const DoubleStorageType &) const;
+ virtual void export_vector(const std::string &filename,
+ const VectorStorageType &) const;
+ virtual void
+ export_tensor_as_vectors(const std::string &filename,
+ const TensorStorageType &_whatToPrint) const;
+
+ virtual void propagateValues(DoubleStorageType &dirichlet,
+ simpleFunction<double> &eval_diffusivity,
+ bool in_parametric_plane = false) = 0;
+ virtual void computeSizeField() = 0;
+ virtual GPoint get_GPoint_from_MVertex(const MVertex *) const = 0;
+ virtual const MElement *getElement(unsigned int i) const = 0;
+ virtual unsigned int getNumMeshElements() const = 0;
+
+ virtual std::vector<double>
+ get_nodal_values(const MElement *e, const DoubleStorageType &data) const;
+ virtual std::vector<std::vector<double> >
+ get_nodal_values(const MElement *e, const VectorStorageType &data) const;
+
+ virtual std::vector<double>
+ get_nodal_value(const MVertex *v, const VectorStorageType &data) const;
+ virtual double get_nodal_value(const MVertex *v,
+ const DoubleStorageType &data) const;
+
+ virtual std::vector<double> get_element_uvw_from_xyz(const MElement *e,
+ double x, double y,
+ double z) const;
+
+ virtual double get_field_value(double u, double v, double w,
+ const DoubleStorageType &data);
+ virtual std::vector<double> get_field_value(double u, double v, double w,
+ const VectorStorageType &data);
+
+public:
+ BGMBase(int dim, GEntity *_gf);
+ ~BGMBase();
+
+ virtual MElementOctree *getOctree() = 0;
+
+ virtual GEntity *getBackgroundGEntity();
+
+ virtual double
+ size(double u, double v,
+ double w = 0.); // get the size field, element interpolation
+ virtual double size(const MVertex *v); // get the nodal size field
+
+ virtual bool inDomain(double u, double v, double w = 0.);
+
+ virtual inline void exportSizeField(const std::string &filename) const
+ {
+ export_scalar(filename, sizeField);
+ };
+
+ // warning: these are "3D", "real" vertices, not copies in a parametric domain
+ virtual std::set<MVertex *> get_vertices_of_maximum_dim(int dim);
+ virtual const MElement *findElement(double u, double v, double w = 0.,
+ bool strict = true);
};
-
#endif
diff --git a/Mesh/BackgroundMesh.cpp b/Mesh/BackgroundMesh.cpp
index 50aeac2c8c1eff7702c2ac72eecefa62ddfe4e79..7fd9c05fe28a66c810b7aab16356cc5b133269b5 100644
--- a/Mesh/BackgroundMesh.cpp
+++ b/Mesh/BackgroundMesh.cpp
@@ -35,19 +35,19 @@ static int _NBANN = 2;
void backgroundMesh::set(GFace *gf)
{
- if (_current) delete _current;
+ if(_current) delete _current;
_current = new backgroundMesh(gf);
}
void backgroundMesh::setCrossFieldsByDistance(GFace *gf)
{
- if (_current) delete _current;
+ if(_current) delete _current;
_current = new backgroundMesh(gf, true);
}
void backgroundMesh::unset()
{
- if (_current) delete _current;
+ if(_current) delete _current;
_current = 0;
}
@@ -56,8 +56,7 @@ backgroundMesh::backgroundMesh(GFace *_gf, bool cfd)
: _octree(0), uv_kdtree(0), nodes(0), angle_nodes(0), angle_kdtree(0)
#endif
{
-
- if (cfd){
+ if(cfd) {
Msg::Info("Building A Cross Field Using Closest Distance");
propagateCrossFieldByDistance(_gf);
return;
@@ -68,43 +67,45 @@ backgroundMesh::backgroundMesh(GFace *_gf, bool cfd)
// they do not depend on the actual mesh that can be deleted
std::set<SPoint2> myBCNodes;
- for (unsigned int i = 0; i < _gf->triangles.size(); i++){
+ for(unsigned int i = 0; i < _gf->triangles.size(); i++) {
MTriangle *e = _gf->triangles[i];
MVertex *news[3];
- for (int j=0;j<3;j++){
+ for(int j = 0; j < 3; j++) {
MVertex *v = e->getVertex(j);
- std::map<MVertex*,MVertex*>::iterator it = _3Dto2D.find(v);
- MVertex *newv =0;
- if (it == _3Dto2D.end()){
+ std::map<MVertex *, MVertex *>::iterator it = _3Dto2D.find(v);
+ MVertex *newv = 0;
+ if(it == _3Dto2D.end()) {
SPoint2 p;
reparamMeshVertexOnFace(v, _gf, p);
- newv = new MVertex (p.x(), p.y(), 0.0);
+ newv = new MVertex(p.x(), p.y(), 0.0);
_vertices.push_back(newv);
_3Dto2D[v] = newv;
_2Dto3D[newv] = v;
- if(v->onWhat()->dim()<2) myBCNodes.insert(p);
+ if(v->onWhat()->dim() < 2) myBCNodes.insert(p);
}
- else newv = it->second;
+ else
+ newv = it->second;
news[j] = newv;
}
- MTriangle *T2D = new MTriangle(news[0],news[1],news[2]);
+ MTriangle *T2D = new MTriangle(news[0], news[1], news[2]);
_triangles.push_back(T2D);
}
#if defined(HAVE_ANN)
- //printf("creating uv kdtree %d \n", myBCNodes.size());
+ // printf("creating uv kdtree %d \n", myBCNodes.size());
index = new ANNidx[2];
- dist = new ANNdist[2];
+ dist = new ANNdist[2];
nodes = annAllocPts(myBCNodes.size(), 3);
std::set<SPoint2>::iterator itp = myBCNodes.begin();
int ind = 0;
- while (itp != myBCNodes.end()){
+ while(itp != myBCNodes.end()) {
SPoint2 pt = *itp;
- //fprintf(of, "SP(%g,%g,%g){%g};\n", pt.x(), pt.y(), 0.0, 10000);
+ // fprintf(of, "SP(%g,%g,%g){%g};\n", pt.x(), pt.y(), 0.0, 10000);
nodes[ind][0] = pt.x();
nodes[ind][1] = pt.y();
nodes[ind][2] = 0.0;
- itp++; ind++;
+ itp++;
+ ind++;
}
uv_kdtree = new ANNkd_tree(nodes, myBCNodes.size(), 3);
#endif
@@ -113,12 +114,12 @@ backgroundMesh::backgroundMesh(GFace *_gf, bool cfd)
_octree = new MElementOctree(_triangles);
// compute the mesh sizes at nodes
- if (CTX::instance()->mesh.lcFromPoints){
+ if(CTX::instance()->mesh.lcFromPoints) {
propagate1dMesh(_gf);
}
else {
- std::map<MVertex*, MVertex*>::iterator itv2 = _2Dto3D.begin();
- for ( ; itv2 != _2Dto3D.end(); ++itv2){
+ std::map<MVertex *, MVertex *>::iterator itv2 = _2Dto3D.begin();
+ for(; itv2 != _2Dto3D.end(); ++itv2) {
_sizes[itv2->first] = CTX::instance()->mesh.lcMax;
}
}
@@ -134,23 +135,23 @@ backgroundMesh::backgroundMesh(GFace *_gf, bool cfd)
backgroundMesh::~backgroundMesh()
{
- for (unsigned int i = 0; i < _vertices.size(); i++) delete _vertices[i];
- for (unsigned int i = 0; i < _triangles.size(); i++) delete _triangles[i];
- if (_octree)delete _octree;
+ for(unsigned int i = 0; i < _vertices.size(); i++) delete _vertices[i];
+ for(unsigned int i = 0; i < _triangles.size(); i++) delete _triangles[i];
+ if(_octree) delete _octree;
#if defined(HAVE_ANN)
if(uv_kdtree) delete uv_kdtree;
if(angle_kdtree) delete angle_kdtree;
if(nodes) annDeallocPts(nodes);
if(angle_nodes) annDeallocPts(angle_nodes);
- delete[]index;
- delete[]dist;
+ delete[] index;
+ delete[] dist;
#endif
}
static void propagateValuesOnFace(GFace *_gf,
- std::map<MVertex*,double> &dirichlet,
- simpleFunction<double> *ONE,
- bool in_parametric_plane = false)
+ std::map<MVertex *, double> &dirichlet,
+ simpleFunction<double> *ONE,
+ bool in_parametric_plane = false)
{
#if defined(HAVE_SOLVER)
linearSystem<double> *_lsys = 0;
@@ -167,53 +168,53 @@ static void propagateValuesOnFace(GFace *_gf,
dofManager<double> myAssembler(_lsys);
// fix boundary conditions
- std::map<MVertex*, double>::iterator itv = dirichlet.begin();
- for ( ; itv != dirichlet.end(); ++itv){
+ std::map<MVertex *, double>::iterator itv = dirichlet.begin();
+ for(; itv != dirichlet.end(); ++itv) {
myAssembler.fixVertex(itv->first, 0, 1, itv->second);
}
// Number vertices
- std::set<MVertex*> vs;
- for (unsigned int k = 0; k < _gf->triangles.size(); k++)
- for (int j=0;j<3;j++)vs.insert(_gf->triangles[k]->getVertex(j));
- for (unsigned int k = 0; k < _gf->quadrangles.size(); k++)
- for (int j=0;j<4;j++)vs.insert(_gf->quadrangles[k]->getVertex(j));
-
- std::map<MVertex*,SPoint3> theMap;
- if ( in_parametric_plane) {
- for (std::set<MVertex*>::iterator it = vs.begin(); it != vs.end(); ++it){
+ std::set<MVertex *> vs;
+ for(unsigned int k = 0; k < _gf->triangles.size(); k++)
+ for(int j = 0; j < 3; j++) vs.insert(_gf->triangles[k]->getVertex(j));
+ for(unsigned int k = 0; k < _gf->quadrangles.size(); k++)
+ for(int j = 0; j < 4; j++) vs.insert(_gf->quadrangles[k]->getVertex(j));
+
+ std::map<MVertex *, SPoint3> theMap;
+ if(in_parametric_plane) {
+ for(std::set<MVertex *>::iterator it = vs.begin(); it != vs.end(); ++it) {
SPoint2 p;
- reparamMeshVertexOnFace ( *it, _gf, p);
- theMap[*it] = SPoint3((*it)->x(),(*it)->y(),(*it)->z());
- (*it)->setXYZ(p.x(),p.y(),0.0);
+ reparamMeshVertexOnFace(*it, _gf, p);
+ theMap[*it] = SPoint3((*it)->x(), (*it)->y(), (*it)->z());
+ (*it)->setXYZ(p.x(), p.y(), 0.0);
}
}
- for (std::set<MVertex*>::iterator it = vs.begin(); it != vs.end(); ++it)
+ for(std::set<MVertex *>::iterator it = vs.begin(); it != vs.end(); ++it)
myAssembler.numberVertex(*it, 0, 1);
// Assemble
laplaceTerm l(0, 1, ONE);
- for (unsigned int k = 0; k < _gf->triangles.size(); k++){
+ for(unsigned int k = 0; k < _gf->triangles.size(); k++) {
MTriangle *t = _gf->triangles[k];
SElement se(t);
l.addToMatrix(myAssembler, &se);
}
// Solve
- if (myAssembler.sizeOfR()){
+ if(myAssembler.sizeOfR()) {
_lsys->systemSolve();
}
// save solution
- for (std::set<MVertex*>::iterator it = vs.begin(); it != vs.end(); ++it){
+ for(std::set<MVertex *>::iterator it = vs.begin(); it != vs.end(); ++it) {
myAssembler.getDofValue(*it, 0, 1, dirichlet[*it]);
}
- if ( in_parametric_plane) {
- for (std::set<MVertex*>::iterator it = vs.begin(); it != vs.end(); ++it){
+ if(in_parametric_plane) {
+ for(std::set<MVertex *>::iterator it = vs.begin(); it != vs.end(); ++it) {
SPoint3 p = theMap[(*it)];
- (*it)->setXYZ(p.x(),p.y(),p.z());
+ (*it)->setXYZ(p.x(), p.y(), p.z());
}
}
delete _lsys;
@@ -222,23 +223,23 @@ static void propagateValuesOnFace(GFace *_gf,
void backgroundMesh::propagate1dMesh(GFace *_gf)
{
- std::vector<GEdge*> const& e = _gf->edges();
- std::vector<GEdge*>::const_iterator it = e.begin();
- std::map<MVertex*,double> sizes;
+ std::vector<GEdge *> const &e = _gf->edges();
+ std::vector<GEdge *>::const_iterator it = e.begin();
+ std::map<MVertex *, double> sizes;
- for( ; it != e.end(); ++it ){
- if (!(*it)->isSeam(_gf)){
- for(unsigned int i = 0; i < (*it)->lines.size(); i++ ){
+ for(; it != e.end(); ++it) {
+ if(!(*it)->isSeam(_gf)) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); i++) {
MVertex *v1 = (*it)->lines[i]->getVertex(0);
MVertex *v2 = (*it)->lines[i]->getVertex(1);
- if (v1 != v2){
+ if(v1 != v2) {
double d = sqrt((v1->x() - v2->x()) * (v1->x() - v2->x()) +
- (v1->y() - v2->y()) * (v1->y() - v2->y()) +
- (v1->z() - v2->z()) * (v1->z() -v2->z()));
- for (int k=0;k<2;k++){
+ (v1->y() - v2->y()) * (v1->y() - v2->y()) +
+ (v1->z() - v2->z()) * (v1->z() - v2->z()));
+ for(int k = 0; k < 2; k++) {
MVertex *v = (*it)->lines[i]->getVertex(k);
- std::map<MVertex*, double>::iterator itv = sizes.find(v);
- if (itv == sizes.end())
+ std::map<MVertex *, double>::iterator itv = sizes.find(v);
+ if(itv == sizes.end())
sizes[v] = log(d);
else
itv->second = 0.5 * (itv->second + log(d));
@@ -249,66 +250,67 @@ void backgroundMesh::propagate1dMesh(GFace *_gf)
}
simpleFunction<double> ONE(1.0);
- propagateValuesOnFace(_gf, sizes,&ONE);
+ propagateValuesOnFace(_gf, sizes, &ONE);
- std::map<MVertex*,MVertex*>::iterator itv2 = _2Dto3D.begin();
- for ( ; itv2 != _2Dto3D.end(); ++itv2){
+ std::map<MVertex *, MVertex *>::iterator itv2 = _2Dto3D.begin();
+ for(; itv2 != _2Dto3D.end(); ++itv2) {
MVertex *v_2D = itv2->first;
MVertex *v_3D = itv2->second;
_sizes[v_2D] = exp(sizes[v_3D]);
}
}
-crossField2d::crossField2d(MVertex* v, GEdge* ge)
+crossField2d::crossField2d(MVertex *v, GEdge *ge)
{
double p;
bool success = reparamMeshVertexOnEdge(v, ge, p);
- if (!success){
+ if(!success) {
Msg::Warning("cannot reparametrize a point in crossField");
_angle = 0;
return;
}
- SVector3 t = ge->firstDer (p);
+ SVector3 t = ge->firstDer(p);
t.normalize();
- _angle = atan2 (t.y(),t.x());
- crossField2d::normalizeAngle (_angle);
+ _angle = atan2(t.y(), t.x());
+ crossField2d::normalizeAngle(_angle);
}
void backgroundMesh::propagateCrossFieldByDistance(GFace *_gf)
{
- std::vector<GEdge*> const& e = _gf->edges();
- std::vector<GEdge*>::const_iterator it = e.begin();
- std::map<MVertex*,double> _cosines4,_sines4;
- std::map<MVertex*,SPoint2> _param;
-
- for( ; it != e.end(); ++it ){
- if (!(*it)->isSeam(_gf)){
- for(unsigned int i = 0; i < (*it)->lines.size(); i++ ){
+ std::vector<GEdge *> const &e = _gf->edges();
+ std::vector<GEdge *>::const_iterator it = e.begin();
+ std::map<MVertex *, double> _cosines4, _sines4;
+ std::map<MVertex *, SPoint2> _param;
+
+ for(; it != e.end(); ++it) {
+ if(!(*it)->isSeam(_gf)) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); i++) {
MVertex *v[2];
v[0] = (*it)->lines[i]->getVertex(0);
v[1] = (*it)->lines[i]->getVertex(1);
- SPoint2 p1,p2;
- reparamMeshEdgeOnFace(v[0],v[1],_gf,p1,p2);
+ SPoint2 p1, p2;
+ reparamMeshEdgeOnFace(v[0], v[1], _gf, p1, p2);
/* a correct way of computing angles */
- Pair<SVector3, SVector3> der = _gf->firstDer((p1+p2)*.5);
+ Pair<SVector3, SVector3> der = _gf->firstDer((p1 + p2) * .5);
SVector3 t1 = der.first();
- SVector3 t2 (v[1]->x()-v[0]->x(),v[1]->y()-v[0]->y(),v[1]->z()-v[0]->z());
+ SVector3 t2(v[1]->x() - v[0]->x(), v[1]->y() - v[0]->y(),
+ v[1]->z() - v[0]->z());
t1.normalize();
t2.normalize();
- double _angle = angle (t1,t2);
+ double _angle = angle(t1, t2);
// double angle = atan2 ( p1.y()-p2.y() , p1.x()-p2.x() );
- crossField2d::normalizeAngle (_angle);
- for (int i=0;i<2;i++){
- std::map<MVertex*,double>::iterator itc = _cosines4.find(v[i]);
- std::map<MVertex*,double>::iterator its = _sines4.find(v[i]);
- if (itc != _cosines4.end()){
- itc->second = 0.5*(itc->second + cos(4*_angle));
- its->second = 0.5*(its->second + sin(4*_angle));
+ crossField2d::normalizeAngle(_angle);
+ for(int i = 0; i < 2; i++) {
+ std::map<MVertex *, double>::iterator itc = _cosines4.find(v[i]);
+ std::map<MVertex *, double>::iterator its = _sines4.find(v[i]);
+ if(itc != _cosines4.end()) {
+ itc->second = 0.5 * (itc->second + cos(4 * _angle));
+ its->second = 0.5 * (its->second + sin(4 * _angle));
}
else {
- _param[v[i]] = (i==0) ? p1 : p2;
- _cosines4[v[i]] = cos(4*_angle);
- _sines4[v[i]] = sin(4*_angle);
+ _param[v[i]] = (i == 0) ? p1 : p2;
+ _cosines4[v[i]] = cos(4 * _angle);
+ _sines4[v[i]] = sin(4 * _angle);
}
}
}
@@ -317,13 +319,13 @@ void backgroundMesh::propagateCrossFieldByDistance(GFace *_gf)
#if defined(HAVE_ANN)
index = new ANNidx[_NBANN];
- dist = new ANNdist[_NBANN];
+ dist = new ANNdist[_NBANN];
angle_nodes = annAllocPts(_cosines4.size(), 3);
- std::map<MVertex*,double>::iterator itp = _cosines4.begin();
+ std::map<MVertex *, double>::iterator itp = _cosines4.begin();
int ind = 0;
_sin.clear();
_cos.clear();
- while (itp != _cosines4.end()){
+ while(itp != _cosines4.end()) {
MVertex *v = itp->first;
double c = itp->second;
SPoint2 pt = _param[v];
@@ -333,17 +335,18 @@ void backgroundMesh::propagateCrossFieldByDistance(GFace *_gf)
angle_nodes[ind][2] = 0.0;
_cos.push_back(c);
_sin.push_back(s);
- itp++;ind++;
+ itp++;
+ ind++;
}
angle_kdtree = new ANNkd_tree(angle_nodes, _cosines4.size(), 3);
#endif
}
-inline double myAngle (const SVector3 &a, const SVector3 &b, const SVector3 &d)
+inline double myAngle(const SVector3 &a, const SVector3 &b, const SVector3 &d)
{
- double cosTheta = dot(a,b);
- double sinTheta = dot(crossprod(a,b),d);
- return atan2 (sinTheta,cosTheta);
+ double cosTheta = dot(a, b);
+ double sinTheta = dot(crossprod(a, b), d);
+ return atan2(sinTheta, cosTheta);
}
// smoothness = h * (|grad (cos 4 a)| + |grad (sin 4 a)|)
@@ -356,17 +359,17 @@ double backgroundMesh::getSmoothness(MElement *e)
MVertex *v0 = _3Dto2D[e->getVertex(0)];
MVertex *v1 = _3Dto2D[e->getVertex(1)];
MVertex *v2 = _3Dto2D[e->getVertex(2)];
- std::map<MVertex*,double> :: const_iterator i0 = _angles.find (v0);
- std::map<MVertex*,double> :: const_iterator i1 = _angles.find (v1);
- std::map<MVertex*,double> :: const_iterator i2 = _angles.find (v2);
- double a[3] = {cos(4*i0->second),cos(4*i1->second),cos(4*i2->second)};
- double b[3] = {sin(4*i0->second),sin(4*i1->second),sin(4*i2->second)};
+ std::map<MVertex *, double>::const_iterator i0 = _angles.find(v0);
+ std::map<MVertex *, double>::const_iterator i1 = _angles.find(v1);
+ std::map<MVertex *, double>::const_iterator i2 = _angles.find(v2);
+ double a[3] = {cos(4 * i0->second), cos(4 * i1->second), cos(4 * i2->second)};
+ double b[3] = {sin(4 * i0->second), sin(4 * i1->second), sin(4 * i2->second)};
// printf("coucou\n");
double f[3];
- e->interpolateGrad(a,0,0,0,f);
- const double gradcos = sqrt (f[0]*f[0]+f[1]*f[1]+f[2]*f[2]);
- e->interpolateGrad(b,0,0,0,f);
- //const double gradsin = sqrt (f[0]*f[0]+f[1]*f[1]+f[2]*f[2]);
+ e->interpolateGrad(a, 0, 0, 0, f);
+ const double gradcos = sqrt(f[0] * f[0] + f[1] * f[1] + f[2] * f[2]);
+ e->interpolateGrad(b, 0, 0, 0, f);
+ // const double gradsin = sqrt (f[0]*f[0]+f[1]*f[1]+f[2]*f[2]);
const double h = e->maxEdge();
return (gradcos /*+ gradsin*/) * h;
}
@@ -374,47 +377,47 @@ double backgroundMesh::getSmoothness(MElement *e)
double backgroundMesh::getSmoothness(double u, double v, double w)
{
MElement *e = _octree->find(u, v, w, 2, true);
- if (!e) return -1.0;
+ if(!e) return -1.0;
MVertex *v0 = e->getVertex(0);
MVertex *v1 = e->getVertex(1);
MVertex *v2 = e->getVertex(2);
- std::map<MVertex*,double> :: const_iterator i0 = _angles.find (v0);
- std::map<MVertex*,double> :: const_iterator i1 = _angles.find (v1);
- std::map<MVertex*,double> :: const_iterator i2 = _angles.find (v2);
- double a[3] = {cos(4*i0->second),cos(4*i1->second),cos(4*i2->second)};
- double b[3] = {sin(4*i0->second),sin(4*i1->second),sin(4*i2->second)};
+ std::map<MVertex *, double>::const_iterator i0 = _angles.find(v0);
+ std::map<MVertex *, double>::const_iterator i1 = _angles.find(v1);
+ std::map<MVertex *, double>::const_iterator i2 = _angles.find(v2);
+ double a[3] = {cos(4 * i0->second), cos(4 * i1->second), cos(4 * i2->second)};
+ double b[3] = {sin(4 * i0->second), sin(4 * i1->second), sin(4 * i2->second)};
// printf("coucou\n");
double f[3];
- e->interpolateGrad(a,0,0,0,f);
- const double gradcos = sqrt (f[0]*f[0]+f[1]*f[1]+f[2]*f[2]);
- e->interpolateGrad(b,0,0,0,f);
- //const double gradsin = sqrt (f[0]*f[0]+f[1]*f[1]+f[2]*f[2]);
+ e->interpolateGrad(a, 0, 0, 0, f);
+ const double gradcos = sqrt(f[0] * f[0] + f[1] * f[1] + f[2] * f[2]);
+ e->interpolateGrad(b, 0, 0, 0, f);
+ // const double gradsin = sqrt (f[0]*f[0]+f[1]*f[1]+f[2]*f[2]);
const double h = e->maxEdge();
return (gradcos /*+ gradsin*/) * h;
}
void backgroundMesh::propagateCrossField(GFace *_gf)
{
- propagateCrossFieldHJ (_gf);
+ propagateCrossFieldHJ(_gf);
// solve the non liear problem
constantPerElement<double> C;
int ITER = 0;
// int NSMOOTH = _gf->triangles.size();
- while(0){
+ while(0) {
// int NSMOOTH_NOW = 0;
- for (unsigned int i = 0; i < _gf->triangles.size(); i++){
- double smoothness = getSmoothness (_gf->triangles[i]);
- double val = smoothness < .5 ? 1.0 : 1.e-3 ;//exp(-absf/10);
- C.set(_gf->triangles[i],val);
+ for(unsigned int i = 0; i < _gf->triangles.size(); i++) {
+ double smoothness = getSmoothness(_gf->triangles[i]);
+ double val = smoothness < .5 ? 1.0 : 1.e-3; // exp(-absf/10);
+ C.set(_gf->triangles[i], val);
}
// if (NSMOOTH_NOW == NSMOOTH) break;
// NSMOOTH = NSMOOTH_NOW;
// break;
_angles.clear();
- propagateCrossField (_gf,&C);
- if (++ITER > 0)break;
+ propagateCrossField(_gf, &C);
+ if(++ITER > 0) break;
}
- // printf("converged in %d iterations\n", ITER);
+ // printf("converged in %d iterations\n", ITER);
#if 0 // debug print
char name[256];
sprintf(name, "cross-%d-%d.pos", _gf->tag(), ITER);
@@ -427,146 +430,154 @@ void backgroundMesh::propagateCrossField(GFace *_gf)
void backgroundMesh::propagateCrossFieldHJ(GFace *_gf)
{
simpleFunction<double> ONE(1.0);
- propagateCrossField (_gf, &ONE);
-
+ propagateCrossField(_gf, &ONE);
}
-void backgroundMesh::propagateCrossField(GFace *_gf, simpleFunction<double> *ONE)
+void backgroundMesh::propagateCrossField(GFace *_gf,
+ simpleFunction<double> *ONE)
{
- std::map<MVertex*,double> _cosines4,_sines4;
- std::vector<GEdge*> const& e = _gf->edges();
- std::vector<GEdge*>::const_iterator it = e.begin();
- for( ; it != e.end(); ++it ){
- if (!(*it)->isSeam(_gf)){
- for(unsigned int i = 0; i < (*it)->lines.size(); i++ ){
+ std::map<MVertex *, double> _cosines4, _sines4;
+ std::vector<GEdge *> const &e = _gf->edges();
+ std::vector<GEdge *>::const_iterator it = e.begin();
+ for(; it != e.end(); ++it) {
+ if(!(*it)->isSeam(_gf)) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); i++) {
MVertex *v[2];
v[0] = (*it)->lines[i]->getVertex(0);
v[1] = (*it)->lines[i]->getVertex(1);
- SPoint2 p1,p2;
- reparamMeshEdgeOnFace(v[0],v[1],_gf,p1,p2);
- Pair<SVector3, SVector3> der = _gf->firstDer((p1+p2)*.5);
+ SPoint2 p1, p2;
+ reparamMeshEdgeOnFace(v[0], v[1], _gf, p1, p2);
+ Pair<SVector3, SVector3> der = _gf->firstDer((p1 + p2) * .5);
SVector3 t1 = der.first();
SVector3 t2 = der.second();
- SVector3 n = crossprod(t1,t2);
+ SVector3 n = crossprod(t1, t2);
n.normalize();
- SVector3 d1(v[1]->x()-v[0]->x(),v[1]->y()-v[0]->y(),v[1]->z()-v[0]->z());
+ SVector3 d1(v[1]->x() - v[0]->x(), v[1]->y() - v[0]->y(),
+ v[1]->z() - v[0]->z());
t1.normalize();
d1.normalize();
- double _angle = myAngle (t1,d1,n);
- crossField2d::normalizeAngle (_angle);
- for (int i=0;i<2;i++){
- std::map<MVertex*,double>::iterator itc = _cosines4.find(v[i]);
- std::map<MVertex*,double>::iterator its = _sines4.find(v[i]);
- if (itc != _cosines4.end()){
- itc->second = 0.5*(itc->second + cos(4*_angle));
- its->second = 0.5*(its->second + sin(4*_angle));
+ double _angle = myAngle(t1, d1, n);
+ crossField2d::normalizeAngle(_angle);
+ for(int i = 0; i < 2; i++) {
+ std::map<MVertex *, double>::iterator itc = _cosines4.find(v[i]);
+ std::map<MVertex *, double>::iterator its = _sines4.find(v[i]);
+ if(itc != _cosines4.end()) {
+ itc->second = 0.5 * (itc->second + cos(4 * _angle));
+ its->second = 0.5 * (its->second + sin(4 * _angle));
}
else {
- _cosines4[v[i]] = cos(4*_angle);
- _sines4[v[i]] = sin(4*_angle);
+ _cosines4[v[i]] = cos(4 * _angle);
+ _sines4[v[i]] = sin(4 * _angle);
}
}
}
}
}
- propagateValuesOnFace(_gf,_cosines4,ONE,false);
- propagateValuesOnFace(_gf,_sines4,ONE,false);
+ propagateValuesOnFace(_gf, _cosines4, ONE, false);
+ propagateValuesOnFace(_gf, _sines4, ONE, false);
// print("cos4.pos",0,_cosines4,0);
// print("sin4.pos",0,_sines4,0);
- std::map<MVertex*,MVertex*>::iterator itv2 = _2Dto3D.begin();
- for ( ; itv2 != _2Dto3D.end(); ++itv2){
+ std::map<MVertex *, MVertex *>::iterator itv2 = _2Dto3D.begin();
+ for(; itv2 != _2Dto3D.end(); ++itv2) {
MVertex *v_2D = itv2->first;
MVertex *v_3D = itv2->second;
- double angle = atan2(_sines4[v_3D],_cosines4[v_3D]) / 4.0;
- crossField2d::normalizeAngle (angle);
+ double angle = atan2(_sines4[v_3D], _cosines4[v_3D]) / 4.0;
+ crossField2d::normalizeAngle(angle);
_angles[v_2D] = angle;
}
}
void backgroundMesh::updateSizes(GFace *_gf)
{
- std::map<MVertex*,double>::iterator itv = _sizes.begin();
- for ( ; itv != _sizes.end(); ++itv){
+ std::map<MVertex *, double>::iterator itv = _sizes.begin();
+ for(; itv != _sizes.end(); ++itv) {
SPoint2 p;
MVertex *v = _2Dto3D[itv->first];
double lc;
- if (v->onWhat()->dim() == 0){
- lc = BGM_MeshSize(v->onWhat(), 0,0,v->x(),v->y(),v->z());
+ if(v->onWhat()->dim() == 0) {
+ lc = BGM_MeshSize(v->onWhat(), 0, 0, v->x(), v->y(), v->z());
}
- else if (v->onWhat()->dim() == 1){
+ else if(v->onWhat()->dim() == 1) {
double u;
v->getParameter(0, u);
lc = BGM_MeshSize(v->onWhat(), u, 0, v->x(), v->y(), v->z());
}
- else{
+ else {
reparamMeshVertexOnFace(v, _gf, p);
lc = BGM_MeshSize(_gf, p.x(), p.y(), v->x(), v->y(), v->z());
}
// printf("2D -- %g %g 3D -- %g %g\n",p.x(),p.y(),v->x(),v->y());
- itv->second = std::min(lc,itv->second);
- itv->second = std::max(itv->second, CTX::instance()->mesh.lcMin);
- itv->second = std::min(itv->second, CTX::instance()->mesh.lcMax);
+ itv->second = std::min(lc, itv->second);
+ itv->second = std::max(itv->second, CTX::instance()->mesh.lcMin);
+ itv->second = std::min(itv->second, CTX::instance()->mesh.lcMax);
}
// do not allow large variations in the size field
// (Int. J. Numer. Meth. Engng. 43, 1143-1165 (1998) MESH GRADATION
// CONTROL, BOROUCHAKI, HECHT, FREY)
- std::set<MEdge,Less_Edge> edges;
- for (unsigned int i = 0; i < _triangles.size(); i++){
- for (int j = 0; j < _triangles[i]->getNumEdges(); j++){
+ std::set<MEdge, Less_Edge> edges;
+ for(unsigned int i = 0; i < _triangles.size(); i++) {
+ for(int j = 0; j < _triangles[i]->getNumEdges(); j++) {
edges.insert(_triangles[i]->getEdge(j));
}
}
const double _beta = 1.3;
- for (int i=0;i<3;i++){
- std::set<MEdge,Less_Edge>::iterator it = edges.begin();
- for ( ; it != edges.end(); ++it){
+ for(int i = 0; i < 3; i++) {
+ std::set<MEdge, Less_Edge>::iterator it = edges.begin();
+ for(; it != edges.end(); ++it) {
MVertex *v0 = it->getVertex(0);
MVertex *v1 = it->getVertex(1);
MVertex *V0 = _2Dto3D[v0];
MVertex *V1 = _2Dto3D[v1];
- std::map<MVertex*,double>::iterator s0 = _sizes.find(V0);
- std::map<MVertex*,double>::iterator s1 = _sizes.find(V1);
- if (s0->second < s1->second)s1->second = std::min(s1->second,_beta*s0->second);
- else s0->second = std::min(s0->second,_beta*s1->second);
+ std::map<MVertex *, double>::iterator s0 = _sizes.find(V0);
+ std::map<MVertex *, double>::iterator s1 = _sizes.find(V1);
+ if(s0->second < s1->second)
+ s1->second = std::min(s1->second, _beta * s0->second);
+ else
+ s0->second = std::min(s0->second, _beta * s1->second);
}
}
}
-bool backgroundMesh::inDomain (double u, double v, double w) const
+bool backgroundMesh::inDomain(double u, double v, double w) const
{
return _octree->find(u, v, w, 2, true) != 0;
}
-double backgroundMesh::operator() (double u, double v, double w) const
+double backgroundMesh::operator()(double u, double v, double w) const
{
double uv[3] = {u, v, w};
double uv2[3];
MElement *e = _octree->find(u, v, w, 2, true);
- if (!e) {
+ if(!e) {
#if defined(HAVE_ANN)
- //printf("BGM octree not found --> find in kdtree \n");
+ // printf("BGM octree not found --> find in kdtree \n");
if(uv_kdtree->nPoints() < 2) return -1000.;
double pt[3] = {u, v, 0.0};
uv_kdtree->annkSearch(pt, 2, index, dist);
- SPoint3 p1(nodes[index[0]][0], nodes[index[0]][1], nodes[index[0]][2]);
- SPoint3 p2(nodes[index[1]][0], nodes[index[1]][1], nodes[index[1]][2]);
- SPoint3 pnew; double d;
+ SPoint3 p1(nodes[index[0]][0], nodes[index[0]][1], nodes[index[0]][2]);
+ SPoint3 p2(nodes[index[1]][0], nodes[index[1]][1], nodes[index[1]][2]);
+ SPoint3 pnew;
+ double d;
signedDistancePointLine(p1, p2, SPoint3(u, v, 0.), d, pnew);
e = _octree->find(pnew.x(), pnew.y(), 0.0, 2, true);
#endif
- if(!e){
+ if(!e) {
Msg::Error("BGM octree: cannot find UVW=%g %g %g", u, v, w);
- return -1000.0;//0.4;
+ return -1000.0; // 0.4;
}
}
e->xyz2uvw(uv, uv2);
- std::map<MVertex*,double>::const_iterator itv1 = _sizes.find(e->getVertex(0));
- std::map<MVertex*,double>::const_iterator itv2 = _sizes.find(e->getVertex(1));
- std::map<MVertex*,double>::const_iterator itv3 = _sizes.find(e->getVertex(2));
- return itv1->second * (1-uv2[0]-uv2[1]) + itv2->second * uv2[0] + itv3->second * uv2[1];
+ std::map<MVertex *, double>::const_iterator itv1 =
+ _sizes.find(e->getVertex(0));
+ std::map<MVertex *, double>::const_iterator itv2 =
+ _sizes.find(e->getVertex(1));
+ std::map<MVertex *, double>::const_iterator itv3 =
+ _sizes.find(e->getVertex(2));
+ return itv1->second * (1 - uv2[0] - uv2[1]) + itv2->second * uv2[0] +
+ itv3->second * uv2[1];
}
double backgroundMesh::getAngle(double u, double v, double w) const
@@ -575,21 +586,22 @@ double backgroundMesh::getAngle(double u, double v, double w) const
// we can use closest point for computing
// cross field angles : this allow NOT to
// generate a spurious mesh and solve a PDE
- if (!_octree){
+ if(!_octree) {
#if defined(HAVE_ANN)
double angle = 0.;
- if(angle_kdtree->nPoints() >= _NBANN){
- double pt[3] = {u,v,0.0};
+ if(angle_kdtree->nPoints() >= _NBANN) {
+ double pt[3] = {u, v, 0.0};
angle_kdtree->annkSearch(pt, _NBANN, index, dist);
- double SINE = 0.0 , COSINE = 0.0;
- for (int i=0;i<_NBANN;i++){
+ double SINE = 0.0, COSINE = 0.0;
+ for(int i = 0; i < _NBANN; i++) {
SINE += _sin[index[i]];
COSINE += _cos[index[i]];
- // printf("%2d %2d %12.5E %12.5E\n",i,index[i],_sin[index[i]],_cos[index[i]]);
+ // printf("%2d %2d %12.5E
+ // %12.5E\n",i,index[i],_sin[index[i]],_cos[index[i]]);
}
- angle = atan2(SINE,COSINE)/4.0;
+ angle = atan2(SINE, COSINE) / 4.0;
}
- crossField2d::normalizeAngle (angle);
+ crossField2d::normalizeAngle(angle);
return angle;
#endif
}
@@ -607,83 +619,83 @@ double backgroundMesh::getAngle(double u, double v, double w) const
double uv[3] = {u, v, w};
double uv2[3];
MElement *e = _octree->find(u, v, w, 2, true);
- if (!e) {
+ if(!e) {
#if defined(HAVE_ANN)
- //printf("BGM octree not found --> find in kdtree \n");
+ // printf("BGM octree not found --> find in kdtree \n");
if(uv_kdtree->nPoints() < 2) return -1000.0;
- double pt[3] = {u,v,0.0};
+ double pt[3] = {u, v, 0.0};
uv_kdtree->annkSearch(pt, 2, index, dist);
- SPoint3 p1(nodes[index[0]][0], nodes[index[0]][1], nodes[index[0]][2]);
- SPoint3 p2(nodes[index[1]][0], nodes[index[1]][1], nodes[index[1]][2]);
- SPoint3 pnew; double d;
+ SPoint3 p1(nodes[index[0]][0], nodes[index[0]][1], nodes[index[0]][2]);
+ SPoint3 p2(nodes[index[1]][0], nodes[index[1]][1], nodes[index[1]][2]);
+ SPoint3 pnew;
+ double d;
signedDistancePointLine(p1, p2, SPoint3(u, v, 0.), d, pnew);
e = _octree->find(pnew.x(), pnew.y(), 0., 2, true);
#endif
- if(!e){
+ if(!e) {
Msg::Error("BGM octree angle: cannot find UVW=%g %g %g", u, v, w);
return -1000.0;
}
}
e->xyz2uvw(uv, uv2);
- std::map<MVertex*,double>::const_iterator itv1 = _angles.find(e->getVertex(0));
- std::map<MVertex*,double>::const_iterator itv2 = _angles.find(e->getVertex(1));
- std::map<MVertex*,double>::const_iterator itv3 = _angles.find(e->getVertex(2));
-
- double cos4 = cos (4*itv1->second) * (1-uv2[0]-uv2[1]) +
- cos (4*itv2->second) * uv2[0] +
- cos (4*itv3->second) * uv2[1] ;
- double sin4 = sin (4*itv1->second) * (1-uv2[0]-uv2[1]) +
- sin (4*itv2->second) * uv2[0] +
- sin (4*itv3->second) * uv2[1] ;
- double angle = atan2(sin4,cos4)/4.0;
- crossField2d::normalizeAngle (angle);
+ std::map<MVertex *, double>::const_iterator itv1 =
+ _angles.find(e->getVertex(0));
+ std::map<MVertex *, double>::const_iterator itv2 =
+ _angles.find(e->getVertex(1));
+ std::map<MVertex *, double>::const_iterator itv3 =
+ _angles.find(e->getVertex(2));
+
+ double cos4 = cos(4 * itv1->second) * (1 - uv2[0] - uv2[1]) +
+ cos(4 * itv2->second) * uv2[0] + cos(4 * itv3->second) * uv2[1];
+ double sin4 = sin(4 * itv1->second) * (1 - uv2[0] - uv2[1]) +
+ sin(4 * itv2->second) * uv2[0] + sin(4 * itv3->second) * uv2[1];
+ double angle = atan2(sin4, cos4) / 4.0;
+ crossField2d::normalizeAngle(angle);
return angle;
}
void backgroundMesh::print(const std::string &filename, GFace *gf,
- const std::map<MVertex*,double> &_whatToPrint, int smooth)
+ const std::map<MVertex *, double> &_whatToPrint,
+ int smooth)
{
FILE *f = Fopen(filename.c_str(), "w");
- if(!f){
+ if(!f) {
Msg::Error("Could not open file '%s'", filename.c_str());
return;
}
fprintf(f, "View \"Background Mesh\"{\n");
- if (smooth){
- for(unsigned int i = 0; i < gf->triangles.size(); i++){
+ if(smooth) {
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
MVertex *v1 = gf->triangles[i]->getVertex(0);
MVertex *v2 = gf->triangles[i]->getVertex(1);
MVertex *v3 = gf->triangles[i]->getVertex(2);
- double x = getSmoothness (gf->triangles[i]);
- fprintf(f,"ST(%g,%g,%g,%g,%g,%g,%g,%g,%g) {%g,%g,%g};\n",
- v1->x(), v1->y(), v1->z(),
- v2->x(), v2->y(), v2->z(),
- v3->x(), v3->y(), v3->z(), x, x, x);
+ double x = getSmoothness(gf->triangles[i]);
+ fprintf(f, "ST(%g,%g,%g,%g,%g,%g,%g,%g,%g) {%g,%g,%g};\n", v1->x(),
+ v1->y(), v1->z(), v2->x(), v2->y(), v2->z(), v3->x(), v3->y(),
+ v3->z(), x, x, x);
}
}
else {
- for(unsigned int i = 0; i < _triangles.size(); i++){
+ for(unsigned int i = 0; i < _triangles.size(); i++) {
MVertex *v1 = _triangles[i]->getVertex(0);
MVertex *v2 = _triangles[i]->getVertex(1);
MVertex *v3 = _triangles[i]->getVertex(2);
- std::map<MVertex*,double>::const_iterator itv1 = _whatToPrint.find(v1);
- std::map<MVertex*,double>::const_iterator itv2 = _whatToPrint.find(v2);
- std::map<MVertex*,double>::const_iterator itv3 = _whatToPrint.find(v3);
- if (!gf){
- fprintf(f,"ST(%g,%g,%g,%g,%g,%g,%g,%g,%g) {%g,%g,%g};\n",
- v1->x(), v1->y(), v1->z(),
- v2->x(), v2->y(), v2->z(),
- v3->x(), v3->y(), v3->z(), itv1->second, itv2->second, itv3->second);
+ std::map<MVertex *, double>::const_iterator itv1 = _whatToPrint.find(v1);
+ std::map<MVertex *, double>::const_iterator itv2 = _whatToPrint.find(v2);
+ std::map<MVertex *, double>::const_iterator itv3 = _whatToPrint.find(v3);
+ if(!gf) {
+ fprintf(f, "ST(%g,%g,%g,%g,%g,%g,%g,%g,%g) {%g,%g,%g};\n", v1->x(),
+ v1->y(), v1->z(), v2->x(), v2->y(), v2->z(), v3->x(), v3->y(),
+ v3->z(), itv1->second, itv2->second, itv3->second);
}
else {
- GPoint p1 = gf->point(SPoint2(v1->x(),v1->y()));
- GPoint p2 = gf->point(SPoint2(v2->x(),v2->y()));
- GPoint p3 = gf->point(SPoint2(v3->x(),v3->y()));
- fprintf(f,"ST(%g,%g,%g,%g,%g,%g,%g,%g,%g) {%g,%g,%g};\n",
- p1.x(), p1.y(), p1.z(),
- p2.x(), p2.y(), p2.z(),
- p3.x(), p3.y(), p3.z(), itv1->second, itv2->second, itv3->second);
+ GPoint p1 = gf->point(SPoint2(v1->x(), v1->y()));
+ GPoint p2 = gf->point(SPoint2(v2->x(), v2->y()));
+ GPoint p3 = gf->point(SPoint2(v3->x(), v3->y()));
+ fprintf(f, "ST(%g,%g,%g,%g,%g,%g,%g,%g,%g) {%g,%g,%g};\n", p1.x(),
+ p1.y(), p1.z(), p2.x(), p2.y(), p2.z(), p3.x(), p3.y(), p3.z(),
+ itv1->second, itv2->second, itv3->second);
}
}
}
@@ -691,18 +703,16 @@ void backgroundMesh::print(const std::string &filename, GFace *gf,
fclose(f);
}
-MElementOctree* backgroundMesh::get_octree()
-{
- return _octree;
-}
+MElementOctree *backgroundMesh::get_octree() { return _octree; }
-MElement *backgroundMesh::getMeshElementByCoord(double u, double v, double w, bool strict)
+MElement *backgroundMesh::getMeshElementByCoord(double u, double v, double w,
+ bool strict)
{
- if(!_octree){
+ if(!_octree) {
Msg::Debug("Rebuilding BackgroundMesh element octree");
_octree = new MElementOctree(_triangles);
}
- return _octree->find(u,v,w, 2, strict);
+ return _octree->find(u, v, w, 2, strict);
}
-backgroundMesh* backgroundMesh::_current = 0;
+backgroundMesh *backgroundMesh::_current = 0;
diff --git a/Mesh/BackgroundMesh.h b/Mesh/BackgroundMesh.h
index 73a179cb8c568d91a9eb3e34a9905480f0ddb175..24742c48882d2457a53a8711c5081ea7932ad8b5 100644
--- a/Mesh/BackgroundMesh.h
+++ b/Mesh/BackgroundMesh.h
@@ -23,80 +23,98 @@ class GEdge;
class MElement;
class MVertex;
-struct crossField2d
-{
+struct crossField2d {
double _angle;
- static void normalizeAngle (double &angle) {
- if (angle < 0)
- while ( angle < 0 ) angle += (M_PI * .5);
- else if (angle >= M_PI * .5)
- while ( angle >= M_PI * .5 ) angle -= (M_PI * .5);
+ static void normalizeAngle(double &angle)
+ {
+ if(angle < 0)
+ while(angle < 0) angle += (M_PI * .5);
+ else if(angle >= M_PI * .5)
+ while(angle >= M_PI * .5) angle -= (M_PI * .5);
}
- crossField2d (MVertex*, GEdge*);
- crossField2d (double a) : _angle(a){}
- crossField2d & operator += ( const crossField2d & );
+ crossField2d(MVertex *, GEdge *);
+ crossField2d(double a) : _angle(a) {}
+ crossField2d &operator+=(const crossField2d &);
};
-
-class backgroundMesh : public simpleFunction<double>
-{
+class backgroundMesh : public simpleFunction<double> {
MElementOctree *_octree;
- std::vector<MVertex*> _vertices;
- std::vector<MElement*> _triangles;
- std::map<MVertex*,double> _sizes;
- std::map<MVertex*,MVertex*> _3Dto2D;
- std::map<MVertex*,MVertex*> _2Dto3D;
- std::map<MVertex*,double> _distance;
- std::map<MVertex*,double> _angles;
- static backgroundMesh * _current;
+ std::vector<MVertex *> _vertices;
+ std::vector<MElement *> _triangles;
+ std::map<MVertex *, double> _sizes;
+ std::map<MVertex *, MVertex *> _3Dto2D;
+ std::map<MVertex *, MVertex *> _2Dto3D;
+ std::map<MVertex *, double> _distance;
+ std::map<MVertex *, double> _angles;
+ static backgroundMesh *_current;
backgroundMesh(GFace *, bool dist = false);
~backgroundMesh();
#if defined(HAVE_ANN)
- mutable ANNkd_tree *uv_kdtree;
- mutable ANNpointArray nodes;
- ANNidxArray index;
- ANNdistArray dist;
- mutable ANNpointArray angle_nodes;
- mutable ANNkd_tree *angle_kdtree;
- std::vector<double> _cos,_sin;
+ mutable ANNkd_tree *uv_kdtree;
+ mutable ANNpointArray nodes;
+ ANNidxArray index;
+ ANNdistArray dist;
+ mutable ANNpointArray angle_nodes;
+ mutable ANNkd_tree *angle_kdtree;
+ std::vector<double> _cos, _sin;
#endif
- public:
+public:
static void set(GFace *);
static void setCrossFieldsByDistance(GFace *);
static void unset();
- static backgroundMesh *current () { return _current; }
+ static backgroundMesh *current() { return _current; }
void propagate1dMesh(GFace *);
void propagateCrossField(GFace *, simpleFunction<double> *);
void propagateCrossFieldHJ(GFace *);
void propagateCrossField(GFace *);
void propagateCrossFieldByDistance(GFace *);
void updateSizes(GFace *);
- double operator () (double u, double v, double w) const; // returns mesh size
- bool inDomain (double u, double v, double w) const; // returns true if in domain
- double getAngle(double u, double v, double w) const ;
- double getSmoothness(double u, double v, double w) ;
- double getSmoothness(MElement*) ;
+ double operator()(double u, double v, double w) const; // returns mesh size
+ bool inDomain(double u, double v,
+ double w) const; // returns true if in domain
+ double getAngle(double u, double v, double w) const;
+ double getSmoothness(double u, double v, double w);
+ double getSmoothness(MElement *);
void print(const std::string &filename, GFace *gf,
- const std::map<MVertex*, double>&, int smooth = 0) ;
+ const std::map<MVertex *, double> &, int smooth = 0);
void print(const std::string &filename, GFace *gf, int choice = 0)
{
switch(choice) {
- case 0 : print(filename, gf, _sizes); return;
- case 2 : print(filename, gf, _sizes, 1); return;
- default : print(filename, gf, _angles); return;
+ case 0: print(filename, gf, _sizes); return;
+ case 2: print(filename, gf, _sizes, 1); return;
+ default: print(filename, gf, _angles); return;
}
}
- MElementOctree* get_octree();
- MElement *getMeshElementByCoord(double u, double v, double w, bool strict=true);
- int getNumMeshElements()const{return _triangles.size();}
- std::vector<MVertex*>::iterator begin_vertices(){return _vertices.begin();}
- std::vector<MVertex*>::iterator end_vertices(){return _vertices.end();}
- std::vector<MVertex*>::const_iterator begin_vertices()const{return _vertices.begin();}
- std::vector<MVertex*>::const_iterator end_vertices()const{return _vertices.end();}
- std::vector<MElement*>::iterator begin_triangles(){return _triangles.begin();}
- std::vector<MElement*>::iterator end_triangles(){return _triangles.end();}
- std::vector<MElement*>::const_iterator begin_triangles()const{return _triangles.begin();}
- std::vector<MElement*>::const_iterator end_triangles()const{return _triangles.end();}
+ MElementOctree *get_octree();
+ MElement *getMeshElementByCoord(double u, double v, double w,
+ bool strict = true);
+ int getNumMeshElements() const { return _triangles.size(); }
+ std::vector<MVertex *>::iterator begin_vertices()
+ {
+ return _vertices.begin();
+ }
+ std::vector<MVertex *>::iterator end_vertices() { return _vertices.end(); }
+ std::vector<MVertex *>::const_iterator begin_vertices() const
+ {
+ return _vertices.begin();
+ }
+ std::vector<MVertex *>::const_iterator end_vertices() const
+ {
+ return _vertices.end();
+ }
+ std::vector<MElement *>::iterator begin_triangles()
+ {
+ return _triangles.begin();
+ }
+ std::vector<MElement *>::iterator end_triangles() { return _triangles.end(); }
+ std::vector<MElement *>::const_iterator begin_triangles() const
+ {
+ return _triangles.begin();
+ }
+ std::vector<MElement *>::const_iterator end_triangles() const
+ {
+ return _triangles.end();
+ }
};
#endif
diff --git a/Mesh/BackgroundMesh2D.cpp b/Mesh/BackgroundMesh2D.cpp
index 22a883d3baeb0c3bf844d3eb94b0c07a3c34636f..761f38e43fa56f43637a3446880053d845468fb4 100644
--- a/Mesh/BackgroundMesh2D.cpp
+++ b/Mesh/BackgroundMesh2D.cpp
@@ -32,34 +32,35 @@
#include "linearSystemPETSc.h"
#endif
-class evalDiffusivityFunction : public simpleFunction<double>{
+class evalDiffusivityFunction : public simpleFunction<double> {
public:
- evalDiffusivityFunction(frameFieldBackgroundMesh2D *_bgm, double t=0.95)
- : bgm(_bgm),threshold(t){};
- double operator () (double u, double v, double w) const
+ evalDiffusivityFunction(frameFieldBackgroundMesh2D *_bgm, double t = 0.95)
+ : bgm(_bgm), threshold(t){};
+ double operator()(double u, double v, double w) const
{
- return ((bgm->get_smoothness(u,v) >= threshold) ? 1. : 1.e-3);
+ return ((bgm->get_smoothness(u, v) >= threshold) ? 1. : 1.e-3);
}
+
private:
frameFieldBackgroundMesh2D *bgm;
const double threshold;
};
-//TODO: move this fct ???
+// TODO: move this fct ???
/* applies rotations of amplitude pi to set the
angle in the first quadrant (in [0,pi/2[ ) */
void normalizeAngle(double &angle)
{
- if (angle < 0)
- while ( angle < 0 ) angle += (M_PI * .5);
- else if (angle >= M_PI * .5)
- while ( angle >= M_PI * .5 ) angle -= (M_PI * .5);
+ if(angle < 0)
+ while(angle < 0) angle += (M_PI * .5);
+ else if(angle >= M_PI * .5)
+ while(angle >= M_PI * .5) angle -= (M_PI * .5);
}
void backgroundMesh2D::create_face_mesh()
{
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
return;
}
@@ -80,7 +81,7 @@ void backgroundMesh2D::create_face_mesh()
int CurvControl = CTX::instance()->mesh.lcFromCurvature;
CTX::instance()->mesh.lcFromCurvature = 0;
// Create a background mesh
- bowyerWatson(face,4000);
+ bowyerWatson(face, 4000);
// Re-enable curv control if asked
CTX::instance()->mesh.lcFromCurvature = CurvControl;
@@ -88,17 +89,16 @@ void backgroundMesh2D::create_face_mesh()
create_mesh_copy();
}
-
-MElementOctree* backgroundMesh2D::getOctree()
+MElementOctree *backgroundMesh2D::getOctree()
{
- if(!octree){
+ if(!octree) {
Msg::Debug("Rebuilding BackgroundMesh element octree");
octree = new MElementOctree(elements);
}
return octree;
}
-const MElement* backgroundMesh2D::getElement(unsigned int i)const
+const MElement *backgroundMesh2D::getElement(unsigned int i) const
{
return elements[i];
}
@@ -107,21 +107,24 @@ void backgroundMesh2D::reset(bool erase_2D3D)
{
unset();
- // create face mesh - this was previously done for old backgroundmesh in buildBackGroundMesh !
+ // create face mesh - this was previously done for old backgroundmesh in
+ // buildBackGroundMesh !
create_face_mesh();
// computes the mesh sizes at nodes
- if (CTX::instance()->mesh.lcFromPoints){
+ if(CTX::instance()->mesh.lcFromPoints) {
computeSizeField();
}
else
- for (std::map<MVertex const* const, MVertex*>::iterator itv2 = _2Dto3D.begin() ; itv2 != _2Dto3D.end(); ++itv2)
+ for(std::map<MVertex const *const, MVertex *>::iterator itv2 =
+ _2Dto3D.begin();
+ itv2 != _2Dto3D.end(); ++itv2)
sizeField[itv2->first] = CTX::instance()->mesh.lcMax;
// ensure that other criteria are fullfilled
updateSizes();
- if (erase_2D3D){
+ if(erase_2D3D) {
_3Dto2D.clear();
_2Dto3D.clear();
}
@@ -129,66 +132,66 @@ void backgroundMesh2D::reset(bool erase_2D3D)
void backgroundMesh2D::unset()
{
- for (unsigned int i = 0; i < vertices.size(); i++) delete vertices[i];
- for (unsigned int i = 0; i < getNumMeshElements(); i++) delete elements[i];
- if (octree)delete octree;
- octree=NULL;
+ for(unsigned int i = 0; i < vertices.size(); i++) delete vertices[i];
+ for(unsigned int i = 0; i < getNumMeshElements(); i++) delete elements[i];
+ if(octree) delete octree;
+ octree = NULL;
}
void backgroundMesh2D::create_mesh_copy()
{
// TODO: useful to extend it to other elements ???
- //std::set<SPoint2> myBCNodes;
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ // std::set<SPoint2> myBCNodes;
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
return;
}
- for (unsigned int i = 0; i < face->triangles.size(); i++){
+ for(unsigned int i = 0; i < face->triangles.size(); i++) {
MTriangle *e = face->triangles[i];
MVertex *news[3];
- for (int j=0;j<3;j++){
+ for(int j = 0; j < 3; j++) {
MVertex *v = e->getVertex(j);
- std::map<MVertex const* const, MVertex*>::iterator it = _3Dto2D.find(v);
- MVertex *newv =0;
- if (it == _3Dto2D.end()){
+ std::map<MVertex const *const, MVertex *>::iterator it = _3Dto2D.find(v);
+ MVertex *newv = 0;
+ if(it == _3Dto2D.end()) {
SPoint2 p;
reparamMeshVertexOnFace(v, face, p);
- newv = new MVertex (p.x(), p.y(), 0.0);// creates new vertex with xyz= u,v,0.
+ newv =
+ new MVertex(p.x(), p.y(), 0.0); // creates new vertex with xyz= u,v,0.
vertices.push_back(newv);
_3Dto2D[v] = newv;
_2Dto3D[newv] = v;
- //if(v->onWhat()->dim()<2) myBCNodes.insert(p);
+ // if(v->onWhat()->dim()<2) myBCNodes.insert(p);
}
else {
newv = it->second;
}
news[j] = newv;
}
- elements.push_back(new MTriangle(news[0],news[1],news[2]));
+ elements.push_back(new MTriangle(news[0], news[1], news[2]));
}
}
-
-GPoint backgroundMesh2D::get_GPoint_from_MVertex(const MVertex *v)const
+GPoint backgroundMesh2D::get_GPoint_from_MVertex(const MVertex *v) const
{
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
return GPoint();
}
- return face->point(SPoint2(v->x(),v->y()));
+ return face->point(SPoint2(v->x(), v->y()));
}
-
-backgroundMesh2D::backgroundMesh2D(GFace *_gf, bool erase_2D3D):BGMBase(2,_gf),sizeFactor(1.)
+backgroundMesh2D::backgroundMesh2D(GFace *_gf, bool erase_2D3D)
+ : BGMBase(2, _gf), sizeFactor(1.)
{
reset(erase_2D3D);
- if (erase_2D3D){
- // now, the new mesh has been copied in local in backgroundMesh2D, deleting the mesh
- // from GFace, back to the previous one !
- GFace *face = dynamic_cast<GFace*>(gf);
+ if(erase_2D3D) {
+ // now, the new mesh has been copied in local in backgroundMesh2D, deleting
+ // the mesh from GFace, back to the previous one !
+ GFace *face = dynamic_cast<GFace *>(gf);
if(!face)
Msg::Error("Entity is not a face in background mesh");
else
@@ -196,11 +199,7 @@ backgroundMesh2D::backgroundMesh2D(GFace *_gf, bool erase_2D3D):BGMBase(2,_gf),s
}
}
-backgroundMesh2D::~backgroundMesh2D()
-{
- unset();
-}
-
+backgroundMesh2D::~backgroundMesh2D() { unset(); }
void backgroundMesh2D::propagateValues(DoubleStorageType &dirichlet,
simpleFunction<double> &eval_diffusivity,
@@ -221,58 +220,59 @@ void backgroundMesh2D::propagateValues(DoubleStorageType &dirichlet,
dofManager<double> myAssembler(_lsys);
// fix boundary conditions
- for (DoubleStorageType::iterator itv = dirichlet.begin(); itv != dirichlet.end(); ++itv){
+ for(DoubleStorageType::iterator itv = dirichlet.begin();
+ itv != dirichlet.end(); ++itv) {
myAssembler.fixVertex(itv->first, 0, 1, itv->second);
}
// Number vertices
- std::set<MVertex*> vs;
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ std::set<MVertex *> vs;
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
delete _lsys;
return;
}
- for (unsigned int k = 0; k < face->triangles.size(); k++)
- for (int j=0;j<3;j++)vs.insert(face->triangles[k]->getVertex(j));
- for (unsigned int k = 0; k < face->quadrangles.size(); k++)
- for (int j=0;j<4;j++)vs.insert(face->quadrangles[k]->getVertex(j));
+ for(unsigned int k = 0; k < face->triangles.size(); k++)
+ for(int j = 0; j < 3; j++) vs.insert(face->triangles[k]->getVertex(j));
+ for(unsigned int k = 0; k < face->quadrangles.size(); k++)
+ for(int j = 0; j < 4; j++) vs.insert(face->quadrangles[k]->getVertex(j));
- std::map<MVertex*,SPoint3> theMap;
- if ( in_parametric_plane) {
- for (std::set<MVertex*>::iterator it = vs.begin(); it != vs.end(); ++it){
+ std::map<MVertex *, SPoint3> theMap;
+ if(in_parametric_plane) {
+ for(std::set<MVertex *>::iterator it = vs.begin(); it != vs.end(); ++it) {
SPoint2 p;
- reparamMeshVertexOnFace ( *it, face, p);
- theMap[*it] = SPoint3((*it)->x(),(*it)->y(),(*it)->z());
- (*it)->setXYZ(p.x(),p.y(),0.0);
+ reparamMeshVertexOnFace(*it, face, p);
+ theMap[*it] = SPoint3((*it)->x(), (*it)->y(), (*it)->z());
+ (*it)->setXYZ(p.x(), p.y(), 0.0);
}
}
- for (std::set<MVertex*>::iterator it = vs.begin(); it != vs.end(); ++it)
+ for(std::set<MVertex *>::iterator it = vs.begin(); it != vs.end(); ++it)
myAssembler.numberVertex(*it, 0, 1);
// Assemble
laplaceTerm l(0, 1, &eval_diffusivity);
- for (unsigned int k = 0; k < face->triangles.size(); k++){
+ for(unsigned int k = 0; k < face->triangles.size(); k++) {
MTriangle *t = face->triangles[k];
SElement se(t);
l.addToMatrix(myAssembler, &se);
}
// Solve
- if (myAssembler.sizeOfR()){
+ if(myAssembler.sizeOfR()) {
_lsys->systemSolve();
}
// save solution
- for (std::set<MVertex*>::iterator it = vs.begin(); it != vs.end(); ++it){
+ for(std::set<MVertex *>::iterator it = vs.begin(); it != vs.end(); ++it) {
myAssembler.getDofValue(*it, 0, 1, dirichlet[*it]);
}
- if ( in_parametric_plane) {
- for (std::set<MVertex*>::iterator it = vs.begin(); it != vs.end(); ++it){
+ if(in_parametric_plane) {
+ for(std::set<MVertex *>::iterator it = vs.begin(); it != vs.end(); ++it) {
SPoint3 p = theMap[(*it)];
- (*it)->setXYZ(p.x(),p.y(),p.z());
+ (*it)->setXYZ(p.x(), p.y(), p.z());
}
}
delete _lsys;
@@ -281,29 +281,29 @@ void backgroundMesh2D::propagateValues(DoubleStorageType &dirichlet,
void backgroundMesh2D::computeSizeField()
{
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
return;
}
- std::vector<GEdge*> const& e = face->edges();
- std::vector<GEdge*>::const_iterator it = e.begin();
+ std::vector<GEdge *> const &e = face->edges();
+ std::vector<GEdge *>::const_iterator it = e.begin();
DoubleStorageType sizes;
- for( ; it != e.end(); ++it ){
- if (!(*it)->isSeam(face)){
- for(unsigned int i = 0; i < (*it)->lines.size(); i++ ){
+ for(; it != e.end(); ++it) {
+ if(!(*it)->isSeam(face)) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); i++) {
MVertex *v1 = (*it)->lines[i]->getVertex(0);
MVertex *v2 = (*it)->lines[i]->getVertex(1);
- if (v1 != v2){
+ if(v1 != v2) {
double d = std::sqrt((v1->x() - v2->x()) * (v1->x() - v2->x()) +
- (v1->y() - v2->y()) * (v1->y() - v2->y()) +
- (v1->z() - v2->z()) * (v1->z() -v2->z()));
- for (int k=0;k<2;k++){
+ (v1->y() - v2->y()) * (v1->y() - v2->y()) +
+ (v1->z() - v2->z()) * (v1->z() - v2->z()));
+ for(int k = 0; k < 2; k++) {
MVertex *v = (*it)->lines[i]->getVertex(k);
DoubleStorageType::iterator itv = sizes.find(v);
- if (itv == sizes.end())
+ if(itv == sizes.end())
sizes[v] = std::log(d);
else
itv->second = 0.5 * (itv->second + std::log(d));
@@ -314,97 +314,97 @@ void backgroundMesh2D::computeSizeField()
}
simpleFunction<double> ONE(1.0);
- propagateValues(sizes,ONE);
+ propagateValues(sizes, ONE);
- std::map<MVertex const* const, MVertex*>::iterator itv2 = _2Dto3D.begin();
- for ( ; itv2 != _2Dto3D.end(); ++itv2){
- MVertex const* const v_2D = itv2->first;
+ std::map<MVertex const *const, MVertex *>::iterator itv2 = _2Dto3D.begin();
+ for(; itv2 != _2Dto3D.end(); ++itv2) {
+ MVertex const *const v_2D = itv2->first;
MVertex *v_3D = itv2->second;
sizeField[v_2D] = std::exp(sizes[v_3D]);
}
}
-
-inline double myAngle (const SVector3 &a, const SVector3 &b, const SVector3 &d){
- double cosTheta = dot(a,b);
- double sinTheta = dot(crossprod(a,b),d);
- return std::atan2(sinTheta,cosTheta);
+inline double myAngle(const SVector3 &a, const SVector3 &b, const SVector3 &d)
+{
+ double cosTheta = dot(a, b);
+ double sinTheta = dot(crossprod(a, b), d);
+ return std::atan2(sinTheta, cosTheta);
}
-
void backgroundMesh2D::updateSizes()
{
DoubleStorageType::iterator itv = sizeField.begin();
- for ( ; itv != sizeField.end(); ++itv){
+ for(; itv != sizeField.end(); ++itv) {
SPoint2 p;
- MVertex const* const v = _2Dto3D[itv->first];
+ MVertex const *const v = _2Dto3D[itv->first];
double lc;
- if (v->onWhat()->dim() == 0){
- lc = sizeFactor * BGM_MeshSize(v->onWhat(), 0,0,v->x(),v->y(),v->z());
+ if(v->onWhat()->dim() == 0) {
+ lc = sizeFactor * BGM_MeshSize(v->onWhat(), 0, 0, v->x(), v->y(), v->z());
}
- else if (v->onWhat()->dim() == 1){
+ else if(v->onWhat()->dim() == 1) {
double u;
v->getParameter(0, u);
lc = sizeFactor * BGM_MeshSize(v->onWhat(), u, 0, v->x(), v->y(), v->z());
}
- else{
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ else {
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
return;
}
reparamMeshVertexOnFace(v, face, p);
- lc = sizeFactor * BGM_MeshSize(face, p.x(), p.y(), v->x(), v->y(), v->z());
+ lc =
+ sizeFactor * BGM_MeshSize(face, p.x(), p.y(), v->x(), v->y(), v->z());
}
// printf("2D -- %g %g 3D -- %g %g\n",p.x(),p.y(),v->x(),v->y());
- itv->second = std::min(lc,itv->second);
- itv->second = std::max(itv->second, sizeFactor * CTX::instance()->mesh.lcMin);
- itv->second = std::min(itv->second, sizeFactor * CTX::instance()->mesh.lcMax);
+ itv->second = std::min(lc, itv->second);
+ itv->second =
+ std::max(itv->second, sizeFactor * CTX::instance()->mesh.lcMin);
+ itv->second =
+ std::min(itv->second, sizeFactor * CTX::instance()->mesh.lcMax);
}
// do not allow large variations in the size field
// (Int. J. Numer. Meth. Engng. 43, 1143-1165 (1998) MESH GRADATION
// CONTROL, BOROUCHAKI, HECHT, FREY)
- std::set<MEdge,Less_Edge> edges;
- for (unsigned int i = 0; i < getNumMeshElements(); i++){
- for (int j = 0; j < getElement(i)->getNumEdges(); j++){
+ std::set<MEdge, Less_Edge> edges;
+ for(unsigned int i = 0; i < getNumMeshElements(); i++) {
+ for(int j = 0; j < getElement(i)->getNumEdges(); j++) {
edges.insert(getElement(i)->getEdge(j));
}
}
const double _beta = 1.3;
- for (int i=0;i<0;i++){
- std::set<MEdge,Less_Edge>::iterator it = edges.begin();
- for ( ; it != edges.end(); ++it){
+ for(int i = 0; i < 0; i++) {
+ std::set<MEdge, Less_Edge>::iterator it = edges.begin();
+ for(; it != edges.end(); ++it) {
MVertex *v0 = it->getVertex(0);
MVertex *v1 = it->getVertex(1);
MVertex *V0 = _2Dto3D[v0];
MVertex *V1 = _2Dto3D[v1];
DoubleStorageType::iterator s0 = sizeField.find(V0);
DoubleStorageType::iterator s1 = sizeField.find(V1);
- if (s0->second < s1->second)s1->second = std::min(s1->second,_beta*s0->second);
- else s0->second = std::min(s0->second,_beta*s1->second);
+ if(s0->second < s1->second)
+ s1->second = std::min(s1->second, _beta * s0->second);
+ else
+ s0->second = std::min(s0->second, _beta * s1->second);
}
}
}
-
-
-
-
frameFieldBackgroundMesh2D::frameFieldBackgroundMesh2D(GFace *_gf)
: backgroundMesh2D(_gf, false)
{
reset();
- // now, the new mesh has been copied in local in backgroundMesh2D, deleting the mesh
- // from GFace, back to the previous one !
- GFace *face = dynamic_cast<GFace*>(gf);
+ // now, the new mesh has been copied in local in backgroundMesh2D, deleting
+ // the mesh from GFace, back to the previous one !
+ GFace *face = dynamic_cast<GFace *>(gf);
if(!face)
Msg::Error("Entity is not a face in background mesh");
else
face->triangles = tempTR;
}
-frameFieldBackgroundMesh2D::~frameFieldBackgroundMesh2D(){}
+frameFieldBackgroundMesh2D::~frameFieldBackgroundMesh2D() {}
void frameFieldBackgroundMesh2D::reset(bool erase_2D3D)
{
@@ -413,22 +413,22 @@ void frameFieldBackgroundMesh2D::reset(bool erase_2D3D)
computeCrossField(ONE);
computeSmoothness();
-// evalDiffusivityFunction eval_diff(this);
-// exportSmoothness("smoothness_iter_0.pos");
-// for (int i=1;i<30;i++){
-// computeCrossField(eval_diff);
-// computeSmoothness();
-//
-// stringstream ss;
-// ss << "smoothness_iter_" << i << ".pos";
-// exportSmoothness(ss.str());
-//
-// stringstream sscf;
-// sscf << "crossfield_iter_" << i << ".pos";
-// exportCrossField(sscf.str());
-// }
+ // evalDiffusivityFunction eval_diff(this);
+ // exportSmoothness("smoothness_iter_0.pos");
+ // for (int i=1;i<30;i++){
+ // computeCrossField(eval_diff);
+ // computeSmoothness();
+ //
+ // stringstream ss;
+ // ss << "smoothness_iter_" << i << ".pos";
+ // exportSmoothness(ss.str());
+ //
+ // stringstream sscf;
+ // sscf << "crossfield_iter_" << i << ".pos";
+ // exportCrossField(sscf.str());
+ // }
- if (erase_2D3D){
+ if(erase_2D3D) {
_3Dto2D.clear();
_2Dto3D.clear();
}
@@ -436,108 +436,115 @@ void frameFieldBackgroundMesh2D::reset(bool erase_2D3D)
double frameFieldBackgroundMesh2D::get_smoothness(MVertex *v)
{
- return get_nodal_value(v,smoothness);
+ return get_nodal_value(v, smoothness);
}
double frameFieldBackgroundMesh2D::get_smoothness(double u, double v)
{
- return get_field_value(u,v,0.,smoothness);
+ return get_field_value(u, v, 0., smoothness);
}
double frameFieldBackgroundMesh2D::angle(MVertex *v)
{
- return get_nodal_value(v,angles);
+ return get_nodal_value(v, angles);
}
double frameFieldBackgroundMesh2D::angle(double u, double v)
{
- MElement *e = const_cast<MElement*>(findElement(u, v));
- if (!e) return -1000.0;
- std::vector<double> val = get_nodal_values(e,angles);
- std::vector<double> element_uvw = get_element_uvw_from_xyz(e,u,v,0.);
- std::vector<double> cosvalues(e->getNumVertices()), sinvalues(e->getNumVertices());
- for (std::size_t i=0;i<e->getNumVertices();i++){
- cosvalues[i]=std::cos(4*val[i]);
- sinvalues[i]=std::sin(4*val[i]);
- }
- double cos4 = e->interpolate(&cosvalues[0], element_uvw[0], element_uvw[1], element_uvw[2], 1, order);
- double sin4 = e->interpolate(&sinvalues[0], element_uvw[0], element_uvw[1], element_uvw[2], 1, order);
- double a = std::atan2(sin4,cos4)/4.0;
- normalizeAngle (a);
+ MElement *e = const_cast<MElement *>(findElement(u, v));
+ if(!e) return -1000.0;
+ std::vector<double> val = get_nodal_values(e, angles);
+ std::vector<double> element_uvw = get_element_uvw_from_xyz(e, u, v, 0.);
+ std::vector<double> cosvalues(e->getNumVertices()),
+ sinvalues(e->getNumVertices());
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) {
+ cosvalues[i] = std::cos(4 * val[i]);
+ sinvalues[i] = std::sin(4 * val[i]);
+ }
+ double cos4 = e->interpolate(&cosvalues[0], element_uvw[0], element_uvw[1],
+ element_uvw[2], 1, order);
+ double sin4 = e->interpolate(&sinvalues[0], element_uvw[0], element_uvw[1],
+ element_uvw[2], 1, order);
+ double a = std::atan2(sin4, cos4) / 4.0;
+ normalizeAngle(a);
return a;
}
-void frameFieldBackgroundMesh2D::computeCrossField(simpleFunction<double> &eval_diffusivity)
+void frameFieldBackgroundMesh2D::computeCrossField(
+ simpleFunction<double> &eval_diffusivity)
{
angles.clear();
- DoubleStorageType _cosines4,_sines4;
+ DoubleStorageType _cosines4, _sines4;
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
return;
}
- std::vector<GEdge*> const& e = face->edges();
- std::vector<GEdge*>::const_iterator it = e.begin();
+ std::vector<GEdge *> const &e = face->edges();
+ std::vector<GEdge *>::const_iterator it = e.begin();
- for( ; it != e.end(); ++it ){
- if (!(*it)->isSeam(face)){
- for(unsigned int i = 0; i < (*it)->lines.size(); i++ ){
+ for(; it != e.end(); ++it) {
+ if(!(*it)->isSeam(face)) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); i++) {
MVertex *v[2];
v[0] = (*it)->lines[i]->getVertex(0);
v[1] = (*it)->lines[i]->getVertex(1);
- SPoint2 p1,p2;
- reparamMeshEdgeOnFace(v[0],v[1],face,p1,p2);
- Pair<SVector3, SVector3> der = face->firstDer((p1+p2)*.5);
+ SPoint2 p1, p2;
+ reparamMeshEdgeOnFace(v[0], v[1], face, p1, p2);
+ Pair<SVector3, SVector3> der = face->firstDer((p1 + p2) * .5);
SVector3 t1 = der.first();
SVector3 t2 = der.second();
- SVector3 n = crossprod(t1,t2);
+ SVector3 n = crossprod(t1, t2);
n.normalize();
- SVector3 d1(v[1]->x()-v[0]->x(),v[1]->y()-v[0]->y(),v[1]->z()-v[0]->z());
+ SVector3 d1(v[1]->x() - v[0]->x(), v[1]->y() - v[0]->y(),
+ v[1]->z() - v[0]->z());
t1.normalize();
d1.normalize();
- double _angle = myAngle (t1,d1,n);
- normalizeAngle (_angle);
- for (int i=0;i<2;i++){
+ double _angle = myAngle(t1, d1, n);
+ normalizeAngle(_angle);
+ for(int i = 0; i < 2; i++) {
DoubleStorageType::iterator itc = _cosines4.find(v[i]);
DoubleStorageType::iterator its = _sines4.find(v[i]);
- if (itc != _cosines4.end()){
- itc->second = 0.5*(itc->second + std::cos(4*_angle));
- its->second = 0.5*(its->second + std::sin(4*_angle));
+ if(itc != _cosines4.end()) {
+ itc->second = 0.5 * (itc->second + std::cos(4 * _angle));
+ its->second = 0.5 * (its->second + std::sin(4 * _angle));
}
else {
- _cosines4[v[i]] = std::cos(4*_angle);
- _sines4[v[i]] = std::sin(4*_angle);
+ _cosines4[v[i]] = std::cos(4 * _angle);
+ _sines4[v[i]] = std::sin(4 * _angle);
}
}
}
}
}
- propagateValues(_cosines4,eval_diffusivity,false);
- propagateValues(_sines4,eval_diffusivity,false);
+ propagateValues(_cosines4, eval_diffusivity, false);
+ propagateValues(_sines4, eval_diffusivity, false);
- std::map<MVertex const* const, MVertex*>::iterator itv2 = _2Dto3D.begin();
- for ( ; itv2 != _2Dto3D.end(); ++itv2){
- MVertex const* const v_2D = itv2->first;
+ std::map<MVertex const *const, MVertex *>::iterator itv2 = _2Dto3D.begin();
+ for(; itv2 != _2Dto3D.end(); ++itv2) {
+ MVertex const *const v_2D = itv2->first;
MVertex *v_3D = itv2->second;
- double angle = std::atan2(_sines4[v_3D],_cosines4[v_3D]) / 4.0;
- normalizeAngle (angle);
+ double angle = std::atan2(_sines4[v_3D], _cosines4[v_3D]) / 4.0;
+ normalizeAngle(angle);
angles[v_2D] = angle;
}
}
-void frameFieldBackgroundMesh2D::eval_crossfield(double u, double v, STensor3 &cf)
+void frameFieldBackgroundMesh2D::eval_crossfield(double u, double v,
+ STensor3 &cf)
{
- double quadAngle = angle(u,v);
- Pair<SVector3, SVector3> dirs = compute_crossfield_directions(u,v,quadAngle);
- SVector3 n = crossprod(dirs.first(),dirs.second());
+ double quadAngle = angle(u, v);
+ Pair<SVector3, SVector3> dirs =
+ compute_crossfield_directions(u, v, quadAngle);
+ SVector3 n = crossprod(dirs.first(), dirs.second());
- for (int i=0;i<3;i++){
- cf(i,0) = dirs.first()[i];
- cf(i,1) = dirs.second()[i];
- cf(i,2) = n[i];
+ for(int i = 0; i < 3; i++) {
+ cf(i, 0) = dirs.first()[i];
+ cf(i, 1) = dirs.second()[i];
+ cf(i, 2) = n[i];
}
// SVector3 t1,t2,n;
@@ -562,8 +569,8 @@ void frameFieldBackgroundMesh2D::eval_crossfield(double u, double v, STensor3 &c
void frameFieldBackgroundMesh2D::eval_crossfield(MVertex *vert, STensor3 &cf)
{
SPoint2 parampoint;
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
return;
}
@@ -576,177 +583,203 @@ void frameFieldBackgroundMesh2D::computeSmoothness()
smoothness.clear();
// build vertex -> neighbors table
- std::multimap<MVertex*,MVertex*> vertex2vertex;
- for (std::vector<MElement*>::iterator it = beginelements();it!=endelements();it++){
+ std::multimap<MVertex *, MVertex *> vertex2vertex;
+ for(std::vector<MElement *>::iterator it = beginelements();
+ it != endelements(); it++) {
MElement *e = *it;
- for (std::size_t i=0;i<e->getNumVertices();i++){
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) {
MVertex *current = e->getVertex(i);
- for (std::size_t j=0;j<e->getNumVertices();j++){
- if (i==j) continue;
+ for(std::size_t j = 0; j < e->getNumVertices(); j++) {
+ if(i == j) continue;
MVertex *neighbor = e->getVertex(j);
- vertex2vertex.insert(std::make_pair(current,neighbor));
+ vertex2vertex.insert(std::make_pair(current, neighbor));
}
}
}
// compute smoothness
- for (std::vector<MVertex*>::iterator it = beginvertices();it!=endvertices();it++){
+ for(std::vector<MVertex *>::iterator it = beginvertices();
+ it != endvertices(); it++) {
MVertex *v = *it;
double angle_current = angle(v);
// compare to all neighbors...
- std::pair<std::multimap<MVertex*,MVertex*>::iterator, std::multimap<MVertex*,MVertex*>::iterator> range = vertex2vertex.equal_range(v);
- double minangle,totalangle=0.;
- int N=0;
- for (std::multimap<MVertex*,MVertex*>::iterator itneighbor = range.first;itneighbor!=range.second;itneighbor++){
+ std::pair<std::multimap<MVertex *, MVertex *>::iterator,
+ std::multimap<MVertex *, MVertex *>::iterator>
+ range = vertex2vertex.equal_range(v);
+ double minangle, totalangle = 0.;
+ int N = 0;
+ for(std::multimap<MVertex *, MVertex *>::iterator itneighbor = range.first;
+ itneighbor != range.second; itneighbor++) {
N++;
- minangle=M_PI/2;
+ minangle = M_PI / 2;
MVertex *v_nb = itneighbor->second;
double angle_nb = angle(v_nb);
// angle comparison...
- minangle = std::min(minangle, std::abs(angle_current-angle_nb));
- minangle = std::min(minangle, std::abs(angle_current-(angle_nb+M_PI/2.)));
- minangle = std::min(minangle, std::abs(angle_current-(angle_nb-M_PI/2.)));
+ minangle = std::min(minangle, std::abs(angle_current - angle_nb));
+ minangle =
+ std::min(minangle, std::abs(angle_current - (angle_nb + M_PI / 2.)));
+ minangle =
+ std::min(minangle, std::abs(angle_current - (angle_nb - M_PI / 2.)));
totalangle += minangle;
}
totalangle /= N;
- smoothness[v] = 1. - (totalangle/M_PI*2);
+ smoothness[v] = 1. - (totalangle / M_PI * 2);
}
}
void frameFieldBackgroundMesh2D::exportCrossField(const std::string &filename)
{
FILE *f = Fopen(filename.c_str(), "w");
- if(!f){
+ if(!f) {
Msg::Error("Could not open file '%s'", filename.c_str());
return;
}
- fprintf(f,"View \"Cross Field\"{\n");
+ fprintf(f, "View \"Cross Field\"{\n");
std::vector<double> deltas(2);
deltas[0] = 0.;
deltas[1] = M_PI;
- for (std::vector<MVertex*>::iterator it = beginvertices();it!=endvertices();it++){
+ for(std::vector<MVertex *>::iterator it = beginvertices();
+ it != endvertices(); it++) {
MVertex *v = *it;
double angle_current = angle(v);
GPoint p = get_GPoint_from_MVertex(v);
- for (int i=0;i<2;i++){
- Pair<SVector3, SVector3> dirs = compute_crossfield_directions(v->x(),v->y(),angle_current+deltas[i]);
- fprintf(f,"VP(%g,%g,%g) {%g,%g,%g};\n",p.x(),p.y(),p.z(),dirs.first()[0], dirs.first()[1], dirs.first()[2]);
- fprintf(f,"VP(%g,%g,%g) {%g,%g,%g};\n",p.x(),p.y(),p.z(),dirs.second()[0], dirs.second()[1], dirs.second()[2]);
+ for(int i = 0; i < 2; i++) {
+ Pair<SVector3, SVector3> dirs = compute_crossfield_directions(
+ v->x(), v->y(), angle_current + deltas[i]);
+ fprintf(f, "VP(%g,%g,%g) {%g,%g,%g};\n", p.x(), p.y(), p.z(),
+ dirs.first()[0], dirs.first()[1], dirs.first()[2]);
+ fprintf(f, "VP(%g,%g,%g) {%g,%g,%g};\n", p.x(), p.y(), p.z(),
+ dirs.second()[0], dirs.second()[1], dirs.second()[2]);
}
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
fclose(f);
}
-// returns the cross field as a pair of othogonal vectors (NOT in parametric coordinates, but real 3D coordinates)
-Pair<SVector3, SVector3> frameFieldBackgroundMesh2D::compute_crossfield_directions(double u, double v,
- double angle_current)
+// returns the cross field as a pair of othogonal vectors (NOT in parametric
+// coordinates, but real 3D coordinates)
+Pair<SVector3, SVector3>
+frameFieldBackgroundMesh2D::compute_crossfield_directions(double u, double v,
+ double angle_current)
{
// get the unit normal at that point
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
- return Pair<SVector3,SVector3>(SVector3(), SVector3());
+ return Pair<SVector3, SVector3>(SVector3(), SVector3());
}
- Pair<SVector3, SVector3> der = face->firstDer(SPoint2(u,v));
+ Pair<SVector3, SVector3> der = face->firstDer(SPoint2(u, v));
SVector3 s1 = der.first();
SVector3 s2 = der.second();
- SVector3 n = crossprod(s1,s2);
+ SVector3 n = crossprod(s1, s2);
n.normalize();
- SVector3 basis_u = s1; basis_u.normalize();
- SVector3 basis_v = crossprod(n,basis_u);
+ SVector3 basis_u = s1;
+ basis_u.normalize();
+ SVector3 basis_v = crossprod(n, basis_u);
// normalize vector t1 that is tangent to gf at uv
- SVector3 t1 = basis_u * std::cos(angle_current) + basis_v * std::sin(angle_current) ;
+ SVector3 t1 =
+ basis_u * std::cos(angle_current) + basis_v * std::sin(angle_current);
t1.normalize();
- // compute the second direction t2 and normalize (t1,t2,n) is the tangent frame
- SVector3 t2 = crossprod(n,t1);
+ // compute the second direction t2 and normalize (t1,t2,n) is the tangent
+ // frame
+ SVector3 t2 = crossprod(n, t1);
t2.normalize();
- return Pair<SVector3,SVector3>(SVector3(t1[0],t1[1],t1[2]),
- SVector3(t2[0],t2[1],t2[2]));
+ return Pair<SVector3, SVector3>(SVector3(t1[0], t1[1], t1[2]),
+ SVector3(t2[0], t2[1], t2[2]));
}
-bool frameFieldBackgroundMesh2D::compute_RK_infos(double u,double v, double x, double y, double z, RK_form &infos)
+bool frameFieldBackgroundMesh2D::compute_RK_infos(double u, double v, double x,
+ double y, double z,
+ RK_form &infos)
{
// check if point is in domain
- if (!inDomain(u,v)) return false;
+ if(!inDomain(u, v)) return false;
// get stored angle
- double angle_current = angle(u,v);
+ double angle_current = angle(u, v);
// compute t1,t2: cross field directions
// get the unit normal at that point
- GFace *face = dynamic_cast<GFace*>(gf);
- if(!face){
+ GFace *face = dynamic_cast<GFace *>(gf);
+ if(!face) {
Msg::Error("Entity is not a face in background mesh");
return false;
}
- Pair<SVector3, SVector3> der = face->firstDer(SPoint2(u,v));
+ Pair<SVector3, SVector3> der = face->firstDer(SPoint2(u, v));
SVector3 s1 = der.first();
SVector3 s2 = der.second();
- SVector3 n = crossprod(s1,s2);
+ SVector3 n = crossprod(s1, s2);
n.normalize();
- SVector3 basis_u = s1; basis_u.normalize();
- SVector3 basis_v = crossprod(n,basis_u);
+ SVector3 basis_u = s1;
+ basis_u.normalize();
+ SVector3 basis_v = crossprod(n, basis_u);
// normalize vector t1 that is tangent to gf at uv
- SVector3 t1 = basis_u * std::cos(angle_current) + basis_v * std::sin(angle_current) ;
+ SVector3 t1 =
+ basis_u * std::cos(angle_current) + basis_v * std::sin(angle_current);
t1.normalize();
- // compute the second direction t2 and normalize (t1,t2,n) is the tangent frame
- SVector3 t2 = crossprod(n,t1);
+ // compute the second direction t2 and normalize (t1,t2,n) is the tangent
+ // frame
+ SVector3 t2 = crossprod(n, t1);
t2.normalize();
// get metric
- double L = size(u,v);
- infos.metricField = SMetric3(1./(L*L));
+ double L = size(u, v);
+ infos.metricField = SMetric3(1. / (L * L));
FieldManager *fields = gf->model()->getFields();
- if(fields->getBackgroundField() > 0){
+ if(fields->getBackgroundField() > 0) {
Field *f = fields->get(fields->getBackgroundField());
- if (!f->isotropic()){
- (*f)(x,y,z, infos.metricField,gf);
+ if(!f->isotropic()) {
+ (*f)(x, y, z, infos.metricField, gf);
}
else {
- L = (*f)(x,y,z,gf);
- infos.metricField = SMetric3(1./(L*L));
+ L = (*f)(x, y, z, gf);
+ infos.metricField = SMetric3(1. / (L * L));
}
}
- double M = dot(s1,s1);
- double N = dot(s2,s2);
- double E = dot(s1,s2);
+ double M = dot(s1, s1);
+ double N = dot(s2, s2);
+ double E = dot(s1, s2);
// compute the first fundamental form i.e. the metric tensor at the point
// M_{ij} = s_i \cdot s_j
- double metric[2][2] = {{M,E},{E,N}};
+ double metric[2][2] = {{M, E}, {E, N}};
// get sizes
- double size_1 = std::sqrt(1. / dot(t1,infos.metricField,t1));
- double size_2 = std::sqrt(1. / dot(t2,infos.metricField,t2));
+ double size_1 = std::sqrt(1. / dot(t1, infos.metricField, t1));
+ double size_2 = std::sqrt(1. / dot(t2, infos.metricField, t2));
- // compute covariant coordinates of t1 and t2 - cross field directions in parametric domain
- double covar1[2],covar2[2];
+ // compute covariant coordinates of t1 and t2 - cross field directions in
+ // parametric domain
+ double covar1[2], covar2[2];
// t1 = a s1 + b s2 -->
// t1 . s1 = a M + b E
// t1 . s2 = a E + b N --> solve the 2 x 2 system
// and get covariant coordinates a and b
- double rhs1[2] = {dot(t1,s1),dot(t1,s2)};
+ double rhs1[2] = {dot(t1, s1), dot(t1, s2)};
bool singular = false;
- if (!sys2x2(metric,rhs1,covar1)){
- Msg::Info("Argh surface %d %g %g %g -- %g %g %g -- %g %g",gf->tag(),s1.x(),s1.y(),s1.z(),s2.x(),s2.y(),s2.z(),size_1,size_2);
- covar1[1] = 1.0; covar1[0] = 0.0;
+ if(!sys2x2(metric, rhs1, covar1)) {
+ Msg::Info("Argh surface %d %g %g %g -- %g %g %g -- %g %g", gf->tag(),
+ s1.x(), s1.y(), s1.z(), s2.x(), s2.y(), s2.z(), size_1, size_2);
+ covar1[1] = 1.0;
+ covar1[0] = 0.0;
singular = true;
}
- double rhs2[2] = {dot(t2,s1),dot(t2,s2)};
- if (!sys2x2(metric,rhs2,covar2)){
- Msg::Info("Argh surface %d %g %g %g -- %g %g %g",gf->tag(),s1.x(),s1.y(),s1.z(),s2.x(),s2.y(),s2.z());
- covar2[0] = 1.0; covar2[1] = 0.0;
+ double rhs2[2] = {dot(t2, s1), dot(t2, s2)};
+ if(!sys2x2(metric, rhs2, covar2)) {
+ Msg::Info("Argh surface %d %g %g %g -- %g %g %g", gf->tag(), s1.x(), s1.y(),
+ s1.z(), s2.x(), s2.y(), s2.z());
+ covar2[0] = 1.0;
+ covar2[1] = 0.0;
singular = true;
}
@@ -754,32 +787,33 @@ bool frameFieldBackgroundMesh2D::compute_RK_infos(double u,double v, double x, d
// consider a vector v of size 1 in the parameter plane
// its length is sqrt (v^T M v) --> if I want a real size
// of size1 in direction v, it should be sqrt(v^T M v) * size1
- double l1 = std::sqrt(covar1[0]*covar1[0]+covar1[1]*covar1[1]);
- double l2 = std::sqrt(covar2[0]*covar2[0]+covar2[1]*covar2[1]);
+ double l1 = std::sqrt(covar1[0] * covar1[0] + covar1[1] * covar1[1]);
+ double l2 = std::sqrt(covar2[0] * covar2[0] + covar2[1] * covar2[1]);
- covar1[0] /= l1;covar1[1] /= l1;
- covar2[0] /= l2;covar2[1] /= l2;
+ covar1[0] /= l1;
+ covar1[1] /= l1;
+ covar2[0] /= l2;
+ covar2[1] /= l2;
- double size_param_1 = size_1 / std::sqrt ( M*covar1[0]*covar1[0]+
- 2*E*covar1[1]*covar1[0]+
- N*covar1[1]*covar1[1]);
- double size_param_2 = size_2 / std::sqrt ( M*covar2[0]*covar2[0]+
- 2*E*covar2[1]*covar2[0]+
- N*covar2[1]*covar2[1]);
- if (singular){
- size_param_1 = size_param_2 = std::min (size_param_1,size_param_2);
+ double size_param_1 = size_1 / std::sqrt(M * covar1[0] * covar1[0] +
+ 2 * E * covar1[1] * covar1[0] +
+ N * covar1[1] * covar1[1]);
+ double size_param_2 = size_2 / std::sqrt(M * covar2[0] * covar2[0] +
+ 2 * E * covar2[1] * covar2[0] +
+ N * covar2[1] * covar2[1]);
+ if(singular) {
+ size_param_1 = size_param_2 = std::min(size_param_1, size_param_2);
}
-
// filling form...
infos.t1 = t1;
- infos.h.first = size_1;
+ infos.h.first = size_1;
infos.h.second = size_2;
- infos.paramh.first = size_param_1;
+ infos.paramh.first = size_param_1;
infos.paramh.second = size_param_2;
- infos.paramt1 = SPoint2(covar1[0],covar1[1]);
- infos.paramt2 = SPoint2(covar2[0],covar2[1]);
+ infos.paramt1 = SPoint2(covar1[0], covar1[1]);
+ infos.paramt2 = SPoint2(covar2[0], covar2[1]);
infos.angle = angle_current;
infos.localsize = L;
infos.normal = n;
diff --git a/Mesh/BackgroundMesh2D.h b/Mesh/BackgroundMesh2D.h
index 55f51520f442f18396612a095dd7c8ff8b793bbd..65b2ee4cfed3c0aa6aba0aa47e0d83c7d6df6e75 100644
--- a/Mesh/BackgroundMesh2D.h
+++ b/Mesh/BackgroundMesh2D.h
@@ -6,7 +6,6 @@
#ifndef _BACKGROUND_MESH2D_H_
#define _BACKGROUND_MESH2D_H_
-
#include <string>
#include <map>
#include <vector>
@@ -18,10 +17,10 @@
class MTriangle;
/*
- The backgroundMesh2D creates a bunch of triangles on the parametric space of a GFace.
- Those triangles are local to the backgroundMesh2D so that
- they do not depend on the actual mesh that can be deleted.
- It extends the sizefield from the edges.
+ The backgroundMesh2D creates a bunch of triangles on the parametric space of
+ a GFace. Those triangles are local to the backgroundMesh2D so that they do
+ not depend on the actual mesh that can be deleted. It extends the sizefield
+ from the edges.
*/
class backgroundMesh2D : public BGMBase {
protected:
@@ -29,56 +28,83 @@ protected:
simpleFunction<double> &eval_diffusivity,
bool in_parametric_plane = false);
virtual void computeSizeField();
- virtual inline unsigned int getNumMeshElements()const{return elements.size();}
- virtual const MElement* getElement(unsigned int i)const;
+ virtual inline unsigned int getNumMeshElements() const
+ {
+ return elements.size();
+ }
+ virtual const MElement *getElement(unsigned int i) const;
virtual GPoint get_GPoint_from_MVertex(const MVertex *) const;
// only 2D:
void updateSizes();
// copy the mesh stored in GFace in local
void create_mesh_copy();
- // creates a mesh of GFace and store it in local !!!, does not store the mesh in GFace !
+ // creates a mesh of GFace and store it in local !!!, does not store the mesh
+ // in GFace !
void create_face_mesh();
double sizeFactor;
- std::vector<MTriangle*> tempTR;
- std::vector<MElement*> elements;
- std::vector<MVertex*> vertices;
- std::map<MVertex const* const, MVertex*> _3Dto2D;
- std::map<MVertex const* const, MVertex*> _2Dto3D;
+ std::vector<MTriangle *> tempTR;
+ std::vector<MElement *> elements;
+ std::vector<MVertex *> vertices;
+ std::map<MVertex const *const, MVertex *> _3Dto2D;
+ std::map<MVertex const *const, MVertex *> _2Dto3D;
public:
- backgroundMesh2D(GFace *, bool erase_2D3D=true);
+ backgroundMesh2D(GFace *, bool erase_2D3D = true);
virtual ~backgroundMesh2D();
- virtual MElementOctree* getOctree();
+ virtual MElementOctree *getOctree();
// TODO: only 2D
- virtual void reset(bool erase_2D3D=true);// deletes everything and rebuild with GFace*
- virtual void unset();// deletes everything... called by destructor.
+ virtual void
+ reset(bool erase_2D3D = true); // deletes everything and rebuild with GFace*
+ virtual void unset(); // deletes everything... called by destructor.
// not used !!!! TODO !!!
- void setSizeFactor (double s) {sizeFactor = s;}
-
- virtual std::vector<MVertex*>::iterator beginvertices(){ return vertices.begin(); }
- virtual std::vector<MVertex*>::iterator endvertices(){ return vertices.end(); }
- virtual std::vector<MElement*>::iterator beginelements(){ return elements.begin(); }
- virtual std::vector<MElement*>::iterator endelements(){ return elements.end(); }
- virtual std::vector<MVertex*>::const_iterator beginvertices() const { return vertices.begin(); }
- virtual std::vector<MVertex*>::const_iterator endvertices() const { return vertices.end(); }
- virtual std::vector<MElement*>::const_iterator beginelements() const { return elements.begin(); }
- virtual std::vector<MElement*>::const_iterator endelements() const { return elements.end(); }
-};
+ void setSizeFactor(double s) { sizeFactor = s; }
-class RK_form{ // informations for RK at one point
-public:
- RK_form() : angle(0.), localsize(0.)
+ virtual std::vector<MVertex *>::iterator beginvertices()
+ {
+ return vertices.begin();
+ }
+ virtual std::vector<MVertex *>::iterator endvertices()
+ {
+ return vertices.end();
+ }
+ virtual std::vector<MElement *>::iterator beginelements()
+ {
+ return elements.begin();
+ }
+ virtual std::vector<MElement *>::iterator endelements()
{
+ return elements.end();
}
+ virtual std::vector<MVertex *>::const_iterator beginvertices() const
+ {
+ return vertices.begin();
+ }
+ virtual std::vector<MVertex *>::const_iterator endvertices() const
+ {
+ return vertices.end();
+ }
+ virtual std::vector<MElement *>::const_iterator beginelements() const
+ {
+ return elements.begin();
+ }
+ virtual std::vector<MElement *>::const_iterator endelements() const
+ {
+ return elements.end();
+ }
+};
+
+class RK_form { // informations for RK at one point
+public:
+ RK_form() : angle(0.), localsize(0.) {}
SMetric3 metricField;
- SVector3 t1, t2;// 3D cross field directions
- SVector3 normal;// 3D cross field directions
- std::pair<double,double> h;// 3D sizes
- std::pair<double,double> paramh;// sizes in parametric domain
+ SVector3 t1, t2; // 3D cross field directions
+ SVector3 normal; // 3D cross field directions
+ std::pair<double, double> h; // 3D sizes
+ std::pair<double, double> paramh; // sizes in parametric domain
SPoint2 paramt1, paramt2;
double angle, localsize;
};
@@ -86,7 +112,7 @@ public:
class frameFieldBackgroundMesh2D : public backgroundMesh2D {
private:
// specification for cross field
- DoubleStorageType angles; // an attached angle
+ DoubleStorageType angles; // an attached angle
DoubleStorageType smoothness;
void computeCrossField(simpleFunction<double> &eval_diffusivity);
void computeSmoothness();
@@ -95,7 +121,7 @@ public:
frameFieldBackgroundMesh2D(GFace *_gf);
virtual ~frameFieldBackgroundMesh2D();
- virtual void reset(bool erase_2D3D=true);
+ virtual void reset(bool erase_2D3D = true);
double angle(double u, double v);
double angle(MVertex *v);
@@ -107,13 +133,14 @@ public:
void eval_crossfield(MVertex *vert, STensor3 &cf);
void exportCrossField(const std::string &filename);
- Pair<SVector3, SVector3> compute_crossfield_directions(double u,double v,
+ Pair<SVector3, SVector3> compute_crossfield_directions(double u, double v,
double angle_current);
- bool compute_RK_infos(double u,double v, double x, double y, double z,RK_form &infos);
+ bool compute_RK_infos(double u, double v, double x, double y, double z,
+ RK_form &infos);
void exportSmoothness(const std::string &filename) const
{
- export_scalar(filename,smoothness);
+ export_scalar(filename, smoothness);
}
};
diff --git a/Mesh/BackgroundMesh3D.cpp b/Mesh/BackgroundMesh3D.cpp
index 74962f126043ac45248f9994ef1f83207880694f..6d01a69cde8ce0dc4c8f62f32e175f2f72dc840e 100644
--- a/Mesh/BackgroundMesh3D.cpp
+++ b/Mesh/BackgroundMesh3D.cpp
@@ -27,18 +27,18 @@
#endif
/// \return -1 if value is negative, +1 if positive and zero otherwise
-template <class T>
-int signof(T const value)
+template <class T> int signof(T const value)
{
return (T(0) < value) - (value < T(0));
}
// TODO: virer les trucs "vertextorank", mettre cette classe-ci :
-//class evalDiffusivity3DFunction : public simpleFunction<double>{
+// class evalDiffusivity3DFunction : public simpleFunction<double>{
// public:
-// evalDiffusivity3DFunction(frameFieldBackgroundMesh3D *_bgm, double t=0.95):bgm(_bgm),threshold(t){};
-// double operator () (double u, double v, double w) const{
+// evalDiffusivity3DFunction(frameFieldBackgroundMesh3D *_bgm, double
+// t=0.95):bgm(_bgm),threshold(t){}; double operator () (double u, double v,
+// double w) const{
// return ((bgm->get_smoothness(u,v) >= threshold) ? 1. : 1.e-3);
// }
// private:
@@ -47,44 +47,45 @@ int signof(T const value)
//};
backgroundMesh3D::backgroundMesh3D(GRegion *_gr)
- : BGMBase(3,_gr), debug(false), verbose(false)
+ : BGMBase(3, _gr), debug(false), verbose(false)
{
computeSizeField();
}
-backgroundMesh3D::~backgroundMesh3D()
-{
-}
+backgroundMesh3D::~backgroundMesh3D() {}
void backgroundMesh3D::computeSizeField()
{
std::cout << "backgroundMesh3D::computeSizeField() " << std::endl;
// fills dirichlet BC
- GRegion *region = dynamic_cast<GRegion*>(gf);
- if(!region){
+ GRegion *region = dynamic_cast<GRegion *>(gf);
+ if(!region) {
Msg::Error("Entity is not a region in background mesh");
return;
}
- std::vector<GFace*> faces = region->faces();
+ std::vector<GFace *> faces = region->faces();
MVertex *v;
MElement *e;
- for (std::vector<GFace*>::iterator it=faces.begin();it!=faces.end();it++){// for all GFace
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) { // for all GFace
GFace *face = *it;
- frameFieldBackgroundMesh2D *bgm2d = dynamic_cast<frameFieldBackgroundMesh2D*>(BGMManager::get(face));
- if(!bgm2d){
+ frameFieldBackgroundMesh2D *bgm2d =
+ dynamic_cast<frameFieldBackgroundMesh2D *>(BGMManager::get(face));
+ if(!bgm2d) {
Msg::Error("Background mesh is not a 2D frame field");
return;
}
- for (unsigned int i=0;i<face->getNumMeshElements();i++){// for all elements
+ for(unsigned int i = 0; i < face->getNumMeshElements();
+ i++) { // for all elements
e = face->getMeshElement(i);
- if (e->getDim()!=2) continue;// of dim=2
- for (std::size_t iv=0;iv<e->getNumVertices();iv++){
+ if(e->getDim() != 2) continue; // of dim=2
+ for(std::size_t iv = 0; iv < e->getNumVertices(); iv++) {
v = e->getVertex(iv);
SPoint2 p;
reparamMeshVertexOnFace(v, face, p);
- sizeField[v] = bgm2d->size(p.x(),p.y());
+ sizeField[v] = bgm2d->size(p.x(), p.y());
// std::cout << "sets sizefield for vertex " << v << std::endl;
}
}
@@ -92,9 +93,10 @@ void backgroundMesh3D::computeSizeField()
// propagate
simpleFunction<double> ONE(1.0);
- propagateValues(sizeField,ONE);
+ propagateValues(sizeField, ONE);
- // std::cout << "backgroundMesh3D::size of sizeField: " << sizeField.size() << std::endl;
+ // std::cout << "backgroundMesh3D::size of sizeField: " << sizeField.size()
+ // << std::endl;
}
void backgroundMesh3D::propagateValues(DoubleStorageType &dirichlet,
@@ -102,140 +104,141 @@ void backgroundMesh3D::propagateValues(DoubleStorageType &dirichlet,
bool in_parametric_plane)
{
// same as Size_field::solve()
- GRegion *gr = dynamic_cast<GRegion*>(gf);
- if(!gr){
+ GRegion *gr = dynamic_cast<GRegion *>(gf);
+ if(!gr) {
Msg::Error("Entity is not a region in background mesh");
return;
}
#if defined(HAVE_PETSC)
- linearSystem<double>* system = new linearSystemPETSc<double>;
+ linearSystem<double> *system = new linearSystemPETSc<double>;
size_t i;
int count;
int count2;
double val;
double volume;
- std::set<MVertex*> interior;
- std::set<MVertex*>::iterator it;
+ std::set<MVertex *> interior;
+ std::set<MVertex *>::iterator it;
DoubleStorageType::iterator it2;
dofManager<double> assembler(system);
count = 0;
- for(it2=dirichlet.begin();it2!=dirichlet.end();it2++){
- assembler.fixVertex(it2->first,0,1,it2->second);
+ for(it2 = dirichlet.begin(); it2 != dirichlet.end(); it2++) {
+ assembler.fixVertex(it2->first, 0, 1, it2->second);
count++;
}
- //printf("\n");
- //printf("number of boundary vertices = %d\n",count);
+ // printf("\n");
+ // printf("number of boundary vertices = %d\n",count);
- for(i=0;i<gr->tetrahedra.size();i++){
+ for(i = 0; i < gr->tetrahedra.size(); i++) {
interior.insert(gr->tetrahedra[i]->getVertex(0));
interior.insert(gr->tetrahedra[i]->getVertex(1));
interior.insert(gr->tetrahedra[i]->getVertex(2));
interior.insert(gr->tetrahedra[i]->getVertex(3));
}
- for(it=interior.begin();it!=interior.end();it++){
+ for(it = interior.begin(); it != interior.end(); it++) {
it2 = dirichlet.find(*it);
- if(it2==dirichlet.end()){
- assembler.numberVertex(*it,0,1);
+ if(it2 == dirichlet.end()) {
+ assembler.numberVertex(*it, 0, 1);
}
}
- for(i=0;i<gr->tetrahedra.size();i++){
+ for(i = 0; i < gr->tetrahedra.size(); i++) {
gr->tetrahedra[i]->setVolumePositive();
}
count2 = 0;
volume = 0.0;
- laplaceTerm term(0,1,&eval_diffusivity);
- for(i=0;i<gr->tetrahedra.size();i++){
+ laplaceTerm term(0, 1, &eval_diffusivity);
+ for(i = 0; i < gr->tetrahedra.size(); i++) {
SElement se(gr->tetrahedra[i]);
- term.addToMatrix(assembler,&se);
+ term.addToMatrix(assembler, &se);
count2++;
volume = volume + gr->tetrahedra[i]->getVolume();
}
- //printf("number of tetrahedra = %d\n",count2);
- //printf("volume = %f\n",volume);
+ // printf("number of tetrahedra = %d\n",count2);
+ // printf("volume = %f\n",volume);
- if(assembler.sizeOfR()){
+ if(assembler.sizeOfR()) {
system->systemSolve();
}
- for(it=interior.begin();it!=interior.end();it++){
- assembler.getDofValue(*it,0,1,val);
- dirichlet.insert(std::pair<MVertex*,double>(*it,val));
+ for(it = interior.begin(); it != interior.end(); it++) {
+ assembler.getDofValue(*it, 0, 1, val);
+ dirichlet.insert(std::pair<MVertex *, double>(*it, val));
}
delete system;
#endif
}
-GPoint backgroundMesh3D::get_GPoint_from_MVertex(const MVertex *v)const
+GPoint backgroundMesh3D::get_GPoint_from_MVertex(const MVertex *v) const
{
- return GPoint(v->x(),v->y(),v->z(),dynamic_cast<GRegion*>(gf));
+ return GPoint(v->x(), v->y(), v->z(), dynamic_cast<GRegion *>(gf));
}
-MVertex* backgroundMesh3D::get_nearest_neighbor(const MVertex *v)
+MVertex *backgroundMesh3D::get_nearest_neighbor(const MVertex *v)
{
double distance;
- return get_nearest_neighbor(v->x(),v->y(),v->z(), distance);
+ return get_nearest_neighbor(v->x(), v->y(), v->z(), distance);
}
-MVertex* backgroundMesh3D::get_nearest_neighbor(const double* xyz)
+MVertex *backgroundMesh3D::get_nearest_neighbor(const double *xyz)
{
double distance;
return get_nearest_neighbor(xyz, distance);
}
-MVertex* backgroundMesh3D::get_nearest_neighbor(double x, double y, double z)
+MVertex *backgroundMesh3D::get_nearest_neighbor(double x, double y, double z)
{
double distance;
- return get_nearest_neighbor(x,y,z,distance);
+ return get_nearest_neighbor(x, y, z, distance);
}
-MVertex* backgroundMesh3D::get_nearest_neighbor(double x, double y, double z,
- double &distance )
+MVertex *backgroundMesh3D::get_nearest_neighbor(double x, double y, double z,
+ double &distance)
{
- double xyz[3] = {x,y,z};
+ double xyz[3] = {x, y, z};
return get_nearest_neighbor(xyz, distance);
}
-MElementOctree* backgroundMesh3D::getOctree()
+MElementOctree *backgroundMesh3D::getOctree()
{
- if(!octree){
- GRegion *gr = dynamic_cast<GRegion*>(gf);
- if(!gr){
+ if(!octree) {
+ GRegion *gr = dynamic_cast<GRegion *>(gf);
+ if(!gr) {
Msg::Error("Entity is not a region in background mesh");
return 0;
}
Msg::Debug("Rebuilding BackgroundMesh element octree");
- std::vector<MElement*> copy(gr->tetrahedra.begin(),
- gr->tetrahedra.end());
+ std::vector<MElement *> copy(gr->tetrahedra.begin(), gr->tetrahedra.end());
octree = new MElementOctree(copy);
}
return octree;
}
-MVertex* backgroundMesh3D::get_nearest_neighbor(const double* xyz, double & distance )
+MVertex *backgroundMesh3D::get_nearest_neighbor(const double *xyz,
+ double &distance)
{
// using the octree instead of ANN, faster.
- MElement *elem = const_cast<MElement*>(findElement(xyz[0],xyz[1],xyz[2]));
+ MElement *elem = const_cast<MElement *>(findElement(xyz[0], xyz[1], xyz[2]));
- if (!elem) return NULL;
+ if(!elem) return NULL;
- std::vector<MVertex*> candidates(elem->getNumVertices());
+ std::vector<MVertex *> candidates(elem->getNumVertices());
std::vector<double> distances(elem->getNumVertices());
- SPoint3 p(xyz[0],xyz[1],xyz[2]);
- for (std::size_t i=0;i<elem->getNumVertices();i++){
- MVertex* const v = elem->getVertex(i);
+ SPoint3 p(xyz[0], xyz[1], xyz[2]);
+ for(std::size_t i = 0; i < elem->getNumVertices(); i++) {
+ MVertex *const v = elem->getVertex(i);
candidates[i] = v;
distances[i] = p.distance(v->point());
}
- std::vector<double>::iterator itmax = std::max_element(distances.begin(),distances.end());
- return candidates[std::distance(distances.begin(),itmax)];
+ std::vector<double>::iterator itmax =
+ std::max_element(distances.begin(), distances.end());
+ return candidates[std::distance(distances.begin(), itmax)];
// map<double,MVertex*> distances;
// SPoint3 p(xyz[0],xyz[1],xyz[2]);
@@ -248,38 +251,40 @@ MVertex* backgroundMesh3D::get_nearest_neighbor(const double* xyz, double & dist
// return it->second;
}
-std::vector<montripletbis> frameFieldBackgroundMesh3D::permutation = std::vector<montripletbis>();
+std::vector<montripletbis> frameFieldBackgroundMesh3D::permutation =
+ std::vector<montripletbis>();
-frameFieldBackgroundMesh3D::frameFieldBackgroundMesh3D(GRegion *_gr):backgroundMesh3D(_gr)
+frameFieldBackgroundMesh3D::frameFieldBackgroundMesh3D(GRegion *_gr)
+ : backgroundMesh3D(_gr)
{
// readValue("param.dat","SMOOTHCF",smooth_the_crossfield);
smooth_the_crossfield = true;
// for the different "quaternion" permutations...
- if (permutation.empty()){
- permutation.push_back(montripletbis( 1, 2, 3));
- permutation.push_back(montripletbis( 2,-1, 3));
- permutation.push_back(montripletbis(-1,-2, 3));
+ if(permutation.empty()) {
+ permutation.push_back(montripletbis(1, 2, 3));
+ permutation.push_back(montripletbis(2, -1, 3));
+ permutation.push_back(montripletbis(-1, -2, 3));
permutation.push_back(montripletbis(-2, 1, 3));
- permutation.push_back(montripletbis( 2, 1,-3));
- permutation.push_back(montripletbis(-1, 2,-3));
- permutation.push_back(montripletbis(-2,-1,-3));
- permutation.push_back(montripletbis( 1,-2,-3));
+ permutation.push_back(montripletbis(2, 1, -3));
+ permutation.push_back(montripletbis(-1, 2, -3));
+ permutation.push_back(montripletbis(-2, -1, -3));
+ permutation.push_back(montripletbis(1, -2, -3));
}
build_vertex_to_element_table();
- int max_recursion_level=1;
- if ((max_recursion_level>3)||(max_recursion_level<1)) throw;
+ int max_recursion_level = 1;
+ if((max_recursion_level > 3) || (max_recursion_level < 1)) throw;
build_neighbors(max_recursion_level);
initiate_ANN_research();
initiate_crossfield();
- if (smooth_the_crossfield){
+ if(smooth_the_crossfield) {
computeCrossField();
}
- else{
+ else {
computeSmoothnessOnlyFromBoundaries();
}
}
@@ -297,16 +302,16 @@ void frameFieldBackgroundMesh3D::initiate_ANN_research()
#ifdef HAVE_ANN
// ANN research for 2D !!!
int maxPts = listOfBndVertices.size();
- dataPtsBnd= annAllocPts(maxPts, 3);
- int i=0;
+ dataPtsBnd = annAllocPts(maxPts, 3);
+ int i = 0;
MVertex *v;
- for (std::set<MVertex*>::iterator it = listOfBndVertices.begin();it!=listOfBndVertices.end();it++){
- v= *it;
- for (int k=0; k< 3; ++k)
- dataPtsBnd[i][k] = (v->point())[k];
+ for(std::set<MVertex *>::iterator it = listOfBndVertices.begin();
+ it != listOfBndVertices.end(); it++) {
+ v = *it;
+ for(int k = 0; k < 3; ++k) dataPtsBnd[i][k] = (v->point())[k];
++i;
}
- annTreeBnd=new ANNkd_tree(dataPtsBnd, maxPts , 3);
+ annTreeBnd = new ANNkd_tree(dataPtsBnd, maxPts, 3);
#endif
return;
}
@@ -318,36 +323,34 @@ void frameFieldBackgroundMesh3D::computeSmoothnessOnlyFromBoundaries()
smoothness_threshold = 0.;
- std::set<MVertex const*> neighbors;
- std::multimap<double, MVertex const*> themap;
+ std::set<MVertex const *> neighbors;
+ std::multimap<double, MVertex const *> themap;
SVector3 mean_axis(0.);
- double mean_angle=0.;
+ double mean_angle = 0.;
std::vector<double> vectorial_smoothness(3);
- for (vert2elemtype::iterator it_vertex=vert2elem.begin();
- it_vertex!=vert2elem.end();it_vertex++){// for all vertices
+ for(vert2elemtype::iterator it_vertex = vert2elem.begin();
+ it_vertex != vert2elem.end(); it_vertex++) { // for all vertices
themap.clear();
neighbors.clear();
- MVertex const* current = it_vertex->first;
- std::pair<graphtype::const_iterator, graphtype::iterator> range = graph.equal_range(current);
+ MVertex const *current = it_vertex->first;
+ std::pair<graphtype::const_iterator, graphtype::iterator> range =
+ graph.equal_range(current);
graphtype::const_iterator itgraph = range.first;
- for (;itgraph!=range.second;itgraph++){// for all neighbors
+ for(; itgraph != range.second; itgraph++) { // for all neighbors
neighbors.insert(itgraph->second.second);
}
- for (std::set<MVertex const*>::iterator it= neighbors.begin();it!=neighbors.end();it++){
- themap.insert(std::make_pair(1.,*it));
+ for(std::set<MVertex const *>::iterator it = neighbors.begin();
+ it != neighbors.end(); it++) {
+ themap.insert(std::make_pair(1., *it));
}
TensorStorageType::iterator itcurrent = crossField.find(current);
STensor3 &ref = itcurrent->second;
- crossFieldSmoothness[current] = compare_to_neighbors(current->point(),
- ref,
- themap.begin(),
- themap.end(),
- mean_axis,
- mean_angle,
- vectorial_smoothness);
+ crossFieldSmoothness[current] =
+ compare_to_neighbors(current->point(), ref, themap.begin(), themap.end(),
+ mean_axis, mean_angle, vectorial_smoothness);
}
}
@@ -359,111 +362,115 @@ void frameFieldBackgroundMesh3D::computeCrossField()
double norme_threshold = 1.;
double localangle_threshold = 1.;
- Niter=40;
+ Niter = 40;
norme_threshold = 3.e-2;
- localangle_threshold=5.e-3;
- smoothness_threshold=0.85;
+ localangle_threshold = 5.e-3;
+ smoothness_threshold = 0.85;
double percentage_threshold = 0.98;
std::vector<double> scal_prods, signs, angles;
STensor3 identity(1.);
- if (debug) exportCrossField("cf_initial.pos");
+ if(debug) exportCrossField("cf_initial.pos");
// initiation
- std::multimap<double, MVertex const*> rank, rank_temp;
- std::map<MVertex const* const, bool> vertex_is_still;
- std::map<MVertex const* const, double> vertex_movement;
+ std::multimap<double, MVertex const *> rank, rank_temp;
+ std::map<MVertex const *const, bool> vertex_is_still;
+ std::map<MVertex const *const, double> vertex_movement;
- for (vert2elemtype::iterator it_vertex=vert2elem.begin();
- it_vertex!=vert2elem.end();it_vertex++){
-
- MVertex const* const current = it_vertex->first;
+ for(vert2elemtype::iterator it_vertex = vert2elem.begin();
+ it_vertex != vert2elem.end(); it_vertex++) {
+ MVertex const *const current = it_vertex->first;
vertex_is_still[current] = current->onWhat()->dim() <= 2;
- rank.insert(std::make_pair(0.,current));
+ rank.insert(std::make_pair(0., current));
}
// OLD - NEW COMPARISON
- std::map<MVertex const*,double> vertex_to_rank;
- for (vert2elemtype::iterator it_vertex=vert2elem.begin();
- it_vertex!=vert2elem.end();it_vertex++){// for all vertices
- //vertex_to_rank[it_vertex->first] = 0.;
+ std::map<MVertex const *, double> vertex_to_rank;
+ for(vert2elemtype::iterator it_vertex = vert2elem.begin();
+ it_vertex != vert2elem.end(); it_vertex++) { // for all vertices
+ // vertex_to_rank[it_vertex->first] = 0.;
vertex_to_rank[it_vertex->first] = 1.;
- rank.insert(std::make_pair(0.,it_vertex->first));
+ rank.insert(std::make_pair(0., it_vertex->first));
}
// END OLD - NEW COMPARISON
- double percentage_not_done=0.;
- double norme = 10.*norme_threshold;
- double norme_inf=10.*norme_threshold;
- int iIter=0;
+ double percentage_not_done = 0.;
+ double norme = 10. * norme_threshold;
+ double norme_inf = 10. * norme_threshold;
+ int iIter = 0;
SVector3 mean_axis(0.);
- double mean_angle=0.;
+ double mean_angle = 0.;
std::vector<double> vectorial_smoothness(3);
// vector<int> nb_local_iterations;
// main smoothing loop
- while (((norme_inf>norme_threshold) &&
- (percentage_not_done<percentage_threshold)) &&
- (iIter<Niter)){// for maximum Niter iterations, or until convergence
+ while(((norme_inf > norme_threshold) &&
+ (percentage_not_done < percentage_threshold)) &&
+ (iIter < Niter)) { // for maximum Niter iterations, or until convergence
// nb_local_iterations.clear();
angles.clear();
- norme_inf=0.;
- int counter_done=0;
- int counter_not_done=0;
- while (rank.size()){// for all vertices, i.e. all cavities
+ norme_inf = 0.;
+ int counter_done = 0;
+ int counter_not_done = 0;
+ while(rank.size()) { // for all vertices, i.e. all cavities
// for (vert2elemtype::iterator
- //it_vertex=vert2elem.begin();it_vertex!=vert2elem.end();it_vertex++)//
- //for all vertices, i.e. all cavities MVertex *current = it_vertex->first;
+ // it_vertex=vert2elem.begin();it_vertex!=vert2elem.end();it_vertex++)//
+ // for all vertices, i.e. all cavities MVertex *current =
+ // it_vertex->first;
- MVertex const* const current = rank.begin()->second;
+ MVertex const *const current = rank.begin()->second;
rank.erase((rank.begin()));
// smooth 3D vertices only
- if (current->onWhat()->dim()<=2){
- if (verbose) std::cout << "-------------------- discard point "
- << current->getNum() << " on dim "
- << current->onWhat()->dim() << " coord ("
- << current->x() << "," << current->y() << ","
- << current->z()<< ")" << std::endl;
+ if(current->onWhat()->dim() <= 2) {
+ if(verbose)
+ std::cout << "-------------------- discard point "
+ << current->getNum() << " on dim "
+ << current->onWhat()->dim() << " coord (" << current->x()
+ << "," << current->y() << "," << current->z() << ")"
+ << std::endl;
continue;
}
TensorStorageType::iterator itcurrent = crossField.find(current);
STensor3 &ref = itcurrent->second;
- if (verbose) std::cout << "-------------------- working on point "
- << current->getNum() << " on dim "
- << current->onWhat()->dim() << " coord ("
- << current->x() << "," << current->y() << ","
- << current->z()<< ")" << std::endl;
-
- std::pair<graphtype::iterator, graphtype::iterator> range = graph.equal_range(current);
+ if(verbose)
+ std::cout << "-------------------- working on point "
+ << current->getNum() << " on dim "
+ << current->onWhat()->dim() << " coord (" << current->x()
+ << "," << current->y() << "," << current->z() << ")"
+ << std::endl;
+
+ std::pair<graphtype::iterator, graphtype::iterator> range =
+ graph.equal_range(current);
graphtype::iterator itgraph = range.first;
- bool all_neighbors_still=true;// if nothing has changed since previous
- // iteration: nothing to do !
- for (;itgraph!=range.second;itgraph++){// for all neighbors
- if (vertex_is_still[itgraph->second.second]==false){
+ bool all_neighbors_still = true; // if nothing has changed since previous
+ // iteration: nothing to do !
+ for(; itgraph != range.second; itgraph++) { // for all neighbors
+ if(vertex_is_still[itgraph->second.second] == false) {
all_neighbors_still = false;
break;
}
}
- // neighbors didn't move, and current didn't move either -> nothing to do !
- if (all_neighbors_still && vertex_is_still[current]){
+ // neighbors didn't move, and current didn't move either -> nothing to do
+ // !
+ if(all_neighbors_still && vertex_is_still[current]) {
vertex_movement[current] = 0.;
- rank_temp.insert(std::make_pair(0.,current));
+ rank_temp.insert(std::make_pair(0., current));
counter_not_done++;
continue;
}
// OLD - NEW COMPARISON
- std::multimap<double, MVertex const*> neighbors_to_trust;
+ std::multimap<double, MVertex const *> neighbors_to_trust;
itgraph = range.first;
- for (;itgraph!=range.second;itgraph++){// for all neighbors
- neighbors_to_trust.insert(std::make_pair(vertex_to_rank[itgraph->second.second],
- itgraph->second.second));
+ for(; itgraph != range.second; itgraph++) { // for all neighbors
+ neighbors_to_trust.insert(std::make_pair(
+ vertex_to_rank[itgraph->second.second], itgraph->second.second));
// if (vertex_to_rank[itgraph->second.second] <= 1. /180.*M_PI){
// neighbors_to_trust.insert(make_pair(vertex_to_rank[itgraph->second.second],
@@ -471,8 +478,8 @@ void frameFieldBackgroundMesh3D::computeCrossField()
// }
}
- if (!neighbors_to_trust.size()){
- rank_temp.insert(std::make_pair(M_PI,current));
+ if(!neighbors_to_trust.size()) {
+ rank_temp.insert(std::make_pair(M_PI, current));
vertex_to_rank[current] = M_PI;
continue;
}
@@ -480,96 +487,108 @@ void frameFieldBackgroundMesh3D::computeCrossField()
counter_done++;
- double angle_to_go;;
+ double angle_to_go;
+ ;
- int Nlocaliter=0;
+ int Nlocaliter = 0;
STensor3 ref_original(ref);
// iterations, convergence of the local cavity...
- for (;Nlocaliter<20;Nlocaliter++) {
- std::multimap<double, MVertex const*>::iterator it_neighbors_to_trust = neighbors_to_trust.begin();
- crossFieldSmoothness[current] = compare_to_neighbors(current->point(),
- ref,
- it_neighbors_to_trust,
- neighbors_to_trust.end(),
- mean_axis,
- mean_angle,
- vectorial_smoothness);
+ for(; Nlocaliter < 20; Nlocaliter++) {
+ std::multimap<double, MVertex const *>::iterator it_neighbors_to_trust =
+ neighbors_to_trust.begin();
+ crossFieldSmoothness[current] =
+ compare_to_neighbors(current->point(), ref, it_neighbors_to_trust,
+ neighbors_to_trust.end(), mean_axis, mean_angle,
+ vectorial_smoothness);
// crossFieldVectorialSmoothness[current] = vectorial_smoothness;
// rotating directions to align closest vectors...
angle_to_go = mean_angle;
- ref = apply_rotation(mean_axis,angle_to_go,ref);
- // std::cout << " iter " << Nlocaliter << ": mean_angle = " << mean_angle <<
+ ref = apply_rotation(mean_axis, angle_to_go, ref);
+ // std::cout << " iter " << Nlocaliter << ": mean_angle = " <<
+ // mean_angle <<
// std::endl;
- if (std::abs(mean_angle) < localangle_threshold / 3.0) break;
+ if(std::abs(mean_angle) < localangle_threshold / 3.0) break;
}
// nb_local_iterations.push_back(Nlocaliter+1);
- if (verbose) std::cout << "iIter " << iIter << ", Nlocaliter = " << Nlocaliter << std::endl;
+ if(verbose)
+ std::cout << "iIter " << iIter << ", Nlocaliter = " << Nlocaliter
+ << std::endl;
// computing the total rotation
- //get_min_rotation_matrix(ref_original, ref, mean_angle, mean_axis,localangle_threshold,true);
- get_min_rotation_matrix(ref_original, ref, mean_angle, mean_axis,localangle_threshold);//,true);
- norme_inf = std::max(norme_inf,mean_angle);
- // std::cout << " #local_iter=" << Nlocaliter << " final mean_angle = " << mean_angle << " threshold=" << localangle_threshold << " condition :" << (mean_angle <= localangle_threshold) << std::endl;
+ // get_min_rotation_matrix(ref_original, ref, mean_angle,
+ // mean_axis,localangle_threshold,true);
+ get_min_rotation_matrix(ref_original, ref, mean_angle, mean_axis,
+ localangle_threshold); //,true);
+ norme_inf = std::max(norme_inf, mean_angle);
+ // std::cout << " #local_iter=" << Nlocaliter << " final
+ // mean_angle = " << mean_angle << " threshold=" <<
+ // localangle_threshold << " condition :" << (mean_angle <=
+ // localangle_threshold) << std::endl;
angles.push_back(mean_angle);
vertex_is_still[current] = (mean_angle <= localangle_threshold);
vertex_movement[current] = mean_angle;
- rank_temp.insert(std::make_pair(mean_angle,current));
+ rank_temp.insert(std::make_pair(mean_angle, current));
// OLD - NEW COMPARISON
- //vertex_to_rank[current] = mean_angle;
+ // vertex_to_rank[current] = mean_angle;
vertex_to_rank[current] = crossFieldSmoothness[current];
// // HACK
// vertex_to_rank[current] = 0.;
// END OLD - NEW COMPARISON
- }// end vertices loop
+ } // end vertices loop
- //rank = rank_temp;
+ // rank = rank_temp;
rank_temp.clear();
- norme = std::accumulate(angles.begin(),angles.end(),0.);
- if (angles.size()) norme = norme/M_PI*180./angles.size();
- percentage_not_done = ((double)counter_not_done)/(counter_done+counter_not_done);
+ norme = std::accumulate(angles.begin(), angles.end(), 0.);
+ if(angles.size()) norme = norme / M_PI * 180. / angles.size();
+ percentage_not_done =
+ ((double)counter_not_done) / (counter_done + counter_not_done);
std::cout << " --- iter " << iIter << " NormeInf=" << norme_inf
- << " mean Angle=" << norme << " counter_not_done="
- << counter_not_done << " NotDone (%)="
- << (percentage_not_done*100.) << " %" << std::endl;
+ << " mean Angle=" << norme
+ << " counter_not_done=" << counter_not_done
+ << " NotDone (%)=" << (percentage_not_done * 100.) << " %"
+ << std::endl;
// std::cout << "Average number of local iterations: "
// << ((double)std::accumulate(nb_local_iterations.begin(),
- // nb_local_iterations.end(),0))/nb_local_iterations.size() << std::endl;
+ // nb_local_iterations.end(),0))/nb_local_iterations.size() <<
+ // std::endl;
- //if (debug){
+ // if (debug){
double temp = std::log10(Niter);
std::stringstream ss;
- ss << "cf_iter_" << std::setfill('0') << std::setw ((int)(std::ceil(temp))) << iIter << ".pos";
+ ss << "cf_iter_" << std::setfill('0') << std::setw((int)(std::ceil(temp)))
+ << iIter << ".pos";
exportCrossField(ss.str().c_str());
//}
iIter++;
- }// end Niter iterations
+ } // end Niter iterations
// also computes smoothness for boundary points
- for (vert2elemtype::iterator it_vertex=vert2elem.begin();
- it_vertex!=vert2elem.end();it_vertex++){
- MVertex const* const current = it_vertex->first;
- if (current->onWhat()->dim()<=2){
+ for(vert2elemtype::iterator it_vertex = vert2elem.begin();
+ it_vertex != vert2elem.end(); it_vertex++) {
+ MVertex const *const current = it_vertex->first;
+ if(current->onWhat()->dim() <= 2) {
TensorStorageType::iterator itcurrent = crossField.find(current);
STensor3 &ref = itcurrent->second;
- std::pair<graphtype::iterator, graphtype::iterator> range = graph.equal_range(current);
+ std::pair<graphtype::iterator, graphtype::iterator> range =
+ graph.equal_range(current);
graphtype::iterator itgraph = range.first;
- std::multimap<double,MVertex const*> neighbors_to_trust;
+ std::multimap<double, MVertex const *> neighbors_to_trust;
itgraph = range.first;
- for (;itgraph!=range.second;itgraph++){// for all neighbors
- neighbors_to_trust.insert(std::make_pair(0.,itgraph->second.second));
+ for(; itgraph != range.second; itgraph++) { // for all neighbors
+ neighbors_to_trust.insert(std::make_pair(0., itgraph->second.second));
}
- crossFieldSmoothness[current] = compare_to_neighbors
- (current->point(), ref, neighbors_to_trust.begin(),
- neighbors_to_trust.end(), mean_axis,mean_angle,vectorial_smoothness);
+ crossFieldSmoothness[current] = compare_to_neighbors(
+ current->point(), ref, neighbors_to_trust.begin(),
+ neighbors_to_trust.end(), mean_axis, mean_angle, vectorial_smoothness);
- //crossFieldSmoothness[current] = compare_to_neighbors
+ // crossFieldSmoothness[current] = compare_to_neighbors
// (current->point(), ref, itgraph, range.second, mean_axis,
// mean_angle,vectorial_smoothness);
// crossFieldVectorialSmoothness[current] = vectorial_smoothness;
@@ -577,13 +596,10 @@ void frameFieldBackgroundMesh3D::computeCrossField()
}
}
-//STensor3 frameFieldBackgroundMesh3D::get_random_cross()const{
-// SVector3 vec1(rand()%10000/9999. , rand()%10000/9999. , rand()%10000/9999. );
-// vec1.normalize();
-// SVector3 ref(1.,0.,0.);
-// SVector3 vec2 = crossprod(ref,vec1);
-// vec2.normalize();
-// SVector3 vec3 = crossprod(vec1,vec2);
+// STensor3 frameFieldBackgroundMesh3D::get_random_cross()const{
+// SVector3 vec1(rand()%10000/9999. , rand()%10000/9999. , rand()%10000/9999.
+// ); vec1.normalize(); SVector3 ref(1.,0.,0.); SVector3 vec2 =
+// crossprod(ref,vec1); vec2.normalize(); SVector3 vec3 = crossprod(vec1,vec2);
// vec3.normalize();
// STensor3 random_cross;
// for (int j=0;j<3;j++){
@@ -600,84 +616,89 @@ void frameFieldBackgroundMesh3D::initiate_crossfield()
MVertex *v;
// first, for boundaries :
- GRegion *gr = dynamic_cast<GRegion*>(gf);
- if(!gr){
+ GRegion *gr = dynamic_cast<GRegion *>(gf);
+ if(!gr) {
Msg::Error("Entity is not a region in background mesh");
return;
}
- std::vector<GFace*> faces = gr->faces();
+ std::vector<GFace *> faces = gr->faces();
// here, not using the gm2D since we are interested by the new 2D vertices,
// not the old (now erased) ones... alternative would be to reset the 2DBGM...
- for (std::vector<GFace*>::iterator it=faces.begin();it!=faces.end();it++){// for all GFace
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) { // for all GFace
GFace *face = *it;
frameFieldBackgroundMesh2D *bgm2d =
- dynamic_cast<frameFieldBackgroundMesh2D*>(BGMManager::get(face));
- if(!bgm2d){
+ dynamic_cast<frameFieldBackgroundMesh2D *>(BGMManager::get(face));
+ if(!bgm2d) {
Msg::Error("Background mesh is not a 2D frame field");
return;
}
// initializing the vertices on the faces
- for (unsigned int i=0;i<face->getNumMeshElements();i++){// for all elements
+ for(unsigned int i = 0; i < face->getNumMeshElements();
+ i++) { // for all elements
MElement *e = face->getMeshElement(i);
- if (e->getDim()!=2) continue;// of dim=2
+ if(e->getDim() != 2) continue; // of dim=2
- for (std::size_t iv=0;iv<e->getNumVertices();iv++){
+ for(std::size_t iv = 0; iv < e->getNumVertices(); iv++) {
v = e->getVertex(iv);
// if already done: continue
- TensorStorageType::iterator itfind = crossField.find(v);
- if (itfind!=crossField.end()) continue;
+ TensorStorageType::iterator itfind = crossField.find(v);
+ if(itfind != crossField.end()) continue;
STensor3 cf;
- bgm2d->eval_crossfield(v,cf);
+ bgm2d->eval_crossfield(v, cf);
crossField[v] = cf;
}
}
}
// then, for volume :
- for (unsigned int i=0;i<gr->getNumMeshElements();i++){// for all elements
+ for(unsigned int i = 0; i < gr->getNumMeshElements();
+ i++) { // for all elements
MElement *e = gr->getMeshElement(i);
- if (e->getDim()!=3) continue;
+ if(e->getDim() != 3) continue;
- for (std::size_t iv=0;iv<e->getNumVertices();iv++){
+ for(std::size_t iv = 0; iv < e->getNumVertices(); iv++) {
v = e->getVertex(iv);
// if not in volume: continue
- if (v->onWhat()->dim()<=2) continue;
+ if(v->onWhat()->dim() <= 2) continue;
// if already done: continue
- TensorStorageType::iterator itfind = crossField.find(v);
- if (itfind!=crossField.end()) continue;
+ TensorStorageType::iterator itfind = crossField.find(v);
+ if(itfind != crossField.end()) continue;
MVertex *closer_on_bnd = get_nearest_neighbor_on_boundary(v);
- crossField[v] = crossField[closer_on_bnd];// prend l'info Bnd (ANN) la plus proche...
+ crossField[v] =
+ crossField[closer_on_bnd]; // prend l'info Bnd (ANN) la plus proche...
}
}
}
-MVertex* frameFieldBackgroundMesh3D::get_nearest_neighbor_on_boundary(MVertex* v)
+MVertex *
+frameFieldBackgroundMesh3D::get_nearest_neighbor_on_boundary(MVertex *v)
{
double distance;
- return get_nearest_neighbor_on_boundary(v,distance);
+ return get_nearest_neighbor_on_boundary(v, distance);
}
-MVertex* frameFieldBackgroundMesh3D::get_nearest_neighbor_on_boundary
- (MVertex* v, double &distance)
+MVertex *
+frameFieldBackgroundMesh3D::get_nearest_neighbor_on_boundary(MVertex *v,
+ double &distance)
{
#ifdef HAVE_ANN
ANNpoint q = annAllocPt(3);
- for (int k=0; k< 3; ++k)
- q[k] = v->point()[k];
- ANNidxArray nn_idx = new ANNidx[1];
- ANNdistArray dists = new ANNdist[1];
- annTreeBnd->annkSearch(q, 1, nn_idx, dists );
- distance = std::sqrt(dists [0]);
+ for(int k = 0; k < 3; ++k) q[k] = v->point()[k];
+ ANNidxArray nn_idx = new ANNidx[1];
+ ANNdistArray dists = new ANNdist[1];
+ annTreeBnd->annkSearch(q, 1, nn_idx, dists);
+ distance = std::sqrt(dists[0]);
int i = nn_idx[0];
- delete [] nn_idx;
- delete [] dists;
+ delete[] nn_idx;
+ delete[] dists;
annDeallocPt(q);
- std::set<MVertex*>::iterator it = listOfBndVertices.begin();
- std::advance(it,i);
+ std::set<MVertex *>::iterator it = listOfBndVertices.begin();
+ std::advance(it, i);
return (*it);
#else
return NULL;
@@ -686,89 +707,101 @@ MVertex* frameFieldBackgroundMesh3D::get_nearest_neighbor_on_boundary
double frameFieldBackgroundMesh3D::get_smoothness(double x, double y, double z)
{
- return get_field_value(x,y,z,crossFieldSmoothness);
+ return get_field_value(x, y, z, crossFieldSmoothness);
};
-double frameFieldBackgroundMesh3D::get_approximate_smoothness(double x, double y, double z)
+double frameFieldBackgroundMesh3D::get_approximate_smoothness(double x,
+ double y,
+ double z)
{
- return crossFieldSmoothness[get_nearest_neighbor(x,y,z)];
+ return crossFieldSmoothness[get_nearest_neighbor(x, y, z)];
}
double frameFieldBackgroundMesh3D::get_approximate_smoothness(MVertex *v)
{
- return get_approximate_smoothness(v->x(),v->y(),v->z());
+ return get_approximate_smoothness(v->x(), v->y(), v->z());
}
double frameFieldBackgroundMesh3D::get_smoothness(MVertex *v)
{
- return get_nodal_value(v,crossFieldSmoothness);
+ return get_nodal_value(v, crossFieldSmoothness);
};
void frameFieldBackgroundMesh3D::eval_approximate_crossfield(double x, double y,
- double z, STensor3 &cf)
+ double z,
+ STensor3 &cf)
{
- cf = crossField[get_nearest_neighbor(x,y,z)];
+ cf = crossField[get_nearest_neighbor(x, y, z)];
};
-void frameFieldBackgroundMesh3D::eval_approximate_crossfield(const MVertex *vert,
- STensor3 &cf)
+void frameFieldBackgroundMesh3D::eval_approximate_crossfield(
+ const MVertex *vert, STensor3 &cf)
{
// check if vertex is ours...
- TensorStorageType::const_iterator itfind = crossField.find(const_cast<MVertex*>(vert));
- if (itfind != crossField.end())
+ TensorStorageType::const_iterator itfind =
+ crossField.find(const_cast<MVertex *>(vert));
+ if(itfind != crossField.end())
cf = itfind->second;
- else// if not, find closest
- eval_approximate_crossfield(vert->x(),vert->y(),vert->z(),cf);
+ else // if not, find closest
+ eval_approximate_crossfield(vert->x(), vert->y(), vert->z(), cf);
}
-
-void frameFieldBackgroundMesh3D::get_vectorial_smoothness(double x, double y, double z,
+void frameFieldBackgroundMesh3D::get_vectorial_smoothness(double x, double y,
+ double z,
SVector3 &cf)
{
- std::vector<double> res = get_field_value(x,y,z,crossFieldVectorialSmoothness);
- for (int i=0;i<3;i++) cf(i)=res[i];
+ std::vector<double> res =
+ get_field_value(x, y, z, crossFieldVectorialSmoothness);
+ for(int i = 0; i < 3; i++) cf(i) = res[i];
}
-void frameFieldBackgroundMesh3D::get_vectorial_smoothness(const MVertex *vert, SVector3 &cf)
+void frameFieldBackgroundMesh3D::get_vectorial_smoothness(const MVertex *vert,
+ SVector3 &cf)
{
- std::vector<double> res = get_nodal_value(vert,crossFieldVectorialSmoothness);
- for (int i=0;i<3;i++) cf(i)=res[i];
+ std::vector<double> res =
+ get_nodal_value(vert, crossFieldVectorialSmoothness);
+ for(int i = 0; i < 3; i++) cf(i) = res[i];
}
-double frameFieldBackgroundMesh3D::get_vectorial_smoothness(const int idir, double x,
- double y, double z)
+double frameFieldBackgroundMesh3D::get_vectorial_smoothness(const int idir,
+ double x, double y,
+ double z)
{
- return get_field_value(x,y,z,crossFieldVectorialSmoothness)[idir];
+ return get_field_value(x, y, z, crossFieldVectorialSmoothness)[idir];
}
double frameFieldBackgroundMesh3D::get_vectorial_smoothness(const int idir,
const MVertex *vert)
{
- return get_nodal_value(vert,crossFieldVectorialSmoothness)[idir];
+ return get_nodal_value(vert, crossFieldVectorialSmoothness)[idir];
}
void frameFieldBackgroundMesh3D::build_vertex_to_element_table()
{
- GRegion *gr = dynamic_cast<GRegion*>(gf);
- if(!gr){
+ GRegion *gr = dynamic_cast<GRegion *>(gf);
+ if(!gr) {
Msg::Error("Entity is not a region in background mesh");
return;
}
MElement *e;
MVertex *v;
- // std::cout << "build_vertex_to_element_table nbelem=" << gr->getNumMeshElements() << std::endl;
+ // std::cout << "build_vertex_to_element_table nbelem=" <<
+ // gr->getNumMeshElements() << std::endl;
- for (unsigned int i=0;i<gr->getNumMeshElements();i++){// for all elements
+ for(unsigned int i = 0; i < gr->getNumMeshElements();
+ i++) { // for all elements
e = gr->getMeshElement(i);
- if (e->getDim()!=3) continue;// of dim=3
+ if(e->getDim() != 3) continue; // of dim=3
- for (std::size_t iv=0;iv<e->getNumVertices();iv++){// for all vertices
+ for(std::size_t iv = 0; iv < e->getNumVertices();
+ iv++) { // for all vertices
v = e->getVertex(iv);
vert2elem[v].insert(e);
elem2vert[e].insert(v);
- // std::cout << "node " << iv << " on " << v->onWhat()->dim() << std::endl;
- if (v->onWhat()->dim()<=2){
+ // std::cout << "node " << iv << " on " << v->onWhat()->dim() <<
+ // std::endl;
+ if(v->onWhat()->dim() <= 2) {
// std::cout << "adding " << std::endl;
listOfBndVertices.insert(v);
}
@@ -776,20 +809,20 @@ void frameFieldBackgroundMesh3D::build_vertex_to_element_table()
}
}
-const MElement* backgroundMesh3D::getElement(unsigned int i)const
+const MElement *backgroundMesh3D::getElement(unsigned int i) const
{
- GRegion *gr = dynamic_cast<GRegion*>(gf);
- if(!gr){
+ GRegion *gr = dynamic_cast<GRegion *>(gf);
+ if(!gr) {
Msg::Error("Entity is not a region in background mesh");
return 0;
}
return gr->getMeshElement(i);
}
-unsigned int backgroundMesh3D::getNumMeshElements()const
+unsigned int backgroundMesh3D::getNumMeshElements() const
{
- GRegion *gr = dynamic_cast<GRegion*>(gf);
- if(!gr){
+ GRegion *gr = dynamic_cast<GRegion *>(gf);
+ if(!gr) {
Msg::Error("Entity is not a region in background mesh");
return 0;
}
@@ -800,14 +833,14 @@ unsigned int backgroundMesh3D::getNumMeshElements()const
// indirect neighbors, depending on the "max_recursion_level".
void frameFieldBackgroundMesh3D::build_neighbors(const int &max_recursion_level)
{
- std::set<MVertex const*> visited, start;
- std::set<MElement const*> visited_elements;
- std::multimap<int, MVertex const*> proximity;
- //int counter=0;
-
- for (vert2elemtype::iterator it_vertex=vert2elem.begin();
- it_vertex!=vert2elem.end();it_vertex++){// for all vertices
- MVertex const* const current_vertex = it_vertex->first;
+ std::set<MVertex const *> visited, start;
+ std::set<MElement const *> visited_elements;
+ std::multimap<int, MVertex const *> proximity;
+ // int counter=0;
+
+ for(vert2elemtype::iterator it_vertex = vert2elem.begin();
+ it_vertex != vert2elem.end(); it_vertex++) { // for all vertices
+ MVertex const *const current_vertex = it_vertex->first;
visited.clear();
visited_elements.clear();
visited.insert(current_vertex);
@@ -815,19 +848,27 @@ void frameFieldBackgroundMesh3D::build_neighbors(const int &max_recursion_level)
start.insert(current_vertex);
proximity.clear();
- get_recursive_neighbors(start, visited, visited_elements, proximity, max_recursion_level);
+ get_recursive_neighbors(start, visited, visited_elements, proximity,
+ max_recursion_level);
- for (std::multimap<int, MVertex const*>::iterator it1 = proximity.begin();it1!=proximity.end();it1++){
- graph.insert(std::make_pair(current_vertex, std::make_pair(it1->first, it1->second)));
+ for(std::multimap<int, MVertex const *>::iterator it1 = proximity.begin();
+ it1 != proximity.end(); it1++) {
+ graph.insert(std::make_pair(current_vertex,
+ std::make_pair(it1->first, it1->second)));
}
// if (debug){// check
- // if (verbose) std::cout << "vertex (" << counter++ << "): " << current_vertex->getNum() << " connected to " << it_vertex->second.size() << " elements, coord: (" << current_vertex->x() << "," << current_vertex->y() << "," << current_vertex->z() << ")" << std::endl;
- // set<MVertex*> allvertex;
- // for (multimap<int,MVertex*>::iterator it1 = proximity.begin();it1!=proximity.end();it1++){
+ // if (verbose) std::cout << "vertex (" << counter++ << "): " <<
+ // current_vertex->getNum() << " connected to " <<
+ // it_vertex->second.size() << " elements, coord: (" <<
+ // current_vertex->x() << "," << current_vertex->y() << "," <<
+ // current_vertex->z() << ")" << std::endl; set<MVertex*> allvertex;
+ // for (multimap<int,MVertex*>::iterator it1 =
+ // proximity.begin();it1!=proximity.end();it1++){
// if (verbose) {
// for (int i=0;i<it1->first;i++) std::cout << " ";
- // std::cout << it1->first << " : " << it1->second->getNum() << std::endl;
+ // std::cout << it1->first << " : " << it1->second->getNum() <<
+ // std::endl;
// }
// set<MVertex*>::iterator itfind = allvertex.find(it1->second);
// if (itfind!=allvertex.end()){
@@ -840,39 +881,39 @@ void frameFieldBackgroundMesh3D::build_neighbors(const int &max_recursion_level)
}
}
-void frameFieldBackgroundMesh3D::get_recursive_neighbors(std::set<MVertex const*> &start,
- std::set<MVertex const*> &visited,
- std::set<MElement const*> &visited_elements,
- std::multimap<int,MVertex const*> &proximity,
- int max_level,
- int level)
+void frameFieldBackgroundMesh3D::get_recursive_neighbors(
+ std::set<MVertex const *> &start, std::set<MVertex const *> &visited,
+ std::set<MElement const *> &visited_elements,
+ std::multimap<int, MVertex const *> &proximity, int max_level, int level)
{
level++;
- if (level>max_level) return;
+ if(level > max_level) return;
- std::set<MVertex const*> new_vertices;
+ std::set<MVertex const *> new_vertices;
- for (std::set<MVertex const*>::iterator it_start=start.begin();
- it_start!=start.end();it_start++){// for all initial vertices
- MVertex const* current = *it_start;
- // std::cout << "get_recursive_neighbors : on vertex " << current->getNum()
+ for(std::set<MVertex const *>::iterator it_start = start.begin();
+ it_start != start.end(); it_start++) { // for all initial vertices
+ MVertex const *current = *it_start;
+ // std::cout << "get_recursive_neighbors : on vertex " <<
+ // current->getNum()
// << " (" << current << ")" << std::endl;
vert2elemtype::iterator itfind = vert2elem.find(current);
- if (itfind==vert2elem.end()) continue;
+ if(itfind == vert2elem.end()) continue;
- std::set<MElement*>::iterator it_elem = itfind->second.begin();
+ std::set<MElement *>::iterator it_elem = itfind->second.begin();
- for (;it_elem!=itfind->second.end();it_elem++){// for all connected elements
+ for(; it_elem != itfind->second.end();
+ it_elem++) { // for all connected elements
MElement *current_elem = *it_elem;
- if (visited_elements.find(current_elem) != visited_elements.end()){
+ if(visited_elements.find(current_elem) != visited_elements.end()) {
continue;
}
// std::cout << current_elem->getNum() << std::endl;
- for (std::size_t i=0;i<current_elem->getNumVertices();i++){
+ for(std::size_t i = 0; i < current_elem->getNumVertices(); i++) {
MVertex *ver = current_elem->getVertex(i);
- if (visited.find(ver) != visited.end()) continue;
+ if(visited.find(ver) != visited.end()) continue;
proximity.insert(std::make_pair(level, ver));
new_vertices.insert(ver);
@@ -882,8 +923,8 @@ void frameFieldBackgroundMesh3D::get_recursive_neighbors(std::set<MVertex const*
}
}
- get_recursive_neighbors(new_vertices, visited, visited_elements,
- proximity, max_level, level);
+ get_recursive_neighbors(new_vertices, visited, visited_elements, proximity,
+ max_level, level);
}
double frameFieldBackgroundMesh3D::compare_to_neighbors(
@@ -892,14 +933,14 @@ double frameFieldBackgroundMesh3D::compare_to_neighbors(
std::multimap<double, MVertex const *>::iterator itend, SVector3 &mean_axis,
double &mean_angle, std::vector<double> &vectorial_smoothness)
{
- for (int i=0;i<3;i++) mean_axis(i)=0.;
+ for(int i = 0; i < 3; i++) mean_axis(i) = 0.;
- std::multimap<double, MVertex const*>::iterator it = itbegin;
+ std::multimap<double, MVertex const *>::iterator it = itbegin;
SVector3 rotation_axis;
double minimum_angle;
- std::vector<double>all_angle;
- std::vector<SVector3>all_axis;
+ std::vector<double> all_angle;
+ std::vector<SVector3> all_axis;
TensorStorageType::iterator itneighbor;
// vectorial_smoothness.assign(3,0.);
@@ -909,13 +950,15 @@ double frameFieldBackgroundMesh3D::compare_to_neighbors(
std::vector<double> alternative;
- for (;it!=itend;it++){// for all trusted neighbors
- //neighbor = it->second.second;
- MVertex const* neighbor = it->second;
- //ponderations_vec.push_back(1.);
- ponderations_vec.push_back((std::abs(it->first) >= smoothness_threshold) ? 1. : 1.e-3);
- //ponderations_vec.push_back(((std::abs(it->first) >= smoothness_threshold) ?
- //1. : 1.e-3) / (current.distance(neighbor->point())));
+ for(; it != itend; it++) { // for all trusted neighbors
+ // neighbor = it->second.second;
+ MVertex const *neighbor = it->second;
+ // ponderations_vec.push_back(1.);
+ ponderations_vec.push_back(
+ (std::abs(it->first) >= smoothness_threshold) ? 1. : 1.e-3);
+ // ponderations_vec.push_back(((std::abs(it->first) >= smoothness_threshold)
+ // ?
+ // 1. : 1.e-3) / (current.distance(neighbor->point())));
itneighbor = crossField.find(neighbor);
STensor3 &neibcross = itneighbor->second;
@@ -933,53 +976,63 @@ double frameFieldBackgroundMesh3D::compare_to_neighbors(
// }
// temp[ivec] = std::abs(temp[ivec]);
// }
- // vectorial_smoothness[j] += acos(fmin(*std::max_element(temp.begin(),temp.end()),1.));
+ // vectorial_smoothness[j] +=
+ // acos(fmin(*std::max_element(temp.begin(),temp.end()),1.));
// }
-
-
}
- // Watch out !!! acos(mean_angle) != mean_acos -> second option gives better results, better contrast between smooth and not smooth
+ // Watch out !!! acos(mean_angle) != mean_acos -> second option
+ // gives better results, better contrast between smooth and not smooth
// for (int j=0;j<3;j++){
- // vectorial_smoothness[j] = (1. - (vectorial_smoothness[j]/all_angle.size())/M_PI*4.);// between 0 (not smooth) and 1 (smooth)
+ // vectorial_smoothness[j] = (1. -
+ // (vectorial_smoothness[j]/all_angle.size())/M_PI*4.);// between 0 (not
+ // smooth) and 1 (smooth)
// }
-
// ----------------------------------------------------------------------------
// Watch out !!! The following definition of smoothness may change A LOT !!!
// ----------------------------------------------------------------------------
// may seem against intuition in some case, but min gives much better results
// finally... mean angle !!!
- // double smoothness_scalar = (*std::max_element(vectorial_smoothness.begin(),vectorial_smoothness.end()));
- // double smoothness_scalar = (*std::min_element(vectorial_smoothness.begin(),vectorial_smoothness.end()));
- double smoothness_scalar = 1. - (std::accumulate(alternative.begin(),alternative.end(),0.)/alternative.size())/M_PI*4.;// APPROXIMATELY between 0 (not smooth) and 1 (smooth), (sometimes <0, always > 1).
-
- std::vector<double>::iterator itan=all_angle.begin();
- std::vector<double>::iterator itpond=ponderations_vec.begin();
-
- for (std::vector<SVector3>::iterator ita = all_axis.begin();ita!=all_axis.end();ita++,itan++,itpond++){
- //mean_axis += ((*ita)*(*itan));
- mean_axis += ((*ita)*(*itan))*(*itpond);
+ // double smoothness_scalar =
+ // (*std::max_element(vectorial_smoothness.begin(),vectorial_smoothness.end()));
+ // double smoothness_scalar =
+ // (*std::min_element(vectorial_smoothness.begin(),vectorial_smoothness.end()));
+ double smoothness_scalar =
+ 1. - (std::accumulate(alternative.begin(), alternative.end(), 0.) /
+ alternative.size()) /
+ M_PI * 4.; // APPROXIMATELY between 0 (not smooth) and 1 (smooth),
+ // (sometimes <0, always > 1).
+
+ std::vector<double>::iterator itan = all_angle.begin();
+ std::vector<double>::iterator itpond = ponderations_vec.begin();
+
+ for(std::vector<SVector3>::iterator ita = all_axis.begin();
+ ita != all_axis.end(); ita++, itan++, itpond++) {
+ // mean_axis += ((*ita)*(*itan));
+ mean_axis += ((*ita) * (*itan)) * (*itpond);
}
- //mean_angle = mean_axis.norm()/all_angle.size();
- double pond_total = std::accumulate(ponderations_vec.begin(),ponderations_vec.end(),0.);
- mean_angle = mean_axis.norm()/pond_total;
+ // mean_angle = mean_axis.norm()/all_angle.size();
+ double pond_total =
+ std::accumulate(ponderations_vec.begin(), ponderations_vec.end(), 0.);
+ mean_angle = mean_axis.norm() / pond_total;
mean_axis.normalize();
return smoothness_scalar;
}
-STensor3 frameFieldBackgroundMesh3D::apply_rotation
- (const SVector3 &axis, const double &angle, const STensor3 &thecross)
+STensor3 frameFieldBackgroundMesh3D::apply_rotation(const SVector3 &axis,
+ const double &angle,
+ const STensor3 &thecross)
{
double rotmat[3][3];
STensor3 res2;
- get_rotation_matrix(angle,axis,&rotmat[0][0]);
-
+ get_rotation_matrix(angle, axis, &rotmat[0][0]);
- // std::cout << "from matrice, rotation of " << angle/M_PI*180 << "° axis(" << axis(0) << "," << axis(1) << "," << axis(2) << ")" << std::endl;
+ // std::cout << "from matrice, rotation of " << angle/M_PI*180 << "° axis("
+ // << axis(0) << "," << axis(1) << "," << axis(2) << ")" << std::endl;
// std::cout << "rotation matrix is :" << std::endl;
// for (int i=0;i<3;i++){
// for (int j=0;j<3;j++)
@@ -988,13 +1041,11 @@ STensor3 frameFieldBackgroundMesh3D::apply_rotation
// }
//
- for (int i=0;i<3;i++)
- for (int j=0;j<3;j++)
- for (int k=0;k<3;k++)
- res2(i,j) += rotmat[i][k] * thecross(k,j);
+ for(int i = 0; i < 3; i++)
+ for(int j = 0; j < 3; j++)
+ for(int k = 0; k < 3; k++) res2(i, j) += rotmat[i][k] * thecross(k, j);
// return res;
-
// std::cout << "result:" << std::endl;
// for (int i=0;i<3;i++){
// for (int j=0;j<3;j++)
@@ -1002,7 +1053,6 @@ STensor3 frameFieldBackgroundMesh3D::apply_rotation
// std::cout << std::endl;
// }
-
// STensor3 res;
// double crossv[4],q[4],qconj[4],resq[4];
// double coss = cos(angle/2.);
@@ -1037,7 +1087,6 @@ STensor3 frameFieldBackgroundMesh3D::apply_rotation
// std::cout << "w="<<resq[0] << std::endl;
return res2;
-
// STensor3 res;
// double coss = cos(angle);
// double sinn = sin(angle);
@@ -1052,95 +1101,101 @@ STensor3 frameFieldBackgroundMesh3D::apply_rotation
// return res;
}
-
// TODO: ce genre de fct... mettre dans une classe FrameField ? Ou bien juste un
// set de fcts à part ? Parce que ça devient bizarre d'avoir ça dans un BGM ???
-void frameFieldBackgroundMesh3D::get_rotation_matrix
- (const double &angle_to_go, const SVector3 &rotvec, double* rotmat)
+void frameFieldBackgroundMesh3D::get_rotation_matrix(const double &angle_to_go,
+ const SVector3 &rotvec,
+ double *rotmat)
{
double c = std::cos(angle_to_go);
double s = std::sin(angle_to_go);
- double temp01 = rotvec[0]*rotvec[1]*(1.-c);
- double temp02 = rotvec[0]*rotvec[2]*(1.-c);
- double temp12 = rotvec[1]*rotvec[2]*(1.-c);
- double square0 = rotvec[0]*rotvec[0];
- double square1 = rotvec[1]*rotvec[1];
- double square2 = rotvec[2]*rotvec[2];
- rotmat[0] = square0 +(1.-square0)*c;
- rotmat[1] = temp01-rotvec[2]*s;
- rotmat[2] = temp02+rotvec[1]*s;
- rotmat[3] = temp01+rotvec[2]*s;
- rotmat[4] = square1 +(1.-square1)*c;
- rotmat[5] = temp12-rotvec[0]*s;
- rotmat[6] = temp02-rotvec[1]*s;
- rotmat[7] = temp12+rotvec[0]*s;
- rotmat[8] = square2 +(1.-square2)*c;
+ double temp01 = rotvec[0] * rotvec[1] * (1. - c);
+ double temp02 = rotvec[0] * rotvec[2] * (1. - c);
+ double temp12 = rotvec[1] * rotvec[2] * (1. - c);
+ double square0 = rotvec[0] * rotvec[0];
+ double square1 = rotvec[1] * rotvec[1];
+ double square2 = rotvec[2] * rotvec[2];
+ rotmat[0] = square0 + (1. - square0) * c;
+ rotmat[1] = temp01 - rotvec[2] * s;
+ rotmat[2] = temp02 + rotvec[1] * s;
+ rotmat[3] = temp01 + rotvec[2] * s;
+ rotmat[4] = square1 + (1. - square1) * c;
+ rotmat[5] = temp12 - rotvec[0] * s;
+ rotmat[6] = temp02 - rotvec[1] * s;
+ rotmat[7] = temp12 + rotvec[0] * s;
+ rotmat[8] = square2 + (1. - square2) * c;
}
-void frameFieldBackgroundMesh3D::get_min_rotation_matrix
- (const STensor3 &reference, const STensor3 &thecross, double &minimum_angle,
- SVector3 &rotation_axis, double threshold, bool debugflag)
+void frameFieldBackgroundMesh3D::get_min_rotation_matrix(
+ const STensor3 &reference, const STensor3 &thecross, double &minimum_angle,
+ SVector3 &rotation_axis, double threshold, bool debugflag)
{
- minimum_angle = M_PI/2.;
- std::pair<int,int> p;
+ minimum_angle = M_PI / 2.;
+ std::pair<int, int> p;
- for (unsigned int iperm=0;iperm<permutation.size();iperm++){
- if (minimum_angle<threshold) break;
- for (int i_rotation_perm=0;i_rotation_perm<3;i_rotation_perm++){
+ for(unsigned int iperm = 0; iperm < permutation.size(); iperm++) {
+ if(minimum_angle < threshold) break;
+ for(int i_rotation_perm = 0; i_rotation_perm < 3; i_rotation_perm++) {
double a;
SVector3 v;
- get_rotation_angle_and_axis(reference,thecross,a,v,i_rotation_perm,permutation[iperm]);
- if (debugflag){
- if (std::abs(a)<M_PI/2.){
- std::cout << " temp parameters: angle=" << a*180./M_PI
- << "pair=(" << iperm << "," << i_rotation_perm << ") axis=("
- << v(0) << "," << v(1) << "," << v(2) << ")" << std::endl;
+ get_rotation_angle_and_axis(reference, thecross, a, v, i_rotation_perm,
+ permutation[iperm]);
+ if(debugflag) {
+ if(std::abs(a) < M_PI / 2.) {
+ std::cout << " temp parameters: angle=" << a * 180. / M_PI
+ << "pair=(" << iperm << "," << i_rotation_perm << ") axis=("
+ << v(0) << "," << v(1) << "," << v(2) << ")" << std::endl;
}
else
- std::cout << " temp parameters: angle=" << a*180./M_PI << std::endl;
+ std::cout << " temp parameters: angle=" << a * 180. / M_PI
+ << std::endl;
}
- if (std::abs(a) < std::abs(minimum_angle)) {
- p = std::make_pair(iperm,i_rotation_perm);
+ if(std::abs(a) < std::abs(minimum_angle)) {
+ p = std::make_pair(iperm, i_rotation_perm);
minimum_angle = a;
rotation_axis = v;
}
- if (minimum_angle<threshold) break;
+ if(minimum_angle < threshold) break;
}
}
// std::cout << "pair=(" << p.first << "," << p.second << ")" << std::endl;
- if (debugflag){
- std::cout << " ---> MIN parameters: angle=" << minimum_angle*180./M_PI
- << " axis=(" << rotation_axis(0) << "," << rotation_axis(1)
- << "," << rotation_axis(2) << ")" << std::endl;
+ if(debugflag) {
+ std::cout << " ---> MIN parameters: angle=" << minimum_angle * 180. / M_PI
+ << " axis=(" << rotation_axis(0) << "," << rotation_axis(1) << ","
+ << rotation_axis(2) << ")" << std::endl;
}
return;
}
-
// compute the angle and axis of rotation between two (unit-orthogonal) cross
// fields using crossfield vectors permutations defined by modulo and trip The
// rotation matrix between cross fields C and M is R = C M^T
-void frameFieldBackgroundMesh3D::get_rotation_angle_and_axis
- (const STensor3 &reference, const STensor3 &thecross, double &minimum_angle,
- SVector3 &rotation_axis, int modulo, montripletbis &trip)
+void frameFieldBackgroundMesh3D::get_rotation_angle_and_axis(
+ const STensor3 &reference, const STensor3 &thecross, double &minimum_angle,
+ SVector3 &rotation_axis, int modulo, montripletbis &trip)
{
- //double MT[3][3],C[3][3],R[3][3];
- double C[3][3],R[3][3];
-
- for (int i=0;i<3;i++){
- for (int j=0;j<3;j++){
- C[i][j] = signof(trip(j)) * thecross(i,((abs(trip(j))-1)+modulo)%3);
- //MT[j][i] = reference(i,j);//transpose !
+ // double MT[3][3],C[3][3],R[3][3];
+ double C[3][3], R[3][3];
+
+ for(int i = 0; i < 3; i++) {
+ for(int j = 0; j < 3; j++) {
+ C[i][j] =
+ signof(trip(j)) * thecross(i, ((abs(trip(j)) - 1) + modulo) % 3);
+ // MT[j][i] = reference(i,j);//transpose !
}
}
// ////////////////////
// for (int k=0;k<2;k++){
- // double test1 = C[0][k]*C[0][k]*C[1][k]*C[1][k] + C[0][k]*C[0][k]*C[2][k]*C[2][k] + C[2][k]*C[2][k]*C[1][k]*C[1][k];
- // double test2 = reference(0,k)*reference(0,k)*reference(1,k)*reference(1,k) + reference(0,k)*reference(0,k)*reference(2,k)*reference(2,k) + reference(2,k)*reference(2,k)*reference(1,k)*reference(1,k);
- // std::cout << " --- k=" << k << " test1=" << test1 << std::endl;
- // std::cout << " --- k=" << k << " test2=" << test2 << std::endl;
+ // double test1 = C[0][k]*C[0][k]*C[1][k]*C[1][k] +
+ // C[0][k]*C[0][k]*C[2][k]*C[2][k] + C[2][k]*C[2][k]*C[1][k]*C[1][k];
+ // double test2 =
+ // reference(0,k)*reference(0,k)*reference(1,k)*reference(1,k) +
+ // reference(0,k)*reference(0,k)*reference(2,k)*reference(2,k) +
+ // reference(2,k)*reference(2,k)*reference(1,k)*reference(1,k); std::cout
+ // << " --- k=" << k << " test1=" << test1 << std::endl; std::cout << "
+ // --- k=" << k << " test2=" << test2 << std::endl;
// }
// ////////////////////
@@ -1149,69 +1204,82 @@ void frameFieldBackgroundMesh3D::get_rotation_angle_and_axis
// R[0][0] = C[0][0]*MT[0][0] + C[0][1]*MT[1][0] + C[0][2]*MT[2][0];
// R[1][1] = C[1][0]*MT[0][1] + C[1][1]*MT[1][1] + C[1][2]*MT[2][1];
// R[2][2] = C[2][0]*MT[0][2] + C[2][1]*MT[1][2] + C[2][2]*MT[2][2];
- R[0][0] = C[0][0]*reference(0,0) + C[0][1]*reference(0,1) + C[0][2]*reference(0,2);
- R[1][1] = C[1][0]*reference(1,0) + C[1][1]*reference(1,1) + C[1][2]*reference(1,2);
- R[2][2] = C[2][0]*reference(2,0) + C[2][1]*reference(2,1) + C[2][2]*reference(2,2);
+ R[0][0] = C[0][0] * reference(0, 0) + C[0][1] * reference(0, 1) +
+ C[0][2] * reference(0, 2);
+ R[1][1] = C[1][0] * reference(1, 0) + C[1][1] * reference(1, 1) +
+ C[1][2] * reference(1, 2);
+ R[2][2] = C[2][0] * reference(2, 0) + C[2][1] * reference(2, 1) +
+ C[2][2] * reference(2, 2);
// computing rotation angle
double trace = R[0][0] + R[1][1] + R[2][2];
- minimum_angle = std::acos(std::max(std::min(0.5*(trace-1.),1.),-1.));// tjrs > 0
+ minimum_angle =
+ std::acos(std::max(std::min(0.5 * (trace - 1.), 1.), -1.)); // tjrs > 0
- // std::cout << "minimum_angle=" << minimum_angle << " trace=" << trace << std::endl;
+ // std::cout << "minimum_angle=" << minimum_angle << " trace=" << trace <<
+ // std::endl;
- if (std::abs(minimum_angle)>M_PI/2.) return;// no need to continue...
+ if(std::abs(minimum_angle) > M_PI / 2.) return; // no need to continue...
// computing rotation axis
// computing the remaining terms, not on diagonal
- if (std::abs(minimum_angle)<1.e-6){
- rotation_axis(0)=0.;
- rotation_axis(1)=0.;
- rotation_axis(2)=1.;
+ if(std::abs(minimum_angle) < 1.e-6) {
+ rotation_axis(0) = 0.;
+ rotation_axis(1) = 0.;
+ rotation_axis(2) = 1.;
return;
}
- R[0][1] = C[0][0]*reference(1,0) + C[0][1]*reference(1,1) + C[0][2]*reference(1,2);
- R[0][2] = C[0][0]*reference(2,0) + C[0][1]*reference(2,1) + C[0][2]*reference(2,2);
- R[1][0] = C[1][0]*reference(0,0) + C[1][1]*reference(0,1) + C[1][2]*reference(0,2);
- R[1][2] = C[1][0]*reference(2,0) + C[1][1]*reference(2,1) + C[1][2]*reference(2,2);
- R[2][0] = C[2][0]*reference(0,0) + C[2][1]*reference(0,1) + C[2][2]*reference(0,2);
- R[2][1] = C[2][0]*reference(1,0) + C[2][1]*reference(1,1) + C[2][2]*reference(1,2);
-
- double factor = -0.5/std::sin(minimum_angle);
- rotation_axis(0) = (R[2][1]-R[1][2])*factor;
- rotation_axis(1) = (R[0][2]-R[2][0])*factor;
- rotation_axis(2) = (R[1][0]-R[0][1])*factor;
+ R[0][1] = C[0][0] * reference(1, 0) + C[0][1] * reference(1, 1) +
+ C[0][2] * reference(1, 2);
+ R[0][2] = C[0][0] * reference(2, 0) + C[0][1] * reference(2, 1) +
+ C[0][2] * reference(2, 2);
+ R[1][0] = C[1][0] * reference(0, 0) + C[1][1] * reference(0, 1) +
+ C[1][2] * reference(0, 2);
+ R[1][2] = C[1][0] * reference(2, 0) + C[1][1] * reference(2, 1) +
+ C[1][2] * reference(2, 2);
+ R[2][0] = C[2][0] * reference(0, 0) + C[2][1] * reference(0, 1) +
+ C[2][2] * reference(0, 2);
+ R[2][1] = C[2][0] * reference(1, 0) + C[2][1] * reference(1, 1) +
+ C[2][2] * reference(1, 2);
+
+ double factor = -0.5 / std::sin(minimum_angle);
+ rotation_axis(0) = (R[2][1] - R[1][2]) * factor;
+ rotation_axis(1) = (R[0][2] - R[2][0]) * factor;
+ rotation_axis(2) = (R[1][0] - R[0][1]) * factor;
return;
}
-void frameFieldBackgroundMesh3D::exportVectorialSmoothness(const std::string &filename)
+void frameFieldBackgroundMesh3D::exportVectorialSmoothness(
+ const std::string &filename)
{
FILE *f = Fopen(filename.c_str(), "w");
- if(!f){
+ if(!f) {
Msg::Error("Could not open file '%s'", filename.c_str());
return;
}
fprintf(f, "View \"Background Mesh\"{\n");
- std::set<const MVertex*> done;
+ std::set<const MVertex *> done;
- for (unsigned int ie = 0; ie < getNumMeshElements(); ie++){// for all elements
+ for(unsigned int ie = 0; ie < getNumMeshElements();
+ ie++) { // for all elements
const MElement *e = getElement(ie);
- for (std::size_t iv = 0; iv < e->getNumVertices(); iv++){
+ for(std::size_t iv = 0; iv < e->getNumVertices(); iv++) {
const MVertex *v = e->getVertex(iv);
- std::set<const MVertex*>::iterator itfind = done.find(v);
- if (itfind!=done.end()) continue;
+ std::set<const MVertex *>::iterator itfind = done.find(v);
+ if(itfind != done.end()) continue;
done.insert(v);
STensor3 cf;
- eval_approximate_crossfield(v,cf);
- for (int i = 0; i < 3; i++){
- double vs = get_vectorial_smoothness(i,v);
- fprintf(f,"VP(%g,%g,%g){%g,%g,%g};\n", v->x(), v->y(), v->z(),
- cf(0,i)*vs,cf(1,i)*vs,cf(2,i)*vs);
+ eval_approximate_crossfield(v, cf);
+ for(int i = 0; i < 3; i++) {
+ double vs = get_vectorial_smoothness(i, v);
+ fprintf(f, "VP(%g,%g,%g){%g,%g,%g};\n", v->x(), v->y(), v->z(),
+ cf(0, i) * vs, cf(1, i) * vs, cf(2, i) * vs);
}
}
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
fclose(f);
}
diff --git a/Mesh/BackgroundMesh3D.h b/Mesh/BackgroundMesh3D.h
index b3ae1b3857eaf502db3bac363961b56f6ce043b0..3a7f68fe2c19e071fa857a14beb4f8538f709b1d 100644
--- a/Mesh/BackgroundMesh3D.h
+++ b/Mesh/BackgroundMesh3D.h
@@ -23,57 +23,61 @@ class ANNkd_tree;
// account vertices at a given topological distance... but using distance=1, it
// seems to work... ?!
-class montripletbis{
+class montripletbis {
public:
~montripletbis(){};
- montripletbis(int a,int b, int c):vec(3){
+ montripletbis(int a, int b, int c) : vec(3)
+ {
vec[0] = a;
vec[1] = b;
vec[2] = c;
};
- inline int operator()(int i)const{return vec[i];}
+ inline int operator()(int i) const { return vec[i]; }
+
private:
std::vector<int> vec;
};
-
-// difference with BackgroundMesh2D: no copy of components, working directly on the vertices and elements of GRegion
+// difference with BackgroundMesh2D: no copy of components, working directly on
+// the vertices and elements of GRegion
class backgroundMesh3D : public BGMBase {
protected:
virtual void computeSizeField();
- virtual void propagateValues(DoubleStorageType &dirichlet, simpleFunction<double> &eval_diffusivity, bool in_parametric_plane = false);
+ virtual void propagateValues(DoubleStorageType &dirichlet,
+ simpleFunction<double> &eval_diffusivity,
+ bool in_parametric_plane = false);
virtual GPoint get_GPoint_from_MVertex(const MVertex *) const;
- virtual const MElement* getElement(unsigned int i)const;
- virtual unsigned int getNumMeshElements()const;
+ virtual const MElement *getElement(unsigned int i) const;
+ virtual unsigned int getNumMeshElements() const;
const bool debug;
const bool verbose;
public:
-
backgroundMesh3D(GRegion *_gr);
virtual ~backgroundMesh3D();
- virtual MElementOctree* getOctree();
+ virtual MElementOctree *getOctree();
- virtual MVertex* get_nearest_neighbor(const double* xyz, double & distance );
- virtual MVertex* get_nearest_neighbor(const double* xyz);
- virtual MVertex* get_nearest_neighbor(const MVertex *v);
- virtual MVertex* get_nearest_neighbor(double x, double y, double z);
- virtual MVertex* get_nearest_neighbor(double x, double y, double z, double &distance );
+ virtual MVertex *get_nearest_neighbor(const double *xyz, double &distance);
+ virtual MVertex *get_nearest_neighbor(const double *xyz);
+ virtual MVertex *get_nearest_neighbor(const MVertex *v);
+ virtual MVertex *get_nearest_neighbor(double x, double y, double z);
+ virtual MVertex *get_nearest_neighbor(double x, double y, double z,
+ double &distance);
};
-
-
-class frameFieldBackgroundMesh3D : public backgroundMesh3D{
+class frameFieldBackgroundMesh3D : public backgroundMesh3D {
public:
- // typedef tr1::unordered_map<hash_key_ptr, std::set<MElement*> > vert2elemtype;
- // typedef tr1::unordered_map<MElement*, std::set<MVertex*> > elem2verttype;
- typedef std::map<hash_key_ptr, std::set<MElement*> > vert2elemtype;
- typedef std::map<MElement*, std::set<MVertex*> > elem2verttype;
- typedef std::multimap<MVertex const* const, std::pair<int,MVertex const*> > graphtype;
+ // typedef tr1::unordered_map<hash_key_ptr, std::set<MElement*> >
+ // vert2elemtype; typedef tr1::unordered_map<MElement*, std::set<MVertex*>
+ // > elem2verttype;
+ typedef std::map<hash_key_ptr, std::set<MElement *> > vert2elemtype;
+ typedef std::map<MElement *, std::set<MVertex *> > elem2verttype;
+ typedef std::multimap<MVertex const *const, std::pair<int, MVertex const *> >
+ graphtype;
protected:
bool smooth_the_crossfield;
@@ -85,16 +89,17 @@ protected:
void build_vertex_to_element_table();
- // fills the multimap "graph": vertex to direct neighbors, or indirect neighbors, depending on the "max_recursion_level".
+ // fills the multimap "graph": vertex to direct neighbors, or indirect
+ // neighbors, depending on the "max_recursion_level".
void build_neighbors(const int &max_recursion_level);
- // function called only by "build_neighbors", recursively recovering vertices neighbors.
- void get_recursive_neighbors(std::set<MVertex const*> &start,
- std::set<MVertex const*> &visited,
- std::set<MElement const*> &visited_elements,
- std::multimap<int, MVertex const*> &proximity,
- int max_level,
- int level=0);
+ // function called only by "build_neighbors", recursively recovering vertices
+ // neighbors.
+ void get_recursive_neighbors(std::set<MVertex const *> &start,
+ std::set<MVertex const *> &visited,
+ std::set<MElement const *> &visited_elements,
+ std::multimap<int, MVertex const *> &proximity,
+ int max_level, int level = 0);
double
compare_to_neighbors(const SPoint3 ¤t, STensor3 &ref,
@@ -103,12 +108,19 @@ protected:
SVector3 &mean_axis, double &mean_angle,
std::vector<double> &vectorial_smoothness);
- STensor3 apply_rotation(const SVector3 &axis, const double &angle, const STensor3 &thecross);
- void get_rotation_matrix(const double &angle_to_go, const SVector3 &rotvec, double* rotmat);
- void get_min_rotation_matrix(const STensor3 &reference, const STensor3 &thecross, double &minimum_angle, SVector3 &rotation_axis, double threshold=-1., bool debugflag=false);
- void get_rotation_angle_and_axis(const STensor3 &reference, const STensor3 &thecross, double &minimum_angle, SVector3 &rotation_axis, int modulo, montripletbis &trip);
-
-
+ STensor3 apply_rotation(const SVector3 &axis, const double &angle,
+ const STensor3 &thecross);
+ void get_rotation_matrix(const double &angle_to_go, const SVector3 &rotvec,
+ double *rotmat);
+ void get_min_rotation_matrix(const STensor3 &reference,
+ const STensor3 &thecross, double &minimum_angle,
+ SVector3 &rotation_axis, double threshold = -1.,
+ bool debugflag = false);
+ void get_rotation_angle_and_axis(const STensor3 &reference,
+ const STensor3 &thecross,
+ double &minimum_angle,
+ SVector3 &rotation_axis, int modulo,
+ montripletbis &trip);
TensorStorageType crossField;
DoubleStorageType crossFieldSmoothness;
@@ -116,16 +128,16 @@ protected:
vert2elemtype vert2elem;
elem2verttype elem2vert;
- std::set<MVertex*> listOfBndVertices;
+ std::set<MVertex *> listOfBndVertices;
graphtype graph;
double smoothness_threshold;
static std::vector<montripletbis> permutation;
#if defined(HAVE_ANN)
- ANNkd_tree* annTree;
+ ANNkd_tree *annTree;
ANNpointArray dataPts;
- ANNkd_tree* annTreeBnd;
+ ANNkd_tree *annTreeBnd;
ANNpointArray dataPtsBnd;
#endif
@@ -133,13 +145,13 @@ public:
frameFieldBackgroundMesh3D(GRegion *_gf);
virtual ~frameFieldBackgroundMesh3D();
- MVertex* get_nearest_neighbor_on_boundary(MVertex* v);
- MVertex* get_nearest_neighbor_on_boundary(MVertex* v, double &distance);
+ MVertex *get_nearest_neighbor_on_boundary(MVertex *v);
+ MVertex *get_nearest_neighbor_on_boundary(MVertex *v, double &distance);
// bool findvertex(const MVertex *v)const{
- // std::map<MVertex*,double>::const_iterator it = sizeField.find(const_cast<MVertex*>(v));
- // if (it==sizeField.end()) return false;
- // return true;
+ // std::map<MVertex*,double>::const_iterator it =
+ // sizeField.find(const_cast<MVertex*>(v)); if (it==sizeField.end())
+ // return false; return true;
// };
double get_smoothness(double x, double y, double z);
@@ -156,14 +168,18 @@ public:
double get_vectorial_smoothness(const int idir, double x, double y, double z);
double get_vectorial_smoothness(const int idir, const MVertex *vert);
- inline void exportCrossField(const std::string &filename){export_tensor_as_vectors(filename,crossField);};
- inline void exportSmoothness(const std::string &filename) const{export_scalar(filename,crossFieldSmoothness);};
+ inline void exportCrossField(const std::string &filename)
+ {
+ export_tensor_as_vectors(filename, crossField);
+ };
+ inline void exportSmoothness(const std::string &filename) const
+ {
+ export_scalar(filename, crossFieldSmoothness);
+ };
void exportVectorialSmoothness(const std::string &filename);
// private:
// STensor3 get_random_cross()const;
-
};
-
#endif
diff --git a/Mesh/BackgroundMeshManager.cpp b/Mesh/BackgroundMeshManager.cpp
index 9c62ffd3eece3d1ea1ad3a81223b60a134bae531..4957b33784ee4e16853ec16bf888d3eda7e17b67 100644
--- a/Mesh/BackgroundMeshManager.cpp
+++ b/Mesh/BackgroundMeshManager.cpp
@@ -11,51 +11,47 @@
#include "GRegion.h"
#include "BackgroundMesh3D.h"
-std::map<GEntity*,BGMBase*> BGMManager::data = std::map<GEntity*,BGMBase*>();
-BGMBase* BGMManager::latest2Dbgm = NULL;
+std::map<GEntity *, BGMBase *> BGMManager::data =
+ std::map<GEntity *, BGMBase *>();
+BGMBase *BGMManager::latest2Dbgm = NULL;
bool BGMManager::use_cross_field = true;
void BGMManager::set_use_cross_field(bool b)
{
- if (b && !BGMManager::use_cross_field){// need to change...
+ if(b && !BGMManager::use_cross_field) { // need to change...
data.clear();
}
BGMManager::use_cross_field = b;
}
-BGMBase* BGMManager::get(GRegion* gf)
+BGMBase *BGMManager::get(GRegion *gf)
{
- std::map<GEntity*,BGMBase*>::iterator itfind = data.find(gf);
- if (itfind!=data.end()){
+ std::map<GEntity *, BGMBase *>::iterator itfind = data.find(gf);
+ if(itfind != data.end()) {
return itfind->second;
}
- BGMBase *bgm = use_cross_field
- ? new frameFieldBackgroundMesh3D(gf)
- : new backgroundMesh3D(gf);
+ BGMBase *bgm = use_cross_field ? new frameFieldBackgroundMesh3D(gf) :
+ new backgroundMesh3D(gf);
data.insert(std::make_pair(gf, bgm));
return bgm;
}
-BGMBase* BGMManager::get(GFace* gf)
+BGMBase *BGMManager::get(GFace *gf)
{
- std::map<GEntity*,BGMBase*>::iterator itfind = data.find(gf);
- if (itfind!=data.end()){
+ std::map<GEntity *, BGMBase *>::iterator itfind = data.find(gf);
+ if(itfind != data.end()) {
latest2Dbgm = itfind->second;
return itfind->second;
}
- BGMBase *bgm = use_cross_field
- ? new frameFieldBackgroundMesh2D(gf)
- : new backgroundMesh2D(gf);
+ BGMBase *bgm = use_cross_field ? new frameFieldBackgroundMesh2D(gf) :
+ new backgroundMesh2D(gf);
data.insert(std::make_pair(gf, bgm));
latest2Dbgm = bgm;
return bgm;
}
-BGMBase* BGMManager::current2D()
-{
- return latest2Dbgm;
-}
+BGMBase *BGMManager::current2D() { return latest2Dbgm; }
diff --git a/Mesh/BackgroundMeshManager.h b/Mesh/BackgroundMeshManager.h
index 57df18f8025e98ba0a99556ad6d1f36af5afac4c..71db7d588b65c6638e4dcef7c3fa51c91f0526c2 100644
--- a/Mesh/BackgroundMeshManager.h
+++ b/Mesh/BackgroundMeshManager.h
@@ -13,16 +13,17 @@ class GEntity;
class GFace;
class GRegion;
-class BGMManager{
+class BGMManager {
public:
- static BGMBase* get(GFace *gf);
- static BGMBase* get(GRegion *gf);
- static BGMBase* current2D();
+ static BGMBase *get(GFace *gf);
+ static BGMBase *get(GRegion *gf);
+ static BGMBase *current2D();
static void set_use_cross_field(bool b);
+
private:
static bool use_cross_field;
static BGMBase *latest2Dbgm;
- static std::map<GEntity*,BGMBase*> data;
+ static std::map<GEntity *, BGMBase *> data;
};
#endif
diff --git a/Mesh/BackgroundMeshTools.cpp b/Mesh/BackgroundMeshTools.cpp
index 930b376b9f585a32fc07b612979928a1dd436ea1..b3e5d980ccc849898577661ba46fc4d0b0ae2946 100644
--- a/Mesh/BackgroundMeshTools.cpp
+++ b/Mesh/BackgroundMeshTools.cpp
@@ -17,7 +17,7 @@ static double max_surf_curvature(const GEdge *ge, double u)
double val = 0;
std::vector<GFace *> faces = ge->faces();
std::vector<GFace *>::iterator it = faces.begin();
- while(it != faces.end()){
+ while(it != faces.end()) {
SPoint2 par = ge->reparamOnFace((*it), u, 1);
double cc = (*it)->curvature(par);
val = std::max(cc, val);
@@ -29,14 +29,16 @@ static double max_surf_curvature(const GEdge *ge, double u)
static double max_edge_curvature(const GVertex *gv)
{
double val = 0;
- std::vector<GEdge*> const& l_edges = gv->edges();
- for (std::vector<GEdge*>::const_iterator ite = l_edges.begin();
- ite != l_edges.end(); ++ite){
+ std::vector<GEdge *> const &l_edges = gv->edges();
+ for(std::vector<GEdge *>::const_iterator ite = l_edges.begin();
+ ite != l_edges.end(); ++ite) {
GEdge *_myGEdge = *ite;
Range<double> range = _myGEdge->parBounds(0);
double cc;
- if (gv == _myGEdge->getBeginVertex()) cc = _myGEdge->curvature(range.low());
- else cc = _myGEdge->curvature(range.high());
+ if(gv == _myGEdge->getBeginVertex())
+ cc = _myGEdge->curvature(range.low());
+ else
+ cc = _myGEdge->curvature(range.high());
val = std::max(val, cc);
}
return val;
@@ -49,43 +51,41 @@ static double max_edge_curvature(const GVertex *gv)
static double LC_MVertex_CURV(GEntity *ge, double U, double V)
{
double Crv = 0;
- switch(ge->dim()){
+ switch(ge->dim()) {
case 0:
Crv = max_edge_curvature((const GVertex *)ge);
// Crv = std::max(max_surf_curvature_vertex((const GVertex *)ge), Crv);
// Crv = max_surf_curvature((const GVertex *)ge);
break;
- case 1:
- {
- GEdge *ged = (GEdge *)ge;
- Crv = ged->curvature(U);
- Crv = std::max(Crv, max_surf_curvature(ged, U));
- // printf("%g %d\n",Crv, CTX::instance()->mesh.minCircPoints);
- // Crv = max_surf_curvature(ged, U);
- }
- break;
- case 2:
- {
- GFace *gf = (GFace *)ge;
- Crv = gf->curvature(SPoint2(U, V));
- }
- break;
+ case 1: {
+ GEdge *ged = (GEdge *)ge;
+ Crv = ged->curvature(U);
+ Crv = std::max(Crv, max_surf_curvature(ged, U));
+ // printf("%g %d\n",Crv, CTX::instance()->mesh.minCircPoints);
+ // Crv = max_surf_curvature(ged, U);
+ } break;
+ case 2: {
+ GFace *gf = (GFace *)ge;
+ Crv = gf->curvature(SPoint2(U, V));
+ } break;
}
- double lc = Crv > 0 ? 2 * M_PI / Crv / CTX::instance()->mesh.minCircPoints : MAX_LC;
+ double lc =
+ Crv > 0 ? 2 * M_PI / Crv / CTX::instance()->mesh.minCircPoints : MAX_LC;
return lc;
}
SMetric3 max_edge_curvature_metric(const GEdge *ge, double u)
{
- SVector3 t = ge->firstDer(u);
+ SVector3 t = ge->firstDer(u);
t.normalize();
- double l_t = (2 * M_PI) / (fabs(ge->curvature(u)) *
- CTX::instance()->mesh.minCircPoints);
+ double l_t =
+ (2 * M_PI) / (fabs(ge->curvature(u)) * CTX::instance()->mesh.minCircPoints);
double l_n = 1.e12;
- return buildMetricTangentToCurve(t,l_t,l_n);
+ return buildMetricTangentToCurve(t, l_t, l_n);
}
-static SMetric3 metric_based_on_surface_curvature(const GEdge *ge, double u, bool iso_surf)
+static SMetric3 metric_based_on_surface_curvature(const GEdge *ge, double u,
+ bool iso_surf)
{
SMetric3 mesh_size(1.e-12);
std::vector<GFace *> faces = ge->faces();
@@ -93,16 +93,18 @@ static SMetric3 metric_based_on_surface_curvature(const GEdge *ge, double u, boo
// we choose the metric eigenvectors to be the ones
// related to the edge ...
SMetric3 curvMetric = max_edge_curvature_metric(ge, u);
- while(it != faces.end()){
+ while(it != faces.end()) {
SPoint2 par = ge->reparamOnFace((*it), u, 1);
- SMetric3 m = metric_based_on_surface_curvature (*it, par.x(), par.y(), iso_surf);
- curvMetric = intersection_conserveM1(curvMetric,m);
+ SMetric3 m =
+ metric_based_on_surface_curvature(*it, par.x(), par.y(), iso_surf);
+ curvMetric = intersection_conserveM1(curvMetric, m);
++it;
}
return curvMetric;
}
-static SMetric3 metric_based_on_surface_curvature(const GVertex *gv, bool iso_surf)
+static SMetric3 metric_based_on_surface_curvature(const GVertex *gv,
+ bool iso_surf)
{
SMetric3 mesh_size(1.e-15);
return mesh_size;
@@ -112,10 +114,13 @@ SMetric3 LC_MVertex_CURV_ANISO(GEntity *ge, double U, double V)
{
bool iso_surf = CTX::instance()->mesh.lcFromCurvature == 2;
- switch(ge->dim()){
- case 0: return metric_based_on_surface_curvature((const GVertex *)ge, iso_surf);
- case 1: return metric_based_on_surface_curvature((const GEdge *)ge, U, iso_surf);
- case 2: return metric_based_on_surface_curvature((const GFace *)ge, U, V, iso_surf);
+ switch(ge->dim()) {
+ case 0:
+ return metric_based_on_surface_curvature((const GVertex *)ge, iso_surf);
+ case 1:
+ return metric_based_on_surface_curvature((const GEdge *)ge, U, iso_surf);
+ case 2:
+ return metric_based_on_surface_curvature((const GFace *)ge, U, V, iso_surf);
}
Msg::Error("Curvature control impossible to compute for a volume!");
return SMetric3();
@@ -125,83 +130,84 @@ SMetric3 LC_MVertex_CURV_ANISO(GEntity *ge, double U, double V)
// mesh vertices
static double LC_MVertex_PNTS(GEntity *ge, double U, double V)
{
- switch(ge->dim()){
- case 0:
- {
- GVertex *gv = (GVertex *)ge;
- double lc = gv->prescribedMeshSizeAtVertex();
- // FIXME we might want to remove this to make all lc treatment consistent
- if(lc >= MAX_LC) return CTX::instance()->lc / 10.;
- return lc;
- }
- case 1:
- {
- GEdge *ged = (GEdge *)ge;
- GVertex *v1 = ged->getBeginVertex();
- GVertex *v2 = ged->getEndVertex();
- if (v1 && v2){
- double lc1 = v1->prescribedMeshSizeAtVertex();
- double lc2 = v2->prescribedMeshSizeAtVertex();
- if (lc1 >= MAX_LC && lc2 >= MAX_LC){
- // FIXME we might want to remove this to make all lc treatment consistent
- return CTX::instance()->lc / 10.;
- }
- else{
+ switch(ge->dim()) {
+ case 0: {
+ GVertex *gv = (GVertex *)ge;
+ double lc = gv->prescribedMeshSizeAtVertex();
+ // FIXME we might want to remove this to make all lc treatment consistent
+ if(lc >= MAX_LC) return CTX::instance()->lc / 10.;
+ return lc;
+ }
+ case 1: {
+ GEdge *ged = (GEdge *)ge;
+ GVertex *v1 = ged->getBeginVertex();
+ GVertex *v2 = ged->getEndVertex();
+ if(v1 && v2) {
+ double lc1 = v1->prescribedMeshSizeAtVertex();
+ double lc2 = v2->prescribedMeshSizeAtVertex();
+ if(lc1 >= MAX_LC && lc2 >= MAX_LC) {
+ // FIXME we might want to remove this to make all lc treatment
+ // consistent
+ return CTX::instance()->lc / 10.;
+ }
+ else {
Range<double> range = ged->parBounds(0);
double a = (U - range.low()) / (range.high() - range.low());
- return (1 - a) * lc1 + (a)* lc2;
+ return (1 - a) * lc1 + (a)*lc2;
}
- }
- else
- return MAX_LC;
}
- default:
- return MAX_LC;
+ else
+ return MAX_LC;
+ }
+ default: return MAX_LC;
}
}
SMetric3 buildMetricTangentToCurve(SVector3 &t, double l_t, double l_n)
{
- if (l_t == 0.0) return SMetric3(1.e-22);
+ if(l_t == 0.0) return SMetric3(1.e-22);
SVector3 a;
- if (fabs(t(0)) <= fabs(t(1)) && fabs(t(0)) <= fabs(t(2))){
- a = SVector3(1,0,0);
+ if(fabs(t(0)) <= fabs(t(1)) && fabs(t(0)) <= fabs(t(2))) {
+ a = SVector3(1, 0, 0);
}
- else if (fabs(t(1)) <= fabs(t(0)) && fabs(t(1)) <= fabs(t(2))){
- a = SVector3(0,1,0);
+ else if(fabs(t(1)) <= fabs(t(0)) && fabs(t(1)) <= fabs(t(2))) {
+ a = SVector3(0, 1, 0);
}
- else{
- a = SVector3(0,0,1);
+ else {
+ a = SVector3(0, 0, 1);
}
- SVector3 b = crossprod (t,a);
- SVector3 c = crossprod (b,t);
+ SVector3 b = crossprod(t, a);
+ SVector3 c = crossprod(b, t);
b.normalize();
c.normalize();
t.normalize();
- SMetric3 Metric (1./(l_t*l_t),1./(l_n*l_n),1./(l_n*l_n),t,b,c);
- // printf("bmttc %g %g %g %g %g\n",l_t,l_n,Metric(0,0),Metric(0,1),Metric(1,1));
+ SMetric3 Metric(1. / (l_t * l_t), 1. / (l_n * l_n), 1. / (l_n * l_n), t, b,
+ c);
+ // printf("bmttc %g %g %g %g
+ // %g\n",l_t,l_n,Metric(0,0),Metric(0,1),Metric(1,1));
return Metric;
}
-SMetric3 buildMetricTangentToSurface(SVector3 &t1, SVector3 &t2,
- double l_t1, double l_t2, double l_n)
+SMetric3 buildMetricTangentToSurface(SVector3 &t1, SVector3 &t2, double l_t1,
+ double l_t2, double l_n)
{
t1.normalize();
t2.normalize();
- SVector3 n = crossprod (t1,t2);
+ SVector3 n = crossprod(t1, t2);
n.normalize();
l_t1 = std::max(l_t1, CTX::instance()->mesh.lcMin);
l_t2 = std::max(l_t2, CTX::instance()->mesh.lcMin);
l_t1 = std::min(l_t1, CTX::instance()->mesh.lcMax);
l_t2 = std::min(l_t2, CTX::instance()->mesh.lcMax);
- SMetric3 Metric (1./(l_t1*l_t1),1./(l_t2*l_t2),1./(l_n*l_n),t1,t2,n);
+ SMetric3 Metric(1. / (l_t1 * l_t1), 1. / (l_t2 * l_t2), 1. / (l_n * l_n), t1,
+ t2, n);
return Metric;
}
// This is the only function that is used by the meshers
-double BGM_MeshSize(GEntity *ge, double U, double V,
- double X, double Y, double Z)
+double BGM_MeshSize(GEntity *ge, double U, double V, double X, double Y,
+ double Z)
{
// default lc (mesh size == size of the model)
double l1 = CTX::instance()->lc;
@@ -219,7 +225,7 @@ double BGM_MeshSize(GEntity *ge, double U, double V,
// lc from fields
double l4 = MAX_LC;
FieldManager *fields = ge->model()->getFields();
- if(fields->getBackgroundField() > 0){
+ if(fields->getBackgroundField() > 0) {
Field *f = fields->get(fields->getBackgroundField());
if(f) l4 = (*f)(X, Y, Z, ge);
}
@@ -232,9 +238,9 @@ double BGM_MeshSize(GEntity *ge, double U, double V,
lc = std::max(lc, CTX::instance()->mesh.lcMin);
lc = std::min(lc, CTX::instance()->mesh.lcMax);
- if(lc <= 0.){
- Msg::Error("Wrong mesh element size lc = %g (lcmin = %g, lcmax = %g)",
- lc, CTX::instance()->mesh.lcMin, CTX::instance()->mesh.lcMax);
+ if(lc <= 0.) {
+ Msg::Error("Wrong mesh element size lc = %g (lcmin = %g, lcmax = %g)", lc,
+ CTX::instance()->mesh.lcMin, CTX::instance()->mesh.lcMax);
lc = l1;
}
@@ -242,11 +248,9 @@ double BGM_MeshSize(GEntity *ge, double U, double V,
}
// anisotropic version of the background field
-SMetric3 BGM_MeshMetric(GEntity *ge,
- double U, double V,
- double X, double Y, double Z)
+SMetric3 BGM_MeshMetric(GEntity *ge, double U, double V, double X, double Y,
+ double Z)
{
-
// Metrics based on element size
// Element size = min. between default lc and lc from point (if applicable),
@@ -257,24 +261,26 @@ SMetric3 BGM_MeshMetric(GEntity *ge,
lc = std::min(lc, ge->getMeshSize());
lc = std::max(lc, CTX::instance()->mesh.lcMin);
lc = std::min(lc, CTX::instance()->mesh.lcMax);
- if(lc <= 0.){
- Msg::Error("Wrong mesh element size lc = %g (lcmin = %g, lcmax = %g)",
- lc, CTX::instance()->mesh.lcMin, CTX::instance()->mesh.lcMax);
+ if(lc <= 0.) {
+ Msg::Error("Wrong mesh element size lc = %g (lcmin = %g, lcmax = %g)", lc,
+ CTX::instance()->mesh.lcMin, CTX::instance()->mesh.lcMax);
lc = CTX::instance()->lc;
}
- SMetric3 m0(1./(lc*lc));
+ SMetric3 m0(1. / (lc * lc));
// Intersect with metrics from fields if applicable
FieldManager *fields = ge->model()->getFields();
SMetric3 m1 = m0;
- if(fields->getBackgroundField() > 0){
+ if(fields->getBackgroundField() > 0) {
Field *f = fields->get(fields->getBackgroundField());
if(f) {
SMetric3 l4;
- if (!f->isotropic()){(*f)(X, Y, Z, l4, ge);}
+ if(!f->isotropic()) {
+ (*f)(X, Y, Z, l4, ge);
+ }
else {
- const double L = (*f)(X, Y, Z, ge);
- l4 = SMetric3(1/(L*L));
+ const double L = (*f)(X, Y, Z, ge);
+ l4 = SMetric3(1 / (L * L));
}
m1 = intersection(l4, m0);
}
@@ -282,7 +288,8 @@ SMetric3 BGM_MeshMetric(GEntity *ge,
// Intersect with metrics from curvature if applicable
SMetric3 m = (CTX::instance()->mesh.lcFromCurvature && ge->dim() < 3) ?
- intersection(m1, LC_MVertex_CURV_ANISO(ge, U, V)) : m1;
+ intersection(m1, LC_MVertex_CURV_ANISO(ge, U, V)) :
+ m1;
return m;
}
@@ -299,49 +306,51 @@ bool Extend2dMeshIn3dVolumes()
SMetric3 max_edge_curvature_metric(const GVertex *gv)
{
- SMetric3 val (1.e-12);
- std::vector<GEdge*> const& l_edges = gv->edges();
- for (std::vector<GEdge*>::const_iterator ite = l_edges.begin();
- ite != l_edges.end(); ++ite){
+ SMetric3 val(1.e-12);
+ std::vector<GEdge *> const &l_edges = gv->edges();
+ for(std::vector<GEdge *>::const_iterator ite = l_edges.begin();
+ ite != l_edges.end(); ++ite) {
GEdge *_myGEdge = *ite;
Range<double> range = _myGEdge->parBounds(0);
SMetric3 cc;
- if (gv == _myGEdge->getBeginVertex()) {
+ if(gv == _myGEdge->getBeginVertex()) {
SVector3 t = _myGEdge->firstDer(range.low());
t.normalize();
- double l_t = ((2 * M_PI) /( fabs(_myGEdge->curvature(range.low()))
- * CTX::instance()->mesh.minCircPoints ));
+ double l_t = ((2 * M_PI) / (fabs(_myGEdge->curvature(range.low())) *
+ CTX::instance()->mesh.minCircPoints));
double l_n = 1.e12;
- cc = buildMetricTangentToCurve(t,l_t,l_n);
+ cc = buildMetricTangentToCurve(t, l_t, l_n);
}
else {
SVector3 t = _myGEdge->firstDer(range.high());
t.normalize();
- double l_t = ((2 * M_PI) /( fabs(_myGEdge->curvature(range.high()))
- * CTX::instance()->mesh.minCircPoints ));
+ double l_t = ((2 * M_PI) / (fabs(_myGEdge->curvature(range.high())) *
+ CTX::instance()->mesh.minCircPoints));
double l_n = 1.e12;
- cc = buildMetricTangentToCurve(t,l_t,l_n);
+ cc = buildMetricTangentToCurve(t, l_t, l_n);
}
- val = intersection(val,cc);
+ val = intersection(val, cc);
}
return val;
}
SMetric3 metric_based_on_surface_curvature(const GFace *gf, double u, double v,
- bool surface_isotropic,
- double d_normal ,
- double d_tangent_max)
+ bool surface_isotropic,
+ double d_normal,
+ double d_tangent_max)
{
- if (gf->geomType() == GEntity::Plane)return SMetric3(1.e-12);
+ if(gf->geomType() == GEntity::Plane) return SMetric3(1.e-12);
double cmax, cmin;
- SVector3 dirMax,dirMin;
+ SVector3 dirMax, dirMin;
cmax = gf->curvatures(SPoint2(u, v), dirMax, dirMin, cmax, cmin);
- if (cmin == 0) cmin =1.e-12;
- if (cmax == 0) cmax =1.e-12;
- double lambda1 = ((2 * M_PI) /( fabs(cmin) * CTX::instance()->mesh.minCircPoints ) );
- double lambda2 = ((2 * M_PI) /( fabs(cmax) * CTX::instance()->mesh.minCircPoints ) );
- SVector3 Z = crossprod(dirMax,dirMin);
- if (surface_isotropic) lambda2 = lambda1 = std::min(lambda2,lambda1);
+ if(cmin == 0) cmin = 1.e-12;
+ if(cmax == 0) cmax = 1.e-12;
+ double lambda1 =
+ ((2 * M_PI) / (fabs(cmin) * CTX::instance()->mesh.minCircPoints));
+ double lambda2 =
+ ((2 * M_PI) / (fabs(cmax) * CTX::instance()->mesh.minCircPoints));
+ SVector3 Z = crossprod(dirMax, dirMin);
+ if(surface_isotropic) lambda2 = lambda1 = std::min(lambda2, lambda1);
dirMin.normalize();
dirMax.normalize();
Z.normalize();
@@ -354,8 +363,7 @@ SMetric3 metric_based_on_surface_curvature(const GFace *gf, double u, double v,
lambda1 = std::min(lambda1, d_tangent_max);
lambda2 = std::min(lambda2, d_tangent_max);
- SMetric3 curvMetric (1./(lambda1*lambda1),1./(lambda2*lambda2),
- 1./(lambda3*lambda3),
- dirMin, dirMax, Z );
+ SMetric3 curvMetric(1. / (lambda1 * lambda1), 1. / (lambda2 * lambda2),
+ 1. / (lambda3 * lambda3), dirMin, dirMax, Z);
return curvMetric;
}
diff --git a/Mesh/BackgroundMeshTools.h b/Mesh/BackgroundMeshTools.h
index 02ad583d341933655551433b1de8ddea94c05786..2d4a203bb41c864004fb77a0eaed4bdff6b84744 100644
--- a/Mesh/BackgroundMeshTools.h
+++ b/Mesh/BackgroundMeshTools.h
@@ -16,8 +16,10 @@ class GEntity;
SMetric3 buildMetricTangentToCurve(SVector3 &t, double l_t, double l_n);
SMetric3 buildMetricTangentToSurface(SVector3 &t1, SVector3 &t2, double l_t1,
double l_t2, double l_n);
-double BGM_MeshSize(GEntity *ge, double U, double V, double X, double Y, double Z);
-SMetric3 BGM_MeshMetric(GEntity *ge, double U, double V, double X, double Y, double Z);
+double BGM_MeshSize(GEntity *ge, double U, double V, double X, double Y,
+ double Z);
+SMetric3 BGM_MeshMetric(GEntity *ge, double U, double V, double X, double Y,
+ double Z);
bool Extend1dMeshIn2dSurfaces();
bool Extend2dMeshIn3dVolumes();
SMetric3 max_edge_curvature_metric(const GVertex *gv);
diff --git a/Mesh/BoundaryLayers.cpp b/Mesh/BoundaryLayers.cpp
index 6541c317585aff9263408fc7842afc4868ea7b38..2ad97587ef889ce344fd57e4cc2df457ce40a236 100644
--- a/Mesh/BoundaryLayers.cpp
+++ b/Mesh/BoundaryLayers.cpp
@@ -19,57 +19,60 @@
#include "PViewData.h"
#include "OctreePost.h"
#else
-class OctreePost{ int dummy; };
+class OctreePost {
+ int dummy;
+};
#endif
-static double GetAveEdgeLength(std::vector<MVertex*> &elem_verts)
+static double GetAveEdgeLength(std::vector<MVertex *> &elem_verts)
{
double ave = 0.0;
int size = elem_verts.size();
- if(!size)
- return 0.0;
- for( int i = 0; i < size-1; i++ )
- ave += elem_verts[i]->distance(elem_verts[i+1]);
- ave += elem_verts[0]->distance(elem_verts[size-1]);
+ if(!size) return 0.0;
+ for(int i = 0; i < size - 1; i++)
+ ave += elem_verts[i]->distance(elem_verts[i + 1]);
+ ave += elem_verts[0]->distance(elem_verts[size - 1]);
ave /= size;
return ave;
}
-template<class T>
-static void addExtrudeNormals(std::vector<T*> &elements, int invert,
+template <class T>
+static void addExtrudeNormals(std::vector<T *> &elements, int invert,
OctreePost *octree, bool gouraud, int index,
bool skipScaleCalc)
{
- if(index < 0 || index > 1){
+ if(index < 0 || index > 1) {
Msg::Error("Boundary layer index should be 0 or 1");
return;
}
- if(octree && !gouraud){ // get extrusion direction from post-processing view
- std::set<MVertex*> verts;
- for(unsigned int i = 0; i < elements.size(); i++){
- if(!ExtrudeParams::calcLayerScaleFactor[index]){
- for(std::size_t j = 0; j < elements[i]->getNumVertices(); j++)
+ if(octree && !gouraud) { // get extrusion direction from post-processing view
+ std::set<MVertex *> verts;
+ for(unsigned int i = 0; i < elements.size(); i++) {
+ if(!ExtrudeParams::calcLayerScaleFactor[index]) {
+ for(std::size_t j = 0; j < elements[i]->getNumVertices(); j++)
verts.insert(elements[i]->getVertex(j));
}
- else{
- std::vector<MVertex*> elem_verts;
- elements[i]->getVertices(elem_verts);
-
- double aveLength = skipScaleCalc ? 1.0 : GetAveEdgeLength(elem_verts);
-
- for(unsigned int j = 0; j < elem_verts.size(); j++){
- verts.insert(elem_verts[j]);
- // if scaleLastLayer selection, but not doing gouraud, then still
- // scale the last layer... This might create weird behavior for the
- // unprepared...
- if(aveLength != 0.0)
- ExtrudeParams::normals[index]->add_scale
- (elem_verts[j]->x(), elem_verts[j]->y(), elem_verts[j]->z(), aveLength);
- }
+ else {
+ std::vector<MVertex *> elem_verts;
+ elements[i]->getVertices(elem_verts);
+
+ double aveLength = skipScaleCalc ? 1.0 : GetAveEdgeLength(elem_verts);
+
+ for(unsigned int j = 0; j < elem_verts.size(); j++) {
+ verts.insert(elem_verts[j]);
+ // if scaleLastLayer selection, but not doing gouraud, then still
+ // scale the last layer... This might create weird behavior for the
+ // unprepared...
+ if(aveLength != 0.0)
+ ExtrudeParams::normals[index]->add_scale(
+ elem_verts[j]->x(), elem_verts[j]->y(), elem_verts[j]->z(),
+ aveLength);
+ }
}
}
- for(std::set<MVertex*>::iterator it = verts.begin(); it != verts.end(); it++){
+ for(std::set<MVertex *>::iterator it = verts.begin(); it != verts.end();
+ it++) {
MVertex *v = *it;
double nn[3] = {0., 0., 0.};
#if defined(HAVE_POST)
@@ -78,8 +81,8 @@ static void addExtrudeNormals(std::vector<T*> &elements, int invert,
ExtrudeParams::normals[index]->add(v->x(), v->y(), v->z(), 3, nn);
}
}
- else{ // get extrusion direction from Gouraud-shaded element normals
- for(unsigned int i = 0; i < elements.size(); i++){
+ else { // get extrusion direction from Gouraud-shaded element normals
+ for(unsigned int i = 0; i < elements.size(); i++) {
MElement *ele = elements[i];
SVector3 n(0, 0, 0);
if(ele->getDim() == 2)
@@ -88,27 +91,28 @@ static void addExtrudeNormals(std::vector<T*> &elements, int invert,
n = crossprod(ele->getEdge(0).tangent(), SVector3(0., 0., 1.));
if(invert) n *= -1.;
double nn[3] = {n[0], n[1], n[2]};
- if(!ExtrudeParams::calcLayerScaleFactor[index]){
- for(std::size_t k = 0; k < ele->getNumVertices(); k++){
+ if(!ExtrudeParams::calcLayerScaleFactor[index]) {
+ for(std::size_t k = 0; k < ele->getNumVertices(); k++) {
MVertex *v = ele->getVertex(k);
ExtrudeParams::normals[index]->add(v->x(), v->y(), v->z(), 3, nn);
}
}
- else{
- std::vector<MVertex*> elem_verts;
- double aveLength = 0.0;
- elements[i]->getVertices(elem_verts);
- if(skipScaleCalc)
- aveLength = 1.0;
- else
- aveLength = GetAveEdgeLength(elem_verts);
- for(unsigned int j = 0; j < elem_verts.size(); j++){
- ExtrudeParams::normals[index]->add
- (elem_verts[j]->x(), elem_verts[j]->y(), elem_verts[j]->z(), 3, nn);
- if(aveLength != 0.0)
- ExtrudeParams::normals[index]->add_scale
- (elem_verts[j]->x(), elem_verts[j]->y(), elem_verts[j]->z(), aveLength);
- }
+ else {
+ std::vector<MVertex *> elem_verts;
+ double aveLength = 0.0;
+ elements[i]->getVertices(elem_verts);
+ if(skipScaleCalc)
+ aveLength = 1.0;
+ else
+ aveLength = GetAveEdgeLength(elem_verts);
+ for(unsigned int j = 0; j < elem_verts.size(); j++) {
+ ExtrudeParams::normals[index]->add(
+ elem_verts[j]->x(), elem_verts[j]->y(), elem_verts[j]->z(), 3, nn);
+ if(aveLength != 0.0)
+ ExtrudeParams::normals[index]->add_scale(
+ elem_verts[j]->x(), elem_verts[j]->y(), elem_verts[j]->z(),
+ aveLength);
+ }
}
}
}
@@ -122,37 +126,37 @@ typedef std::set<std::pair<bool, std::pair<int, int> > > infoset;
// scaleLast region. Effectively, this makes the vertices on the boundary
// between a scaled and not scaled region 'average' between being scaled and not
// scaled.
-template<class T>
-static void addExtrudeNormals(std::set<T*> &entities,
+template <class T>
+static void addExtrudeNormals(std::set<T *> &entities,
std::map<int, infoset> &infos,
std::map<int, bool> &skipScaleCalcMap)
{
- bool normalize = true, special3dbox = false, extrudeField=false;
- std::vector<OctreePost*> octrees;
+ bool normalize = true, special3dbox = false, extrudeField = false;
+ std::vector<OctreePost *> octrees;
- for(typename std::set<T*>::iterator it = entities.begin(); it != entities.end(); it++){
+ for(typename std::set<T *>::iterator it = entities.begin();
+ it != entities.end(); it++) {
T *ge = *it;
infoset info = infos[ge->tag()];
- for(infoset::iterator it2 = info.begin(); it2 != info.end(); it2++){
+ for(infoset::iterator it2 = info.begin(); it2 != info.end(); it2++) {
bool invert = it2->first;
int index = it2->second.first;
int view = it2->second.second;
bool gouraud = true;
OctreePost *octree = 0;
#if defined(HAVE_POST)
- if(view != -1){
- if(view >= 0 && view < (int)PView::list.size()){
+ if(view != -1) {
+ if(view >= 0 && view < (int)PView::list.size()) {
octree = new OctreePost(PView::list[view]);
- if(PView::list[view]->getData()->getNumVectors())
- gouraud = false;
+ if(PView::list[view]->getData()->getNumVectors()) gouraud = false;
octrees.push_back(octree);
}
- else if(view == -3){
+ else if(view == -3) {
// Force extrusion normals along x,y,z axes for single normals or at
// 45 degrees for multiple normals (allows to build nice 3D "boxes")
special3dbox = true;
}
- else if(view == -5){
+ else if(view == -5) {
// Force extrusion normals with a field
extrudeField = true;
}
@@ -163,22 +167,22 @@ static void addExtrudeNormals(std::set<T*> &entities,
bool skipScaleCalc = true;
std::map<int, bool>::iterator itskip = skipScaleCalcMap.find(ge->tag());
if(itskip != skipScaleCalcMap.end())
- skipScaleCalc = skipScaleCalcMap[ge->tag()];
+ skipScaleCalc = skipScaleCalcMap[ge->tag()];
if(ge->dim() == 1)
- addExtrudeNormals(((GEdge*)ge)->lines, invert, octree,
- gouraud, index, skipScaleCalc);
- else if(ge->dim() == 2){
- addExtrudeNormals(((GFace*)ge)->triangles, invert, octree,
- gouraud, index, skipScaleCalc );
- addExtrudeNormals(((GFace*)ge)->quadrangles, invert, octree,
- gouraud, index, skipScaleCalc );
+ addExtrudeNormals(((GEdge *)ge)->lines, invert, octree, gouraud, index,
+ skipScaleCalc);
+ else if(ge->dim() == 2) {
+ addExtrudeNormals(((GFace *)ge)->triangles, invert, octree, gouraud,
+ index, skipScaleCalc);
+ addExtrudeNormals(((GFace *)ge)->quadrangles, invert, octree, gouraud,
+ index, skipScaleCalc);
}
if(!gouraud) normalize = false;
}
}
// enforce coherent normals at some points if necessary
- for(unsigned int i = 0; i < ExtrudeParams::normalsCoherence.size(); i++){
+ for(unsigned int i = 0; i < ExtrudeParams::normalsCoherence.size(); i++) {
SPoint3 &p(ExtrudeParams::normalsCoherence[i]);
double n0[3], n1[3];
ExtrudeParams::normals[0]->get(p.x(), p.y(), p.z(), 3, n0);
@@ -189,38 +193,41 @@ static void addExtrudeNormals(std::set<T*> &entities,
// normalize extrusion directions if not using explicit vector post-processing
// views
- if(normalize){
- for(int i = 0; i < 2; i++){
+ if(normalize) {
+ for(int i = 0; i < 2; i++) {
ExtrudeParams::normals[i]->normalize();
- if(special3dbox){ // force normals for 3d "box" along x,y,z
+ if(special3dbox) { // force normals for 3d "box" along x,y,z
for(smooth_data::iter it = ExtrudeParams::normals[i]->begin();
- it != ExtrudeParams::normals[i]->end(); it++){
- for(int j = 0; j < 3; j++){
- if(it->vals[j] < -0.1) it->vals[j] = -1.;
- else if(it->vals[j] > 0.1) it->vals[j] = 1.;
- else it->vals[j] = 0.;
+ it != ExtrudeParams::normals[i]->end(); it++) {
+ for(int j = 0; j < 3; j++) {
+ if(it->vals[j] < -0.1)
+ it->vals[j] = -1.;
+ else if(it->vals[j] > 0.1)
+ it->vals[j] = 1.;
+ else
+ it->vals[j] = 0.;
}
}
}
- if(extrudeField){ // force normals according to field
+ if(extrudeField) { // force normals according to field
for(smooth_data::iter it = ExtrudeParams::normals[i]->begin();
- it != ExtrudeParams::normals[i]->end(); it++){
- GEntity *ge = (GEntity*)(*entities.begin());
- FieldManager *fields = ge->model()->getFields();
- if(fields->getBackgroundField() > 0){
- Field *f = fields->get(fields->getBackgroundField());
- double radius = (*f)(it->x,it->y,it->z);
- for(int k = 0; k < 3; k++) it->vals[k] *= radius;
- }
+ it != ExtrudeParams::normals[i]->end(); it++) {
+ GEntity *ge = (GEntity *)(*entities.begin());
+ FieldManager *fields = ge->model()->getFields();
+ if(fields->getBackgroundField() > 0) {
+ Field *f = fields->get(fields->getBackgroundField());
+ double radius = (*f)(it->x, it->y, it->z);
+ for(int k = 0; k < 3; k++) it->vals[k] *= radius;
+ }
}
}
#if defined(HAVE_POST)
- if(octrees.size()){ // scale normals by scalar views
+ if(octrees.size()) { // scale normals by scalar views
for(smooth_data::iter it = ExtrudeParams::normals[i]->begin();
- it != ExtrudeParams::normals[i]->end(); it++){
- for(unsigned int j = 0; j < octrees.size(); j++){
+ it != ExtrudeParams::normals[i]->end(); it++) {
+ for(unsigned int j = 0; j < octrees.size(); j++) {
double d;
- if(octrees[j]->searchScalarWithTol(it->x, it->y, it->z, &d, 0)){
+ if(octrees[j]->searchScalarWithTol(it->x, it->y, it->z, &d, 0)) {
for(int k = 0; k < 3; k++) it->vals[k] *= d;
break;
}
@@ -231,16 +238,15 @@ static void addExtrudeNormals(std::set<T*> &entities,
}
}
- for(unsigned int i = 0; i < octrees.size(); i++)
- delete octrees[i];
+ for(unsigned int i = 0; i < octrees.size(); i++) delete octrees[i];
}
-static void checkDepends(GModel *m, GFace *f, std::set<GFace*> &dep)
+static void checkDepends(GModel *m, GFace *f, std::set<GFace *> &dep)
{
ExtrudeParams *ep = f->meshAttributes.extrude;
- if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == COPIED_ENTITY){
+ if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == COPIED_ENTITY) {
GFace *from = m->getFaceByTag(std::abs(ep->geo.Source));
- if(!from){
+ if(!from) {
Msg::Error("Unknown origin face %d", ep->geo.Source);
return;
}
@@ -249,28 +255,28 @@ static void checkDepends(GModel *m, GFace *f, std::set<GFace*> &dep)
}
}
-static unsigned int FixErasedExtrScaleFlags(GModel *m,
- std::map<int, bool> &faceSkipScaleCalc,
- std::map<int, bool> &edgeSkipScaleCalc)
+static unsigned int
+FixErasedExtrScaleFlags(GModel *m, std::map<int, bool> &faceSkipScaleCalc,
+ std::map<int, bool> &edgeSkipScaleCalc)
{
unsigned int num_changed = 0;
std::set<GRegion *, GEntityLessThan>::iterator itreg;
// fix all extruded faces bordering ScaleLast regions
- for( itreg = m->firstRegion(); itreg != m->lastRegion(); itreg++ ){
+ for(itreg = m->firstRegion(); itreg != m->lastRegion(); itreg++) {
ExtrudeParams *r_ep = (*itreg)->meshAttributes.extrude;
- if(!r_ep || !r_ep->mesh.ExtrudeMesh || r_ep->geo.Mode != EXTRUDED_ENTITY
- || !r_ep->mesh.ScaleLast )
+ if(!r_ep || !r_ep->mesh.ExtrudeMesh || r_ep->geo.Mode != EXTRUDED_ENTITY ||
+ !r_ep->mesh.ScaleLast)
continue;
std::vector<GFace *> reg_faces = (*itreg)->faces();
std::vector<GFace *>::iterator itface;
- for( itface = reg_faces.begin(); itface != reg_faces.end(); itface++ ){
- if( m->getFaceByTag( std::abs(r_ep->geo.Source) ) != (*itface) ){
- ExtrudeParams *f_ep = (*itface)->meshAttributes.extrude;
- if(f_ep && f_ep->mesh.ExtrudeMesh && !f_ep->mesh.ScaleLast){
- num_changed++;
- f_ep->mesh.ScaleLast = true;
- faceSkipScaleCalc[(*itface)->tag()] = false;
- }
+ for(itface = reg_faces.begin(); itface != reg_faces.end(); itface++) {
+ if(m->getFaceByTag(std::abs(r_ep->geo.Source)) != (*itface)) {
+ ExtrudeParams *f_ep = (*itface)->meshAttributes.extrude;
+ if(f_ep && f_ep->mesh.ExtrudeMesh && !f_ep->mesh.ScaleLast) {
+ num_changed++;
+ f_ep->mesh.ScaleLast = true;
+ faceSkipScaleCalc[(*itface)->tag()] = false;
+ }
}
}
}
@@ -279,20 +285,19 @@ static unsigned int FixErasedExtrScaleFlags(GModel *m,
// a region, then it would not have been replaced except by a pointless
// degenerate extrusion right on it...which makes no sense anyway. So... just
// loop through faces.
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++) {
ExtrudeParams *f_ep = (*it)->meshAttributes.extrude;
- if(!f_ep || !f_ep->mesh.ExtrudeMesh || !f_ep->mesh.ScaleLast )
- continue;
+ if(!f_ep || !f_ep->mesh.ExtrudeMesh || !f_ep->mesh.ScaleLast) continue;
std::vector<GEdge *> f_edges = (*it)->edges();
std::vector<GEdge *>::iterator itedge;
- for(itedge = f_edges.begin(); itedge != f_edges.end(); itedge++){
- if(m->getEdgeByTag( std::abs(f_ep->geo.Source) ) != (*itedge)){
- ExtrudeParams *e_ep = (*itedge)->meshAttributes.extrude;
- if(e_ep && e_ep->mesh.ExtrudeMesh && !e_ep->mesh.ScaleLast){
- num_changed++;
- e_ep->mesh.ScaleLast = true;
- edgeSkipScaleCalc[(*itedge)->tag()] = false;
- }
+ for(itedge = f_edges.begin(); itedge != f_edges.end(); itedge++) {
+ if(m->getEdgeByTag(std::abs(f_ep->geo.Source)) != (*itedge)) {
+ ExtrudeParams *e_ep = (*itedge)->meshAttributes.extrude;
+ if(e_ep && e_ep->mesh.ExtrudeMesh && !e_ep->mesh.ScaleLast) {
+ num_changed++;
+ e_ep->mesh.ScaleLast = true;
+ edgeSkipScaleCalc[(*itedge)->tag()] = false;
+ }
}
}
}
@@ -302,83 +307,87 @@ static unsigned int FixErasedExtrScaleFlags(GModel *m,
int Mesh2DWithBoundaryLayers(GModel *m)
{
- std::set<GFace*> sourceFaces, otherFaces;
- std::set<GEdge*> sourceEdges, otherEdges;
+ std::set<GFace *> sourceFaces, otherFaces;
+ std::set<GEdge *> sourceEdges, otherEdges;
std::map<int, infoset> sourceFaceInfo, sourceEdgeInfo;
std::map<int, bool> faceSkipScaleCalc, edgeSkipScaleCalc; // Trevor Strickler
ExtrudeParams::calcLayerScaleFactor[0] = 0; // Trevor Strickler
ExtrudeParams::calcLayerScaleFactor[1] = 0; // Trevor Strickler
// 2D boundary layers
- for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++){
+ for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++) {
GEdge *ge = *it;
if(ge->getNativeType() == GEntity::GmshModel &&
- ge->geomType() == GEntity::BoundaryLayerCurve){
+ ge->geomType() == GEntity::BoundaryLayerCurve) {
ExtrudeParams *ep = ge->meshAttributes.extrude;
- if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == COPIED_ENTITY){
+ if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == COPIED_ENTITY) {
GEdge *from = m->getEdgeByTag(std::abs(ep->geo.Source));
- if(!from){
- Msg::Error("Unknown source curve %d for boundary layer", ep->geo.Source);
+ if(!from) {
+ Msg::Error("Unknown source curve %d for boundary layer",
+ ep->geo.Source);
return 0;
}
- std::pair<bool, std::pair<int, int> > tags
- (ep->geo.Source < 0, std::pair<int, int>
- (ep->mesh.BoundaryLayerIndex, ep->mesh.ViewIndex));
+ std::pair<bool, std::pair<int, int> > tags(
+ ep->geo.Source < 0,
+ std::pair<int, int>(ep->mesh.BoundaryLayerIndex, ep->mesh.ViewIndex));
sourceEdgeInfo[from->tag()].insert(tags);
sourceEdges.insert(from);
// Added to scale last layer size locally: Do not worry if one section
- // of the boundary layer index = 0 or 1 is not supposed to be
- // scaled...that section's normals will have scaleFactor = 1.0 (exactly
- // 1.0 to all sig figs) ...however, if that non-scaled section borders a
- // scaled section, the boundary normals will extrude scaled.
- if(!ep->mesh.ScaleLast){
- edgeSkipScaleCalc[from->tag()] = true;
+ // of the boundary layer index = 0 or 1 is not supposed to be
+ // scaled...that section's normals will have scaleFactor = 1.0 (exactly
+ // 1.0 to all sig figs) ...however, if that non-scaled section borders a
+ // scaled section, the boundary normals will extrude scaled.
+ if(!ep->mesh.ScaleLast) {
+ edgeSkipScaleCalc[from->tag()] = true;
+ }
+ else {
+ edgeSkipScaleCalc[from->tag()] = false;
+ ExtrudeParams::calcLayerScaleFactor[ep->mesh.BoundaryLayerIndex] =
+ true;
}
- else{
- edgeSkipScaleCalc[from->tag()] = false;
- ExtrudeParams::calcLayerScaleFactor[ep->mesh.BoundaryLayerIndex] = true;
- }
}
}
}
// 3D boundary layers
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++) {
GFace *gf = *it;
if(gf->getNativeType() == GEntity::GmshModel &&
- gf->geomType() == GEntity::BoundaryLayerSurface){
+ gf->geomType() == GEntity::BoundaryLayerSurface) {
ExtrudeParams *ep = gf->meshAttributes.extrude;
- if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == COPIED_ENTITY){
+ if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == COPIED_ENTITY) {
GFace *from = m->getFaceByTag(std::abs(ep->geo.Source));
- if(!from){
- Msg::Error("Unknown source face %d for boundary layer", ep->geo.Source);
+ if(!from) {
+ Msg::Error("Unknown source face %d for boundary layer",
+ ep->geo.Source);
return 0;
}
- std::pair<bool, std::pair<int, int> > tags
- (ep->geo.Source < 0, std::pair<int, int>
- (ep->mesh.BoundaryLayerIndex, ep->mesh.ViewIndex));
+ std::pair<bool, std::pair<int, int> > tags(
+ ep->geo.Source < 0,
+ std::pair<int, int>(ep->mesh.BoundaryLayerIndex, ep->mesh.ViewIndex));
sourceFaceInfo[from->tag()].insert(tags);
sourceFaces.insert(from);
- // Added to scale last layer size locally: Do not worry if one section
- // of the boundary layer index = 0 or 1 is not supposed to be
- // scaled...that section's normals will have scaleFactor = 1.0 (exactly
- // 1.0 to all sig figs) ...however, if that non-scaled section borders a
- // scaled section, the boundary normals will extrude scaled
- if(!ep->mesh.ScaleLast){
- faceSkipScaleCalc[from->tag()] = true;
+ // Added to scale last layer size locally: Do not worry if one section
+ // of the boundary layer index = 0 or 1 is not supposed to be
+ // scaled...that section's normals will have scaleFactor = 1.0 (exactly
+ // 1.0 to all sig figs) ...however, if that non-scaled section borders a
+ // scaled section, the boundary normals will extrude scaled
+ if(!ep->mesh.ScaleLast) {
+ faceSkipScaleCalc[from->tag()] = true;
}
- else{
- faceSkipScaleCalc[from->tag()] = false;
- ExtrudeParams::calcLayerScaleFactor[ep->mesh.BoundaryLayerIndex] = true;
- }
- std::vector<GEdge*> const& e = from->edges();
+ else {
+ faceSkipScaleCalc[from->tag()] = false;
+ ExtrudeParams::calcLayerScaleFactor[ep->mesh.BoundaryLayerIndex] =
+ true;
+ }
+ std::vector<GEdge *> const &e = from->edges();
sourceEdges.insert(e.begin(), e.end());
- for(std::vector<GEdge*>::const_iterator ite = e.begin(); ite != e.end(); ite++){
- if(edgeSkipScaleCalc.find( (*ite)->tag() ) == edgeSkipScaleCalc.end())
- edgeSkipScaleCalc[ (*ite)->tag() ] = true; // a default
- if(ep->mesh.ScaleLast)
- edgeSkipScaleCalc[(*ite)->tag()] = false;
- }
+ for(std::vector<GEdge *>::const_iterator ite = e.begin();
+ ite != e.end(); ite++) {
+ if(edgeSkipScaleCalc.find((*ite)->tag()) == edgeSkipScaleCalc.end())
+ edgeSkipScaleCalc[(*ite)->tag()] = true; // a default
+ if(ep->mesh.ScaleLast) edgeSkipScaleCalc[(*ite)->tag()] = false;
+ }
}
}
}
@@ -391,22 +400,25 @@ int Mesh2DWithBoundaryLayers(GModel *m)
// the TreeUtils.... but I do not want to change the code too much and create
// a bug. The developers should decide that.
if(ExtrudeParams::calcLayerScaleFactor[0] ||
- ExtrudeParams::calcLayerScaleFactor[1]){
- unsigned int num_changed = FixErasedExtrScaleFlags(m, faceSkipScaleCalc,
- edgeSkipScaleCalc);
+ ExtrudeParams::calcLayerScaleFactor[1]) {
+ unsigned int num_changed =
+ FixErasedExtrScaleFlags(m, faceSkipScaleCalc, edgeSkipScaleCalc);
if(num_changed)
- Msg::Warning("%d entities were changed from ScaleLast = false to ScaleLast = true",
- num_changed);
+ Msg::Warning(
+ "%d entities were changed from ScaleLast = false to ScaleLast = true",
+ num_changed);
}
// compute mesh dependencies in source faces (so we can e.g. create a boundary
// layer on an extruded mesh)
- std::set<GFace*> sourceFacesDependencies;
- for(std::set<GFace*>::iterator it = sourceFaces.begin(); it != sourceFaces.end(); it++)
+ std::set<GFace *> sourceFacesDependencies;
+ for(std::set<GFace *>::iterator it = sourceFaces.begin();
+ it != sourceFaces.end(); it++)
checkDepends(m, *it, sourceFacesDependencies);
- Msg::Info("%d dependencies in mesh of source faces", sourceFacesDependencies.size());
- for(std::set<GFace*>::iterator it = sourceFacesDependencies.begin();
- it != sourceFacesDependencies.end(); it++){
- std::vector<GEdge*> const& e = (*it)->edges();
+ Msg::Info("%d dependencies in mesh of source faces",
+ sourceFacesDependencies.size());
+ for(std::set<GFace *>::iterator it = sourceFacesDependencies.begin();
+ it != sourceFacesDependencies.end(); it++) {
+ std::vector<GEdge *> const &e = (*it)->edges();
sourceEdges.insert(e.begin(), e.end());
}
@@ -419,12 +431,13 @@ int Mesh2DWithBoundaryLayers(GModel *m)
otherFaces.insert(*it);
// mesh source surfaces (and dependencies)
- for(int i = 0; i < 10; i++){ // FIXME: should check PENDING status instead!
- for(std::set<GFace*>::iterator it = sourceFacesDependencies.begin();
+ for(int i = 0; i < 10; i++) { // FIXME: should check PENDING status instead!
+ for(std::set<GFace *>::iterator it = sourceFacesDependencies.begin();
it != sourceFacesDependencies.end(); it++)
(*it)->mesh(false);
}
- for(std::set<GFace*>::iterator it = sourceFaces.begin(); it != sourceFaces.end(); it++)
+ for(std::set<GFace *>::iterator it = sourceFaces.begin();
+ it != sourceFaces.end(); it++)
(*it)->mesh(false);
// make sure the source surfaces for the boundary layers are oriented
@@ -433,7 +446,7 @@ int Mesh2DWithBoundaryLayers(GModel *m)
std::for_each(sourceFaces.begin(), sourceFaces.end(), orientMeshGFace());
// compute a normal field for all the source edges or faces
- for(int i = 0; i < 2; i++){
+ for(int i = 0; i < 2; i++) {
if(ExtrudeParams::normals[i]) delete ExtrudeParams::normals[i];
ExtrudeParams::normals[i] = new smooth_data();
}
@@ -443,24 +456,25 @@ int Mesh2DWithBoundaryLayers(GModel *m)
addExtrudeNormals(sourceFaces, sourceFaceInfo, faceSkipScaleCalc);
// set the position of boundary layer points using the smooth normal field
- for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++){
+ for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++) {
GEdge *ge = *it;
- if(ge->geomType() == GEntity::BoundaryLayerCurve){
+ if(ge->geomType() == GEntity::BoundaryLayerCurve) {
ExtrudeParams *ep = ge->meshAttributes.extrude;
- if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == EXTRUDED_ENTITY){
+ if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == EXTRUDED_ENTITY) {
GVertex *vsrc, *vdest;
- if(ge->getBeginVertex()->geomType() == GEntity::BoundaryLayerPoint){
+ if(ge->getBeginVertex()->geomType() == GEntity::BoundaryLayerPoint) {
vsrc = ge->getEndVertex();
vdest = ge->getBeginVertex();
}
- else{
+ else {
vsrc = ge->getBeginVertex();
vdest = ge->getEndVertex();
}
GPoint p = vsrc->point();
- ep->Extrude(ep->mesh.NbLayer - 1, ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1],
- p.x(), p.y(), p.z());
+ ep->Extrude(ep->mesh.NbLayer - 1,
+ ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1], p.x(), p.y(),
+ p.z());
vdest->setPosition(p);
}
}
@@ -469,14 +483,15 @@ int Mesh2DWithBoundaryLayers(GModel *m)
// remesh non-source edges (since they might have been modified by the change
// in boundary layer points)
std::for_each(otherFaces.begin(), otherFaces.end(), deMeshGFace());
- for(std::set<GEdge*>::iterator it = otherEdges.begin(); it != otherEdges.end(); it++)
+ for(std::set<GEdge *>::iterator it = otherEdges.begin();
+ it != otherEdges.end(); it++)
(*it)->mesh(false);
// mesh the curves bounding the boundary layers by extrusion using the smooth
// normal field
- for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++){
+ for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++) {
GEdge *ge = *it;
- if(ge->geomType() == GEntity::BoundaryLayerCurve){
+ if(ge->geomType() == GEntity::BoundaryLayerCurve) {
Msg::Info("Meshing curve %d", ge->tag());
deMeshGEdge dem;
dem(ge);
@@ -485,22 +500,24 @@ int Mesh2DWithBoundaryLayers(GModel *m)
}
// recompute mean plane for plane surfaces just in case
- for(std::set<GFace*>::iterator it = otherFaces.begin(); it != otherFaces.end(); it++){
+ for(std::set<GFace *>::iterator it = otherFaces.begin();
+ it != otherFaces.end(); it++) {
GFace *gf = *it;
- if(gf->geomType() == GEntity::Plane)
- gf->computeMeanPlane();
+ if(gf->geomType() == GEntity::Plane) gf->computeMeanPlane();
}
// mesh non-source surfaces
- for(std::set<GFace*>::iterator it = otherFaces.begin(); it != otherFaces.end(); it++)
+ for(std::set<GFace *>::iterator it = otherFaces.begin();
+ it != otherFaces.end(); it++)
(*it)->mesh(false);
// mesh the surfaces bounding the boundary layers by extrusion using the
// smooth normal field
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++) {
GFace *gf = *it;
- if(gf->geomType() == GEntity::BoundaryLayerSurface){
- Msg::Info("Meshing surface %d (%s)", gf->tag(), gf->getTypeString().c_str());
+ if(gf->geomType() == GEntity::BoundaryLayerSurface) {
+ Msg::Info("Meshing surface %d (%s)", gf->tag(),
+ gf->getTypeString().c_str());
deMeshGFace dem;
dem(gf);
MeshExtrudedSurface(gf);
diff --git a/Mesh/DivideAndConquer.cpp b/Mesh/DivideAndConquer.cpp
index aaadc702128e2adb3ed0e117bf1d76914961b805..387b4ee4e6feb51c55fe92a32b5e412fd541ebdf 100644
--- a/Mesh/DivideAndConquer.cpp
+++ b/Mesh/DivideAndConquer.cpp
@@ -31,12 +31,10 @@
PointNumero DocRecord::Predecessor(PointNumero a, PointNumero b)
{
DListPeek p = points[a].adjacent;
- if(p == NULL)
- return -1;
+ if(p == NULL) return -1;
do {
- if(p->point_num == b)
- return Pred(p)->point_num;
+ if(p->point_num == b) return Pred(p)->point_num;
p = Pred(p);
} while(p != points[a].adjacent);
@@ -46,12 +44,10 @@ PointNumero DocRecord::Predecessor(PointNumero a, PointNumero b)
PointNumero DocRecord::Successor(PointNumero a, PointNumero b)
{
DListPeek p = points[a].adjacent;
- if(p == NULL)
- return -1;
+ if(p == NULL) return -1;
do {
- if(p->point_num == b)
- return Succ(p)->point_num;
+ if(p->point_num == b) return Succ(p)->point_num;
p = Succ(p);
} while(p != points[a].adjacent);
@@ -61,8 +57,7 @@ PointNumero DocRecord::Successor(PointNumero a, PointNumero b)
int DocRecord::FixFirst(PointNumero x, PointNumero f)
{
DListPeek p = points[x].adjacent;
- if(p == NULL)
- return 0;
+ if(p == NULL) return 0;
int out = 0;
DListPeek copy = p;
@@ -104,7 +99,7 @@ Segment DocRecord::LowerCommonTangent(DT vl, DT vr)
PointNumero x, y, z, z1, z2, temp;
Segment s;
- x = vl.end; // vu le tri, c'est le point le + a droite
+ x = vl.end; // vu le tri, c'est le point le + a droite
y = vr.begin; // idem, le + a gauche
z = First(y);
z1 = First(x);
@@ -133,7 +128,7 @@ Segment DocRecord::UpperCommonTangent(DT vl, DT vr)
PointNumero x, y, z, z1, z2, temp;
Segment s;
- x = vl.end; // vu le tri, c'est le point le + a droite
+ x = vl.end; // vu le tri, c'est le point le + a droite
y = vr.begin; // idem, le + a gauche
z = First(y);
z1 = First(x);
@@ -162,7 +157,7 @@ int DocRecord::Qtest(PointNumero h, PointNumero i, PointNumero j, PointNumero k)
{
if((h == i) && (h == j) && (h == k)) {
throw "Identical points in triangulation: increase element size "
- "or Mesh.RandomFactor";
+ "or Mesh.RandomFactor";
return 0;
}
@@ -173,7 +168,7 @@ int DocRecord::Qtest(PointNumero h, PointNumero i, PointNumero j, PointNumero k)
// we use robust predicates here
double result = robustPredicates::incircle(pa, pb, pc, pd) *
- robustPredicates::orient2d(pa, pb, pc);
+ robustPredicates::orient2d(pa, pb, pc);
return (result < 0) ? 1 : 0;
}
@@ -186,60 +181,51 @@ int DocRecord::Merge(DT vl, DT vr)
bt = LowerCommonTangent(vl, vr);
ut = UpperCommonTangent(vl, vr);
- l = bt.from; // left endpoint of BT
- r = bt.to; // right endpoint of BT
+ l = bt.from; // left endpoint of BT
+ r = bt.to; // right endpoint of BT
while((l != ut.from) || (r != ut.to)) {
a = b = 0;
- if(!Insert(l, r))
- return 0;
+ if(!Insert(l, r)) return 0;
r1 = Predecessor(r, l);
- if(r1 == -1)
- return 0;
+ if(r1 == -1) return 0;
if(IsRightOf(l, r, r1))
a = 1;
else {
out = 0;
while(!out) {
r2 = Predecessor(r, r1);
- if(r2 == -1)
- return 0;
+ if(r2 == -1) return 0;
if(r2 < vr.begin)
out = 1;
else if(Qtest(l, r, r1, r2))
out = 1;
else {
- if(!Delete(r, r1))
- return 0;
+ if(!Delete(r, r1)) return 0;
r1 = r2;
- if(IsRightOf(l, r, r1))
- out = a = 1;
+ if(IsRightOf(l, r, r1)) out = a = 1;
}
}
}
l1 = Successor(l, r);
- if(l1 == -1)
- return 0;
+ if(l1 == -1) return 0;
if(IsLeftOf(r, l, l1))
b = 1;
else {
out = 0;
while(!out) {
l2 = Successor(l, l1);
- if(l2 == -1)
- return 0;
+ if(l2 == -1) return 0;
if(l2 > vl.end)
out = 1;
else if(Qtest(r, l, l1, l2))
out = 1;
else {
- if(!Delete(l, l1))
- return 0;
+ if(!Delete(l, l1)) return 0;
l1 = l2;
- if(IsLeftOf(r, l, l1))
- out = b = 1;
+ if(IsLeftOf(r, l, l1)) out = b = 1;
}
}
}
@@ -255,13 +241,10 @@ int DocRecord::Merge(DT vl, DT vr)
l = l1;
}
}
- if(!Insert(l, r))
- return 0;
+ if(!Insert(l, r)) return 0;
- if(!FixFirst(ut.to, ut.from))
- return 0;
- if(!FixFirst(bt.from, bt.to))
- return 0;
+ if(!FixFirst(ut.to, ut.from)) return 0;
+ if(!FixFirst(bt.from, bt.to)) return 0;
return 1;
}
@@ -273,7 +256,7 @@ DT DocRecord::RecurTrig(PointNumero left, PointNumero right)
dt.begin = left;
dt.end = right;
n = right - left + 1; // nombre de points a triangulariser
- switch (n) {
+ switch(n) {
case 0:
case 1:
// 0 ou 1 points -> rien a faire
@@ -303,8 +286,7 @@ DT DocRecord::RecurTrig(PointNumero left, PointNumero right)
default: // plus de trois points : cas recursif
m = (left + right) >> 1;
- if(!Merge(RecurTrig(left, m), RecurTrig(m + 1, right)))
- break;
+ if(!Merge(RecurTrig(left, m), RecurTrig(m + 1, right))) break;
}
return dt;
}
@@ -313,9 +295,9 @@ static int comparePoints(const void *i, const void *j)
{
double x, y;
- x = ((PointRecord *) i)->where.h - ((PointRecord *) j)->where.h;
+ x = ((PointRecord *)i)->where.h - ((PointRecord *)j)->where.h;
if(x == 0.) {
- y = ((PointRecord *) i)->where.v - ((PointRecord *) j)->where.v;
+ y = ((PointRecord *)i)->where.v - ((PointRecord *)j)->where.v;
return (y < 0.) ? -1 : 1;
}
else
@@ -373,8 +355,7 @@ int DocRecord::DListInsert(PointNumero centerPoint, PointNumero newPoint)
yy = (double)(points[newPoint].where.v - center.v);
xx = (double)(points[newPoint].where.h - center.h);
beta = atan2(yy, xx) - alpha1;
- if(beta <= 0)
- beta += 2. * M_PI;
+ if(beta <= 0) beta += 2. * M_PI;
do {
yy = (double)(points[Succ(p)->point_num].where.v - center.v);
@@ -382,29 +363,27 @@ int DocRecord::DListInsert(PointNumero centerPoint, PointNumero newPoint)
alpha = atan2(yy, xx) - alpha1;
if(alpha <= -1.e-15 || Succ(p)->point_num == first)
alpha += 2. * M_PI;
- else if(abs(alpha) <= 1e-15 && IsRightOf(centerPoint, first, Succ(p)->point_num))
+ else if(abs(alpha) <= 1e-15 &&
+ IsRightOf(centerPoint, first, Succ(p)->point_num))
alpha += 2. * M_PI;
- if(alpha >= beta+1e-15) {
+ if(alpha >= beta + 1e-15) {
Succ(newp) = Succ(p);
Succ(p) = newp;
Pred(newp) = p;
Pred(Succ(newp)) = newp;
return 1;
}
- else if (alpha >= beta - 1e-15)
- {
- // Angles more or less the same. To keep consistency with rest of algorithm
- // check with IsLeftOf to see which point should be first
- if (IsRightOf(centerPoint, Succ(p)->point_num, newPoint))
- {
+ else if(alpha >= beta - 1e-15) {
+ // Angles more or less the same. To keep consistency with rest of
+ // algorithm check with IsLeftOf to see which point should be first
+ if(IsRightOf(centerPoint, Succ(p)->point_num, newPoint)) {
// New point should become before Succ(p)
Succ(newp) = Succ(p);
Succ(p) = newp;
Pred(newp) = p;
Pred(Succ(newp)) = newp;
}
- else
- {
+ else {
// New point should become after Succ(p)
Succ(newp) = Succ(Succ(p));
Succ(Succ(p)) = newp;
@@ -433,8 +412,7 @@ int DocRecord::DListDelete(DListPeek *dlist, PointNumero oldPoint)
{
DListPeek p;
- if(*dlist == NULL)
- return 0;
+ if(*dlist == NULL) return 0;
if(Succ(*dlist) == *dlist) {
if((*dlist)->point_num == oldPoint) {
delete *dlist;
@@ -474,10 +452,9 @@ int DocRecord::Delete(PointNumero a, PointNumero b)
int DocRecord::CountPointsOnHull()
{
PointNumero p, p2, temp;
- int i, n=numPoints;
+ int i, n = numPoints;
- if(points[0].adjacent == NULL)
- return 0;
+ if(points[0].adjacent == NULL) return 0;
i = 1;
p = 0;
p2 = First(0);
@@ -495,8 +472,7 @@ void DocRecord::ConvexHull()
{
PointNumero p, p2, temp;
- if(points[0].adjacent == NULL)
- return;
+ if(points[0].adjacent == NULL) return;
int count = 0;
p = 0;
_hull[count++] = p;
@@ -521,8 +497,7 @@ PointNumero *DocRecord::ConvertDlistToArray(DListPeek *dlist, int *n)
p = Pred(p);
} while(p != *dlist);
ptr = new PointNumero[max + 1];
- if(ptr == NULL)
- return NULL;
+ if(ptr == NULL) return NULL;
p = *dlist;
for(i = 0; i < max; i++) {
ptr[i] = p->point_num;
@@ -539,45 +514,45 @@ PointNumero *DocRecord::ConvertDlistToArray(DListPeek *dlist, int *n)
// build ready to use voronoi data
void DocRecord::ConvertDListToVoronoiData()
{
- if (_adjacencies){
+ if(_adjacencies) {
for(int i = 0; i < numPoints; i++)
- if (_adjacencies[i].t)
- delete [] _adjacencies[i].t;
- delete [] _adjacencies;
+ if(_adjacencies[i].t) delete[] _adjacencies[i].t;
+ delete[] _adjacencies;
}
- if (_hull) delete [] _hull;
- _hullSize = CountPointsOnHull ();
+ if(_hull) delete[] _hull;
+ _hullSize = CountPointsOnHull();
_hull = new PointNumero[_hullSize];
ConvexHull();
- std::sort(_hull, _hull+_hullSize);
+ std::sort(_hull, _hull + _hullSize);
_adjacencies = new STriangle[numPoints];
for(PointNumero i = 0; i < numPoints; i++)
- _adjacencies[i].t = ConvertDlistToArray(&points[i].adjacent,
- &_adjacencies[i].t_length);
+ _adjacencies[i].t =
+ ConvertDlistToArray(&points[i].adjacent, &_adjacencies[i].t_length);
}
void DocRecord::voronoiCell(PointNumero pt, std::vector<SPoint2> &pts) const
{
- if (!_adjacencies){
+ if(!_adjacencies) {
Msg::Error("No adjacencies were created");
return;
}
const int n = _adjacencies[pt].t_length;
for(int j = 0; j < n; j++) {
PointNumero a = _adjacencies[pt].t[j];
- PointNumero b = _adjacencies[pt].t[(j+1) %n];
+ PointNumero b = _adjacencies[pt].t[(j + 1) % n];
double pa[2] = {(double)points[a].where.h, (double)points[a].where.v};
double pb[2] = {(double)points[b].where.h, (double)points[b].where.v};
double pc[2] = {(double)points[pt].where.h, (double)points[pt].where.v};
double center[2];
- circumCenterXY (pa,pb,pc,center);
- pts.push_back(SPoint2(center[0],center[1]));
+ circumCenterXY(pa, pb, pc, center);
+ pts.push_back(SPoint2(center[0], center[1]));
}
}
/*
- Consider N points {X_1, \dots, X_N}. We want to find the point X_P that verifies
+ Consider N points {X_1, \dots, X_N}. We want to find the point X_P that
+ verifies
min max | X_i - X_P | , i=1,\dots,N
@@ -596,66 +571,65 @@ void DocRecord::voronoiCell(PointNumero pt, std::vector<SPoint2> &pts) const
void DocRecord::makePosView(const std::string &fileName, GFace *gf)
{
- FILE *f = Fopen(fileName.c_str(),"w");
- if(!f){
+ FILE *f = Fopen(fileName.c_str(), "w");
+ if(!f) {
Msg::Error("Could not open file '%s'", fileName.c_str());
return;
}
- if (_adjacencies){
+ if(_adjacencies) {
fprintf(f, "View \"voronoi\" {\n");
for(PointNumero i = 0; i < numPoints; i++) {
std::vector<SPoint2> pts;
double pc[2] = {(double)points[i].where.h, (double)points[i].where.v};
- if (!onHull(i)){
- GPoint p0(pc[0], pc[1], 0.0);
- //if (gf) p0 = gf->point(pc[0], pc[1]);
- fprintf(f,"SP(%g,%g,%g){%g};\n",p0.x(), p0.y(), p0.z(), (double)i);
+ if(!onHull(i)) {
+ GPoint p0(pc[0], pc[1], 0.0);
+ // if (gf) p0 = gf->point(pc[0], pc[1]);
+ fprintf(f, "SP(%g,%g,%g){%g};\n", p0.x(), p0.y(), p0.z(), (double)i);
voronoiCell(i, pts);
- for (unsigned int j = 0; j < pts.size(); j++){
- SPoint2 pp1 = pts[j];
- SPoint2 pp2 = pts[(j+1)%pts.size()];
- GPoint p1(pp1.x(), pp1.y(), 0.0);
- GPoint p2(pp2.x(), pp2.y(), 0.0);
- // if (gf) {
- // p1 = gf->point(p1.x(), p1.y());
- // p2 = gf->point(p2.x(), p2.y());
- // }
- fprintf(f,"SL(%g,%g,%g,%g,%g,%g){%g,%g};\n",
- p1.x(), p1.y(), p1.z(), p2.x(), p2.y(), p2.z(),
- (double)i, (double)i);
+ for(unsigned int j = 0; j < pts.size(); j++) {
+ SPoint2 pp1 = pts[j];
+ SPoint2 pp2 = pts[(j + 1) % pts.size()];
+ GPoint p1(pp1.x(), pp1.y(), 0.0);
+ GPoint p2(pp2.x(), pp2.y(), 0.0);
+ // if (gf) {
+ // p1 = gf->point(p1.x(), p1.y());
+ // p2 = gf->point(p2.x(), p2.y());
+ // }
+ fprintf(f, "SL(%g,%g,%g,%g,%g,%g){%g,%g};\n", p1.x(), p1.y(), p1.z(),
+ p2.x(), p2.y(), p2.z(), (double)i, (double)i);
}
- }
+ }
else {
- fprintf(f,"SP(%g,%g,%g){%g};\n", pc[0] ,pc[1], 0., -(double)i);
+ fprintf(f, "SP(%g,%g,%g){%g};\n", pc[0], pc[1], 0., -(double)i);
}
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
}
- else
- {
+ else {
fprintf(f, "View \"scalar\" {\n");
- for (PointNumero iPoint = 0; iPoint < numPoints; iPoint++){
+ for(PointNumero iPoint = 0; iPoint < numPoints; iPoint++) {
DListPeek p = points[iPoint].adjacent;
- if (!p){
+ if(!p) {
continue;
}
std::vector<PointNumero> adjacentPoints;
do {
adjacentPoints.push_back(p->point_num);
p = Pred(p);
- } while (p != points[iPoint].adjacent);
+ } while(p != points[iPoint].adjacent);
adjacentPoints.push_back(p->point_num);
- for (size_t iTriangle = 0; iTriangle < adjacentPoints.size() - 1; iTriangle++) {
+ for(size_t iTriangle = 0; iTriangle < adjacentPoints.size() - 1;
+ iTriangle++) {
const PointNumero jPoint = adjacentPoints[iTriangle];
const PointNumero kPoint = adjacentPoints[iTriangle + 1];
- if ((jPoint > iPoint) && (kPoint > iPoint) &&
- (IsRightOf(iPoint, jPoint, kPoint))) {
+ if((jPoint > iPoint) && (kPoint > iPoint) &&
+ (IsRightOf(iPoint, jPoint, kPoint))) {
fprintf(f, "ST(%g,%g,%g,%g,%g,%g,%g,%g,%g){%g,%g,%g};\n",
- points[iPoint].where.h, points[iPoint].where.v, 0.0,
- points[jPoint].where.h, points[jPoint].where.v, 0.0,
- points[kPoint].where.h, points[kPoint].where.v, 0.0,
- (double)iPoint, (double)jPoint, (double)kPoint);
+ points[iPoint].where.h, points[iPoint].where.v, 0.0,
+ points[jPoint].where.h, points[jPoint].where.v, 0.0,
+ points[kPoint].where.h, points[kPoint].where.v, 0.0,
+ (double)iPoint, (double)jPoint, (double)kPoint);
}
}
}
@@ -667,118 +641,120 @@ void DocRecord::makePosView(const std::string &fileName, GFace *gf)
void DocRecord::printMedialAxis(Octree *_octree, const std::string &fileName,
GFace *gf, GEdge *ge)
{
- FILE *f = Fopen(fileName.c_str(),"w");
- if(!f){
+ FILE *f = Fopen(fileName.c_str(), "w");
+ if(!f) {
Msg::Error("Could not open file '%s'", fileName.c_str());
return;
}
- if (_adjacencies){
- fprintf(f,"View \"medial axis\" {\n");
+ if(_adjacencies) {
+ fprintf(f, "View \"medial axis\" {\n");
for(PointNumero i = 0; i < numPoints; i++) {
std::vector<SPoint2> pts;
SPoint2 pc((double)points[i].where.h, (double)points[i].where.v);
- if (!onHull(i)){
- GPoint p0(pc[0], pc[1], 0.0);
- if (gf) p0 = gf->point(pc[0], pc[1]);
- fprintf(f,"SP(%g,%g,%g){%g};\n", p0.x(), p0.y(), p0.z(), (double)i);
+ if(!onHull(i)) {
+ GPoint p0(pc[0], pc[1], 0.0);
+ if(gf) p0 = gf->point(pc[0], pc[1]);
+ fprintf(f, "SP(%g,%g,%g){%g};\n", p0.x(), p0.y(), p0.z(), (double)i);
voronoiCell(i, pts);
- for (unsigned int j = 0; j < pts.size(); j++){
- SVector3 pp1(pts[j].x(), pts[j].y(), 0.0);
- SVector3 pp2(pts[(j+1) % pts.size()].x(), pts[(j+1) % pts.size()].y(), 0.0);
- SVector3 v1(pp1.x()-pc.x(), pp1.y()-pc.y(), 0.0);
- SVector3 v2(pp2.x()-pc.x(), pp2.y()-pc.y(), 0.0);
- GPoint p1(pp1.x(), pp1.y(), 0.0);
- GPoint p2(pp2.x(), pp2.y(), 0.0);
- if (gf) {
+ for(unsigned int j = 0; j < pts.size(); j++) {
+ SVector3 pp1(pts[j].x(), pts[j].y(), 0.0);
+ SVector3 pp2(pts[(j + 1) % pts.size()].x(),
+ pts[(j + 1) % pts.size()].y(), 0.0);
+ SVector3 v1(pp1.x() - pc.x(), pp1.y() - pc.y(), 0.0);
+ SVector3 v2(pp2.x() - pc.x(), pp2.y() - pc.y(), 0.0);
+ GPoint p1(pp1.x(), pp1.y(), 0.0);
+ GPoint p2(pp2.x(), pp2.y(), 0.0);
+ if(gf) {
p1 = gf->point(p1.x(), p1.y());
p2 = gf->point(p2.x(), p2.y());
- }
- double P1[3] = {p1.x(), p1.y(), p1.z()};
- double P2[3] = {p2.x(), p2.y(), p2.z()};
- MElement *m1 = (MElement*)Octree_Search(P1, _octree);
- MElement *m2 = (MElement*)Octree_Search(P2, _octree);
- if (m1 && m2){
- MVertex *v0 = new MVertex(p1.x(), p1.y(), p1.z());
- MVertex *v1 = new MVertex(p2.x(), p2.y(), p2.z());
- ge->lines.push_back(new MLine(v0, v1));
- ge->mesh_vertices.push_back(v0);
- ge->mesh_vertices.push_back(v1);
- fprintf(f,"SL(%g,%g,%g,%g,%g,%g){%g,%g};\n",
- p1.x(), p1.y(), p1.z(),
- p2.x(), p2.y(), p2.z(),
- (double)i, (double)i);
+ }
+ double P1[3] = {p1.x(), p1.y(), p1.z()};
+ double P2[3] = {p2.x(), p2.y(), p2.z()};
+ MElement *m1 = (MElement *)Octree_Search(P1, _octree);
+ MElement *m2 = (MElement *)Octree_Search(P2, _octree);
+ if(m1 && m2) {
+ MVertex *v0 = new MVertex(p1.x(), p1.y(), p1.z());
+ MVertex *v1 = new MVertex(p2.x(), p2.y(), p2.z());
+ ge->lines.push_back(new MLine(v0, v1));
+ ge->mesh_vertices.push_back(v0);
+ ge->mesh_vertices.push_back(v1);
+ fprintf(f, "SL(%g,%g,%g,%g,%g,%g){%g,%g};\n", p1.x(), p1.y(),
+ p1.z(), p2.x(), p2.y(), p2.z(), (double)i, (double)i);
}
}
}
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
}
fclose(f);
}
void centroidOfOrientedBox(std::vector<SPoint2> &pts, const double &angle,
- double &xc, double &yc, double &inertia, double &area)
+ double &xc, double &yc, double &inertia,
+ double &area)
{
const int N = pts.size();
double sina = sin(angle);
double cosa = cos(angle);
- double xmin = cosa* pts[0].x()+ sina*pts[0].y();
- double xmax = cosa* pts[0].x()+ sina*pts[0].y();
- double ymin = -sina* pts[0].x()+ cosa*pts[0].y();
- double ymax = -sina* pts[0].x()+ cosa*pts[0].y();
- for (int j=1;j<N;j++){
- xmin = std::min(cosa* pts[j].x()+ sina*pts[j].y(),xmin);
- ymin = std::min(-sina* pts[j].x()+ cosa*pts[j].y(),ymin);
- xmax = std::max(cosa* pts[j].x()+ sina*pts[j].y(),xmax);
- ymax = std::max(-sina* pts[j].x()+ cosa*pts[j].y(),ymax);
+ double xmin = cosa * pts[0].x() + sina * pts[0].y();
+ double xmax = cosa * pts[0].x() + sina * pts[0].y();
+ double ymin = -sina * pts[0].x() + cosa * pts[0].y();
+ double ymax = -sina * pts[0].x() + cosa * pts[0].y();
+ for(int j = 1; j < N; j++) {
+ xmin = std::min(cosa * pts[j].x() + sina * pts[j].y(), xmin);
+ ymin = std::min(-sina * pts[j].x() + cosa * pts[j].y(), ymin);
+ xmax = std::max(cosa * pts[j].x() + sina * pts[j].y(), xmax);
+ ymax = std::max(-sina * pts[j].x() + cosa * pts[j].y(), ymax);
}
- double XC = 0.5*(xmax+xmin);
- double YC = 0.5*(ymax+ymin);
- xc = XC*cosa - YC *sina;
- yc = XC*sina + YC *cosa;
- inertia = std::max(xmax-xmin,ymax-ymin);
- area = (xmax-xmin) * (ymax-ymin);
+ double XC = 0.5 * (xmax + xmin);
+ double YC = 0.5 * (ymax + ymin);
+ xc = XC * cosa - YC * sina;
+ yc = XC * sina + YC * cosa;
+ inertia = std::max(xmax - xmin, ymax - ymin);
+ area = (xmax - xmin) * (ymax - ymin);
}
-void centroidOfPolygon(SPoint2 &pc, std::vector<SPoint2> &pts,
- double &xc, double &yc, double &inertia, double &areaCell,
+void centroidOfPolygon(SPoint2 &pc, std::vector<SPoint2> &pts, double &xc,
+ double &yc, double &inertia, double &areaCell,
simpleFunction<double> *bgm)
{
double area_tot = 0;
areaCell = 0.0;
- SPoint2 center(0,0);
- for (unsigned int j = 0; j < pts.size(); j++){
+ SPoint2 center(0, 0);
+ for(unsigned int j = 0; j < pts.size(); j++) {
SPoint2 &pa = pts[j];
- SPoint2 &pb = pts[(j+1)%pts.size()];
- const double area = triangle_area2d(pa,pb,pc);
- const double lc = bgm ? (*bgm)((pa.x()+pb.x()+pc.x())/3.0,
- (pa.y()+pb.y()+pc.y())/3.0,
- 0.0) : 1.0;
- const double fact = 1./(lc*lc*lc*lc);//rho = 1/lc^4 (emi)
+ SPoint2 &pb = pts[(j + 1) % pts.size()];
+ const double area = triangle_area2d(pa, pb, pc);
+ const double lc = bgm ? (*bgm)((pa.x() + pb.x() + pc.x()) / 3.0,
+ (pa.y() + pb.y() + pc.y()) / 3.0, 0.0) :
+ 1.0;
+ const double fact = 1. / (lc * lc * lc * lc); // rho = 1/lc^4 (emi)
areaCell += area;
- area_tot += area*fact;
- center += ((pa+pb+pc) * (area*fact/3.0));
+ area_tot += area * fact;
+ center += ((pa + pb + pc) * (area * fact / 3.0));
}
- SPoint2 x = center * (1.0/area_tot);
+ SPoint2 x = center * (1.0 / area_tot);
inertia = 0;
- for (unsigned int j = 0; j < pts.size(); j++){
+ for(unsigned int j = 0; j < pts.size(); j++) {
SPoint2 &pa = pts[j];
- SPoint2 &pb = pts[(j+1)%pts.size()];
- const double area = triangle_area2d(pa,pb,pc);
+ SPoint2 &pb = pts[(j + 1) % pts.size()];
+ const double area = triangle_area2d(pa, pb, pc);
- const double b = sqrt ( (pa.x()-pb.x())*(pa.x()-pb.x()) +
- (pa.y()-pb.y())*(pa.y()-pb.y()) );
+ const double b = sqrt((pa.x() - pb.x()) * (pa.x() - pb.x()) +
+ (pa.y() - pb.y()) * (pa.y() - pb.y()));
const double h = 2.0 * area / b;
- const double a = fabs((pb.x()-pa.x())*(pc.x()-pa.x())*
- (pb.y()-pa.y())*(pc.y()-pa.y()))/b;
+ const double a = fabs((pb.x() - pa.x()) * (pc.x() - pa.x()) *
+ (pb.y() - pa.y()) * (pc.y() - pa.y())) /
+ b;
- const double j2 = (h*b*b*b + h*a*b*b + h*a*a*b + b*h*h*h) / 12.0;
+ const double j2 =
+ (h * b * b * b + h * a * b * b + h * a * a * b + b * h * h * h) / 12.0;
- center = (pa+pb+pc) * (1.0/3.0);
+ center = (pa + pb + pc) * (1.0 / 3.0);
const SPoint2 dx = x - center;
- inertia += j2 + area*area*(dx.x()+dx.x()+dx.y()*dx.y());
+ inertia += j2 + area * area * (dx.x() + dx.x() + dx.y() * dx.y());
}
xc = x.x();
yc = x.y();
@@ -806,8 +782,8 @@ int DocRecord::ConvertDListToTriangles()
for(i = 0; i < n; i++) {
// on cree une liste de points connectes au point i (t) + nombre
// de points (t_length)
- striangle[i].t = ConvertDlistToArray(&points[i].adjacent,
- &striangle[i].t_length);
+ striangle[i].t =
+ ConvertDlistToArray(&points[i].adjacent, &striangle[i].t_length);
}
// on balaye les noeuds de gauche a droite -> on cree les triangles
@@ -828,9 +804,8 @@ int DocRecord::ConvertDListToTriangles()
}
numTriangles = count2;
- for(int i = 0; i < n; i++)
- delete [] striangle[i].t;
- delete [] striangle;
+ for(int i = 0; i < n; i++) delete[] striangle[i].t;
+ delete[] striangle;
return 1;
}
@@ -854,32 +829,27 @@ void DocRecord::RemoveAllDList()
}
DocRecord::DocRecord(int n)
- : _hullSize(0), _hull(NULL), _adjacencies(NULL),
- numPoints(n), points(NULL), numTriangles(0), triangles(NULL)
+ : _hullSize(0), _hull(NULL), _adjacencies(NULL), numPoints(n), points(NULL),
+ numTriangles(0), triangles(NULL)
{
- if(numPoints)
- points = new PointRecord[numPoints+3000];
+ if(numPoints) points = new PointRecord[numPoints + 3000];
}
DocRecord::~DocRecord()
{
- if(points) delete [] points;
- if(triangles) delete [] triangles;
- if(_hull) delete [] _hull;
- if (_adjacencies){
- for(int i = 0; i < numPoints; i++)
- delete [] _adjacencies[i].t;
+ if(points) delete[] points;
+ if(triangles) delete[] triangles;
+ if(_hull) delete[] _hull;
+ if(_adjacencies) {
+ for(int i = 0; i < numPoints; i++) delete[] _adjacencies[i].t;
delete _adjacencies;
}
}
-
bool DocRecord::AdjacentNullptrExists()
{
- for (int i = 0; i < numPoints; i++)
- {
- if (points[i].adjacent == NULL)
- return false;
+ for(int i = 0; i < numPoints; i++) {
+ if(points[i].adjacent == NULL) return false;
}
return true;
}
@@ -889,12 +859,10 @@ void DocRecord::MakeMeshWithPoints()
if(numPoints < 3) return;
BuildDelaunay();
- if (AdjacentNullptrExists())
- {
+ if(AdjacentNullptrExists()) {
ConvertDListToTriangles();
}
- else
- {
+ else {
Msg::Error("Adjacent nullptrs found");
}
@@ -910,17 +878,17 @@ void DocRecord::Voronoi()
void DocRecord::setPoints(fullMatrix<double> *p)
{
- if (numPoints != p->size1())throw;
- for (int i = 0; i < p->size1(); i++){
+ if(numPoints != p->size1()) throw;
+ for(int i = 0; i < p->size1(); i++) {
x(i) = (*p)(i, 0);
y(i) = (*p)(i, 1);
- data(i) = (*p)(i, 2) < 0 ? (void *) 1 : NULL;
+ data(i) = (*p)(i, 2) < 0 ? (void *)1 : NULL;
}
}
-void DocRecord::recur_tag_triangles(int iTriangle, std::set<int>& taggedTriangles,
- std::map<std::pair<void*, void*>,
- std::pair<int,int> > &edgesToTriangles)
+void DocRecord::recur_tag_triangles(
+ int iTriangle, std::set<int> &taggedTriangles,
+ std::map<std::pair<void *, void *>, std::pair<int, int> > &edgesToTriangles)
{
if(taggedTriangles.find(iTriangle) != taggedTriangles.end()) return;
@@ -929,14 +897,14 @@ void DocRecord::recur_tag_triangles(int iTriangle, std::set<int>& taggedTriangle
int a = triangles[iTriangle].a;
int b = triangles[iTriangle].b;
int c = triangles[iTriangle].c;
- PointRecord* p[3] = {&points[a], &points[b], &points[c]};
-
- for(int j=0;j<3;j++){
- if(!lookForBoundaryEdge(p[j]->data, p[(j + 1) % 3]->data)){
- std::pair<void*,void*> ab = std::make_pair
- (std::min(p[j]->data, p[(j + 1) % 3]->data),
- std::max(p[j]->data, p[(j + 1) % 3]->data));
- std::pair<int,int>& adj = (edgesToTriangles.find(ab))->second;
+ PointRecord *p[3] = {&points[a], &points[b], &points[c]};
+
+ for(int j = 0; j < 3; j++) {
+ if(!lookForBoundaryEdge(p[j]->data, p[(j + 1) % 3]->data)) {
+ std::pair<void *, void *> ab =
+ std::make_pair(std::min(p[j]->data, p[(j + 1) % 3]->data),
+ std::max(p[j]->data, p[(j + 1) % 3]->data));
+ std::pair<int, int> &adj = (edgesToTriangles.find(ab))->second;
if(iTriangle == adj.first && adj.second != -1)
recur_tag_triangles(adj.second, taggedTriangles, edgesToTriangles);
else
@@ -947,34 +915,36 @@ void DocRecord::recur_tag_triangles(int iTriangle, std::set<int>& taggedTriangle
std::set<int> DocRecord::tagInterior(double x, double y)
{
- std::map<std::pair<void*,void*>,std::pair<int,int> > edgesToTriangles;
+ std::map<std::pair<void *, void *>, std::pair<int, int> > edgesToTriangles;
int iFirst = 1;
- for(int i = 0; i < numTriangles; i++){
+ for(int i = 0; i < numTriangles; i++) {
int a = triangles[i].a;
int b = triangles[i].b;
int c = triangles[i].c;
- PointRecord* p[3] = {&points[a],&points[b],&points[c]};
+ PointRecord *p[3] = {&points[a], &points[b], &points[c]};
- //Weisstein, Eric W. "Triangle Interior." From MathWorld--A Wolfram Web Resource.
+ // Weisstein, Eric W. "Triangle Interior." From MathWorld--A Wolfram Web
+ // Resource.
double x0 = points[a].where.h;
double y0 = points[a].where.v;
double x1 = points[b].where.h - points[a].where.h;
double y1 = points[b].where.v - points[a].where.v;
double x2 = points[c].where.h - points[a].where.h;
double y2 = points[c].where.v - points[a].where.v;
- double k1 = ((x*y2-x2*y)-(x0*y2-x2*y0))/(x1*y2-x2*y1);
- double k2 = -((x*y1-x1*y)-(x0*y1-x1*y0))/(x1*y2-x2*y1);
- if(k1>0.0 && k2>0.0 && k1+k2<1.0) iFirst = i;
- for(int j=0;j<3;j++){
- std::pair<void*,void*> ab = std::make_pair
- (std::min(p[j]->data, p[(j + 1) % 3]->data),
- std::max(p[j]->data, p[(j + 1) % 3]->data));
- std::map<std::pair<void*,void*>, std::pair<int,int> >::iterator it =
+ double k1 = ((x * y2 - x2 * y) - (x0 * y2 - x2 * y0)) / (x1 * y2 - x2 * y1);
+ double k2 =
+ -((x * y1 - x1 * y) - (x0 * y1 - x1 * y0)) / (x1 * y2 - x2 * y1);
+ if(k1 > 0.0 && k2 > 0.0 && k1 + k2 < 1.0) iFirst = i;
+ for(int j = 0; j < 3; j++) {
+ std::pair<void *, void *> ab =
+ std::make_pair(std::min(p[j]->data, p[(j + 1) % 3]->data),
+ std::max(p[j]->data, p[(j + 1) % 3]->data));
+ std::map<std::pair<void *, void *>, std::pair<int, int> >::iterator it =
edgesToTriangles.find(ab);
- if(it == edgesToTriangles.end()){
+ if(it == edgesToTriangles.end()) {
edgesToTriangles[ab] = std::make_pair(i, -1);
}
- else{
+ else {
it->second.second = i;
}
}
@@ -984,110 +954,110 @@ std::set<int> DocRecord::tagInterior(double x, double y)
return taggedTriangles;
}
-void DocRecord::concave(double x,double y,GFace* gf)
+void DocRecord::concave(double x, double y, GFace *gf)
{
int index1;
int index2;
int index3;
- GEdge* edge;
- MElement* element;
- MVertex* vertex1;
- MVertex* vertex2;
+ GEdge *edge;
+ MElement *element;
+ MVertex *vertex1;
+ MVertex *vertex2;
std::set<int> set;
std::set<int>::iterator it2;
- std::vector<GEdge*> list = gf->edges();
- std::vector<GEdge*>::const_iterator it1;
+ std::vector<GEdge *> list = gf->edges();
+ std::vector<GEdge *>::const_iterator it1;
- for(it1 = list.begin(); it1 != list.end(); it1++){
+ for(it1 = list.begin(); it1 != list.end(); it1++) {
edge = *it1;
- for(unsigned int i = 0; i < edge->getNumMeshElements(); i++){
+ for(unsigned int i = 0; i < edge->getNumMeshElements(); i++) {
element = edge->getMeshElement(i);
vertex1 = element->getVertex(0);
vertex2 = element->getVertex(1);
- addBoundaryEdge(vertex1,vertex2);
+ addBoundaryEdge(vertex1, vertex2);
}
}
- for(int i = 0; i < numPoints; i++){
+ for(int i = 0; i < numPoints; i++) {
points[i].vicinity.clear();
}
- try{
+ try {
MakeMeshWithPoints();
- }
- catch(const char *err){
+ } catch(const char *err) {
Msg::Error("%s", err);
}
- set = tagInterior(x,y);
- for(it2 = set.begin(); it2 != set.end(); it2++){
+ set = tagInterior(x, y);
+ for(it2 = set.begin(); it2 != set.end(); it2++) {
index1 = triangles[*it2].a;
index2 = triangles[*it2].b;
index3 = triangles[*it2].c;
- add(index1,index2);
- add(index1,index3);
- add(index2,index1);
- add(index2,index3);
- add(index3,index1);
- add(index3,index2);
+ add(index1, index2);
+ add(index1, index3);
+ add(index2, index1);
+ add(index2, index3);
+ add(index3, index1);
+ add(index3, index2);
}
}
-bool DocRecord::contain(int index1,int index2,int index3)
+bool DocRecord::contain(int index1, int index2, int index3)
{
- void* dataA;
- void* dataB;
+ void *dataA;
+ void *dataB;
dataA = points[index2].data;
dataB = points[index3].data;
- for(unsigned int i = 0; i < points[index1].vicinity.size() - 1; i = i+2){
+ for(unsigned int i = 0; i < points[index1].vicinity.size() - 1; i = i + 2) {
if(points[index1].vicinity[i] == dataA &&
- points[index1].vicinity[i + 1] == dataB){
+ points[index1].vicinity[i + 1] == dataB) {
return 1;
}
else if(points[index1].vicinity[i] == dataB &&
- points[index1].vicinity[i + 1] == dataA){
+ points[index1].vicinity[i + 1] == dataA) {
return 1;
}
}
return 0;
}
-void DocRecord::add(int index1,int index2)
+void DocRecord::add(int index1, int index2)
{
- void* data;
+ void *data;
data = points[index2].data;
points[index1].vicinity.push_back(data);
}
void DocRecord::initialize()
{
- for(int i = 0; i < numPoints; i++){
+ for(int i = 0; i < numPoints; i++) {
points[i].flag = 0;
}
}
bool DocRecord::remove_point(int index)
{
- if(points[index].flag == 0){
+ if(points[index].flag == 0) {
points[index].flag = 1;
return 1;
}
- else return 0;
+ else
+ return 0;
}
void DocRecord::remove_all()
{
int numPoints2 = 0;
- for(int i = 0; i < numPoints; i++){
- if(points[i].flag == 0){
+ for(int i = 0; i < numPoints; i++) {
+ if(points[i].flag == 0) {
numPoints2++;
}
}
PointRecord *points2 = new PointRecord[numPoints2];
int index = 0;
- for(int i = 0; i < numPoints; i++){
- if(points[i].flag == 0){
+ for(int i = 0; i < numPoints; i++) {
+ if(points[i].flag == 0) {
points2[index].where.h = points[i].where.h;
points2[index].where.v = points[i].where.v;
points2[index].data = points[i].data;
@@ -1096,50 +1066,48 @@ void DocRecord::remove_all()
index++;
}
}
- delete [] points;
+ delete[] points;
points = points2;
numPoints = numPoints2;
}
-void DocRecord::add_point(double x,double y,GFace*face)
+void DocRecord::add_point(double x, double y, GFace *face)
{
PointRecord point;
point.where.h = x;
point.where.v = y;
- point.data = new MVertex(x, y, 0.0, (GEntity*)face, 2);
+ point.data = new MVertex(x, y, 0.0, (GEntity *)face, 2);
points[numPoints] = point;
numPoints = numPoints + 1;
}
void DocRecord::build_edges()
{
- for(int i = 0; i < numPoints; i++){
- MVertex *vertex1 = (MVertex*)points[i].data;
+ for(int i = 0; i < numPoints; i++) {
+ MVertex *vertex1 = (MVertex *)points[i].data;
int num = _adjacencies[i].t_length;
- for(int j = 0; j < num; j++){
+ for(int j = 0; j < num; j++) {
int index = _adjacencies[i].t[j];
- MVertex *vertex2 = (MVertex*)points[index].data;
+ MVertex *vertex2 = (MVertex *)points[index].data;
add_edge(vertex1, vertex2);
}
}
}
-void DocRecord::clear_edges()
-{
- mesh_edges.clear();
-}
+void DocRecord::clear_edges() { mesh_edges.clear(); }
-bool DocRecord::delaunay_conformity(GFace* gf)
+bool DocRecord::delaunay_conformity(GFace *gf)
{
- std::vector<GEdge*> const& list = gf->edges();
+ std::vector<GEdge *> const &list = gf->edges();
- for(std::vector<GEdge*>::const_iterator it = list.begin(); it!= list.end(); it++){
+ for(std::vector<GEdge *>::const_iterator it = list.begin(); it != list.end();
+ it++) {
GEdge *edge = *it;
- for(unsigned int i = 0; i < edge->getNumMeshElements(); i++){
+ for(unsigned int i = 0; i < edge->getNumMeshElements(); i++) {
MElement *element = edge->getMeshElement(i);
MVertex *vertex1 = element->getVertex(0);
MVertex *vertex2 = element->getVertex(1);
- bool flag = find_edge(vertex1,vertex2);
+ bool flag = find_edge(vertex1, vertex2);
if(!flag) return false;
}
}
diff --git a/Mesh/DivideAndConquer.h b/Mesh/DivideAndConquer.h
index 34b2ab90bc240a0b4092e8cc0706fcf386037963..c6712d46bb9150b32124b5647d7ce0248d880511 100644
--- a/Mesh/DivideAndConquer.h
+++ b/Mesh/DivideAndConquer.h
@@ -18,50 +18,50 @@ class GFace;
typedef struct _CDLIST DListRecord, *DListPeek;
typedef int PointNumero;
-typedef struct{
+typedef struct {
double v;
double h;
-}DPoint;
+} DPoint;
struct PointRecord {
DPoint where;
DListPeek adjacent;
void *data;
- int flag; //0:to be kept, 1:to be removed
+ int flag; // 0:to be kept, 1:to be removed
int identificator;
- std::vector<void*> vicinity;
+ std::vector<void *> vicinity;
PointRecord() : adjacent(0), data(0), flag(0), identificator(0)
{
where.v = where.h = 0.;
}
};
-struct _CDLIST{
+struct _CDLIST {
PointNumero point_num;
DListPeek next, prev;
};
-typedef struct{
+typedef struct {
PointNumero *t;
int t_length;
-}STriangle;
+} STriangle;
-typedef struct{
+typedef struct {
PointNumero begin;
PointNumero end;
-}DT;
+} DT;
-typedef struct{
+typedef struct {
PointNumero from;
PointNumero to;
-}Segment;
+} Segment;
-typedef struct{
+typedef struct {
PointNumero a, b, c;
-}Triangle;
+} Triangle;
-class DocRecord{
- private:
+class DocRecord {
+private:
int _hullSize;
PointNumero *_hull;
PointNumero Predecessor(PointNumero a, PointNumero b);
@@ -87,93 +87,90 @@ class DocRecord{
void ConvexHull();
bool AdjacentNullptrExists();
- public:
+public:
STriangle *_adjacencies;
- int numPoints; // number of points
+ int numPoints; // number of points
int size_points;
- PointRecord *points; // points to triangulate
- int numTriangles; // number of triangles
- Triangle *triangles; // 2D results
+ PointRecord *points; // points to triangulate
+ int numTriangles; // number of triangles
+ Triangle *triangles; // 2D results
DocRecord(int n);
- double &x(int i){ return points[i].where.h; }
- double &y(int i){ return points[i].where.v; }
- void* &data(int i){ return points[i].data; }
+ double &x(int i) { return points[i].where.h; }
+ double &y(int i) { return points[i].where.v; }
+ void *&data(int i) { return points[i].data; }
void setPoints(fullMatrix<double> *p);
~DocRecord();
void MakeMeshWithPoints();
- void Voronoi ();
- int hullSize() {return _hullSize;}
- int onHull(PointNumero i) { return std::binary_search(_hull, _hull+_hullSize, i); }
+ void Voronoi();
+ int hullSize() { return _hullSize; }
+ int onHull(PointNumero i)
+ {
+ return std::binary_search(_hull, _hull + _hullSize, i);
+ }
void makePosView(const std::string &, GFace *gf = NULL);
void printMedialAxis(Octree *_octree, const std::string &, GFace *gf = NULL,
GEdge *ge = NULL);
void voronoiCell(PointNumero pt, std::vector<SPoint2> &pts) const;
- std::set<std::pair<void*,void*> > boundaryEdges;
+ std::set<std::pair<void *, void *> > boundaryEdges;
- void addBoundaryEdge(void* p1,void* p2)
+ void addBoundaryEdge(void *p1, void *p2)
{
void *a = (p1 < p2) ? p1 : p2;
void *b = (p1 > p2) ? p1 : p2;
- boundaryEdges.insert(std::make_pair(a,b));
+ boundaryEdges.insert(std::make_pair(a, b));
}
- bool lookForBoundaryEdge(void* p1,void* p2)
+ bool lookForBoundaryEdge(void *p1, void *p2)
{
void *a = (p1 < p2) ? p1 : p2;
void *b = (p1 > p2) ? p1 : p2;
- std::set<std::pair<void*,void*> >::iterator it =
- boundaryEdges.find(std::make_pair(a,b));
+ std::set<std::pair<void *, void *> >::iterator it =
+ boundaryEdges.find(std::make_pair(a, b));
return it != boundaryEdges.end();
}
- void recur_tag_triangles(int, std::set<int>&, std::map<std::pair<void*,void*>,
- std::pair<int,int> >&);
- std::set<int> tagInterior(double,double);
- void concave(double,double,GFace*);
- bool contain(int,int,int);
- void add(int,int);
+ void recur_tag_triangles(
+ int, std::set<int> &,
+ std::map<std::pair<void *, void *>, std::pair<int, int> > &);
+ std::set<int> tagInterior(double, double);
+ void concave(double, double, GFace *);
+ bool contain(int, int, int);
+ void add(int, int);
void initialize();
bool remove_point(int);
void remove_all();
- void add_point(double,double,GFace*);
+ void add_point(double, double, GFace *);
- std::set<std::pair<void*,void*> > mesh_edges;
+ std::set<std::pair<void *, void *> > mesh_edges;
- void add_edge(void* p1,void* p2)
+ void add_edge(void *p1, void *p2)
{
void *a = (p1 < p2) ? p1 : p2;
void *b = (p1 > p2) ? p1 : p2;
- mesh_edges.insert(std::make_pair(a,b));
+ mesh_edges.insert(std::make_pair(a, b));
}
- bool find_edge(void* p1,void* p2)
+ bool find_edge(void *p1, void *p2)
{
void *a = (p1 < p2) ? p1 : p2;
void *b = (p1 > p2) ? p1 : p2;
- std::set<std::pair<void*,void*> >::iterator it =
- mesh_edges.find(std::make_pair(a,b));
+ std::set<std::pair<void *, void *> >::iterator it =
+ mesh_edges.find(std::make_pair(a, b));
return it != mesh_edges.end();
}
void build_edges();
void clear_edges();
- bool delaunay_conformity(GFace*);
+ bool delaunay_conformity(GFace *);
PointNumero *ConvertDlistToArray(DListPeek *dlist, int *n);
};
-void centroidOfOrientedBox(std::vector<SPoint2> &pts,
- const double &angle,
- double &xc,
- double &yc,
- double &inertia,
- double &area);
-void centroidOfPolygon(SPoint2 &pc,
- std::vector<SPoint2> &pts,
- double &xc,
- double &yc,
- double &inertia,
- double &areaCell,
+void centroidOfOrientedBox(std::vector<SPoint2> &pts, const double &angle,
+ double &xc, double &yc, double &inertia,
+ double &area);
+void centroidOfPolygon(SPoint2 &pc, std::vector<SPoint2> &pts, double &xc,
+ double &yc, double &inertia, double &areaCell,
simpleFunction<double> *bgm = 0);
#endif
diff --git a/Mesh/Field.cpp b/Mesh/Field.cpp
index 413d8813fe5493d4cd1e586992d41ccfbf889043..b5d8453340f90a1f2eb3aebd41c1dc71760cf081 100644
--- a/Mesh/Field.cpp
+++ b/Mesh/Field.cpp
@@ -49,18 +49,18 @@
Field::~Field()
{
- for(std::map<std::string, FieldOption*>::iterator it = options.begin();
+ for(std::map<std::string, FieldOption *>::iterator it = options.begin();
it != options.end(); ++it)
delete it->second;
- for(std::map<std::string, FieldCallback*>::iterator it = callbacks.begin();
+ for(std::map<std::string, FieldCallback *>::iterator it = callbacks.begin();
it != callbacks.end(); ++it)
delete it->second;
}
FieldOption *Field::getOption(const std::string &optionName)
{
- std::map<std::string, FieldOption*>::iterator it = options.find(optionName);
- if (it == options.end()) {
+ std::map<std::string, FieldOption *>::iterator it = options.find(optionName);
+ if(it == options.end()) {
Msg::Error("field option :%s does not exist", optionName.c_str());
return NULL;
}
@@ -92,9 +92,8 @@ Field *FieldManager::newField(int id, const std::string &type_name)
Msg::Error("Unknown field type \"%s\"", type_name.c_str());
return 0;
}
- Field *f = (*map_type_name[type_name]) ();
- if(!f)
- return 0;
+ Field *f = (*map_type_name[type_name])();
+ if(!f) return 0;
f->id = id;
(*this)[id] = f;
return f;
@@ -106,10 +105,8 @@ int FieldManager::newId()
iterator it = begin();
while(1) {
i++;
- while(it != end() && it->first < i)
- it++;
- if(it == end() || it->first != i)
- break;
+ while(it != end() && it->first < i) it++;
+ if(it == end() || it->first != i) break;
}
return std::max(i, 1);
}
@@ -134,8 +131,7 @@ void FieldManager::deleteField(int id)
}
// StructuredField
-class StructuredField : public Field
-{
+class StructuredField : public Field {
double o[3], d[3];
int n[3];
double *data;
@@ -143,47 +139,51 @@ class StructuredField : public Field
bool text_format, outside_value_set;
double outside_value;
std::string file_name;
- public:
+
+public:
StructuredField()
{
- options["FileName"] = new FieldOptionPath
- (file_name, "Name of the input file", &update_needed);
+ options["FileName"] =
+ new FieldOptionPath(file_name, "Name of the input file", &update_needed);
text_format = false;
- options["TextFormat"] = new FieldOptionBool
- (text_format, "True for ASCII input files, false for binary files (4 bite "
- "signed integers for n, double precision floating points for v, D and O)",
- &update_needed);
- options["SetOutsideValue"] = new FieldOptionBool(outside_value_set, "True to use the \"OutsideValue\" option. If False, the last values of the grid are used.");
- options["OutsideValue"] = new FieldOptionDouble(outside_value, "Value of the field outside the grid (only used if the \"SetOutsideValue\" option is true).");
+ options["TextFormat"] = new FieldOptionBool(
+ text_format,
+ "True for ASCII input files, false for binary files (4 bite "
+ "signed integers for n, double precision floating points for v, D and O)",
+ &update_needed);
+ options["SetOutsideValue"] = new FieldOptionBool(
+ outside_value_set, "True to use the \"OutsideValue\" option. If False, "
+ "the last values of the grid are used.");
+ options["OutsideValue"] = new FieldOptionDouble(
+ outside_value, "Value of the field outside the grid (only used if the "
+ "\"SetOutsideValue\" option is true).");
data = 0;
}
std::string getDescription()
{
return "Linearly interpolate between data provided on a 3D rectangular "
- "structured grid.\n\n"
- "The format of the input file is:\n\n"
- " Ox Oy Oz \n"
- " Dx Dy Dz \n"
- " nx ny nz \n"
- " v(0,0,0) v(0,0,1) v(0,0,2) ... \n"
- " v(0,1,0) v(0,1,1) v(0,1,2) ... \n"
- " v(0,2,0) v(0,2,1) v(0,2,2) ... \n"
- " ... ... ... \n"
- " v(1,0,0) ... ... \n\n"
- "where O are the coordinates of the first node, D are the distances "
- "between nodes in each direction, n are the numbers of nodes in each "
- "direction, and v are the values on each node.";
- }
- const char *getName()
- {
- return "Structured";
- }
+ "structured grid.\n\n"
+ "The format of the input file is:\n\n"
+ " Ox Oy Oz \n"
+ " Dx Dy Dz \n"
+ " nx ny nz \n"
+ " v(0,0,0) v(0,0,1) v(0,0,2) ... \n"
+ " v(0,1,0) v(0,1,1) v(0,1,2) ... \n"
+ " v(0,2,0) v(0,2,1) v(0,2,2) ... \n"
+ " ... ... ... \n"
+ " v(1,0,0) ... ... \n\n"
+ "where O are the coordinates of the first node, D are the distances "
+ "between nodes in each direction, n are the numbers of nodes in "
+ "each "
+ "direction, and v are the values on each node.";
+ }
+ const char *getName() { return "Structured"; }
virtual ~StructuredField()
{
- if(data) delete[]data;
+ if(data) delete[] data;
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
if(update_needed) {
error_status = false;
@@ -192,19 +192,16 @@ class StructuredField : public Field
if(text_format)
input.open(file_name.c_str());
else
- input.open(file_name.c_str(),std::ios::binary);
- if(!input.is_open())
- throw(1);
- input.
- exceptions(std::ifstream::eofbit | std::ifstream::failbit | std::
- ifstream::badbit);
+ input.open(file_name.c_str(), std::ios::binary);
+ if(!input.is_open()) throw(1);
+ input.exceptions(std::ifstream::eofbit | std::ifstream::failbit |
+ std::ifstream::badbit);
if(!text_format) {
input.read((char *)o, 3 * sizeof(double));
input.read((char *)d, 3 * sizeof(double));
input.read((char *)n, 3 * sizeof(int));
int nt = n[0] * n[1] * n[2];
- if(data)
- delete[]data;
+ if(data) delete[] data;
data = new double[nt];
input.read((char *)data, nt * sizeof(double));
}
@@ -212,30 +209,27 @@ class StructuredField : public Field
input >> o[0] >> o[1] >> o[2] >> d[0] >> d[1] >> d[2] >> n[0] >>
n[1] >> n[2];
int nt = n[0] * n[1] * n[2];
- if(data)
- delete[]data;
+ if(data) delete[] data;
data = new double[nt];
- for(int i = 0; i < nt; i++)
- input >> data[i];
+ for(int i = 0; i < nt; i++) input >> data[i];
}
input.close();
- }
- catch(...) {
+ } catch(...) {
error_status = true;
- Msg::Error("Field %i : error reading file %s", this->id, file_name.c_str());
+ Msg::Error("Field %i : error reading file %s", this->id,
+ file_name.c_str());
}
update_needed = false;
}
- if(error_status)
- return MAX_LC;
- //tri-linear
+ if(error_status) return MAX_LC;
+ // tri-linear
int id[2][3];
double xi[3];
- double xyz[3] = { x, y, z };
+ double xyz[3] = {x, y, z};
for(int i = 0; i < 3; i++) {
id[0][i] = (int)floor((xyz[i] - o[i]) / d[i]);
id[1][i] = id[0][i] + 1;
- if (outside_value_set && (id[0][i] < 0 || id[1][i] >= n[i]) && n[i] > 1)
+ if(outside_value_set && (id[0][i] < 0 || id[1][i] >= n[i]) && n[i] > 1)
return outside_value;
id[0][i] = std::max(std::min(id[0][i], n[i] - 1), 0);
id[1][i] = std::max(std::min(id[1][i], n[i] - 1), 0);
@@ -246,10 +240,10 @@ class StructuredField : public Field
for(int i = 0; i < 2; i++)
for(int j = 0; j < 2; j++)
for(int k = 0; k < 2; k++) {
- v += data[id[i][0] * n[1] * n[2] + id[j][1] * n[2] + id[k][2]]
- * (i * xi[0] + (1 - i) * (1 - xi[0]))
- * (j * xi[1] + (1 - j) * (1 - xi[1]))
- * (k * xi[2] + (1 - k) * (1 - xi[2]));
+ v += data[id[i][0] * n[1] * n[2] + id[j][1] * n[2] + id[k][2]] *
+ (i * xi[0] + (1 - i) * (1 - xi[0])) *
+ (j * xi[1] + (1 - j) * (1 - xi[1])) *
+ (k * xi[2] + (1 - k) * (1 - xi[2]));
}
return v;
}
@@ -263,9 +257,9 @@ class StructuredField : public Field
public:
std::string getDescription()
{
- return "Evaluate Field[IField] in Universal Transverse Mercator coordinates.\n\n"
- "The formulas for the coordinates transformation are taken from:\n\n"
- " http://www.uwgb.edu/dutchs/UsefulData/UTMFormulas.HTM";
+ return "Evaluate Field[IField] in Universal Transverse Mercator
+coordinates.\n\n" "The formulas for the coordinates transformation are taken
+from:\n\n" " http://www.uwgb.edu/dutchs/UsefulData/UTMFormulas.HTM";
}
UTMField()
{
@@ -343,231 +337,216 @@ class StructuredField : public Field
}
};*/
-class LonLatField : public Field
-{
+class LonLatField : public Field {
int iField, fromStereo;
double stereoRadius;
- public:
+
+public:
std::string getDescription()
{
- return "Evaluate Field[IField] in geographic coordinates (longitude, latitude):\n\n"
- " F = Field[IField](atan(y/x), asin(z/sqrt(x^2+y^2+z^2))";
+ return "Evaluate Field[IField] in geographic coordinates (longitude, "
+ "latitude):\n\n"
+ " F = Field[IField](atan(y/x), asin(z/sqrt(x^2+y^2+z^2))";
}
LonLatField()
{
iField = 1;
- options["IField"] = new FieldOptionInt
- (iField, "Index of the field to evaluate.");
+ options["IField"] =
+ new FieldOptionInt(iField, "Index of the field to evaluate.");
fromStereo = 0;
stereoRadius = 6371e3;
- options["FromStereo"] = new FieldOptionInt
- (fromStereo, "if = 1, the mesh is in stereographic coordinates. "
- "xi = 2Rx/(R+z), eta = 2Ry/(R+z)");
- options["RadiusStereo"] = new FieldOptionDouble
- (stereoRadius, "radius of the sphere of the stereograpic coordinates");
- }
- const char *getName()
- {
- return "LonLat";
+ options["FromStereo"] = new FieldOptionInt(
+ fromStereo, "if = 1, the mesh is in stereographic coordinates. "
+ "xi = 2Rx/(R+z), eta = 2Ry/(R+z)");
+ options["RadiusStereo"] = new FieldOptionDouble(
+ stereoRadius, "radius of the sphere of the stereograpic coordinates");
}
+ const char *getName() { return "LonLat"; }
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
Field *field = GModel::current()->getFields()->get(iField);
if(!field || iField == id) return MAX_LC;
- if (fromStereo == 1) {
+ if(fromStereo == 1) {
double xi = x;
double eta = y;
double r2 = stereoRadius * stereoRadius;
- x = 4 * r2 * xi / ( 4 * r2 + xi * xi + eta * eta);
- y = 4 * r2 * eta / ( 4 * r2 + xi * xi + eta * eta);
- z = stereoRadius * (4 * r2 - eta * eta - xi * xi) / ( 4 * r2 + xi * xi + eta * eta);
+ x = 4 * r2 * xi / (4 * r2 + xi * xi + eta * eta);
+ y = 4 * r2 * eta / (4 * r2 + xi * xi + eta * eta);
+ z = stereoRadius * (4 * r2 - eta * eta - xi * xi) /
+ (4 * r2 + xi * xi + eta * eta);
}
return (*field)(atan2(y, x), asin(z / stereoRadius), 0);
}
};
-
-class BoxField : public Field
-{
+class BoxField : public Field {
double v_in, v_out, x_min, x_max, y_min, y_max, z_min, z_max;
- public:
+
+public:
std::string getDescription()
{
- return "The value of this field is VIn inside the box, VOut outside the box. "
- "The box is given by\n\n"
- " Xmin <= x <= XMax &&\n"
- " YMin <= y <= YMax &&\n"
- " ZMin <= z <= ZMax";
+ return "The value of this field is VIn inside the box, VOut outside the "
+ "box. "
+ "The box is given by\n\n"
+ " Xmin <= x <= XMax &&\n"
+ " YMin <= y <= YMax &&\n"
+ " ZMin <= z <= ZMax";
}
BoxField()
{
v_in = v_out = x_min = x_max = y_min = y_max = z_min = z_max = 0;
- options["VIn"] = new FieldOptionDouble
- (v_in, "Value inside the box");
- options["VOut"] = new FieldOptionDouble
- (v_out, "Value outside the box");
- options["XMin"] = new FieldOptionDouble
- (x_min, "Minimum X coordinate of the box");
- options["XMax"] = new FieldOptionDouble
- (x_max, "Maximum X coordinate of the box");
- options["YMin"] = new FieldOptionDouble
- (y_min, "Minimum Y coordinate of the box");
- options["YMax"] = new FieldOptionDouble
- (y_max, "Maximum Y coordinate of the box");
- options["ZMin"] = new FieldOptionDouble
- (z_min, "Minimum Z coordinate of the box");
- options["ZMax"] = new FieldOptionDouble
- (z_max, "Maximum Z coordinate of the box");
- }
- const char *getName()
- {
- return "Box";
- }
+ options["VIn"] = new FieldOptionDouble(v_in, "Value inside the box");
+ options["VOut"] = new FieldOptionDouble(v_out, "Value outside the box");
+ options["XMin"] =
+ new FieldOptionDouble(x_min, "Minimum X coordinate of the box");
+ options["XMax"] =
+ new FieldOptionDouble(x_max, "Maximum X coordinate of the box");
+ options["YMin"] =
+ new FieldOptionDouble(y_min, "Minimum Y coordinate of the box");
+ options["YMax"] =
+ new FieldOptionDouble(y_max, "Maximum Y coordinate of the box");
+ options["ZMin"] =
+ new FieldOptionDouble(z_min, "Minimum Z coordinate of the box");
+ options["ZMax"] =
+ new FieldOptionDouble(z_max, "Maximum Z coordinate of the box");
+ }
+ const char *getName() { return "Box"; }
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
- return (x <= x_max && x >= x_min && y <= y_max && y >= y_min && z <= z_max
- && z >= z_min) ? v_in : v_out;
+ return (x <= x_max && x >= x_min && y <= y_max && y >= y_min &&
+ z <= z_max && z >= z_min) ?
+ v_in :
+ v_out;
}
};
-class CylinderField : public Field
-{
+class CylinderField : public Field {
double v_in, v_out;
- double xc,yc,zc;
- double xa,ya,za;
+ double xc, yc, zc;
+ double xa, ya, za;
double R;
- public:
+public:
std::string getDescription()
{
- return "The value of this field is VIn inside a frustrated cylinder, VOut outside. "
- "The cylinder is given by\n\n"
- " ||dX||^2 < R^2 &&\n"
- " (X-X0).A < ||A||^2\n"
- " dX = (X - X0) - ((X - X0).A)/(||A||^2) . A";
+ return "The value of this field is VIn inside a frustrated cylinder, VOut "
+ "outside. "
+ "The cylinder is given by\n\n"
+ " ||dX||^2 < R^2 &&\n"
+ " (X-X0).A < ||A||^2\n"
+ " dX = (X - X0) - ((X - X0).A)/(||A||^2) . A";
}
CylinderField()
{
v_in = v_out = xc = yc = zc = xa = ya = R = 0;
za = 1.;
- options["VIn"] = new FieldOptionDouble
- (v_in, "Value inside the cylinder");
- options["VOut"] = new FieldOptionDouble
- (v_out, "Value outside the cylinder");
+ options["VIn"] = new FieldOptionDouble(v_in, "Value inside the cylinder");
+ options["VOut"] =
+ new FieldOptionDouble(v_out, "Value outside the cylinder");
- options["XCenter"] = new FieldOptionDouble
- (xc, "X coordinate of the cylinder center");
- options["YCenter"] = new FieldOptionDouble
- (yc, "Y coordinate of the cylinder center");
- options["ZCenter"] = new FieldOptionDouble
- (zc, "Z coordinate of the cylinder center");
+ options["XCenter"] =
+ new FieldOptionDouble(xc, "X coordinate of the cylinder center");
+ options["YCenter"] =
+ new FieldOptionDouble(yc, "Y coordinate of the cylinder center");
+ options["ZCenter"] =
+ new FieldOptionDouble(zc, "Z coordinate of the cylinder center");
+ options["XAxis"] =
+ new FieldOptionDouble(xa, "X component of the cylinder axis");
+ options["YAxis"] =
+ new FieldOptionDouble(ya, "Y component of the cylinder axis");
+ options["ZAxis"] =
+ new FieldOptionDouble(za, "Z component of the cylinder axis");
- options["XAxis"] = new FieldOptionDouble
- (xa, "X component of the cylinder axis");
- options["YAxis"] = new FieldOptionDouble
- (ya, "Y component of the cylinder axis");
- options["ZAxis"] = new FieldOptionDouble
- (za, "Z component of the cylinder axis");
-
- options["Radius"] = new FieldOptionDouble
- (R,"Radius");
-
- }
- const char *getName()
- {
- return "Cylinder";
+ options["Radius"] = new FieldOptionDouble(R, "Radius");
}
+ const char *getName() { return "Cylinder"; }
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
- double dx = x-xc;
- double dy = y-yc;
- double dz = z-zc;
+ double dx = x - xc;
+ double dy = y - yc;
+ double dz = z - zc;
- double adx = (xa * dx + ya * dy + za * dz)/(xa*xa + ya*ya + za*za);
+ double adx = (xa * dx + ya * dy + za * dz) / (xa * xa + ya * ya + za * za);
dx -= adx * xa;
dy -= adx * ya;
dz -= adx * za;
- return ((dx*dx + dy*dy + dz*dz < R*R) && fabs(adx) < 1) ? v_in : v_out;
+ return ((dx * dx + dy * dy + dz * dz < R * R) && fabs(adx) < 1) ? v_in :
+ v_out;
}
};
-class BallField : public Field
-{
+class BallField : public Field {
double v_in, v_out;
- double xc,yc,zc;
+ double xc, yc, zc;
double R;
- public:
+public:
std::string getDescription()
{
- return "The value of this field is VIn inside a spherical ball, VOut outside. "
- "The ball is defined by\n\n"
- " ||dX||^2 < R^2 &&\n"
- " dX = (X - XC)^2 + (Y-YC)^2 + (Z-ZC)^2";
+ return "The value of this field is VIn inside a spherical ball, VOut "
+ "outside. "
+ "The ball is defined by\n\n"
+ " ||dX||^2 < R^2 &&\n"
+ " dX = (X - XC)^2 + (Y-YC)^2 + (Z-ZC)^2";
}
BallField()
{
v_in = v_out = xc = yc = zc = R = 0;
- options["VIn"] = new FieldOptionDouble
- (v_in, "Value inside the ball");
- options["VOut"] = new FieldOptionDouble
- (v_out, "Value outside the ball");
+ options["VIn"] = new FieldOptionDouble(v_in, "Value inside the ball");
+ options["VOut"] = new FieldOptionDouble(v_out, "Value outside the ball");
- options["XCenter"] = new FieldOptionDouble
- (xc, "X coordinate of the ball center");
- options["YCenter"] = new FieldOptionDouble
- (yc, "Y coordinate of the ball center");
- options["ZCenter"] = new FieldOptionDouble
- (zc, "Z coordinate of the ball center");
+ options["XCenter"] =
+ new FieldOptionDouble(xc, "X coordinate of the ball center");
+ options["YCenter"] =
+ new FieldOptionDouble(yc, "Y coordinate of the ball center");
+ options["ZCenter"] =
+ new FieldOptionDouble(zc, "Z coordinate of the ball center");
- options["Radius"] = new FieldOptionDouble
- (R,"Radius");
- }
- const char *getName()
- {
- return "Ball";
+ options["Radius"] = new FieldOptionDouble(R, "Radius");
}
+ const char *getName() { return "Ball"; }
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
- double dx = x-xc;
- double dy = y-yc;
- double dz = z-zc;
+ double dx = x - xc;
+ double dy = y - yc;
+ double dz = z - zc;
- return ( (dx*dx + dy*dy + dz*dz < R*R) ) ? v_in : v_out;
+ return ((dx * dx + dy * dy + dz * dz < R * R)) ? v_in : v_out;
}
};
-class FrustumField : public Field
-{
- double x1,y1,z1;
- double x2,y2,z2;
- double r1i,r1o,r2i,r2o;
- double v1i,v1o,v2i,v2o;
+class FrustumField : public Field {
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double r1i, r1o, r2i, r2o;
+ double v1i, v1o, v2i, v2o;
- public:
+public:
std::string getDescription()
{
- return "This field is an extended cylinder with inner (i) and outer (o) radiuses"
- "on both endpoints (1 and 2). Length scale is bilinearly interpolated between"
- "these locations (inner and outer radiuses, endpoints 1 and 2)"
- "The field values for a point P are given by :"
- " u = P1P.P1P2/||P1P2|| "
- " r = || P1P - u*P1P2 || "
- " Ri = (1-u)*R1i + u*R2i "
- " Ro = (1-u)*R1o + u*R2o "
- " v = (r-Ri)/(Ro-Ri)"
- " lc = (1-v)*( (1-u)*v1i + u*v2i ) + v*( (1-u)*v1o + u*v2o )"
- " where (u,v) in [0,1]x[0,1]";
+ return "This field is an extended cylinder with inner (i) and outer (o) "
+ "radiuses"
+ "on both endpoints (1 and 2). Length scale is bilinearly "
+ "interpolated between"
+ "these locations (inner and outer radiuses, endpoints 1 and 2)"
+ "The field values for a point P are given by :"
+ " u = P1P.P1P2/||P1P2|| "
+ " r = || P1P - u*P1P2 || "
+ " Ri = (1-u)*R1i + u*R2i "
+ " Ro = (1-u)*R1o + u*R2o "
+ " v = (r-Ri)/(Ro-Ri)"
+ " lc = (1-v)*( (1-u)*v1i + u*v2i ) + v*( (1-u)*v1o + u*v2o )"
+ " where (u,v) in [0,1]x[0,1]";
}
FrustumField()
{
@@ -579,86 +558,73 @@ class FrustumField : public Field
v1i = v2i = 0.1;
v1o = v2o = 1.;
- options["X1"] = new FieldOptionDouble
- (x1, "X coordinate of endpoint 1");
- options["Y1"] = new FieldOptionDouble
- (y1, "Y coordinate of endpoint 1");
- options["Z1"] = new FieldOptionDouble
- (z1, "Z coordinate of endpoint 1");
- options["X2"] = new FieldOptionDouble
- (x2, "X coordinate of endpoint 2");
- options["Y2"] = new FieldOptionDouble
- (y2, "Y coordinate of endpoint 2");
- options["Z2"] = new FieldOptionDouble
- (z2, "Z coordinate of endpoint 2");
-
- options["R1_inner"] = new FieldOptionDouble
- (r1i, "Inner radius of Frustum at endpoint 1");
- options["R1_outer"] = new FieldOptionDouble
- (r1o, "Outer radius of Frustum at endpoint 1");
- options["R2_inner"] = new FieldOptionDouble
- (r2i, "Inner radius of Frustum at endpoint 2");
- options["R2_outer"] = new FieldOptionDouble
- (r2o, "Outer radius of Frustum at endpoint 2");
-
- options["V1_inner"] = new FieldOptionDouble
- (v1i, "Element size at point 1, inner radius");
- options["V1_outer"] = new FieldOptionDouble
- (v1o, "Element size at point 1, outer radius");
- options["V2_inner"] = new FieldOptionDouble
- (v2i, "Element size at point 2, inner radius");
- options["V2_outer"] = new FieldOptionDouble
- (v2o, "Element size at point 2, outer radius");
-
- }
- const char *getName()
- {
- return "Frustum";
- }
+ options["X1"] = new FieldOptionDouble(x1, "X coordinate of endpoint 1");
+ options["Y1"] = new FieldOptionDouble(y1, "Y coordinate of endpoint 1");
+ options["Z1"] = new FieldOptionDouble(z1, "Z coordinate of endpoint 1");
+ options["X2"] = new FieldOptionDouble(x2, "X coordinate of endpoint 2");
+ options["Y2"] = new FieldOptionDouble(y2, "Y coordinate of endpoint 2");
+ options["Z2"] = new FieldOptionDouble(z2, "Z coordinate of endpoint 2");
+
+ options["R1_inner"] =
+ new FieldOptionDouble(r1i, "Inner radius of Frustum at endpoint 1");
+ options["R1_outer"] =
+ new FieldOptionDouble(r1o, "Outer radius of Frustum at endpoint 1");
+ options["R2_inner"] =
+ new FieldOptionDouble(r2i, "Inner radius of Frustum at endpoint 2");
+ options["R2_outer"] =
+ new FieldOptionDouble(r2o, "Outer radius of Frustum at endpoint 2");
+
+ options["V1_inner"] =
+ new FieldOptionDouble(v1i, "Element size at point 1, inner radius");
+ options["V1_outer"] =
+ new FieldOptionDouble(v1o, "Element size at point 1, outer radius");
+ options["V2_inner"] =
+ new FieldOptionDouble(v2i, "Element size at point 2, inner radius");
+ options["V2_outer"] =
+ new FieldOptionDouble(v2o, "Element size at point 2, outer radius");
+ }
+ const char *getName() { return "Frustum"; }
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
- double dx = x-x1;
- double dy = y-y1;
- double dz = z-z1;
- double x12 = x2-x1;
- double y12 = y2-y1;
- double z12 = z2-z1;
- double l12 = sqrt( x12*x12 + y12*y12 + z12*z12 );
+ double dx = x - x1;
+ double dy = y - y1;
+ double dz = z - z1;
+ double x12 = x2 - x1;
+ double y12 = y2 - y1;
+ double z12 = z2 - z1;
+ double l12 = sqrt(x12 * x12 + y12 * y12 + z12 * z12);
- double l = (dx*x12 + dy*y12 + dz*z12)/l12 ;
- double r = sqrt( dx*dx+dy*dy+dz*dz - l*l );
+ double l = (dx * x12 + dy * y12 + dz * z12) / l12;
+ double r = sqrt(dx * dx + dy * dy + dz * dz - l * l);
- double u = l/l12 ; // u varies between 0 (P1) and 1 (P2)
- double ri = (1-u)*r1i + u*r2i ;
- double ro = (1-u)*r1o + u*r2o ;
- double v = (r-ri)/(ro-ri) ; // v varies between 0 (inner) and 1 (outer)
+ double u = l / l12; // u varies between 0 (P1) and 1 (P2)
+ double ri = (1 - u) * r1i + u * r2i;
+ double ro = (1 - u) * r1o + u * r2o;
+ double v = (r - ri) / (ro - ri); // v varies between 0 (inner) and 1 (outer)
- double lc = MAX_LC ;
- if( u>=0 && u<=1 && v>=0 && v<=1 ){
- lc = (1-v)*( (1-u)*v1i + u*v2i ) + v*( (1-u)*v1o + u*v2o );
+ double lc = MAX_LC;
+ if(u >= 0 && u <= 1 && v >= 0 && v <= 1) {
+ lc = (1 - v) * ((1 - u) * v1i + u * v2i) + v * ((1 - u) * v1o + u * v2o);
}
return lc;
-
}
};
-class ThresholdField : public Field
-{
- protected :
+class ThresholdField : public Field {
+protected:
int iField;
double dmin, dmax, lcmin, lcmax;
bool sigmoid, stopAtDistMax;
- public:
- virtual const char *getName()
- {
- return "Threshold";
- }
+
+public:
+ virtual const char *getName() { return "Threshold"; }
virtual std::string getDescription()
{
return "F = LCMin if Field[IField] <= DistMin,\n"
- "F = LCMax if Field[IField] >= DistMax,\n"
- "F = interpolation between LcMin and LcMax if DistMin < Field[IField] < DistMax";
+ "F = LCMax if Field[IField] >= DistMax,\n"
+ "F = interpolation between LcMin and LcMax if DistMin < "
+ "Field[IField] < DistMax";
}
ThresholdField()
{
@@ -669,143 +635,130 @@ class ThresholdField : public Field
lcmax = 1;
sigmoid = false;
stopAtDistMax = false;
- options["IField"] = new FieldOptionInt
- (iField, "Index of the field to evaluate");
- options["DistMin"] = new FieldOptionDouble
- (dmin, "Distance from entity up to which element size will be LcMin");
- options["DistMax"] = new FieldOptionDouble
- (dmax, "Distance from entity after which element size will be LcMax");
- options["LcMin"] = new FieldOptionDouble
- (lcmin, "Element size inside DistMin");
- options["LcMax"] = new FieldOptionDouble
- (lcmax, "Element size outside DistMax");
- options["Sigmoid"] = new FieldOptionBool
- (sigmoid, "True to interpolate between LcMin and LcMax using a sigmoid, "
- "false to interpolate linearly");
- options["StopAtDistMax"] = new FieldOptionBool
- (stopAtDistMax, "True to not impose element size outside DistMax (i.e., "
- "F = a very big value if Field[IField] > DistMax)");
+ options["IField"] =
+ new FieldOptionInt(iField, "Index of the field to evaluate");
+ options["DistMin"] = new FieldOptionDouble(
+ dmin, "Distance from entity up to which element size will be LcMin");
+ options["DistMax"] = new FieldOptionDouble(
+ dmax, "Distance from entity after which element size will be LcMax");
+ options["LcMin"] =
+ new FieldOptionDouble(lcmin, "Element size inside DistMin");
+ options["LcMax"] =
+ new FieldOptionDouble(lcmax, "Element size outside DistMax");
+ options["Sigmoid"] = new FieldOptionBool(
+ sigmoid, "True to interpolate between LcMin and LcMax using a sigmoid, "
+ "false to interpolate linearly");
+ options["StopAtDistMax"] = new FieldOptionBool(
+ stopAtDistMax, "True to not impose element size outside DistMax (i.e., "
+ "F = a very big value if Field[IField] > DistMax)");
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
Field *field = GModel::current()->getFields()->get(iField);
if(!field || iField == id) return MAX_LC;
- double r = ((*field) (x, y, z) - dmin) / (dmax - dmin);
+ double r = ((*field)(x, y, z) - dmin) / (dmax - dmin);
r = std::max(std::min(r, 1.), 0.);
double lc;
- if(stopAtDistMax && r >= 1.){
+ if(stopAtDistMax && r >= 1.) {
lc = MAX_LC;
}
- else if(sigmoid){
+ else if(sigmoid) {
double s = exp(12. * r - 6.) / (1. + exp(12. * r - 6.));
lc = lcmin * (1. - s) + lcmax * s;
}
- else{ // linear
+ else { // linear
lc = lcmin * (1 - r) + lcmax * r;
}
return lc;
}
};
-class GradientField : public Field
-{
+class GradientField : public Field {
int iField, kind;
double delta;
- public:
- const char *getName()
- {
- return "Gradient";
- }
+
+public:
+ const char *getName() { return "Gradient"; }
std::string getDescription()
{
return "Compute the finite difference gradient of Field[IField]:\n\n"
- " F = (Field[IField](X + Delta/2) - "
- " Field[IField](X - Delta/2)) / Delta";
+ " F = (Field[IField](X + Delta/2) - "
+ " Field[IField](X - Delta/2)) / Delta";
}
GradientField() : iField(0), kind(3), delta(CTX::instance()->lc / 1e4)
{
iField = 1;
kind = 0;
delta = 0.;
- options["IField"] = new FieldOptionInt
- (iField, "Field index");
- options["Kind"] = new FieldOptionInt
- (kind, "Component of the gradient to evaluate: 0 for X, 1 for Y, 2 for Z, "
- "3 for the norm");
- options["Delta"] = new FieldOptionDouble
- (delta, "Finite difference step");
+ options["IField"] = new FieldOptionInt(iField, "Field index");
+ options["Kind"] = new FieldOptionInt(
+ kind, "Component of the gradient to evaluate: 0 for X, 1 for Y, 2 for Z, "
+ "3 for the norm");
+ options["Delta"] = new FieldOptionDouble(delta, "Finite difference step");
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
Field *field = GModel::current()->getFields()->get(iField);
if(!field || iField == id) return MAX_LC;
double gx, gy, gz;
- switch (kind) {
- case 0: /* x */
- return ((*field) (x + delta / 2, y, z) -
- (*field) (x - delta / 2, y, z)) / delta;
- case 1: /* y */
- return ((*field) (x, y + delta / 2, z) -
- (*field) (x, y - delta / 2, z)) / delta;
- case 2: /* z */
- return ((*field) (x, y, z + delta / 2) -
- (*field) (x, y, z - delta / 2)) / delta;
- case 3: /* norm */
+ switch(kind) {
+ case 0: /* x */
+ return ((*field)(x + delta / 2, y, z) - (*field)(x - delta / 2, y, z)) /
+ delta;
+ case 1: /* y */
+ return ((*field)(x, y + delta / 2, z) - (*field)(x, y - delta / 2, z)) /
+ delta;
+ case 2: /* z */
+ return ((*field)(x, y, z + delta / 2) - (*field)(x, y, z - delta / 2)) /
+ delta;
+ case 3: /* norm */
gx =
- ((*field) (x + delta / 2, y, z) -
- (*field) (x - delta / 2, y, z)) / delta;
+ ((*field)(x + delta / 2, y, z) - (*field)(x - delta / 2, y, z)) / delta;
gy =
- ((*field) (x, y + delta / 2, z) -
- (*field) (x, y - delta / 2, z)) / delta;
+ ((*field)(x, y + delta / 2, z) - (*field)(x, y - delta / 2, z)) / delta;
gz =
- ((*field) (x, y, z + delta / 2) -
- (*field) (x, y, z - delta / 2)) / delta;
+ ((*field)(x, y, z + delta / 2) - (*field)(x, y, z - delta / 2)) / delta;
return sqrt(gx * gx + gy * gy + gz * gz);
default:
- Msg::Error("Field %i : Unknown kind (%i) of gradient", this->id,
- kind);
+ Msg::Error("Field %i : Unknown kind (%i) of gradient", this->id, kind);
return MAX_LC;
}
}
};
-class CurvatureField : public Field
-{
+class CurvatureField : public Field {
int iField;
double delta;
- public:
- const char *getName()
- {
- return "Curvature";
- }
+
+public:
+ const char *getName() { return "Curvature"; }
std::string getDescription()
{
return "Compute the curvature of Field[IField]:\n\n"
- " F = div(norm(grad(Field[IField])))";
+ " F = div(norm(grad(Field[IField])))";
}
CurvatureField() : iField(0), delta(CTX::instance()->lc / 1e4)
{
iField = 1;
delta = 0.;
- options["IField"] = new FieldOptionInt
- (iField, "Field index");
- options["Delta"] = new FieldOptionDouble
- (delta, "Step of the finite differences");
+ options["IField"] = new FieldOptionInt(iField, "Field index");
+ options["Delta"] =
+ new FieldOptionDouble(delta, "Step of the finite differences");
}
void grad_norm(Field &f, double x, double y, double z, double *g)
{
g[0] = f(x + delta / 2, y, z) - f(x - delta / 2, y, z);
g[1] = f(x, y + delta / 2, z) - f(x, y - delta / 2, z);
g[2] = f(x, y, z + delta / 2) - f(x, y, z - delta / 2);
- double n=sqrt(g[0] * g[0] + g[1] * g[1] + g[2] * g[2]);
+ double n = sqrt(g[0] * g[0] + g[1] * g[1] + g[2] * g[2]);
g[0] /= n;
g[1] /= n;
g[2] /= n;
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
Field *field = GModel::current()->getFields()->get(iField);
if(!field || iField == id) return MAX_LC;
@@ -816,53 +769,51 @@ class CurvatureField : public Field
grad_norm(*field, x, y - delta / 2, z, grad[3]);
grad_norm(*field, x, y, z + delta / 2, grad[4]);
grad_norm(*field, x, y, z - delta / 2, grad[5]);
- return (grad[0][0] - grad[1][0] + grad[2][1] -
- grad[3][1] + grad[4][2] - grad[5][2]) / delta;
+ return (grad[0][0] - grad[1][0] + grad[2][1] - grad[3][1] + grad[4][2] -
+ grad[5][2]) /
+ delta;
}
};
-class MaxEigenHessianField : public Field
-{
+class MaxEigenHessianField : public Field {
int iField;
double delta;
- public:
- const char *getName()
- {
- return "MaxEigenHessian";
- }
+
+public:
+ const char *getName() { return "MaxEigenHessian"; }
std::string getDescription()
{
return "Compute the maximum eigenvalue of the Hessian matrix of "
- "Field[IField], with the gradients evaluated by finite differences:\n\n"
- " F = max(eig(grad(grad(Field[IField]))))";
+ "Field[IField], with the gradients evaluated by finite "
+ "differences:\n\n"
+ " F = max(eig(grad(grad(Field[IField]))))";
}
MaxEigenHessianField() : iField(0), delta(CTX::instance()->lc / 1e4)
{
iField = 1;
delta = 0.;
- options["IField"] = new FieldOptionInt
- (iField, "Field index");
- options["Delta"] = new FieldOptionDouble
- (delta, "Step used for the finite differences");
+ options["IField"] = new FieldOptionInt(iField, "Field index");
+ options["Delta"] =
+ new FieldOptionDouble(delta, "Step used for the finite differences");
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
Field *field = GModel::current()->getFields()->get(iField);
if(!field || iField == id) return MAX_LC;
double mat[3][3], eig[3];
- mat[1][0] = mat[0][1] = (*field) (x + delta / 2 , y + delta / 2, z)
- + (*field) (x - delta / 2 , y - delta / 2, z)
- - (*field) (x - delta / 2 , y + delta / 2, z)
- - (*field) (x + delta / 2 , y - delta / 2, z);
- mat[2][0] = mat[0][2] = (*field) (x + delta/2 , y, z + delta / 2)
- + (*field) (x - delta / 2 , y, z - delta / 2)
- - (*field) (x - delta / 2 , y, z + delta / 2)
- - (*field) (x + delta / 2 , y, z - delta / 2);
- mat[2][1] = mat[1][2] = (*field) (x, y + delta/2 , z + delta / 2)
- + (*field) (x, y - delta / 2 , z - delta / 2)
- - (*field) (x, y - delta / 2 , z + delta / 2)
- - (*field) (x, y + delta / 2 , z - delta / 2);
+ mat[1][0] = mat[0][1] = (*field)(x + delta / 2, y + delta / 2, z) +
+ (*field)(x - delta / 2, y - delta / 2, z) -
+ (*field)(x - delta / 2, y + delta / 2, z) -
+ (*field)(x + delta / 2, y - delta / 2, z);
+ mat[2][0] = mat[0][2] = (*field)(x + delta / 2, y, z + delta / 2) +
+ (*field)(x - delta / 2, y, z - delta / 2) -
+ (*field)(x - delta / 2, y, z + delta / 2) -
+ (*field)(x + delta / 2, y, z - delta / 2);
+ mat[2][1] = mat[1][2] = (*field)(x, y + delta / 2, z + delta / 2) +
+ (*field)(x, y - delta / 2, z - delta / 2) -
+ (*field)(x, y - delta / 2, z + delta / 2) -
+ (*field)(x, y + delta / 2, z - delta / 2);
double f = (*field)(x, y, z);
mat[0][0] = (*field)(x + delta, y, z) + (*field)(x - delta, y, z) - 2 * f;
mat[1][1] = (*field)(x, y + delta, z) + (*field)(x, y - delta, z) - 2 * f;
@@ -872,99 +823,96 @@ class MaxEigenHessianField : public Field
}
};
-class LaplacianField : public Field
-{
+class LaplacianField : public Field {
int iField;
double delta;
- public:
- const char *getName()
- {
- return "Laplacian";
- }
+
+public:
+ const char *getName() { return "Laplacian"; }
std::string getDescription()
{
return "Compute finite difference the Laplacian of Field[IField]:\n\n"
- " F = G(x+d,y,z) + G(x-d,y,z) +\n"
- " G(x,y+d,z) + G(x,y-d,z) +\n"
- " G(x,y,z+d) + G(x,y,z-d) - 6 * G(x,y,z),\n\n"
- "where G=Field[IField] and d=Delta";
+ " F = G(x+d,y,z) + G(x-d,y,z) +\n"
+ " G(x,y+d,z) + G(x,y-d,z) +\n"
+ " G(x,y,z+d) + G(x,y,z-d) - 6 * G(x,y,z),\n\n"
+ "where G=Field[IField] and d=Delta";
}
LaplacianField() : iField(0), delta(CTX::instance()->lc / 1e4)
{
iField = 1;
delta = 0.1;
- options["IField"] = new FieldOptionInt
- (iField, "Field index");
- options["Delta"] = new FieldOptionDouble
- (delta, "Finite difference step");
+ options["IField"] = new FieldOptionInt(iField, "Field index");
+ options["Delta"] = new FieldOptionDouble(delta, "Finite difference step");
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
Field *field = GModel::current()->getFields()->get(iField);
if(!field || iField == id) return MAX_LC;
- return ((*field) (x + delta , y, z)+ (*field) (x - delta , y, z)
- +(*field) (x, y + delta , z)+ (*field) (x, y - delta , z)
- +(*field) (x, y, z + delta )+ (*field) (x, y, z - delta )
- -6* (*field) (x , y, z)) / (delta*delta);
+ return ((*field)(x + delta, y, z) + (*field)(x - delta, y, z) +
+ (*field)(x, y + delta, z) + (*field)(x, y - delta, z) +
+ (*field)(x, y, z + delta) + (*field)(x, y, z - delta) -
+ 6 * (*field)(x, y, z)) /
+ (delta * delta);
}
};
-class MeanField : public Field
-{
+class MeanField : public Field {
int iField;
double delta;
- public:
- const char *getName()
- {
- return "Mean";
- }
+
+public:
+ const char *getName() { return "Mean"; }
std::string getDescription()
{
return "Simple smoother:\n\n"
- " F = (G(x+delta,y,z) + G(x-delta,y,z) +\n"
- " G(x,y+delta,z) + G(x,y-delta,z) +\n"
- " G(x,y,z+delta) + G(x,y,z-delta) +\n"
- " G(x,y,z)) / 7,\n\n"
- "where G=Field[IField]";
+ " F = (G(x+delta,y,z) + G(x-delta,y,z) +\n"
+ " G(x,y+delta,z) + G(x,y-delta,z) +\n"
+ " G(x,y,z+delta) + G(x,y,z-delta) +\n"
+ " G(x,y,z)) / 7,\n\n"
+ "where G=Field[IField]";
}
MeanField() : iField(0), delta(CTX::instance()->lc / 1e4)
{
- options["IField"] = new FieldOptionInt
- (iField, "Field index");
- options["Delta"] = new FieldOptionDouble
- (delta, "Distance used to compute the mean value");
+ options["IField"] = new FieldOptionInt(iField, "Field index");
+ options["Delta"] =
+ new FieldOptionDouble(delta, "Distance used to compute the mean value");
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
Field *field = GModel::current()->getFields()->get(iField);
if(!field || iField == id) return MAX_LC;
- return ((*field) (x + delta , y, z) + (*field) (x - delta, y, z)
- + (*field) (x, y + delta, z) + (*field) (x, y - delta, z)
- + (*field) (x, y, z + delta) + (*field) (x, y, z - delta)
- + (*field) (x, y, z)) / 7;
+ return ((*field)(x + delta, y, z) + (*field)(x - delta, y, z) +
+ (*field)(x, y + delta, z) + (*field)(x, y - delta, z) +
+ (*field)(x, y, z + delta) + (*field)(x, y, z - delta) +
+ (*field)(x, y, z)) /
+ 7;
}
};
-class MathEvalExpression
-{
- private:
+class MathEvalExpression {
+private:
mathEvaluator *_f;
std::set<int> _fields;
- public:
+
+public:
MathEvalExpression() : _f(0) {}
- ~MathEvalExpression(){ if(_f) delete _f; }
+ ~MathEvalExpression()
+ {
+ if(_f) delete _f;
+ }
bool set_function(const std::string &f)
{
// get id numbers of fields appearing in the function
_fields.clear();
unsigned int i = 0;
- while(i < f.size()){
+ while(i < f.size()) {
unsigned int j = 0;
- if(f[i] == 'F'){
+ if(f[i] == 'F') {
std::string id("");
- while(i + 1 + j < f.size() && f[i + 1 + j] >= '0' && f[i + 1 + j] <= '9'){
+ while(i + 1 + j < f.size() && f[i + 1 + j] >= '0' &&
+ f[i + 1 + j] <= '9') {
id += f[i + 1 + j];
j++;
}
@@ -978,7 +926,8 @@ class MathEvalExpression
variables[1] = "y";
variables[2] = "z";
i = 3;
- for(std::set<int>::iterator it = _fields.begin(); it != _fields.end(); it++){
+ for(std::set<int>::iterator it = _fields.begin(); it != _fields.end();
+ it++) {
std::ostringstream sstream;
sstream << "F" << *it;
variables[i++] = sstream.str();
@@ -1000,7 +949,8 @@ class MathEvalExpression
values[1] = y;
values[2] = z;
int i = 3;
- for(std::set<int>::iterator it = _fields.begin(); it != _fields.end(); it++){
+ for(std::set<int>::iterator it = _fields.begin(); it != _fields.end();
+ it++) {
Field *field = GModel::current()->getFields()->get(*it);
values[i++] = field ? (*field)(x, y, z) : MAX_LC;
}
@@ -1011,30 +961,32 @@ class MathEvalExpression
}
};
-class MathEvalExpressionAniso
-{
- private:
+class MathEvalExpressionAniso {
+private:
mathEvaluator *_f[6];
std::set<int> _fields[6];
- public:
+
+public:
MathEvalExpressionAniso()
{
for(int i = 0; i < 6; i++) _f[i] = 0;
}
~MathEvalExpressionAniso()
{
- for(int i = 0; i < 6; i++) if(_f[i]) delete _f[i];
+ for(int i = 0; i < 6; i++)
+ if(_f[i]) delete _f[i];
}
bool set_function(int iFunction, const std::string &f)
{
// get id numbers of fields appearing in the function
_fields[iFunction].clear();
unsigned int i = 0;
- while(i < f.size()){
+ while(i < f.size()) {
unsigned int j = 0;
- if(f[i] == 'F'){
+ if(f[i] == 'F') {
std::string id("");
- while(i + 1 + j < f.size() && f[i + 1 + j] >= '0' && f[i + 1 + j] <= '9'){
+ while(i + 1 + j < f.size() && f[i + 1 + j] >= '0' &&
+ f[i + 1 + j] <= '9') {
id += f[i + 1 + j];
j++;
}
@@ -1042,14 +994,15 @@ class MathEvalExpressionAniso
}
i += j + 1;
}
- std::vector<std::string> expressions(1), variables(3 + _fields[iFunction].size());
+ std::vector<std::string> expressions(1),
+ variables(3 + _fields[iFunction].size());
expressions[0] = f;
variables[0] = "x";
variables[1] = "y";
variables[2] = "z";
i = 3;
for(std::set<int>::iterator it = _fields[iFunction].begin();
- it != _fields[iFunction].end(); it++){
+ it != _fields[iFunction].end(); it++) {
std::ostringstream sstream;
sstream << "F" << *it;
variables[i++] = sstream.str();
@@ -1063,113 +1016,109 @@ class MathEvalExpressionAniso
}
return true;
}
- void evaluate (double x, double y, double z, SMetric3 &metr)
+ void evaluate(double x, double y, double z, SMetric3 &metr)
{
- const int index[6][2] = {{0,0},{1,1},{2,2},{0,1},{0,2},{1,2}};
- for (int iFunction = 0; iFunction < 6; iFunction++){
+ const int index[6][2] = {{0, 0}, {1, 1}, {2, 2}, {0, 1}, {0, 2}, {1, 2}};
+ for(int iFunction = 0; iFunction < 6; iFunction++) {
if(!_f[iFunction])
metr(index[iFunction][0], index[iFunction][1]) = MAX_LC;
- else{
- std::vector<double> values(3 + _fields[iFunction].size()), res(1);
- values[0] = x;
- values[1] = y;
- values[2] = z;
- int i = 3;
- for(std::set<int>::iterator it = _fields[iFunction].begin();
- it != _fields[iFunction].end(); it++){
- Field *field = GModel::current()->getFields()->get(*it);
- values[i++] = field ? (*field)(x, y, z) : MAX_LC;
- }
- if(_f[iFunction]->eval(values, res))
- metr(index[iFunction][0],index[iFunction][1]) = res[0];
- else
- metr(index[iFunction][0],index[iFunction][1]) = MAX_LC;
+ else {
+ std::vector<double> values(3 + _fields[iFunction].size()), res(1);
+ values[0] = x;
+ values[1] = y;
+ values[2] = z;
+ int i = 3;
+ for(std::set<int>::iterator it = _fields[iFunction].begin();
+ it != _fields[iFunction].end(); it++) {
+ Field *field = GModel::current()->getFields()->get(*it);
+ values[i++] = field ? (*field)(x, y, z) : MAX_LC;
+ }
+ if(_f[iFunction]->eval(values, res))
+ metr(index[iFunction][0], index[iFunction][1]) = res[0];
+ else
+ metr(index[iFunction][0], index[iFunction][1]) = MAX_LC;
}
}
}
};
-class MathEvalField : public Field
-{
+class MathEvalField : public Field {
MathEvalExpression expr;
std::string f;
- public:
+public:
MathEvalField()
{
- options["F"] = new FieldOptionString
- (f, "Mathematical function to evaluate.", &update_needed);
+ options["F"] = new FieldOptionString(
+ f, "Mathematical function to evaluate.", &update_needed);
f = "F2 + Sin(z)";
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
if(update_needed) {
if(!expr.set_function(f))
- Msg::Error("Field %i: Invalid matheval expression \"%s\"",
- this->id, f.c_str());
+ Msg::Error("Field %i: Invalid matheval expression \"%s\"", this->id,
+ f.c_str());
update_needed = false;
}
return expr.evaluate(x, y, z);
}
- const char *getName()
- {
- return "MathEval";
- }
+ const char *getName() { return "MathEval"; }
std::string getDescription()
{
return "Evaluate a mathematical expression. The expression can contain "
- "x, y, z for spatial coordinates, F0, F1, ... for field values, and "
- "and mathematical functions.";
+ "x, y, z for spatial coordinates, F0, F1, ... for field values, and "
+ "and mathematical functions.";
}
};
-class MathEvalFieldAniso : public Field
-{
+class MathEvalFieldAniso : public Field {
MathEvalExpressionAniso expr;
std::string f[6];
- public:
- virtual bool isotropic () const { return false; }
+
+public:
+ virtual bool isotropic() const { return false; }
MathEvalFieldAniso()
{
- options["m11"] = new FieldOptionString
- (f[0], "element 11 of the metric tensor.", &update_needed);
+ options["m11"] = new FieldOptionString(
+ f[0], "element 11 of the metric tensor.", &update_needed);
f[0] = "F2 + Sin(z)";
- options["m22"] = new FieldOptionString
- (f[1], "element 22 of the metric tensor.", &update_needed);
+ options["m22"] = new FieldOptionString(
+ f[1], "element 22 of the metric tensor.", &update_needed);
f[1] = "F2 + Sin(z)";
- options["m33"] = new FieldOptionString
- (f[2], "element 33 of the metric tensor.", &update_needed);
+ options["m33"] = new FieldOptionString(
+ f[2], "element 33 of the metric tensor.", &update_needed);
f[2] = "F2 + Sin(z)";
- options["m12"] = new FieldOptionString
- (f[3], "element 12 of the metric tensor.", &update_needed);
+ options["m12"] = new FieldOptionString(
+ f[3], "element 12 of the metric tensor.", &update_needed);
f[3] = "F2 + Sin(z)";
- options["m13"] = new FieldOptionString
- (f[4], "element 13 of the metric tensor.", &update_needed);
+ options["m13"] = new FieldOptionString(
+ f[4], "element 13 of the metric tensor.", &update_needed);
f[4] = "F2 + Sin(z)";
- options["m23"] = new FieldOptionString
- (f[5], "element 23 of the metric tensor.", &update_needed);
+ options["m23"] = new FieldOptionString(
+ f[5], "element 23 of the metric tensor.", &update_needed);
f[5] = "F2 + Sin(z)";
}
- void operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge=0)
+ void operator()(double x, double y, double z, SMetric3 &metr, GEntity *ge = 0)
{
if(update_needed) {
- for (int i=0;i<6;i++){
- if(!expr.set_function(i,f[i]))
- Msg::Error("Field %i: Invalid matheval expression \"%s\"",
- this->id, f[i].c_str());
+ for(int i = 0; i < 6; i++) {
+ if(!expr.set_function(i, f[i]))
+ Msg::Error("Field %i: Invalid matheval expression \"%s\"", this->id,
+ f[i].c_str());
}
update_needed = false;
}
expr.evaluate(x, y, z, metr);
}
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
if(update_needed) {
- for (int i = 0; i < 6; i++){
- if(!expr.set_function(i, f[i]))
- Msg::Error("Field %i: Invalid matheval expression \"%s\"",
- this->id, f[i].c_str());
+ for(int i = 0; i < 6; i++) {
+ if(!expr.set_function(i, f[i]))
+ Msg::Error("Field %i: Invalid matheval expression \"%s\"", this->id,
+ f[i].c_str());
}
update_needed = false;
}
@@ -1177,37 +1126,38 @@ class MathEvalFieldAniso : public Field
expr.evaluate(x, y, z, metr);
return metr(0, 0);
}
- const char *getName()
- {
- return "MathEvalAniso";
- }
+ const char *getName() { return "MathEvalAniso"; }
std::string getDescription()
{
return "Evaluate a metric expression. The expressions can contain "
- "x, y, z for spatial coordinates, F0, F1, ... for field values, and "
- "and mathematical functions.";
+ "x, y, z for spatial coordinates, F0, F1, ... for field values, and "
+ "and mathematical functions.";
}
};
-
#if defined(WIN32) && !defined(__CYGWIN__)
-//windows implementation from https://msdn.microsoft.com/en-us/library/windows/desktop/ms682499(v=vs.85).aspx
+// windows implementation from
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms682499(v=vs.85).aspx
class Popen2 {
HANDLE _hIn, _hOut;
- public:
- Popen2(){
+
+public:
+ Popen2()
+ {
_hIn = NULL;
_hOut = NULL;
}
- void stop(){
- if (_hIn) {
+ void stop()
+ {
+ if(_hIn) {
CloseHandle(_hIn);
CloseHandle(_hOut);
_hIn = _hOut = NULL;
}
}
bool started() const { return _hIn; }
- bool start(const char *command) {
+ bool start(const char *command)
+ {
stop();
HANDLE hChildStd_OUT_Wr, hChildStd_IN_Rd;
PROCESS_INFORMATION piProcInfo;
@@ -1215,76 +1165,76 @@ class Popen2 {
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
- if (!CreatePipe(&_hIn, &hChildStd_OUT_Wr, &saAttr, 0))
+ if(!CreatePipe(&_hIn, &hChildStd_OUT_Wr, &saAttr, 0))
Msg::Error("StdoutRd CreatePipe");
- if (!CreatePipe(&hChildStd_IN_Rd, &_hOut, &saAttr, 0))
+ if(!CreatePipe(&hChildStd_IN_Rd, &_hOut, &saAttr, 0))
Msg::Error("Stdin CreatePipe");
- if (!CreatePipe(&_hIn, &hChildStd_OUT_Wr, &saAttr, 0))
+ if(!CreatePipe(&_hIn, &hChildStd_OUT_Wr, &saAttr, 0))
Msg::Error("StdoutRd CreatePipe");
- if (!SetHandleInformation(_hIn, HANDLE_FLAG_INHERIT, 0))
+ if(!SetHandleInformation(_hIn, HANDLE_FLAG_INHERIT, 0))
Msg::Error("Stdout SetHandleInformation");
STARTUPINFO siStartInfo;
BOOL bSuccess = FALSE;
- ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
- ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
+ ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
+ ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
siStartInfo.cb = sizeof(STARTUPINFO);
siStartInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
siStartInfo.hStdOutput = hChildStd_OUT_Wr;
siStartInfo.hStdInput = hChildStd_IN_Rd;
siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
- bSuccess = CreateProcess(NULL, (char*)command, NULL, NULL,
- TRUE, 0, NULL, NULL, &siStartInfo, &piProcInfo);
- if (!bSuccess){
+ bSuccess = CreateProcess(NULL, (char *)command, NULL, NULL, TRUE, 0, NULL,
+ NULL, &siStartInfo, &piProcInfo);
+ if(!bSuccess) {
Msg::Error("Child process creation failed %i", GetLastError());
_hIn = _hOut = NULL;
return false;
}
- CloseHandle(piProcInfo.hProcess);
- CloseHandle(piProcInfo.hThread);
+ CloseHandle(piProcInfo.hProcess);
+ CloseHandle(piProcInfo.hThread);
return true;
}
- bool read(void *data, size_t size) {
- if (!_hIn) return false;
- DWORD nSuccess = 0;
+ bool read(void *data, size_t size)
+ {
+ if(!_hIn) return false;
+ DWORD nSuccess = 0;
ReadFile(_hIn, data, size, &nSuccess, NULL);
return nSuccess == size;
}
- bool write(void *data, size_t size) {
- if (!_hOut) return false;
- DWORD nSuccess = 0;
+ bool write(void *data, size_t size)
+ {
+ if(!_hOut) return false;
+ DWORD nSuccess = 0;
WriteFile(_hOut, data, size, &nSuccess, NULL);
return nSuccess == size;
}
- ~Popen2() {
- stop();
- }
+ ~Popen2() { stop(); }
};
-#else //unix
+#else // unix
class Popen2 {
int _fdIn, _fdOut;
- public:
- Popen2(){
- _fdIn = _fdOut = -1;
- }
- void stop(){
- if (_fdIn != -1) {
+
+public:
+ Popen2() { _fdIn = _fdOut = -1; }
+ void stop()
+ {
+ if(_fdIn != -1) {
::close(_fdIn);
::close(_fdOut);
_fdIn = _fdOut = -1;
}
}
- bool started() const {return _fdIn;}
- bool start(const char *command) {
+ bool started() const { return _fdIn; }
+ bool start(const char *command)
+ {
stop();
int p_stdin[2], p_stdout[2];
- if (pipe(p_stdin) != 0 || pipe(p_stdout) != 0)
- return false;
+ if(pipe(p_stdin) != 0 || pipe(p_stdout) != 0) return false;
int pid = fork();
- if (pid < 0)
+ if(pid < 0)
return false;
- else if (pid == 0) {
+ else if(pid == 0) {
close(p_stdin[1]);
dup2(p_stdin[0], 0);
close(p_stdout[0]);
@@ -1297,44 +1247,42 @@ class Popen2 {
_fdIn = p_stdout[0];
return true;
}
- bool read(void *data, size_t size) {
- return ::read(_fdIn, data, size)== (ssize_t)size;
- }
- bool write(void *data, size_t size) {
- return ::write(_fdOut, data, size)== (ssize_t)size;
+ bool read(void *data, size_t size)
+ {
+ return ::read(_fdIn, data, size) == (ssize_t)size;
}
- ~Popen2() {
- stop();
+ bool write(void *data, size_t size)
+ {
+ return ::write(_fdOut, data, size) == (ssize_t)size;
}
+ ~Popen2() { stop(); }
};
#endif
-class ExternalProcessField : public Field
-{
+class ExternalProcessField : public Field {
std::string _cmdLine;
Popen2 _pipes;
- void closePipes() {
- if (_pipes.started()) {
- double xyz[3] = {
- std::numeric_limits<double>::quiet_NaN(),
- std::numeric_limits<double>::quiet_NaN(),
- std::numeric_limits<double>::quiet_NaN() };
- _pipes.write((void*)xyz, 3 * sizeof(double));
+ void closePipes()
+ {
+ if(_pipes.started()) {
+ double xyz[3] = {std::numeric_limits<double>::quiet_NaN(),
+ std::numeric_limits<double>::quiet_NaN(),
+ std::numeric_limits<double>::quiet_NaN()};
+ _pipes.write((void *)xyz, 3 * sizeof(double));
_pipes.stop();
}
}
- public:
+
+public:
ExternalProcessField()
{
- options["CommandLine"] = new FieldOptionString
- (_cmdLine, "Command line to launch.", &update_needed);
- _cmdLine ="";
- }
- ~ExternalProcessField() {
- closePipes();
+ options["CommandLine"] = new FieldOptionString(
+ _cmdLine, "Command line to launch.", &update_needed);
+ _cmdLine = "";
}
+ ~ExternalProcessField() { closePipes(); }
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
double xyz[3] = {x, y, z};
double f;
@@ -1343,151 +1291,148 @@ class ExternalProcessField : public Field
_pipes.start(_cmdLine.c_str());
update_needed = false;
}
- if (!_pipes.write((void*)xyz, 3*sizeof(double))
- || !_pipes.read((void*)&f, sizeof(double))){
- f = 1e22;// std::numeric_limits<double>::max();
+ if(!_pipes.write((void *)xyz, 3 * sizeof(double)) ||
+ !_pipes.read((void *)&f, sizeof(double))) {
+ f = 1e22; // std::numeric_limits<double>::max();
}
return f;
}
- const char *getName()
- {
- return "ExternalProcess";
- }
+ const char *getName() { return "ExternalProcess"; }
std::string getDescription()
{
return "**This Field is experimental**\n"
- "Call an external process that received coordinates triple (x,y,z) "
- "as binary double precision numbers on stdin and is supposed to write the "
- "field value on stdout as a binary double precision number.\n"
- "NaN,NaN,NaN is sent as coordinate to indicate the end of the process.\n"
- "\n"
- "Example of client (python2):\n"
- "import os\n"
- "import struct\n"
- "import math\n"
- "import sys\n"
- "if sys.platform == \"win32\" :\n"
- "import msvcrt\n"
- "msvcrt.setmode(0, os.O_BINARY)\n"
- "msvcrt.setmode(1, os.O_BINARY)\n"
- "while(True):\n"
- "____xyz = struct.unpack(\"ddd\", os.read(0,24))\n"
- "____if math.isnan(xyz[0]):\n"
- "_________break\n"
- "____f = 0.001 + xyz[1]*0.009\n"
- "____os.write(1,struct.pack(\"d\",f))\n"
- "\n"
- "Example of client (python3):\n"
- "import struct\n"
- "import sys\n"
- "import math\n"
- "while(True):\n"
- "____xyz = struct.unpack(\"ddd\", sys.stdin.buffer.read(24))\n"
- "____if math.isnan(xyz[0]):\n"
- "________break\n"
- "____f = 0.001 + xyz[1]*0.009\n"
- "____sys.stdout.buffer.write(struct.pack(\"d\",f))\n"
- "____sys.stdout.flush()\n"
- "\n"
- "Example of client (c, unix):\n"
- "#include <unistd.h>\n"
- "int main(int argc, char **argv) {\n"
- "__double xyz[3];\n"
- "__while(read(STDIN_FILENO, &xyz, 3*sizeof(double)) == 3*sizeof(double)) {\n"
- "____if (xyz[0] != xyz[0]) break; //nan\n"
- "____double f = 0.001 + 0.009 * xyz[1];\n"
- "____write(STDOUT_FILENO, &f, sizeof(double));\n"
- "__}\n"
- "__return 0;\n"
- "}\n"
- "\n"
- "Example of client (c, windows):\n"
- "#include <stdio.h>\n"
- "#include <io.h>\n"
- "#include <fcntl.h>\n"
- "int main(int argc, char **argv) {\n"
- "__double xyz[3];\n"
- "__setmode(fileno(stdin),O_BINARY);\n"
- "__setmode(fileno(stdout),O_BINARY);\n"
- "__while(read(fileno(stdin), &xyz, 3*sizeof(double)) == 3*sizeof(double)) {\n"
- "____if (xyz[0] != xyz[0])\n"
- "______break;\n"
- "____double f = f = 0.01 + 0.09 * xyz[1];\n"
- "____write(fileno(stdout), &f, sizeof(double));\n"
- "__}\n"
- "}\n";
+ "Call an external process that received coordinates triple (x,y,z) "
+ "as binary double precision numbers on stdin and is supposed to "
+ "write the "
+ "field value on stdout as a binary double precision number.\n"
+ "NaN,NaN,NaN is sent as coordinate to indicate the end of the "
+ "process.\n"
+ "\n"
+ "Example of client (python2):\n"
+ "import os\n"
+ "import struct\n"
+ "import math\n"
+ "import sys\n"
+ "if sys.platform == \"win32\" :\n"
+ "import msvcrt\n"
+ "msvcrt.setmode(0, os.O_BINARY)\n"
+ "msvcrt.setmode(1, os.O_BINARY)\n"
+ "while(True):\n"
+ "____xyz = struct.unpack(\"ddd\", os.read(0,24))\n"
+ "____if math.isnan(xyz[0]):\n"
+ "_________break\n"
+ "____f = 0.001 + xyz[1]*0.009\n"
+ "____os.write(1,struct.pack(\"d\",f))\n"
+ "\n"
+ "Example of client (python3):\n"
+ "import struct\n"
+ "import sys\n"
+ "import math\n"
+ "while(True):\n"
+ "____xyz = struct.unpack(\"ddd\", sys.stdin.buffer.read(24))\n"
+ "____if math.isnan(xyz[0]):\n"
+ "________break\n"
+ "____f = 0.001 + xyz[1]*0.009\n"
+ "____sys.stdout.buffer.write(struct.pack(\"d\",f))\n"
+ "____sys.stdout.flush()\n"
+ "\n"
+ "Example of client (c, unix):\n"
+ "#include <unistd.h>\n"
+ "int main(int argc, char **argv) {\n"
+ "__double xyz[3];\n"
+ "__while(read(STDIN_FILENO, &xyz, 3*sizeof(double)) == "
+ "3*sizeof(double)) {\n"
+ "____if (xyz[0] != xyz[0]) break; //nan\n"
+ "____double f = 0.001 + 0.009 * xyz[1];\n"
+ "____write(STDOUT_FILENO, &f, sizeof(double));\n"
+ "__}\n"
+ "__return 0;\n"
+ "}\n"
+ "\n"
+ "Example of client (c, windows):\n"
+ "#include <stdio.h>\n"
+ "#include <io.h>\n"
+ "#include <fcntl.h>\n"
+ "int main(int argc, char **argv) {\n"
+ "__double xyz[3];\n"
+ "__setmode(fileno(stdin),O_BINARY);\n"
+ "__setmode(fileno(stdout),O_BINARY);\n"
+ "__while(read(fileno(stdin), &xyz, 3*sizeof(double)) == "
+ "3*sizeof(double)) {\n"
+ "____if (xyz[0] != xyz[0])\n"
+ "______break;\n"
+ "____double f = f = 0.01 + 0.09 * xyz[1];\n"
+ "____write(fileno(stdout), &f, sizeof(double));\n"
+ "__}\n"
+ "}\n";
}
};
-class ParametricField : public Field
-{
+class ParametricField : public Field {
MathEvalExpression expr[3];
std::string f[3];
int iField;
- public:
+
+public:
ParametricField()
{
iField = 1;
- options["IField"] = new FieldOptionInt
- (iField, "Field index");
- options["FX"] = new FieldOptionString
- (f[0], "X component of parametric function", &update_needed);
- options["FY"] = new FieldOptionString
- (f[1], "Y component of parametric function", &update_needed);
- options["FZ"] = new FieldOptionString
- (f[2], "Z component of parametric function", &update_needed);
+ options["IField"] = new FieldOptionInt(iField, "Field index");
+ options["FX"] = new FieldOptionString(
+ f[0], "X component of parametric function", &update_needed);
+ options["FY"] = new FieldOptionString(
+ f[1], "Y component of parametric function", &update_needed);
+ options["FZ"] = new FieldOptionString(
+ f[2], "Z component of parametric function", &update_needed);
}
std::string getDescription()
{
return "Evaluate Field IField in parametric coordinates:\n\n"
- " F = Field[IField](FX,FY,FZ)\n\n"
- "See the MathEval Field help to get a description of valid FX, FY "
- "and FZ expressions.";
+ " F = Field[IField](FX,FY,FZ)\n\n"
+ "See the MathEval Field help to get a description of valid FX, FY "
+ "and FZ expressions.";
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
if(update_needed) {
for(int i = 0; i < 3; i++) {
if(!expr[i].set_function(f[i]))
- Msg::Error("Field %i : Invalid matheval expression \"%s\"",
- this->id, f[i].c_str());
+ Msg::Error("Field %i : Invalid matheval expression \"%s\"", this->id,
+ f[i].c_str());
}
update_needed = false;
}
Field *field = GModel::current()->getFields()->get(iField);
if(!field || iField == id) return MAX_LC;
- return (*field)(expr[0].evaluate(x, y, z),
- expr[1].evaluate(x, y, z),
+ return (*field)(expr[0].evaluate(x, y, z), expr[1].evaluate(x, y, z),
expr[2].evaluate(x, y, z));
}
- const char *getName()
- {
- return "Param";
- }
+ const char *getName() { return "Param"; }
};
#if defined(HAVE_POST)
-class PostViewField : public Field
-{
+class PostViewField : public Field {
OctreePost *octree;
int view_index, view_tag;
bool crop_negative_values;
- public:
+
+public:
PostViewField()
{
octree = 0;
view_index = 0;
view_tag = -1;
- options["IView"] = new FieldOptionInt
- (view_index, "Post-processing view index", &update_needed);
- options["ViewTag"] = new FieldOptionInt
- (view_tag, "Post-processing view tag", &update_needed);
+ options["IView"] = new FieldOptionInt(
+ view_index, "Post-processing view index", &update_needed);
+ options["ViewTag"] =
+ new FieldOptionInt(view_tag, "Post-processing view tag", &update_needed);
crop_negative_values = true;
- options["CropNegativeValues"] = new FieldOptionBool
- (crop_negative_values, "return LC_MAX instead of a negative value (this "
- "option is needed for backward compatibility with the BackgroundMesh option");
+ options["CropNegativeValues"] = new FieldOptionBool(
+ crop_negative_values, "return LC_MAX instead of a negative value (this "
+ "option is needed for backward compatibility with "
+ "the BackgroundMesh option");
}
~PostViewField()
{
@@ -1496,34 +1441,33 @@ class PostViewField : public Field
PView *getView() const
{
PView *v = 0;
- if(view_tag >= 0)
- v = PView::getViewByTag(view_tag);
- if(!v){
- if(view_index < 0 || view_index >= (int)PView::list.size()){
+ if(view_tag >= 0) v = PView::getViewByTag(view_tag);
+ if(!v) {
+ if(view_index < 0 || view_index >= (int)PView::list.size()) {
Msg::Error("View[%d] does not exist", view_index);
return 0;
}
v = PView::list[view_index];
}
- if(v->getData()->hasModel(GModel::current())){
- Msg::Error("Cannot use view based on current mesh for background mesh: you might"
- " want to use a list-based view (.pos file) instead");
+ if(v->getData()->hasModel(GModel::current())) {
+ Msg::Error(
+ "Cannot use view based on current mesh for background mesh: you might"
+ " want to use a list-based view (.pos file) instead");
return 0;
}
return v;
}
- virtual bool isotropic () const
+ virtual bool isotropic() const
{
PView *v = getView();
if(v && v->getData()->getNumTensors()) return false;
return true;
}
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
-
PView *v = getView();
if(!v) return MAX_LC;
- if(update_needed){
+ if(update_needed) {
if(octree) delete octree;
octree = new OctreePost(v);
update_needed = false;
@@ -1536,11 +1480,11 @@ class PostViewField : public Field
if(l <= 0 && crop_negative_values) return MAX_LC;
return l;
}
- void operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge=0)
+ void operator()(double x, double y, double z, SMetric3 &metr, GEntity *ge = 0)
{
PView *v = getView();
if(!v) return;
- if(update_needed){
+ if(update_needed) {
if(octree) delete octree;
octree = new OctreePost(v);
update_needed = false;
@@ -1550,27 +1494,30 @@ class PostViewField : public Field
// of finding an element
if(!octree->searchTensorWithTol(x, y, z, l, 0, 0, 0.05))
Msg::Info("No tensor element found containing point (%g,%g,%g)", x, y, z);
- if(0 && crop_negative_values){
- if(l[0] <= 0 && l[1] <= 0 && l[2] <= 0 &&
- l[3] <= 0 && l[4] <= 0 && l[5] <= 0 &&
- l[6] <= 0 && l[7] <= 0 && l[8] <= 0){
+ if(0 && crop_negative_values) {
+ if(l[0] <= 0 && l[1] <= 0 && l[2] <= 0 && l[3] <= 0 && l[4] <= 0 &&
+ l[5] <= 0 && l[6] <= 0 && l[7] <= 0 && l[8] <= 0) {
for(int i = 0; i < 9; i++) l[i] = MAX_LC;
}
- else{
- for(int i = 0; i < 9; i++){
+ else {
+ for(int i = 0; i < 9; i++) {
if(l[i] <= 0) l[i] = 0;
}
}
}
- // printf("%g %g %g %g %g %g %g %g %g\n",l[0],l[1], l[2],l[3],l[4], l[5],l[6],l[7], l[8]);
- metr(0, 0) = l[0]; metr(0, 1) = l[1]; metr(0, 2) = l[2];
- metr(1, 0) = l[3]; metr(1, 1) = l[4]; metr(1, 2) = l[5];
- metr(2, 0) = l[6]; metr(2, 1) = l[7]; metr(2, 2) = l[8];
- }
- const char *getName()
- {
- return "PostView";
- }
+ // printf("%g %g %g %g %g %g %g %g %g\n",l[0],l[1], l[2],l[3],l[4],
+ // l[5],l[6],l[7], l[8]);
+ metr(0, 0) = l[0];
+ metr(0, 1) = l[1];
+ metr(0, 2) = l[2];
+ metr(1, 0) = l[3];
+ metr(1, 1) = l[4];
+ metr(1, 2) = l[5];
+ metr(2, 0) = l[6];
+ metr(2, 1) = l[7];
+ metr(2, 2) = l[8];
+ }
+ const char *getName() { return "PostView"; }
std::string getDescription()
{
return "Evaluate the post processing view IView.";
@@ -1579,225 +1526,220 @@ class PostViewField : public Field
#endif
-class MinAnisoField : public Field
-{
+class MinAnisoField : public Field {
std::list<int> idlist;
- public:
+
+public:
MinAnisoField()
{
- options["FieldsList"] = new FieldOptionList
- (idlist, "Field indices", &update_needed);
+ options["FieldsList"] =
+ new FieldOptionList(idlist, "Field indices", &update_needed);
}
- virtual bool isotropic () const {return false;}
+ virtual bool isotropic() const { return false; }
std::string getDescription()
{
return "Take the intersection of a list of possibly anisotropic fields.";
}
- virtual void operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge=0)
+ virtual void operator()(double x, double y, double z, SMetric3 &metr,
+ GEntity *ge = 0)
{
- SMetric3 v (1./MAX_LC);
- for(std::list<int>::iterator it = idlist.begin(); it != idlist.end(); it++) {
+ SMetric3 v(1. / MAX_LC);
+ for(std::list<int>::iterator it = idlist.begin(); it != idlist.end();
+ it++) {
Field *f = (GModel::current()->getFields()->get(*it));
SMetric3 ff;
if(f && *it != id) {
- if (f->isotropic()){
- double l = (*f) (x, y, z, ge);
- ff = SMetric3(1./(l*l));
- }
- else{
- (*f) (x, y, z, ff, ge);
- }
- v = intersection_conserve_mostaniso(v,ff);
+ if(f->isotropic()) {
+ double l = (*f)(x, y, z, ge);
+ ff = SMetric3(1. / (l * l));
+ }
+ else {
+ (*f)(x, y, z, ff, ge);
+ }
+ v = intersection_conserve_mostaniso(v, ff);
}
}
metr = v;
}
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
- SMetric3 metr (1./MAX_LC);
+ SMetric3 metr(1. / MAX_LC);
double v = MAX_LC;
- for(std::list<int>::iterator it = idlist.begin(); it != idlist.end(); it++) {
+ for(std::list<int>::iterator it = idlist.begin(); it != idlist.end();
+ it++) {
Field *f = (GModel::current()->getFields()->get(*it));
SMetric3 m;
- if(f && *it != id){
- if (!f->isotropic()){
+ if(f && *it != id) {
+ if(!f->isotropic()) {
(*f)(x, y, z, m, ge);
}
- else {
+ else {
double L = (*f)(x, y, z, ge);
- for (int i = 0; i < 3; i++)
- m(i,i) = 1. / (L*L);
- }
+ for(int i = 0; i < 3; i++) m(i, i) = 1. / (L * L);
+ }
}
metr = intersection(metr, m);
}
- fullMatrix<double> V(3,3);
+ fullMatrix<double> V(3, 3);
fullVector<double> S(3);
metr.eig(V, S, 1);
- double val = sqrt(1./S(2)); //S(2) is largest eigenvalue
+ double val = sqrt(1. / S(2)); // S(2) is largest eigenvalue
return std::min(v, val);
}
- const char *getName()
- {
- return "MinAniso";
- }
+ const char *getName() { return "MinAniso"; }
};
-class IntersectAnisoField : public Field
-{
+class IntersectAnisoField : public Field {
std::list<int> idlist;
- public:
+
+public:
IntersectAnisoField()
{
- options["FieldsList"] = new FieldOptionList
- (idlist, "Field indices", &update_needed);
+ options["FieldsList"] =
+ new FieldOptionList(idlist, "Field indices", &update_needed);
}
- virtual bool isotropic () const {return false;}
+ virtual bool isotropic() const { return false; }
std::string getDescription()
{
- return "Take the intersection of 2 anisotropic fields according to Alauzet.";
+ return "Take the intersection of 2 anisotropic fields according to "
+ "Alauzet.";
}
- virtual void operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge=0)
+ virtual void operator()(double x, double y, double z, SMetric3 &metr,
+ GEntity *ge = 0)
{
// check if idlist contains 2 elements other error message
SMetric3 v;
- for(std::list<int>::iterator it = idlist.begin(); it != idlist.end(); it++) {
+ for(std::list<int>::iterator it = idlist.begin(); it != idlist.end();
+ it++) {
Field *f = (GModel::current()->getFields()->get(*it));
SMetric3 ff;
if(f && *it != id) {
- if (f->isotropic()){
- double l = (*f) (x, y, z, ge);
- ff = SMetric3(1./(l*l));
- }
- else{
- (*f) (x, y, z, ff, ge);
- }
- if (it == idlist.begin())
+ if(f->isotropic()) {
+ double l = (*f)(x, y, z, ge);
+ ff = SMetric3(1. / (l * l));
+ }
+ else {
+ (*f)(x, y, z, ff, ge);
+ }
+ if(it == idlist.begin())
v = ff;
- else
- v = intersection_alauzet(v,ff);
+ else
+ v = intersection_alauzet(v, ff);
}
}
metr = v;
}
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
// check if idlist contains 2 elements other error message
SMetric3 metr;
- for(std::list<int>::iterator it = idlist.begin(); it != idlist.end(); it++) {
+ for(std::list<int>::iterator it = idlist.begin(); it != idlist.end();
+ it++) {
Field *f = (GModel::current()->getFields()->get(*it));
SMetric3 m;
- if(f && *it != id){
- if (!f->isotropic()){
+ if(f && *it != id) {
+ if(!f->isotropic()) {
(*f)(x, y, z, m, ge);
}
- else {
+ else {
double L = (*f)(x, y, z, ge);
- for (int i = 0; i < 3; i++)
- m(i,i) = 1. / (L*L);
- }
+ for(int i = 0; i < 3; i++) m(i, i) = 1. / (L * L);
+ }
}
- if (it == idlist.begin())
+ if(it == idlist.begin())
metr = m;
else
- metr = intersection_alauzet(metr,m);
+ metr = intersection_alauzet(metr, m);
}
- fullMatrix<double> V(3,3);
+ fullMatrix<double> V(3, 3);
fullVector<double> S(3);
metr.eig(V, S, 1);
- return sqrt(1./S(2)); //S(2) is largest eigenvalue
- }
- const char *getName()
- {
- return "IntersectAniso";
+ return sqrt(1. / S(2)); // S(2) is largest eigenvalue
}
+ const char *getName() { return "IntersectAniso"; }
};
-class MinField : public Field
-{
+class MinField : public Field {
std::list<int> idlist;
- public:
+
+public:
MinField()
{
- options["FieldsList"] = new FieldOptionList
- (idlist, "Field indices", &update_needed);
+ options["FieldsList"] =
+ new FieldOptionList(idlist, "Field indices", &update_needed);
}
std::string getDescription()
{
return "Take the minimum value of a list of fields.";
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
double v = MAX_LC;
- for(std::list<int>::iterator it = idlist.begin(); it != idlist.end(); it++) {
+ for(std::list<int>::iterator it = idlist.begin(); it != idlist.end();
+ it++) {
Field *f = (GModel::current()->getFields()->get(*it));
if(f && *it != id) {
- if (f->isotropic())
- v = std::min(v, (*f) (x, y, z, ge));
- else{
- SMetric3 ff;
- (*f) (x, y, z, ff, ge);
- fullMatrix<double> V(3,3);
- fullVector<double> S(3);
- ff.eig(V, S, 1);
- v = std::min(v, sqrt(1./S(2))); //S(2) is largest eigenvalue
- }
+ if(f->isotropic())
+ v = std::min(v, (*f)(x, y, z, ge));
+ else {
+ SMetric3 ff;
+ (*f)(x, y, z, ff, ge);
+ fullMatrix<double> V(3, 3);
+ fullVector<double> S(3);
+ ff.eig(V, S, 1);
+ v = std::min(v, sqrt(1. / S(2))); // S(2) is largest eigenvalue
+ }
}
}
return v;
}
- const char *getName()
- {
- return "Min";
- }
+ const char *getName() { return "Min"; }
};
-class MaxField : public Field
-{
+class MaxField : public Field {
std::list<int> idlist;
- public:
+
+public:
MaxField()
{
- options["FieldsList"] = new FieldOptionList
- (idlist, "Field indices", &update_needed);
+ options["FieldsList"] =
+ new FieldOptionList(idlist, "Field indices", &update_needed);
}
std::string getDescription()
{
return "Take the maximum value of a list of fields.";
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
double v = -MAX_LC;
- for(std::list<int>::iterator it = idlist.begin(); it != idlist.end(); it++) {
+ for(std::list<int>::iterator it = idlist.begin(); it != idlist.end();
+ it++) {
Field *f = (GModel::current()->getFields()->get(*it));
if(f && *it != id) {
- if (f->isotropic())
- v = std::max(v, (*f) (x, y, z, ge));
- else{
- SMetric3 ff;
- (*f) (x, y, z, ff, ge);
- fullMatrix<double> V(3,3);
- fullVector<double> S(3);
- ff.eig(V, S, 1);
- v = std::max(v, sqrt(1./S(0))); //S(0) is smallest eigenvalue
- }
+ if(f->isotropic())
+ v = std::max(v, (*f)(x, y, z, ge));
+ else {
+ SMetric3 ff;
+ (*f)(x, y, z, ff, ge);
+ fullMatrix<double> V(3, 3);
+ fullVector<double> S(3);
+ ff.eig(V, S, 1);
+ v = std::max(v, sqrt(1. / S(0))); // S(0) is smallest eigenvalue
+ }
}
}
return v;
}
- const char *getName()
- {
- return "Max";
- }
+ const char *getName() { return "Max"; }
};
-class RestrictField : public Field
-{
+class RestrictField : public Field {
int iField;
std::list<int> vertices, edges, faces, regions;
- public:
+
+public:
RestrictField()
{
iField = 1;
@@ -1810,38 +1752,36 @@ class RestrictField : public Field
std::string getDescription()
{
return "Restrict the application of a field to a given list of geometrical "
- "points, curves, surfaces or volumes.";
+ "points, curves, surfaces or volumes.";
}
using Field::operator();
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
Field *f = (GModel::current()->getFields()->get(iField));
if(!f || iField == id) return MAX_LC;
- if(!ge) return (*f) (x, y, z);
- if((ge->dim() == 0 && std::find
- (vertices.begin(), vertices.end(), ge->tag()) != vertices.end()) ||
- (ge->dim() == 1 && std::find
- (edges.begin(), edges.end(), ge->tag()) != edges.end()) ||
- (ge->dim() == 2 && std::find
- (faces.begin(), faces.end(), ge->tag()) != faces.end()) ||
- (ge->dim() == 3 && std::find
- (regions.begin(), regions.end(), ge->tag()) != regions.end()))
- return (*f) (x, y, z);
+ if(!ge) return (*f)(x, y, z);
+ if((ge->dim() == 0 && std::find(vertices.begin(), vertices.end(),
+ ge->tag()) != vertices.end()) ||
+ (ge->dim() == 1 &&
+ std::find(edges.begin(), edges.end(), ge->tag()) != edges.end()) ||
+ (ge->dim() == 2 &&
+ std::find(faces.begin(), faces.end(), ge->tag()) != faces.end()) ||
+ (ge->dim() == 3 &&
+ std::find(regions.begin(), regions.end(), ge->tag()) != regions.end()))
+ return (*f)(x, y, z);
return MAX_LC;
}
- const char *getName()
- {
- return "Restrict";
- }
+ const char *getName() { return "Restrict"; }
};
#if defined(HAVE_ANN)
-struct AttractorInfo{
- AttractorInfo (int a=0, int b=0, double c=0, double d=0)
- : ent(a),dim(b),u(c),v(d) {
+struct AttractorInfo {
+ AttractorInfo(int a = 0, int b = 0, double c = 0, double d = 0)
+ : ent(a), dim(b), u(c), v(d)
+ {
}
- int ent,dim;
- double u,v;
+ int ent, dim;
+ double u, v;
};
class AttractorAnisoCurveField : public Field {
@@ -1853,7 +1793,8 @@ class AttractorAnisoCurveField : public Field {
double dMin, dMax, lMinTangent, lMaxTangent, lMinNormal, lMaxNormal;
int n_nodes_by_edge;
std::vector<SVector3> tg;
- public:
+
+public:
AttractorAnisoCurveField() : kdtree(0), zeronodes(0)
{
index = new ANNidx[1];
@@ -1866,46 +1807,50 @@ class AttractorAnisoCurveField : public Field {
lMinTangent = 0.5;
lMaxNormal = 0.5;
lMaxTangent = 0.5;
- options["EdgesList"] = new FieldOptionList
- (edges_id, "Indices of curves in the geometric model", &update_needed);
- options["NNodesByEdge"] = new FieldOptionInt
- (n_nodes_by_edge, "Number of nodes used to discretized each curve",
- &update_needed);
- options["dMin"] = new FieldOptionDouble
- (dMin, "Minimum distance, below this distance from the curves, "
- "prescribe the minimum mesh sizes.");
- options["dMax"] = new FieldOptionDouble
- (dMax, "Maxmium distance, above this distance from the curves, prescribe "
- "the maximum mesh sizes.");
- options["lMinTangent"] = new FieldOptionDouble
- (lMinTangent, "Minimum mesh size in the direction tangeant to the closest curve.");
- options["lMaxTangent"] = new FieldOptionDouble
- (lMaxTangent, "Maximum mesh size in the direction tangeant to the closest curve.");
- options["lMinNormal"] = new FieldOptionDouble
- (lMinNormal, "Minimum mesh size in the direction normal to the closest curve.");
- options["lMaxNormal"] = new FieldOptionDouble
- (lMaxNormal, "Maximum mesh size in the direction normal to the closest curve.");
+ options["EdgesList"] = new FieldOptionList(
+ edges_id, "Indices of curves in the geometric model", &update_needed);
+ options["NNodesByEdge"] = new FieldOptionInt(
+ n_nodes_by_edge, "Number of nodes used to discretized each curve",
+ &update_needed);
+ options["dMin"] = new FieldOptionDouble(
+ dMin, "Minimum distance, below this distance from the curves, "
+ "prescribe the minimum mesh sizes.");
+ options["dMax"] = new FieldOptionDouble(
+ dMax, "Maxmium distance, above this distance from the curves, prescribe "
+ "the maximum mesh sizes.");
+ options["lMinTangent"] = new FieldOptionDouble(
+ lMinTangent,
+ "Minimum mesh size in the direction tangeant to the closest curve.");
+ options["lMaxTangent"] = new FieldOptionDouble(
+ lMaxTangent,
+ "Maximum mesh size in the direction tangeant to the closest curve.");
+ options["lMinNormal"] = new FieldOptionDouble(
+ lMinNormal,
+ "Minimum mesh size in the direction normal to the closest curve.");
+ options["lMaxNormal"] = new FieldOptionDouble(
+ lMaxNormal,
+ "Maximum mesh size in the direction normal to the closest curve.");
// make sure all internal GEO CAD data has been synced with GModel
GModel::current()->getGEOInternals()->synchronize(GModel::current());
}
- virtual bool isotropic () const {return false;}
+ virtual bool isotropic() const { return false; }
~AttractorAnisoCurveField()
{
if(kdtree) delete kdtree;
if(zeronodes) annDeallocPts(zeronodes);
- delete[]index;
- delete[]dist;
- }
- const char *getName()
- {
- return "AttractorAnisoCurve";
+ delete[] index;
+ delete[] dist;
}
+ const char *getName() { return "AttractorAnisoCurve"; }
std::string getDescription()
{
- return "Compute the distance from the nearest curve in a list. Then the mesh "
- "size can be specified independently in the direction normal to the curve "
+ return "Compute the distance from the nearest curve in a list. Then the "
+ "mesh "
+ "size can be specified independently in the direction normal to the "
+ "curve "
"and in the direction parallel to the curve (Each curve "
- "is replaced by NNodesByEdge equidistant nodes and the distance from those "
+ "is replaced by NNodesByEdge equidistant nodes and the distance "
+ "from those "
"nodes is computed.)";
}
void update()
@@ -1915,13 +1860,13 @@ class AttractorAnisoCurveField : public Field {
delete kdtree;
}
int totpoints = n_nodes_by_edge * edges_id.size();
- if(totpoints){
+ if(totpoints) {
zeronodes = annAllocPts(totpoints, 3);
}
tg.resize(totpoints);
int k = 0;
- for(std::list<int>::iterator it = edges_id.begin();
- it != edges_id.end(); ++it) {
+ for(std::list<int>::iterator it = edges_id.begin(); it != edges_id.end();
+ ++it) {
GEdge *e = GModel::current()->getEdgeByTag(*it);
if(e) {
for(int i = 1; i < n_nodes_by_edge - 1; i++) {
@@ -1942,31 +1887,34 @@ class AttractorAnisoCurveField : public Field {
kdtree = new ANNkd_tree(zeronodes, totpoints, 3);
update_needed = false;
}
- void operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge=0)
+ void operator()(double x, double y, double z, SMetric3 &metr, GEntity *ge = 0)
{
- if(update_needed)
- update();
- double xyz[3] = { x, y, z };
+ if(update_needed) update();
+ double xyz[3] = {x, y, z};
#if defined(_OPENMP)
#pragma omp critical
#endif
kdtree->annkSearch(xyz, 1, index, dist);
double d = sqrt(dist[0]);
- double lTg = d < dMin ? lMinTangent : d > dMax ? lMaxTangent :
- lMinTangent + (lMaxTangent - lMinTangent) * (d - dMin) / (dMax - dMin);
- double lN = d < dMin ? lMinNormal : d > dMax ? lMaxNormal :
- lMinNormal + (lMaxNormal - lMinNormal) * (d - dMin) / (dMax - dMin);
+ double lTg = d < dMin ?
+ lMinTangent :
+ d > dMax ? lMaxTangent :
+ lMinTangent + (lMaxTangent - lMinTangent) *
+ (d - dMin) / (dMax - dMin);
+ double lN = d < dMin ? lMinNormal :
+ d > dMax ? lMaxNormal :
+ lMinNormal + (lMaxNormal - lMinNormal) *
+ (d - dMin) / (dMax - dMin);
SVector3 t = tg[index[0]];
- SVector3 n0 = crossprod(t, fabs(t(0)) > fabs(t(1)) ? SVector3(0,1,0) :
- SVector3(1,0,0));
+ SVector3 n0 = crossprod(t, fabs(t(0)) > fabs(t(1)) ? SVector3(0, 1, 0) :
+ SVector3(1, 0, 0));
SVector3 n1 = crossprod(t, n0);
- metr = SMetric3(1/lTg/lTg, 1/lN/lN, 1/lN/lN, t, n0, n1);
+ metr = SMetric3(1 / lTg / lTg, 1 / lN / lN, 1 / lN / lN, t, n0, n1);
}
- virtual double operator() (double X, double Y, double Z, GEntity *ge=0)
+ virtual double operator()(double X, double Y, double Z, GEntity *ge = 0)
{
- if(update_needed)
- update();
- double xyz[3] = { X, Y, Z };
+ if(update_needed) update();
+ double xyz[3] = {X, Y, Z};
#if defined(_OPENMP)
#pragma omp critical
#endif
@@ -1976,8 +1924,7 @@ class AttractorAnisoCurveField : public Field {
}
};
-class AttractorField : public Field
-{
+class AttractorField : public Field {
ANNkd_tree *kdtree;
ANNpointArray zeronodes;
std::list<int> nodes_id, edges_id, faces_id;
@@ -1987,15 +1934,19 @@ class AttractorField : public Field
int n_nodes_by_edge;
ANNidxArray index;
ANNdistArray dist;
+
public:
AttractorField(int dim, int tag, int nbe)
: kdtree(0), zeronodes(0), n_nodes_by_edge(nbe)
{
index = new ANNidx[1];
dist = new ANNdist[1];
- if (dim == 0) nodes_id.push_back(tag);
- else if (dim == 1) edges_id.push_back(tag);
- else if (dim == 2) faces_id.push_back(tag);
+ if(dim == 0)
+ nodes_id.push_back(tag);
+ else if(dim == 1)
+ edges_id.push_back(tag);
+ else if(dim == 2)
+ faces_id.push_back(tag);
_xField = _yField = _zField = NULL;
_xFieldId = _yFieldId = _zFieldId = -1;
update_needed = true;
@@ -2005,63 +1956,72 @@ public:
index = new ANNidx[1];
dist = new ANNdist[1];
n_nodes_by_edge = 20;
- options["NodesList"] = new FieldOptionList
- (nodes_id, "Indices of nodes in the geometric model", &update_needed);
- options["EdgesList"] = new FieldOptionList
- (edges_id, "Indices of curves in the geometric model", &update_needed);
- options["NNodesByEdge"] = new FieldOptionInt
- (n_nodes_by_edge, "Number of nodes used to discretized each curve",
- &update_needed);
- options["FacesList"] = new FieldOptionList
- (faces_id, "Indices of surfaces in the geometric model (Warning, this feature "
- "is still experimental. It might (read: will probably) give wrong results "
- "for complex surfaces)", &update_needed);
+ options["NodesList"] = new FieldOptionList(
+ nodes_id, "Indices of nodes in the geometric model", &update_needed);
+ options["EdgesList"] = new FieldOptionList(
+ edges_id, "Indices of curves in the geometric model", &update_needed);
+ options["NNodesByEdge"] = new FieldOptionInt(
+ n_nodes_by_edge, "Number of nodes used to discretized each curve",
+ &update_needed);
+ options["FacesList"] = new FieldOptionList(
+ faces_id,
+ "Indices of surfaces in the geometric model (Warning, this feature "
+ "is still experimental. It might (read: will probably) give wrong "
+ "results "
+ "for complex surfaces)",
+ &update_needed);
_xFieldId = _yFieldId = _zFieldId = -1;
- options["FieldX"] = new FieldOptionInt
- (_xFieldId, "Id of the field to use as x coordinate.", &update_needed);
- options["FieldY"] = new FieldOptionInt
- (_yFieldId, "Id of the field to use as y coordinate.", &update_needed);
- options["FieldZ"] = new FieldOptionInt
- (_zFieldId, "Id of the field to use as z coordinate.", &update_needed);
+ options["FieldX"] = new FieldOptionInt(
+ _xFieldId, "Id of the field to use as x coordinate.", &update_needed);
+ options["FieldY"] = new FieldOptionInt(
+ _yFieldId, "Id of the field to use as y coordinate.", &update_needed);
+ options["FieldZ"] = new FieldOptionInt(
+ _zFieldId, "Id of the field to use as z coordinate.", &update_needed);
}
~AttractorField()
{
- delete[]index;
- delete[]dist;
+ delete[] index;
+ delete[] dist;
if(kdtree) delete kdtree;
if(zeronodes) annDeallocPts(zeronodes);
}
- const char *getName()
- {
- return "Attractor";
- }
+ const char *getName() { return "Attractor"; }
std::string getDescription()
{
return "Compute the distance from the nearest node in a list. It can also "
- "be used to compute the distance from curves, in which case each curve "
- "is replaced by NNodesByEdge equidistant nodes and the distance from those "
- "nodes is computed.";
+ "be used to compute the distance from curves, in which case each "
+ "curve "
+ "is replaced by NNodesByEdge equidistant nodes and the distance "
+ "from those "
+ "nodes is computed.";
}
- void getCoord(double x, double y, double z, double &cx, double &cy, double &cz,
- GEntity *ge = NULL)
+ void getCoord(double x, double y, double z, double &cx, double &cy,
+ double &cz, GEntity *ge = NULL)
{
- cx = _xField ? (*_xField)(x, y, z, ge) : x;
- cy = _yField ? (*_yField)(x, y, z, ge) : y;
- cz = _zField ? (*_zField)(x, y, z, ge) : z;
+ cx = _xField ? (*_xField)(x, y, z, ge) : x;
+ cy = _yField ? (*_yField)(x, y, z, ge) : y;
+ cz = _zField ? (*_zField)(x, y, z, ge) : z;
}
- std::pair<AttractorInfo,SPoint3> getAttractorInfo() const
+ std::pair<AttractorInfo, SPoint3> getAttractorInfo() const
{
return std::make_pair(_infos[index[0]], SPoint3(zeronodes[index[0]][0],
- zeronodes[index[0]][1],
- zeronodes[index[0]][2]));
+ zeronodes[index[0]][1],
+ zeronodes[index[0]][2]));
}
- void update() {
+ void update()
+ {
if(update_needed) {
// printf("updating\n");
- _xField = _xFieldId >= 0 ? (GModel::current()->getFields()->get(_xFieldId)) : NULL;
- _yField = _yFieldId >= 0 ? (GModel::current()->getFields()->get(_yFieldId)) : NULL;
- _zField = _zFieldId >= 0 ? (GModel::current()->getFields()->get(_zFieldId)) : NULL;
+ _xField = _xFieldId >= 0 ?
+ (GModel::current()->getFields()->get(_xFieldId)) :
+ NULL;
+ _yField = _yFieldId >= 0 ?
+ (GModel::current()->getFields()->get(_yFieldId)) :
+ NULL;
+ _zField = _zFieldId >= 0 ?
+ (GModel::current()->getFields()->get(_zFieldId)) :
+ NULL;
if(zeronodes) {
annDeallocPts(zeronodes);
delete kdtree;
@@ -2071,67 +2031,67 @@ public:
std::vector<SPoint2> uvpoints;
std::vector<int> offset;
offset.push_back(0);
- for(std::list<int>::iterator it = faces_id.begin();
- it != faces_id.end(); ++it) {
- GFace *f = GModel::current()->getFaceByTag(*it);
- if (f){
- if (f->mesh_vertices.size()){
- for (unsigned int i = 0; i < f->mesh_vertices.size(); i++){
- MVertex *v = f->mesh_vertices[i];
- double uu, vv;
- v->getParameter(0,uu);
- v->getParameter(1,vv);
- points.push_back(SPoint3(v->x(), v->y(), v->z()));
- uvpoints.push_back(SPoint2(uu, vv));
- }
- }
- else {
- SBoundingBox3d bb = f->bounds();
- SVector3 dd = bb.max() - bb.min();
- double maxDist = dd.norm() / n_nodes_by_edge ;
- f->fillPointCloud(maxDist, &points, &uvpoints);
- offset.push_back(points.size());
- }
- }
+ for(std::list<int>::iterator it = faces_id.begin(); it != faces_id.end();
+ ++it) {
+ GFace *f = GModel::current()->getFaceByTag(*it);
+ if(f) {
+ if(f->mesh_vertices.size()) {
+ for(unsigned int i = 0; i < f->mesh_vertices.size(); i++) {
+ MVertex *v = f->mesh_vertices[i];
+ double uu, vv;
+ v->getParameter(0, uu);
+ v->getParameter(1, vv);
+ points.push_back(SPoint3(v->x(), v->y(), v->z()));
+ uvpoints.push_back(SPoint2(uu, vv));
+ }
+ }
+ else {
+ SBoundingBox3d bb = f->bounds();
+ SVector3 dd = bb.max() - bb.min();
+ double maxDist = dd.norm() / n_nodes_by_edge;
+ f->fillPointCloud(maxDist, &points, &uvpoints);
+ offset.push_back(points.size());
+ }
+ }
}
double x, y, z;
std::vector<double> px, py, pz;
- for(std::list<int>::iterator it = nodes_id.begin();
- it != nodes_id.end(); ++it) {
- GVertex *gv = GModel::current()->getVertexByTag(*it);
- if(gv) {
- getCoord(gv->x(), gv->y(), gv->z(), x, y, z, gv);
+ for(std::list<int>::iterator it = nodes_id.begin(); it != nodes_id.end();
+ ++it) {
+ GVertex *gv = GModel::current()->getVertexByTag(*it);
+ if(gv) {
+ getCoord(gv->x(), gv->y(), gv->z(), x, y, z, gv);
px.push_back(x);
py.push_back(y);
pz.push_back(z);
- _infos.push_back(AttractorInfo(*it, 0, 0, 0));
+ _infos.push_back(AttractorInfo(*it, 0, 0, 0));
}
}
- for(std::list<int>::iterator it = edges_id.begin();
- it != edges_id.end(); ++it) {
- GEdge *e = GModel::current()->getEdgeByTag(*it);
- if(e) {
- if (e->mesh_vertices.size()){
- for(unsigned int i = 0; i < e->mesh_vertices.size(); i++) {
- double u ;
+ for(std::list<int>::iterator it = edges_id.begin(); it != edges_id.end();
+ ++it) {
+ GEdge *e = GModel::current()->getEdgeByTag(*it);
+ if(e) {
+ if(e->mesh_vertices.size()) {
+ for(unsigned int i = 0; i < e->mesh_vertices.size(); i++) {
+ double u;
e->mesh_vertices[i]->getParameter(0, u);
- GPoint gp = e->point(u);
- getCoord(gp.x(), gp.y(), gp.z(), x, y, z, e);
+ GPoint gp = e->point(u);
+ getCoord(gp.x(), gp.y(), gp.z(), x, y, z, e);
px.push_back(x);
py.push_back(y);
pz.push_back(z);
- _infos.push_back(AttractorInfo(*it, 1, u, 0));
- }
- }
- int NNN = n_nodes_by_edge - e->mesh_vertices.size();
- for(int i = 1; i < NNN - 1; i++) {
- double u = (double)i / (NNN - 1);
- Range<double> b = e->parBounds(0);
- double t = b.low() + u * (b.high() - b.low());
- GPoint gp = e->point(t);
- getCoord(gp.x(), gp.y(), gp.z(), x, y, z, e);
+ _infos.push_back(AttractorInfo(*it, 1, u, 0));
+ }
+ }
+ int NNN = n_nodes_by_edge - e->mesh_vertices.size();
+ for(int i = 1; i < NNN - 1; i++) {
+ double u = (double)i / (NNN - 1);
+ Range<double> b = e->parBounds(0);
+ double t = b.low() + u * (b.high() - b.low());
+ GPoint gp = e->point(t);
+ getCoord(gp.x(), gp.y(), gp.z(), x, y, z, e);
px.push_back(x);
py.push_back(y);
pz.push_back(z);
@@ -2142,46 +2102,47 @@ public:
// This can lead to weird results as we generate attractors over the whole
// parametric plane (we should really use a mesh, e.g. a refined STL.)
int count = 0;
- for(std::list<int>::iterator it = faces_id.begin();
- it != faces_id.end(); ++it) {
- GFace *f = GModel::current()->getFaceByTag(*it);
- if(f) {
- if (points.size()){
- for(int j = offset[count]; j < offset[count + 1]; j++) {
- px.push_back(points[j].x());
- py.push_back(points[j].y());
- pz.push_back(points[j].z());
- _infos.push_back(AttractorInfo(*it, 2, uvpoints[j].x(), uvpoints[j].y()));
- }
- count++;
- }
-
- else{
- for(int i = 0; i < n_nodes_by_edge; i++) {
- for(int j = 0; j < n_nodes_by_edge; j++) {
- double u = (double)i / (n_nodes_by_edge - 1);
- double v = (double)j / (n_nodes_by_edge - 1);
- Range<double> b1 = f->parBounds(0);
- Range<double> b2 = f->parBounds(1);
- double t1 = b1.low() + u * (b1.high() - b1.low());
- double t2 = b2.low() + v * (b2.high() - b2.low());
- GPoint gp = f->point(t1, t2);
- getCoord(gp.x(), gp.y(), gp.z(), x, y, z, f);
+ for(std::list<int>::iterator it = faces_id.begin(); it != faces_id.end();
+ ++it) {
+ GFace *f = GModel::current()->getFaceByTag(*it);
+ if(f) {
+ if(points.size()) {
+ for(int j = offset[count]; j < offset[count + 1]; j++) {
+ px.push_back(points[j].x());
+ py.push_back(points[j].y());
+ pz.push_back(points[j].z());
+ _infos.push_back(
+ AttractorInfo(*it, 2, uvpoints[j].x(), uvpoints[j].y()));
+ }
+ count++;
+ }
+
+ else {
+ for(int i = 0; i < n_nodes_by_edge; i++) {
+ for(int j = 0; j < n_nodes_by_edge; j++) {
+ double u = (double)i / (n_nodes_by_edge - 1);
+ double v = (double)j / (n_nodes_by_edge - 1);
+ Range<double> b1 = f->parBounds(0);
+ Range<double> b2 = f->parBounds(1);
+ double t1 = b1.low() + u * (b1.high() - b1.low());
+ double t2 = b2.low() + v * (b2.high() - b2.low());
+ GPoint gp = f->point(t1, t2);
+ getCoord(gp.x(), gp.y(), gp.z(), x, y, z, f);
px.push_back(x);
py.push_back(y);
pz.push_back(z);
- _infos.push_back(AttractorInfo(*it, 2, u, v));
- }
- }
- }
- }
- else {
+ _infos.push_back(AttractorInfo(*it, 2, u, v));
+ }
+ }
+ }
+ }
+ else {
Msg::Error("Face %d not yet created", *it);
- }
+ }
}
int totpoints = px.size();
- if(!totpoints){ // for backward compatibility
+ if(!totpoints) { // for backward compatibility
totpoints = 1;
px.push_back(0.);
py.push_back(0.);
@@ -2189,7 +2150,7 @@ public:
}
zeronodes = annAllocPts(totpoints, 3);
- for(int i = 0; i < totpoints; i++){
+ for(int i = 0; i < totpoints; i++) {
zeronodes[i][0] = px[i];
zeronodes[i][1] = py[i];
zeronodes[i][2] = pz[i];
@@ -2200,7 +2161,7 @@ public:
}
using Field::operator();
- virtual double operator() (double X, double Y, double Z, GEntity *ge=0)
+ virtual double operator()(double X, double Y, double Z, GEntity *ge = 0)
{
#if defined(_OPENMP)
#pragma omp critical
@@ -2222,18 +2183,21 @@ class OctreeField : public Field {
class Cell {
void *_data;
bool _isleaf;
- public:
- double evaluate(double x, double y, double z) const {
- if (_isleaf)
- return *(double*)_data;
- Cell *sub = (Cell*)_data;
+
+ public:
+ double evaluate(double x, double y, double z) const
+ {
+ if(_isleaf) return *(double *)_data;
+ Cell *sub = (Cell *)_data;
int i = x > 0.5 ? 1 : 0;
int j = y > 0.5 ? 1 : 0;
int k = z > 0.5 ? 1 : 0;
- return sub[i*4+j*2+k].evaluate(2*x-i, 2*y-j, 2*z-k);
+ return sub[i * 4 + j * 2 + k].evaluate(2 * x - i, 2 * y - j, 2 * z - k);
}
Cell(){};
- void init(double x0, double y0, double z0, double l, Field &field, int level) {
+ void init(double x0, double y0, double z0, double l, Field &field,
+ int level)
+ {
#if 0
double v[8] = {
field(x0,y0,z0),field(x0,y0,z0+l),field(x0,y0+l,z0),field(x0,y0+l,z0+l),
@@ -2248,131 +2212,131 @@ class OctreeField : public Field {
}
#else
double dmax = 0;
- double vc = field(x0+l/2,y0+l/2,z0+l/2);
+ double vc = field(x0 + l / 2, y0 + l / 2, z0 + l / 2);
double vmin = vc;
bool split = level > 0;
- if (level > -4) {
+ if(level > -4) {
#define NSAMPLE 2
- double dl = l/NSAMPLE;
- for (int i = 0; i <= NSAMPLE; ++i){
- for (int j = 0; j <= NSAMPLE; ++j){
- for (int k = 0; k <= NSAMPLE; ++k){
- double w = field(x0 + i*dl, y0+j*dl, z0+k*dl);
- dmax = std::max(dmax, std::abs(vc-w));
+ double dl = l / NSAMPLE;
+ for(int i = 0; i <= NSAMPLE; ++i) {
+ for(int j = 0; j <= NSAMPLE; ++j) {
+ for(int k = 0; k <= NSAMPLE; ++k) {
+ double w = field(x0 + i * dl, y0 + j * dl, z0 + k * dl);
+ dmax = std::max(dmax, std::abs(vc - w));
vmin = std::min(vmin, w);
- split |= (dmax/vmin > 0.2 && vmin < l);
- if(split)
- break;
+ split |= (dmax / vmin > 0.2 && vmin < l);
+ if(split) break;
}
}
}
#endif
- }
- if (split) {
- _isleaf = false;
- Cell *sub = new Cell[8];
- double l2 = l/2;
- sub[0].init(x0, y0, z0, l2, field, level-1);
- sub[1].init(x0, y0, z0+l2, l2, field, level-1);
- sub[2].init(x0, y0+l2, z0, l2, field, level-1);
- sub[3].init(x0, y0+l2, z0+l2, l2, field, level-1);
- sub[4].init(x0+l2, y0, z0, l2, field, level-1);
- sub[5].init(x0+l2, y0, z0+l2, l2, field, level-1);
- sub[6].init(x0+l2, y0+l2, z0, l2, field, level-1);
- sub[7].init(x0+l2, y0+l2, z0+l2, l2, field, level-1);
- _data = (void*)sub;
- }
- else {
- _isleaf = true;
- _data = (void*)new double;
- *(double*)_data = vc;
- }
}
- ~Cell() {
- if (_isleaf) {
- delete (double*)_data;
- }
- else {
- Cell *sub = (Cell*)_data;
- delete []sub;
- }
+ if(split) {
+ _isleaf = false;
+ Cell *sub = new Cell[8];
+ double l2 = l / 2;
+ sub[0].init(x0, y0, z0, l2, field, level - 1);
+ sub[1].init(x0, y0, z0 + l2, l2, field, level - 1);
+ sub[2].init(x0, y0 + l2, z0, l2, field, level - 1);
+ sub[3].init(x0, y0 + l2, z0 + l2, l2, field, level - 1);
+ sub[4].init(x0 + l2, y0, z0, l2, field, level - 1);
+ sub[5].init(x0 + l2, y0, z0 + l2, l2, field, level - 1);
+ sub[6].init(x0 + l2, y0 + l2, z0, l2, field, level - 1);
+ sub[7].init(x0 + l2, y0 + l2, z0 + l2, l2, field, level - 1);
+ _data = (void *)sub;
}
- void print(double x0, double y0, double z0, double l, FILE *f) {
- if (_isleaf) {
- fprintf(f, "SP(%g, %g, %g) {%g};\n", x0+l/2, y0+l/2, z0+l/2, *(double*)_data);
- }
- else {
- Cell *sub = (Cell*)_data;
- double l2 = l/2;
- sub[0].print(x0, y0, z0, l2, f);
- sub[1].print(x0, y0, z0+l2, l2, f);
- sub[2].print(x0, y0+l2, z0, l2, f);
- sub[3].print(x0, y0+l2, z0+l2, l2, f);
- sub[4].print(x0+l2, y0, z0, l2, f);
- sub[5].print(x0+l2, y0, z0+l2, l2, f);
- sub[6].print(x0+l2, y0+l2, z0, l2, f);
- sub[7].print(x0+l2, y0+l2, z0+l2, l2, f);
- }
+ else {
+ _isleaf = true;
+ _data = (void *)new double;
+ *(double *)_data = vc;
}
- };
- Cell *_root;
- int _inFieldId;
- Field *_inField;
- SBoundingBox3d bounds;
- double _l0;
- public:
- OctreeField()
- {
- options["InField"] = new FieldOptionInt
- (_inFieldId, "Id of the field to use as x coordinate.", &update_needed);
- _root = NULL;
- }
- ~OctreeField()
+ } ~Cell()
{
- if (_root)
- delete _root;
- }
- const char *getName()
- {
- return "Octree";
- }
- std::string getDescription()
- {
- return "Pre compute another field on an octree to speed-up evalution";
- }
- void update(){
- if(update_needed) {
- update_needed = false;
- if (_root) {
- delete _root;
- _root = NULL;
- }
+ if(_isleaf) {
+ delete(double *)_data;
}
- if(!_root) {
- _inField = _inFieldId >= 0 ? (GModel::current()->getFields()->get(_inFieldId)) : NULL;
- if (!_inField)
- return;
- GModel::current()->getFields()->get(_inFieldId)->update();
- bounds = GModel::current()->bounds();
- _root = new Cell;
- SVector3 d = bounds.max() - bounds.min();
- _l0 = std::max(std::max(d.x(), d.y()), d.z());
- _root->init(bounds.min().x(), bounds.min().y(), bounds.min().z(), _l0, *_inField, 4);
+ else {
+ Cell *sub = (Cell *)_data;
+ delete[] sub;
}
}
- using Field::operator();
- virtual double operator() (double X, double Y, double Z, GEntity *ge=0)
+ void print(double x0, double y0, double z0, double l, FILE *f)
{
- SPoint3 xmin = bounds.min();
- SVector3 d = bounds.max() - xmin;
- return _root->evaluate((X-xmin.x())/_l0,(Y-xmin.y())/_l0,(Z-xmin.z())/_l0);
+ if(_isleaf) {
+ fprintf(f, "SP(%g, %g, %g) {%g};\n", x0 + l / 2, y0 + l / 2, z0 + l / 2,
+ *(double *)_data);
+ }
+ else {
+ Cell *sub = (Cell *)_data;
+ double l2 = l / 2;
+ sub[0].print(x0, y0, z0, l2, f);
+ sub[1].print(x0, y0, z0 + l2, l2, f);
+ sub[2].print(x0, y0 + l2, z0, l2, f);
+ sub[3].print(x0, y0 + l2, z0 + l2, l2, f);
+ sub[4].print(x0 + l2, y0, z0, l2, f);
+ sub[5].print(x0 + l2, y0, z0 + l2, l2, f);
+ sub[6].print(x0 + l2, y0 + l2, z0, l2, f);
+ sub[7].print(x0 + l2, y0 + l2, z0 + l2, l2, f);
+ }
}
};
+Cell *_root;
+int _inFieldId;
+Field *_inField;
+SBoundingBox3d bounds;
+double _l0;
-const char *BoundaryLayerField::getName()
+public:
+OctreeField()
{
- return "BoundaryLayer";
+ options["InField"] = new FieldOptionInt(
+ _inFieldId, "Id of the field to use as x coordinate.", &update_needed);
+ _root = NULL;
}
+~OctreeField()
+{
+ if(_root) delete _root;
+}
+const char *getName() { return "Octree"; }
+std::string getDescription()
+{
+ return "Pre compute another field on an octree to speed-up evalution";
+}
+void update()
+{
+ if(update_needed) {
+ update_needed = false;
+ if(_root) {
+ delete _root;
+ _root = NULL;
+ }
+ }
+ if(!_root) {
+ _inField = _inFieldId >= 0 ?
+ (GModel::current()->getFields()->get(_inFieldId)) :
+ NULL;
+ if(!_inField) return;
+ GModel::current()->getFields()->get(_inFieldId)->update();
+ bounds = GModel::current()->bounds();
+ _root = new Cell;
+ SVector3 d = bounds.max() - bounds.min();
+ _l0 = std::max(std::max(d.x(), d.y()), d.z());
+ _root->init(bounds.min().x(), bounds.min().y(), bounds.min().z(), _l0,
+ *_inField, 4);
+ }
+}
+using Field::operator();
+virtual double operator()(double X, double Y, double Z, GEntity *ge = 0)
+{
+ SPoint3 xmin = bounds.min();
+ SVector3 d = bounds.max() - xmin;
+ return _root->evaluate((X - xmin.x()) / _l0, (Y - xmin.y()) / _l0,
+ (Z - xmin.z()) / _l0);
+}
+}
+;
+
+const char *BoundaryLayerField::getName() { return "BoundaryLayer"; }
std::string BoundaryLayerField::getDescription()
{
@@ -2389,44 +2353,53 @@ BoundaryLayerField::BoundaryLayerField()
tgt_aniso_ratio = 1.e10;
iRecombine = 0;
iIntersect = 0;
- options["EdgesList"] = new FieldOptionList
- (edges_id, "Indices of curves in the geometric model for which a boundary "
- "layer is needed", &update_needed);
- options["FanNodesList"] = new FieldOptionList
- (fan_nodes_id, "Indices of vertices in the geometric model for which a fan "
- "is created", &update_needed);
- options["NodesList"] = new FieldOptionList
- (nodes_id, "Indices of vertices in the geometric model for which a BL "
- "ends", &update_needed);
- options["Quads"] = new FieldOptionInt
- (iRecombine, "Generate recombined elements in the boundary layer");
- options["IntersectMetrics"] = new FieldOptionInt
- (iIntersect, "Intersect metrics of all faces");
- options["hwall_n"] = new FieldOptionDouble
- (hwall_n, "Mesh Size Normal to the The Wall");
- options["hwall_n_nodes"] = new FieldOptionListDouble
- (hwall_n_nodes, "Mesh Size Normal to the The Wall at nodes (overwrite hwall_n when defined)");
- options["AnisoMax"] = new FieldOptionDouble
- (tgt_aniso_ratio, "Threshold angle for creating a mesh fan in the boundary layer");
- options["ratio"] = new FieldOptionDouble
- (ratio, "Size Ratio Between Two Successive Layers");
- options["hfar"] = new FieldOptionDouble
- (hfar, "Element size far from the wall");
- options["thickness"] = new FieldOptionDouble
- (thickness, "Maximal thickness of the boundary layer");
+ options["EdgesList"] = new FieldOptionList(
+ edges_id,
+ "Indices of curves in the geometric model for which a boundary "
+ "layer is needed",
+ &update_needed);
+ options["FanNodesList"] = new FieldOptionList(
+ fan_nodes_id,
+ "Indices of vertices in the geometric model for which a fan "
+ "is created",
+ &update_needed);
+ options["NodesList"] = new FieldOptionList(
+ nodes_id,
+ "Indices of vertices in the geometric model for which a BL "
+ "ends",
+ &update_needed);
+ options["Quads"] = new FieldOptionInt(
+ iRecombine, "Generate recombined elements in the boundary layer");
+ options["IntersectMetrics"] =
+ new FieldOptionInt(iIntersect, "Intersect metrics of all faces");
+ options["hwall_n"] =
+ new FieldOptionDouble(hwall_n, "Mesh Size Normal to the The Wall");
+ options["hwall_n_nodes"] = new FieldOptionListDouble(
+ hwall_n_nodes, "Mesh Size Normal to the The Wall at nodes (overwrite "
+ "hwall_n when defined)");
+ options["AnisoMax"] = new FieldOptionDouble(
+ tgt_aniso_ratio,
+ "Threshold angle for creating a mesh fan in the boundary layer");
+ options["ratio"] =
+ new FieldOptionDouble(ratio, "Size Ratio Between Two Successive Layers");
+ options["hfar"] =
+ new FieldOptionDouble(hfar, "Element size far from the wall");
+ options["thickness"] =
+ new FieldOptionDouble(thickness, "Maximal thickness of the boundary layer");
}
void BoundaryLayerField::removeAttractors()
{
- for (std::list<AttractorField *>::iterator it = _att_fields.begin();
- it != _att_fields.end() ; ++it) delete *it;
+ for(std::list<AttractorField *>::iterator it = _att_fields.begin();
+ it != _att_fields.end(); ++it)
+ delete *it;
_att_fields.clear();
update_needed = true;
}
void BoundaryLayerField::setupFor1d(int iE)
{
- if (edges_id_saved.empty() ){
+ if(edges_id_saved.empty()) {
edges_id_saved = edges_id;
nodes_id_saved = nodes_id;
}
@@ -2435,18 +2408,18 @@ void BoundaryLayerField::setupFor1d(int iE)
edges_id.clear();
bool found = std::find(edges_id_saved.begin(), edges_id_saved.end(), iE) !=
- edges_id_saved.end();
+ edges_id_saved.end();
- if (!found) {
+ if(!found) {
GEdge *ge = GModel::current()->getEdgeByTag(iE);
GVertex *gv0 = ge->getBeginVertex();
- found = std::find(nodes_id_saved.begin(), nodes_id_saved.end(), gv0->tag()) !=
- nodes_id_saved.end();
- if (found)nodes_id.push_back(gv0->tag());
+ found = std::find(nodes_id_saved.begin(), nodes_id_saved.end(),
+ gv0->tag()) != nodes_id_saved.end();
+ if(found) nodes_id.push_back(gv0->tag());
GVertex *gv1 = ge->getEndVertex();
- found = std::find(nodes_id_saved.begin(), nodes_id_saved.end(), gv1->tag()) !=
- nodes_id_saved.end();
- if (found)nodes_id.push_back(gv1->tag());
+ found = std::find(nodes_id_saved.begin(), nodes_id_saved.end(),
+ gv1->tag()) != nodes_id_saved.end();
+ if(found) nodes_id.push_back(gv1->tag());
}
// printf("edge %d %d nodes added\n",iE,nodes_id.size());
// getchar();
@@ -2456,7 +2429,7 @@ void BoundaryLayerField::setupFor1d(int iE)
void BoundaryLayerField::setupFor2d(int iF)
{
// remove GFaces from the attractors (only used in 2D) for edges and vertices
- if (edges_id_saved.empty()){
+ if(edges_id_saved.empty()) {
edges_id_saved = edges_id;
nodes_id_saved = nodes_id;
}
@@ -2470,74 +2443,77 @@ void BoundaryLayerField::setupFor2d(int iF)
// OR (better) CHANGE THE PHILOSOPHY
GFace *gf = GModel::current()->getFaceByTag(iF);
- std::vector<GEdge*> ed = gf->edges();
- std::vector<GEdge*> const& embedded_edges = gf->embeddedEdges();
+ std::vector<GEdge *> ed = gf->edges();
+ std::vector<GEdge *> const &embedded_edges = gf->embeddedEdges();
ed.insert(ed.begin(), embedded_edges.begin(), embedded_edges.end());
- for (std::vector<GEdge*>::iterator it = ed.begin(); it != ed.end() ; ++it){
+ for(std::vector<GEdge *>::iterator it = ed.begin(); it != ed.end(); ++it) {
bool isIn = false;
int iE = (*it)->tag();
bool found = std::find(edges_id_saved.begin(), edges_id_saved.end(), iE) !=
- edges_id_saved.end();
+ edges_id_saved.end();
// this edge is a BL Edge
- if (found){
- std::vector<GFace*> fc = (*it)->faces();
+ if(found) {
+ std::vector<GFace *> fc = (*it)->faces();
int numf = 0;
- for(std::vector<GFace*>::iterator it = fc.begin(); it != fc.end(); it++){
+ for(std::vector<GFace *>::iterator it = fc.begin(); it != fc.end();
+ it++) {
if((*it)->meshAttributes.extrude &&
- (*it)->meshAttributes.extrude->geo.Mode == EXTRUDED_ENTITY){
+ (*it)->meshAttributes.extrude->geo.Mode == EXTRUDED_ENTITY) {
// ok
}
- else{
+ else {
numf++;
}
}
// one only face, or other faces are extruded --> 2D --> BL
- if (numf <= 1) isIn = true;
+ if(numf <= 1)
+ isIn = true;
else {
- Msg::Error ("Only 2D Boundary Layers are supported (edge %d is adjacet to %d faces",
- iE, fc.size());
+ Msg::Error("Only 2D Boundary Layers are supported (edge %d is adjacet "
+ "to %d faces",
+ iE, fc.size());
}
}
- if (isIn){
+ if(isIn) {
edges_id.push_back(iE);
- nodes_id.push_back ((*it)->getBeginVertex()->tag());
- nodes_id.push_back ((*it)->getEndVertex()->tag());
+ nodes_id.push_back((*it)->getBeginVertex()->tag());
+ nodes_id.push_back((*it)->getEndVertex()->tag());
}
}
removeAttractors();
}
-double BoundaryLayerField::operator() (double x, double y, double z, GEntity *ge)
+double BoundaryLayerField::operator()(double x, double y, double z, GEntity *ge)
{
- if (update_needed){
- for(std::list<int>::iterator it = nodes_id.begin();
- it != nodes_id.end(); ++it) {
- _att_fields.push_back(new AttractorField(0,*it,100000));
+ if(update_needed) {
+ for(std::list<int>::iterator it = nodes_id.begin(); it != nodes_id.end();
+ ++it) {
+ _att_fields.push_back(new AttractorField(0, *it, 100000));
}
- for(std::list<int>::iterator it = edges_id.begin();
- it != edges_id.end(); ++it) {
- _att_fields.push_back(new AttractorField(1,*it,300000));
+ for(std::list<int>::iterator it = edges_id.begin(); it != edges_id.end();
+ ++it) {
+ _att_fields.push_back(new AttractorField(1, *it, 300000));
}
update_needed = false;
}
double dist = 1.e22;
- if (_att_fields.empty())return dist;
- for (std::list<AttractorField*>::iterator it = _att_fields.begin();
- it != _att_fields.end(); ++it){
- double cdist = (*(*it)) (x, y, z);
- if (cdist < dist){
+ if(_att_fields.empty()) return dist;
+ for(std::list<AttractorField *>::iterator it = _att_fields.begin();
+ it != _att_fields.end(); ++it) {
+ double cdist = (*(*it))(x, y, z);
+ if(cdist < dist) {
dist = cdist;
}
}
- if (dist > thickness*ratio) return 1.e22;
+ if(dist > thickness * ratio) return 1.e22;
current_distance = dist;
// const double dist = (*field) (x, y, z);
// current_distance = dist;
- double lc = dist*(ratio-1) + hwall_n;
+ double lc = dist * (ratio - 1) + hwall_n;
// double lc = hwall_n;
return std::min(hfar, lc);
@@ -2549,16 +2525,15 @@ void BoundaryLayerField::computeFor1dMesh(double x, double y, double z,
{
double xpk = 0., ypk = 0., zpk = 0.;
double distk = 1.e22;
- for(std::list<int>::iterator it = nodes_id.begin();
- it != nodes_id.end(); ++it) {
+ for(std::list<int>::iterator it = nodes_id.begin(); it != nodes_id.end();
+ ++it) {
GVertex *v = GModel::current()->getVertexByTag(*it);
double xp = v->x();
double yp = v->y();
double zp = v->z();
- const double dist = sqrt ((x - xp) *(x - xp)+
- (y - yp) *(y - yp)+
- (z - zp) *(z - zp));
- if (dist < distk){
+ const double dist =
+ sqrt((x - xp) * (x - xp) + (y - yp) * (y - yp) + (z - zp) * (z - zp));
+ if(dist < distk) {
distk = dist;
xpk = xp;
ypk = yp;
@@ -2566,21 +2541,21 @@ void BoundaryLayerField::computeFor1dMesh(double x, double y, double z,
}
}
- const double ll1 = (distk*(ratio-1) + hwall_n) / (1. + 0.5 * (ratio - 1));
+ const double ll1 = (distk * (ratio - 1) + hwall_n) / (1. + 0.5 * (ratio - 1));
// const double ll1 = (distk*(ratio-1) + hwall_n) / (1.);
- double lc_n = std::min(ll1,hfar);
+ double lc_n = std::min(ll1, hfar);
- if (distk > thickness) lc_n = hfar;
+ if(distk > thickness) lc_n = hfar;
lc_n = std::max(lc_n, CTX::instance()->mesh.lcMin);
lc_n = std::min(lc_n, CTX::instance()->mesh.lcMax);
- SVector3 t1= SVector3(x-xpk,y-ypk,z-zpk);
+ SVector3 t1 = SVector3(x - xpk, y - ypk, z - zpk);
t1.normalize();
- metr = buildMetricTangentToCurve(t1,lc_n,lc_n);
+ metr = buildMetricTangentToCurve(t1, lc_n, lc_n);
}
-void BoundaryLayerField::operator() (AttractorField *cc, double dist,
- double x, double y, double z,
- SMetric3 &metr, GEntity *ge)
+void BoundaryLayerField::operator()(AttractorField *cc, double dist, double x,
+ double y, double z, SMetric3 &metr,
+ GEntity *ge)
{
// dist = hwall -> lc = hwall * ratio
// dist = hwall (1+ratio) -> lc = hwall ratio ^ 2
@@ -2592,38 +2567,40 @@ void BoundaryLayerField::operator() (AttractorField *cc, double dist,
// (dist/hwall)*(ratio-1) + 1 = ratio^{m}
// lc = dist*(ratio-1) + hwall
- const double ll1 = dist*(ratio-1) + hwall_n;
- double lc_n = std::min(ll1,hfar);
- double lc_t = std::min(lc_n*CTX::instance()->mesh.anisoMax, hfar);
+ const double ll1 = dist * (ratio - 1) + hwall_n;
+ double lc_n = std::min(ll1, hfar);
+ double lc_t = std::min(lc_n * CTX::instance()->mesh.anisoMax, hfar);
lc_n = std::max(lc_n, CTX::instance()->mesh.lcMin);
lc_n = std::min(lc_n, CTX::instance()->mesh.lcMax);
lc_t = std::max(lc_t, CTX::instance()->mesh.lcMin);
lc_t = std::min(lc_t, CTX::instance()->mesh.lcMax);
- std::pair<AttractorInfo,SPoint3> pp = cc->getAttractorInfo();
+ std::pair<AttractorInfo, SPoint3> pp = cc->getAttractorInfo();
double beta = CTX::instance()->mesh.smoothRatio;
- if (pp.first.dim ==0){
+ if(pp.first.dim == 0) {
GVertex *v = GModel::current()->getVertexByTag(pp.first.ent);
SVector3 t1;
- if (dist < thickness){
- t1 = SVector3(1,0,0);
+ if(dist < thickness) {
+ t1 = SVector3(1, 0, 0);
}
else {
- t1 = SVector3(v->x() -x,v->y() -y,v->z() -z);
+ t1 = SVector3(v->x() - x, v->y() - y, v->z() - z);
}
- metr = buildMetricTangentToCurve(t1,lc_n,lc_n);
+ metr = buildMetricTangentToCurve(t1, lc_n, lc_n);
return;
}
- else if (pp.first.dim ==1){
+ else if(pp.first.dim == 1) {
GEdge *e = GModel::current()->getEdgeByTag(pp.first.ent);
- if (dist < thickness){
+ if(dist < thickness) {
SVector3 t1 = e->firstDer(pp.first.u);
double crv = e->curvature(pp.first.u);
const double b = lc_t;
const double h = lc_n;
- double oneOverD2 = .5/(b * b) *
- (1. + sqrt (1. + (4. * crv * crv * b * b * b * b / (h * h * beta * beta))));
+ double oneOverD2 =
+ .5 / (b * b) *
+ (1. +
+ sqrt(1. + (4. * crv * crv * b * b * b * b / (h * h * beta * beta))));
metr = buildMetricTangentToCurve(t1, sqrt(1. / oneOverD2), lc_n);
return;
}
@@ -2636,17 +2613,21 @@ void BoundaryLayerField::operator() (AttractorField *cc, double dist,
}
else {
GFace *gf = GModel::current()->getFaceByTag(pp.first.ent);
- if (dist < thickness){
+ if(dist < thickness) {
double cmin, cmax;
SVector3 dirMax, dirMin;
- cmax = gf->curvatures(SPoint2(pp.first.u, pp.first.v),
- dirMax, dirMin, cmax, cmin);
+ cmax = gf->curvatures(SPoint2(pp.first.u, pp.first.v), dirMax, dirMin,
+ cmax, cmin);
const double b = lc_t;
const double h = lc_n;
- double oneOverD2_min = .5/(b * b) *
- (1. + sqrt(1. + (4. * cmin * cmin * b * b * b * b / (h * h * beta * beta))));
- double oneOverD2_max = .5/(b * b) *
- (1. + sqrt(1. + (4. * cmax * cmax * b * b * b * b / (h * h * beta * beta))));
+ double oneOverD2_min =
+ .5 / (b * b) *
+ (1. +
+ sqrt(1. + (4. * cmin * cmin * b * b * b * b / (h * h * beta * beta))));
+ double oneOverD2_max =
+ .5 / (b * b) *
+ (1. +
+ sqrt(1. + (4. * cmax * cmax * b * b * b * b / (h * h * beta * beta))));
double dmin = sqrt(1. / oneOverD2_min);
double dmax = sqrt(1. / oneOverD2_max);
dmin = std::min(dmin, dmax * tgt_aniso_ratio);
@@ -2654,25 +2635,25 @@ void BoundaryLayerField::operator() (AttractorField *cc, double dist,
return;
}
else {
- GPoint p = gf->point(SPoint2(pp.first.u,pp.first.v));
- SVector3 t2 = SVector3(p.x() -x,p.y() -y,p.z() -z);
- metr = buildMetricTangentToCurve(t2,lc_n,lc_t);
+ GPoint p = gf->point(SPoint2(pp.first.u, pp.first.v));
+ SVector3 t2 = SVector3(p.x() - x, p.y() - y, p.z() - z);
+ metr = buildMetricTangentToCurve(t2, lc_n, lc_t);
return;
}
}
}
-void BoundaryLayerField::operator() (double x, double y, double z,
- SMetric3 &metr, GEntity *ge)
+void BoundaryLayerField::operator()(double x, double y, double z,
+ SMetric3 &metr, GEntity *ge)
{
- if (update_needed){
- for(std::list<int>::iterator it = nodes_id.begin();
- it != nodes_id.end(); ++it) {
- _att_fields.push_back(new AttractorField(0,*it,100000));
+ if(update_needed) {
+ for(std::list<int>::iterator it = nodes_id.begin(); it != nodes_id.end();
+ ++it) {
+ _att_fields.push_back(new AttractorField(0, *it, 100000));
}
- for(std::list<int>::iterator it = edges_id.begin();
- it != edges_id.end(); ++it) {
- _att_fields.push_back(new AttractorField(1,*it,10000));
+ for(std::list<int>::iterator it = edges_id.begin(); it != edges_id.end();
+ ++it) {
+ _att_fields.push_back(new AttractorField(1, *it, 10000));
}
update_needed = false;
}
@@ -2680,40 +2661,40 @@ void BoundaryLayerField::operator() (double x, double y, double z,
current_distance = 1.e22;
current_closest = 0;
std::vector<SMetric3> hop;
- SMetric3 v (1./(CTX::instance()->mesh.lcMax*CTX::instance()->mesh.lcMax));
+ SMetric3 v(1. / (CTX::instance()->mesh.lcMax * CTX::instance()->mesh.lcMax));
hop.push_back(v);
- for (std::list<AttractorField*>::iterator it = _att_fields.begin();
- it != _att_fields.end(); ++it){
- double cdist = (*(*it)) (x, y, z);
- AttractorInfo ainfo= (*it)->getAttractorInfo().first;
- SPoint3 CLOSEST= (*it)->getAttractorInfo().second;
+ for(std::list<AttractorField *>::iterator it = _att_fields.begin();
+ it != _att_fields.end(); ++it) {
+ double cdist = (*(*it))(x, y, z);
+ AttractorInfo ainfo = (*it)->getAttractorInfo().first;
+ SPoint3 CLOSEST = (*it)->getAttractorInfo().second;
bool doNotConsider = false;
- if (ge->dim () == ainfo.dim && ge->tag() == ainfo.ent){
+ if(ge->dim() == ainfo.dim && ge->tag() == ainfo.ent) {
// doNotConsider = true;
}
- else if (ge->dim () == 1 && ainfo.dim == 2){
+ else if(ge->dim() == 1 && ainfo.dim == 2) {
// GFace *gf = ge->model()->getFaceByTag(ainfo.ent);
// if (gf->containsEdge(ge->tag())) doNotConsider = true;
}
- if (!doNotConsider) {
+ if(!doNotConsider) {
SMetric3 localMetric;
- if (iIntersect){
- (*this)(*it, cdist,x, y, z, localMetric, ge);
- hop.push_back(localMetric);
+ if(iIntersect) {
+ (*this)(*it, cdist, x, y, z, localMetric, ge);
+ hop.push_back(localMetric);
}
- if (cdist < current_distance){
- if (!iIntersect)(*this)(*it, cdist,x, y, z, localMetric, ge);
- current_distance = cdist;
- current_closest = *it;
- v = localMetric;
- _closest_point = CLOSEST;
+ if(cdist < current_distance) {
+ if(!iIntersect) (*this)(*it, cdist, x, y, z, localMetric, ge);
+ current_distance = cdist;
+ current_closest = *it;
+ v = localMetric;
+ _closest_point = CLOSEST;
}
}
}
- if (iIntersect)
- for (unsigned int i = 0; i < hop.size(); i++)
+ if(iIntersect)
+ for(unsigned int i = 0; i < hop.size(); i++)
v = intersection_conserveM1(v, hop[i]);
metr = v;
}
@@ -2724,35 +2705,32 @@ void BoundaryLayerField::operator() (double x, double y, double z,
using namespace nanoflann;
// This is an exampleof a custom data set class
-struct PointCloud
-{
- std::vector<SPoint3> pts;
+struct PointCloud {
+ std::vector<SPoint3> pts;
};
// And this is the "dataset to kd-tree" adaptor class:
-template <typename Derived>
-struct PointCloudAdaptor
-{
-
+template <typename Derived> struct PointCloudAdaptor {
const Derived &obj; //!< A const ref to the data set origin
// The constructor that sets the data set source
- PointCloudAdaptor(const Derived &obj_) : obj(obj_) { }
+ PointCloudAdaptor(const Derived &obj_) : obj(obj_) {}
// CRTP helper method
- inline const Derived& derived() const { return obj; }
+ inline const Derived &derived() const { return obj; }
// Must return the number of data points
inline size_t kdtree_get_point_count() const { return derived().pts.size(); }
// Returns the distance between the vector "p1[0:size-1]" and the data point
// with index "idx_p2" stored in the class:
- inline double kdtree_distance(const double *p1, const size_t idx_p2,size_t /*size*/) const
+ inline double kdtree_distance(const double *p1, const size_t idx_p2,
+ size_t /*size*/) const
{
- const double d0=p1[0]-derived().pts[idx_p2].x();
- const double d1=p1[1]-derived().pts[idx_p2].y();
- const double d2=p1[2]-derived().pts[idx_p2].z();
- return d0*d0+d1*d1+d2*d2;
+ const double d0 = p1[0] - derived().pts[idx_p2].x();
+ const double d1 = p1[1] - derived().pts[idx_p2].y();
+ const double d2 = p1[2] - derived().pts[idx_p2].z();
+ return d0 * d0 + d1 * d1 + d2 * d2;
}
// Returns the dim'th component of the idx'th point in the class: Since this
@@ -2760,9 +2738,12 @@ struct PointCloudAdaptor
// "if/else's" are actually solved at compile time.
inline double kdtree_get_pt(const size_t idx, int dim) const
{
- if (dim==0) return derived().pts[idx].x();
- else if (dim==1) return derived().pts[idx].y();
- else return derived().pts[idx].z();
+ if(dim == 0)
+ return derived().pts[idx].x();
+ else if(dim == 1)
+ return derived().pts[idx].y();
+ else
+ return derived().pts[idx].z();
}
// Optional bounding-box computation: return false to default to a standard
@@ -2770,19 +2751,19 @@ struct PointCloudAdaptor
// class and returned in "bb" so it can be avoided to redo it again. Look at
// bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point
// clouds)
- template <class BBOX>
- bool kdtree_get_bbox(BBOX& /*bb*/) const { return false; }
+ template <class BBOX> bool kdtree_get_bbox(BBOX & /*bb*/) const
+ {
+ return false;
+ }
}; // end of PointCloudAdaptor
typedef PointCloudAdaptor<PointCloud> PC2KD;
-typedef KDTreeSingleIndexAdaptor<
- L2_Simple_Adaptor<double, PC2KD > ,
- PC2KD, 3 > my_kd_tree_t;
+typedef KDTreeSingleIndexAdaptor<L2_Simple_Adaptor<double, PC2KD>, PC2KD, 3>
+ my_kd_tree_t;
-class DistanceField : public Field
-{
+class DistanceField : public Field {
std::list<int> nodes_id, edges_id, faces_id;
int _xFieldId, _yFieldId, _zFieldId;
Field *_xField, *_yField, *_zField;
@@ -2790,117 +2771,126 @@ class DistanceField : public Field
PointCloud P;
my_kd_tree_t *index;
PC2KD pc2kd;
+
public:
- DistanceField() : index(NULL) , pc2kd(P)
+ DistanceField() : index(NULL), pc2kd(P)
{
n_nodes_by_edge = 20;
- options["NodesList"] = new FieldOptionList
- (nodes_id, "Indices of nodes in the geometric model", &update_needed);
- options["EdgesList"] = new FieldOptionList
- (edges_id, "Indices of curves in the geometric model", &update_needed);
- options["NNodesByEdge"] = new FieldOptionInt
- (n_nodes_by_edge, "Number of nodes used to discretized each curve",
- &update_needed);
- options["FacesList"] = new FieldOptionList
- (faces_id, "Indices of surfaces in the geometric model (Warning, this feature "
- "is still experimental. It might (read: will probably) give wrong results "
- "for complex surfaces)", &update_needed);
+ options["NodesList"] = new FieldOptionList(
+ nodes_id, "Indices of nodes in the geometric model", &update_needed);
+ options["EdgesList"] = new FieldOptionList(
+ edges_id, "Indices of curves in the geometric model", &update_needed);
+ options["NNodesByEdge"] = new FieldOptionInt(
+ n_nodes_by_edge, "Number of nodes used to discretized each curve",
+ &update_needed);
+ options["FacesList"] = new FieldOptionList(
+ faces_id,
+ "Indices of surfaces in the geometric model (Warning, this feature "
+ "is still experimental. It might (read: will probably) give wrong "
+ "results "
+ "for complex surfaces)",
+ &update_needed);
_xFieldId = _yFieldId = _zFieldId = -1;
- options["FieldX"] = new FieldOptionInt
- (_xFieldId, "Id of the field to use as x coordinate.", &update_needed);
- options["FieldY"] = new FieldOptionInt
- (_yFieldId, "Id of the field to use as y coordinate.", &update_needed);
- options["FieldZ"] = new FieldOptionInt
- (_zFieldId, "Id of the field to use as z coordinate.", &update_needed);
+ options["FieldX"] = new FieldOptionInt(
+ _xFieldId, "Id of the field to use as x coordinate.", &update_needed);
+ options["FieldY"] = new FieldOptionInt(
+ _yFieldId, "Id of the field to use as y coordinate.", &update_needed);
+ options["FieldZ"] = new FieldOptionInt(
+ _zFieldId, "Id of the field to use as z coordinate.", &update_needed);
}
~DistanceField()
{
- if (index) delete index;
- }
- const char *getName()
- {
- return "DistanceField";
+ if(index) delete index;
}
+ const char *getName() { return "DistanceField"; }
std::string getDescription()
{
return "Compute the distance from the nearest node in a list. It can also "
- "be used to compute the distance from curves, in which case each curve "
- "is replaced by NNodesByEdge equidistant nodes and the distance from those "
- "nodes is computed.";
+ "be used to compute the distance from curves, in which case each "
+ "curve "
+ "is replaced by NNodesByEdge equidistant nodes and the distance "
+ "from those "
+ "nodes is computed.";
}
void update()
{
if(update_needed) {
- _xField = _xFieldId >= 0 ? (GModel::current()->getFields()->get(_xFieldId)) : NULL;
- _yField = _yFieldId >= 0 ? (GModel::current()->getFields()->get(_yFieldId)) : NULL;
- _zField = _zFieldId >= 0 ? (GModel::current()->getFields()->get(_zFieldId)) : NULL;
+ _xField = _xFieldId >= 0 ?
+ (GModel::current()->getFields()->get(_xFieldId)) :
+ NULL;
+ _yField = _yFieldId >= 0 ?
+ (GModel::current()->getFields()->get(_yFieldId)) :
+ NULL;
+ _zField = _zFieldId >= 0 ?
+ (GModel::current()->getFields()->get(_zFieldId)) :
+ NULL;
std::vector<SPoint3> &points = P.pts;
- for(std::list<int>::iterator it = faces_id.begin();
- it != faces_id.end(); ++it) {
- GFace *f = GModel::current()->getFaceByTag(*it);
- if (f){
- if (f->mesh_vertices.size()){
- for (unsigned int i = 0; i < f->mesh_vertices.size(); i++){
- MVertex *v = f->mesh_vertices[i];
- points.push_back(SPoint3(v->x(), v->y(), v->z()));
- }
- }
- else {
- SBoundingBox3d bb = f->bounds();
- SVector3 dd = bb.max() - bb.min();
- double maxDist = dd.norm() / n_nodes_by_edge ;
- std::vector<SPoint2> uvpoints;
- f->fillPointCloud(maxDist, &points, &uvpoints);
- }
- }
+ for(std::list<int>::iterator it = faces_id.begin(); it != faces_id.end();
+ ++it) {
+ GFace *f = GModel::current()->getFaceByTag(*it);
+ if(f) {
+ if(f->mesh_vertices.size()) {
+ for(unsigned int i = 0; i < f->mesh_vertices.size(); i++) {
+ MVertex *v = f->mesh_vertices[i];
+ points.push_back(SPoint3(v->x(), v->y(), v->z()));
+ }
+ }
+ else {
+ SBoundingBox3d bb = f->bounds();
+ SVector3 dd = bb.max() - bb.min();
+ double maxDist = dd.norm() / n_nodes_by_edge;
+ std::vector<SPoint2> uvpoints;
+ f->fillPointCloud(maxDist, &points, &uvpoints);
+ }
+ }
}
- for(std::list<int>::iterator it = nodes_id.begin();
- it != nodes_id.end(); ++it) {
- GVertex *gv = GModel::current()->getVertexByTag(*it);
- if(gv) points.push_back(SPoint3(gv->x(), gv->y(), gv->z()));
+ for(std::list<int>::iterator it = nodes_id.begin(); it != nodes_id.end();
+ ++it) {
+ GVertex *gv = GModel::current()->getVertexByTag(*it);
+ if(gv) points.push_back(SPoint3(gv->x(), gv->y(), gv->z()));
}
- for(std::list<int>::iterator it = edges_id.begin();
- it != edges_id.end(); ++it) {
- GEdge *e = GModel::current()->getEdgeByTag(*it);
- if(e) {
- if (e->mesh_vertices.size()){
- for(unsigned int i = 0; i < e->mesh_vertices.size(); i++)
+ for(std::list<int>::iterator it = edges_id.begin(); it != edges_id.end();
+ ++it) {
+ GEdge *e = GModel::current()->getEdgeByTag(*it);
+ if(e) {
+ if(e->mesh_vertices.size()) {
+ for(unsigned int i = 0; i < e->mesh_vertices.size(); i++)
points.push_back(SPoint3(e->mesh_vertices[i]->x(),
- e->mesh_vertices[i]->y(),
- e->mesh_vertices[i]->z()));
- }
- int NNN = n_nodes_by_edge - e->mesh_vertices.size();
- for(int i = 1; i < NNN - 1; i++) {
- double u = (double)i / (NNN - 1);
- Range<double> b = e->parBounds(0);
- double t = b.low() + u * (b.high() - b.low());
- GPoint gp = e->point(t);
- points.push_back(SPoint3(gp.x(),gp.y(),gp.z()));
- }
- }
+ e->mesh_vertices[i]->y(),
+ e->mesh_vertices[i]->z()));
+ }
+ int NNN = n_nodes_by_edge - e->mesh_vertices.size();
+ for(int i = 1; i < NNN - 1; i++) {
+ double u = (double)i / (NNN - 1);
+ Range<double> b = e->parBounds(0);
+ double t = b.low() + u * (b.high() - b.low());
+ GPoint gp = e->point(t);
+ points.push_back(SPoint3(gp.x(), gp.y(), gp.z()));
+ }
+ }
}
// construct a kd-tree index:
- index = new my_kd_tree_t(3 , pc2kd, KDTreeSingleIndexAdaptorParams(10) );
+ index = new my_kd_tree_t(3, pc2kd, KDTreeSingleIndexAdaptorParams(10));
index->buildIndex();
- update_needed=false;
+ update_needed = false;
}
}
using Field::operator();
- virtual double operator() (double X, double Y, double Z, GEntity *ge=0)
+ virtual double operator()(double X, double Y, double Z, GEntity *ge = 0)
{
- double query_pt[3] = {X,Y,Z};
+ double query_pt[3] = {X, Y, Z};
const size_t num_results = 1;
size_t ret_index;
double out_dist_sqr;
nanoflann::KNNResultSet<double> resultSet(num_results);
- resultSet.init(&ret_index, &out_dist_sqr );
+ resultSet.init(&ret_index, &out_dist_sqr);
index->findNeighbors(resultSet, &query_pt[0], nanoflann::SearchParams(10));
- return sqrt (out_dist_sqr);
+ return sqrt(out_dist_sqr);
}
};
@@ -2938,27 +2928,29 @@ FieldManager::FieldManager()
map_type_name["MathEvalAniso"] = new FieldFactoryT<MathEvalFieldAniso>();
#if defined(HAVE_ANN)
map_type_name["Attractor"] = new FieldFactoryT<AttractorField>();
- map_type_name["AttractorAnisoCurve"] = new FieldFactoryT<AttractorAnisoCurveField>();
+ map_type_name["AttractorAnisoCurve"] =
+ new FieldFactoryT<AttractorAnisoCurveField>();
#endif
map_type_name["MaxEigenHessian"] = new FieldFactoryT<MaxEigenHessianField>();
_background_field = -1;
}
-void FieldManager::initialize(){
- std::map<int,Field*> :: iterator it = begin();
- for (; it != end() ; ++it) it->second->update();
+void FieldManager::initialize()
+{
+ std::map<int, Field *>::iterator it = begin();
+ for(; it != end(); ++it) it->second->update();
}
FieldManager::~FieldManager()
{
- for(std::map<std::string, FieldFactory*>::iterator it = map_type_name.begin();
+ for(std::map<std::string, FieldFactory *>::iterator it =
+ map_type_name.begin();
it != map_type_name.end(); it++)
delete it->second;
- for (FieldManager::iterator it = begin(); it != end(); it++)
- delete it->second;
+ for(FieldManager::iterator it = begin(); it != end(); it++) delete it->second;
}
-void FieldManager::setBackgroundField(Field* BGF)
+void FieldManager::setBackgroundField(Field *BGF)
{
int id = newId();
(*this)[id] = BGF;
@@ -2968,15 +2960,15 @@ void FieldManager::setBackgroundField(Field* BGF)
void Field::putOnNewView()
{
#if defined(HAVE_POST)
- if(GModel::current()->getMeshStatus() < 1){
+ if(GModel::current()->getMeshStatus() < 1) {
Msg::Error("No mesh available to create the view: please mesh your model!");
return;
}
std::map<int, std::vector<double> > d;
- std::vector<GEntity*> entities;
+ std::vector<GEntity *> entities;
GModel::current()->getEntities(entities);
- for(unsigned int i = 0; i < entities.size(); i++){
- for(unsigned int j = 0; j < entities[i]->mesh_vertices.size(); j++){
+ for(unsigned int i = 0; i < entities.size(); i++) {
+ for(unsigned int j = 0; j < entities[i]->mesh_vertices.size(); j++) {
MVertex *v = entities[i]->mesh_vertices[j];
d[v->getNum()].push_back((*this)(v->x(), v->y(), v->z(), entities[i]));
}
@@ -2992,10 +2984,10 @@ void Field::putOnNewView()
void Field::putOnView(PView *view, int comp)
{
PViewData *data = view->getData();
- for(int ent = 0; ent < data->getNumEntities(0); ent++){
- for(int ele = 0; ele < data->getNumElements(0, ent); ele++){
+ for(int ent = 0; ent < data->getNumEntities(0); ent++) {
+ for(int ele = 0; ele < data->getNumElements(0, ent); ele++) {
if(data->skipElement(0, ent, ele)) continue;
- for(int nod = 0; nod < data->getNumNodes(0, ent, ele); nod++){
+ for(int nod = 0; nod < data->getNumNodes(0, ent, ele); nod++) {
double x, y, z;
data->getNode(0, ent, ele, nod, x, y, z);
double val = (*this)(x, y, z);
@@ -3026,18 +3018,19 @@ GenericField::GenericField(){};
GenericField::~GenericField(){};
-double GenericField::operator() (double x, double y, double z, GEntity *ge)
+double GenericField::operator()(double x, double y, double z, GEntity *ge)
{
std::vector<double> sizes(cbs.size());
std::vector<ptrfunction>::iterator itcbs = cbs.begin();
- std::vector<void*>::iterator itdata = user_data.begin();
- for (std::vector<double>::iterator it = sizes.begin();it!=sizes.end();it++,itdata++,itcbs++){
- bool ok = (*itcbs)(x,y,z,(*itdata),(*it));
- if (!ok){
+ std::vector<void *>::iterator itdata = user_data.begin();
+ for(std::vector<double>::iterator it = sizes.begin(); it != sizes.end();
+ it++, itdata++, itcbs++) {
+ bool ok = (*itcbs)(x, y, z, (*itdata), (*it));
+ if(!ok) {
Msg::Warning("GenericField::ERROR from callback ");
}
}
- return (*std::min_element(sizes.begin(),sizes.end()));
+ return (*std::min_element(sizes.begin(), sizes.end()));
}
void GenericField::setCallbackWithData(ptrfunction fct, void *data)
diff --git a/Mesh/Field.h b/Mesh/Field.h
index 0e1619bb0d2b86f110a19a128dc8f6e7cf35865c..be614fc3a758e6abb7012e52f889780065e3d20e 100644
--- a/Mesh/Field.h
+++ b/Mesh/Field.h
@@ -36,43 +36,48 @@ typedef enum {
} FieldOptionType;
class FieldCallback {
- private:
- std::string _help;
- public:
+private:
+ std::string _help;
+
+public:
virtual void run() = 0;
FieldCallback(const std::string &help) { _help = help; }
virtual ~FieldCallback(){};
- virtual std::string getDescription(){ return _help; }
+ virtual std::string getDescription() { return _help; }
};
class FieldOption {
- private:
+private:
std::string _help;
- protected:
+
+protected:
bool *status;
- inline void modified(){ if(status) *status = true; }
- public:
- FieldOption(const std::string &help, bool *_status)
- : _help(help)
- , status(_status)
- {
- }
- virtual ~FieldOption() {}
- virtual FieldOptionType getType() = 0;
- virtual void getTextRepresentation(std::string &v_str) = 0;
- virtual std::string getDescription() { return _help; }
- std::string getTypeName()
- {
- switch(getType()) {
- case FIELD_OPTION_INT: return "integer"; break;
- case FIELD_OPTION_DOUBLE: return "float"; break;
- case FIELD_OPTION_BOOL: return "boolean"; break;
- case FIELD_OPTION_PATH: return "path"; break;
- case FIELD_OPTION_STRING: return "string"; break;
- case FIELD_OPTION_LIST: return "list"; break;
- case FIELD_OPTION_LIST_DOUBLE: return "list_double"; break;
- default: return "unknown";
- }
+ inline void modified()
+ {
+ if(status) *status = true;
+ }
+
+public:
+ FieldOption(const std::string &help, bool *_status)
+ : _help(help), status(_status)
+ {
+ }
+ virtual ~FieldOption() {}
+ virtual FieldOptionType getType() = 0;
+ virtual void getTextRepresentation(std::string &v_str) = 0;
+ virtual std::string getDescription() { return _help; }
+ std::string getTypeName()
+ {
+ switch(getType()) {
+ case FIELD_OPTION_INT: return "integer"; break;
+ case FIELD_OPTION_DOUBLE: return "float"; break;
+ case FIELD_OPTION_BOOL: return "boolean"; break;
+ case FIELD_OPTION_PATH: return "path"; break;
+ case FIELD_OPTION_STRING: return "string"; break;
+ case FIELD_OPTION_LIST: return "list"; break;
+ case FIELD_OPTION_LIST_DOUBLE: return "list_double"; break;
+ default: return "unknown";
+ }
}
virtual void numericalValue(double val) {}
virtual double numericalValue() const { return 0.; }
@@ -86,47 +91,51 @@ class FieldOption {
static std::list<double> l;
return l;
}
- virtual void list(std::list<int> value) { }
- virtual void listdouble(std::list<double> value) { }
+ virtual void list(std::list<int> value) {}
+ virtual void listdouble(std::list<double> value) {}
virtual std::string string() const { return ""; }
- virtual void string(const std::string value) { }
+ virtual void string(const std::string value) {}
};
class Field {
- public:
+public:
Field() : update_needed(false) {}
virtual ~Field();
virtual void update() {}
int id;
std::map<std::string, FieldOption *> options;
- std::map<std::string, FieldCallback*> callbacks;
- virtual bool isotropic () const { return true; }
+ std::map<std::string, FieldCallback *> callbacks;
+ virtual bool isotropic() const { return true; }
// isotropic
- virtual double operator() (double x, double y, double z, GEntity *ge=0) = 0;
+ virtual double operator()(double x, double y, double z, GEntity *ge = 0) = 0;
// anisotropic
- virtual void operator() (double x, double y, double z, SMetric3 &, GEntity *ge=0){}
+ virtual void operator()(double x, double y, double z, SMetric3 &,
+ GEntity *ge = 0)
+ {
+ }
bool update_needed;
virtual const char *getName() = 0;
#if defined(HAVE_POST)
- void putOnView(PView * view, int comp = -1);
+ void putOnView(PView *view, int comp = -1);
#endif
void putOnNewView();
- virtual std::string getDescription(){ return ""; }
+ virtual std::string getDescription() { return ""; }
FieldOption *getOption(const std::string &optionName);
};
class FieldFactory {
- public:
+public:
virtual ~FieldFactory() {}
- virtual Field * operator() () = 0;
+ virtual Field *operator()() = 0;
};
-class FieldManager : public std::map<int, Field*> {
- private:
+class FieldManager : public std::map<int, Field *> {
+private:
int _background_field;
std::vector<int> _boundaryLayer_fields;
- public:
- std::map<std::string, FieldFactory*> map_type_name;
+
+public:
+ std::map<std::string, FieldFactory *> map_type_name;
void initialize();
void reset();
Field *get(int id);
@@ -139,23 +148,26 @@ class FieldManager : public std::map<int, Field*> {
// compatibility with -bgm
void setBackgroundMesh(int iView);
// set and get background field
- void setBackgroundField(Field* BGF);
- inline void setBackgroundFieldId(int id){_background_field = id;};
+ void setBackgroundField(Field *BGF);
+ inline void setBackgroundFieldId(int id) { _background_field = id; };
inline void addBoundaryLayerFieldId(int id)
{
- for (unsigned int i = 0; i < _boundaryLayer_fields.size(); ++i) {
- if (_boundaryLayer_fields[i] == id) return;
+ for(unsigned int i = 0; i < _boundaryLayer_fields.size(); ++i) {
+ if(_boundaryLayer_fields[i] == id) return;
}
_boundaryLayer_fields.push_back(id);
}
inline void addBoundaryLayerFieldId(std::vector<int> &tags)
{
- for (unsigned int i = 0; i < tags.size(); ++i)
+ for(unsigned int i = 0; i < tags.size(); ++i)
addBoundaryLayerFieldId(tags[i]);
}
- inline int getBackgroundField(){return _background_field;}
- inline int getNumBoundaryLayerFields() {return (int)_boundaryLayer_fields.size();}
- inline int getBoundaryLayerField(int i) {return _boundaryLayer_fields[i];}
+ inline int getBackgroundField() { return _background_field; }
+ inline int getNumBoundaryLayerFields()
+ {
+ return (int)_boundaryLayer_fields.size();
+ }
+ inline int getBoundaryLayerField(int i) { return _boundaryLayer_fields[i]; }
};
// Boundary Layer Field (used both for anisotropic meshing and BL
@@ -165,48 +177,54 @@ class FieldManager : public std::map<int, Field*> {
class AttractorField;
class BoundaryLayerField : public Field {
- private:
+private:
std::list<AttractorField *> _att_fields;
std::list<double> hwall_n_nodes;
std::list<int> nodes_id, edges_id;
std::list<int> edges_id_saved, nodes_id_saved, fan_nodes_id;
- void operator() (AttractorField *cc, double dist, double x, double y, double z,
- SMetric3 &metr, GEntity *ge);
- public:
- double hwall_n,ratio,hfar,thickness,fan_angle;
+ void operator()(AttractorField *cc, double dist, double x, double y, double z,
+ SMetric3 &metr, GEntity *ge);
+
+public:
+ double hwall_n, ratio, hfar, thickness, fan_angle;
double current_distance, tgt_aniso_ratio;
SPoint3 _closest_point;
int iRecombine, iIntersect;
AttractorField *current_closest;
- virtual bool isotropic () const {return false;}
+ virtual bool isotropic() const { return false; }
virtual const char *getName();
virtual std::string getDescription();
BoundaryLayerField();
- ~BoundaryLayerField() {removeAttractors();}
- virtual double operator() (double x, double y, double z, GEntity *ge=0);
- virtual void operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge=0);
- bool isEdgeBL (int iE) const
+ ~BoundaryLayerField() { removeAttractors(); }
+ virtual double operator()(double x, double y, double z, GEntity *ge = 0);
+ virtual void operator()(double x, double y, double z, SMetric3 &metr,
+ GEntity *ge = 0);
+ bool isEdgeBL(int iE) const
{
- return std::find(edges_id.begin(),edges_id.end(),iE) != edges_id.end();
+ return std::find(edges_id.begin(), edges_id.end(), iE) != edges_id.end();
}
- bool isEdgeBLSaved (int iE) const
+ bool isEdgeBLSaved(int iE) const
{
- return std::find(edges_id_saved.begin(),edges_id_saved.end(),iE)
- != edges_id_saved.end();
+ return std::find(edges_id_saved.begin(), edges_id_saved.end(), iE) !=
+ edges_id_saved.end();
}
- bool isFanNode (int iV) const
+ bool isFanNode(int iV) const
{
- return std::find(fan_nodes_id.begin(),fan_nodes_id.end(),iV) != fan_nodes_id.end();
+ return std::find(fan_nodes_id.begin(), fan_nodes_id.end(), iV) !=
+ fan_nodes_id.end();
}
- bool isEndNode (int iV) const
+ bool isEndNode(int iV) const
{
- return std::find(nodes_id.begin(),nodes_id.end(),iV) != nodes_id.end();
+ return std::find(nodes_id.begin(), nodes_id.end(), iV) != nodes_id.end();
}
- double hwall (int iV){
- for (std::list<double>::iterator it = hwall_n_nodes.begin(); it != hwall_n_nodes.end(); ++it){
- int i = (int) *it; ++it;
+ double hwall(int iV)
+ {
+ for(std::list<double>::iterator it = hwall_n_nodes.begin();
+ it != hwall_n_nodes.end(); ++it) {
+ int i = (int)*it;
+ ++it;
double h = *it;
- if (i == iV)return h;
+ if(i == iV) return h;
}
return hwall_n;
}
@@ -220,41 +238,49 @@ class BoundaryLayerField : public Field {
#else
class BoundaryLayerField : public Field {
- public:
+public:
virtual bool isotropic() const { return false; }
- virtual const char *getName(){ return ""; }
- virtual std::string getDescription(){ return ""; }
+ virtual const char *getName() { return ""; }
+ virtual std::string getDescription() { return ""; }
BoundaryLayerField()
{
Msg::Error("You must compile with ANN to use BoundaryLayerField");
}
~BoundaryLayerField() {}
- virtual double operator() (double x, double y, double z, GEntity *ge=0){ return 0.; }
- virtual void operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge=0){}
- bool isFaceBL (int iF) const {return false;}
- bool isEdgeBL (int iE) const {return false;}
- bool isFan (int iE) const {return false;}
- bool isVertexBL (int iV) const {return false;}
- void computeFor1dMesh(double x, double y, double z, SMetric3 &metr){}
- void setupFor2d(int iF){}
- void setupFor3d(){}
- void removeAttractors(){}
+ virtual double operator()(double x, double y, double z, GEntity *ge = 0)
+ {
+ return 0.;
+ }
+ virtual void operator()(double x, double y, double z, SMetric3 &metr,
+ GEntity *ge = 0)
+ {
+ }
+ bool isFaceBL(int iF) const { return false; }
+ bool isEdgeBL(int iE) const { return false; }
+ bool isFan(int iE) const { return false; }
+ bool isVertexBL(int iV) const { return false; }
+ void computeFor1dMesh(double x, double y, double z, SMetric3 &metr) {}
+ void setupFor2d(int iF) {}
+ void setupFor3d() {}
+ void removeAttractors() {}
};
#endif
-class FieldOptionString : public FieldOption
-{
- public:
- std::string & val;
- virtual FieldOptionType getType(){ return FIELD_OPTION_STRING; }
+class FieldOptionString : public FieldOption {
+public:
+ std::string &val;
+ virtual FieldOptionType getType() { return FIELD_OPTION_STRING; }
FieldOptionString(std::string &_val, const std::string &_help,
bool *_status = 0)
- : FieldOption(_help, _status)
- , val(_val)
+ : FieldOption(_help, _status), val(_val)
+ {
+ }
+ void string(const std::string value)
{
+ modified();
+ val = value;
}
- void string(const std::string value) { modified(); val = value;}
std::string string() const { return val; }
void getTextRepresentation(std::string &v_str)
{
@@ -264,18 +290,20 @@ class FieldOptionString : public FieldOption
}
};
-class FieldOptionDouble : public FieldOption
-{
- public:
+class FieldOptionDouble : public FieldOption {
+public:
double &val;
- FieldOptionType getType(){ return FIELD_OPTION_DOUBLE; }
+ FieldOptionType getType() { return FIELD_OPTION_DOUBLE; }
FieldOptionDouble(double &_val, const std::string &_help, bool *_status = 0)
- : FieldOption(_help, _status)
- , val(_val)
+ : FieldOption(_help, _status), val(_val)
{
}
double numericalValue() const { return val; }
- void numericalValue(double v){ modified(); val = v; }
+ void numericalValue(double v)
+ {
+ modified();
+ val = v;
+ }
void getTextRepresentation(std::string &v_str)
{
std::ostringstream sstream;
@@ -285,19 +313,21 @@ class FieldOptionDouble : public FieldOption
}
};
-class FieldOptionInt : public FieldOption
-{
- public:
+class FieldOptionInt : public FieldOption {
+public:
int &val;
- FieldOptionType getType(){ return FIELD_OPTION_INT; }
+ FieldOptionType getType() { return FIELD_OPTION_INT; }
FieldOptionInt(int &_val, const std::string &_help, bool *_status = 0)
- : FieldOption(_help, _status)
- , val(_val)
+ : FieldOption(_help, _status), val(_val)
{
}
double numericalValue() const { return val; }
- void numericalValue(double v){ modified(); val = (int)v; }
- void getTextRepresentation(std::string & v_str)
+ void numericalValue(double v)
+ {
+ modified();
+ val = (int)v;
+ }
+ void getTextRepresentation(std::string &v_str)
{
std::ostringstream sstream;
sstream << val;
@@ -305,26 +335,27 @@ class FieldOptionInt : public FieldOption
}
};
-class FieldOptionList : public FieldOption
-{
- public:
+class FieldOptionList : public FieldOption {
+public:
std::list<int> &val;
- FieldOptionType getType(){ return FIELD_OPTION_LIST; }
+ FieldOptionType getType() { return FIELD_OPTION_LIST; }
FieldOptionList(std::list<int> &_val, const std::string &_help,
bool *_status = 0)
- : FieldOption(_help, _status)
- , val(_val)
+ : FieldOption(_help, _status), val(_val)
+ {
+ }
+ void list(std::list<int> value)
{
+ modified();
+ val = value;
}
- void list(std::list<int> value){ modified(); val = value; }
- const std::list<int>& list() const { return val; }
- void getTextRepresentation(std::string & v_str)
+ const std::list<int> &list() const { return val; }
+ void getTextRepresentation(std::string &v_str)
{
std::ostringstream sstream;
sstream << "{";
for(std::list<int>::iterator it = val.begin(); it != val.end(); it++) {
- if(it != val.begin())
- sstream << ", ";
+ if(it != val.begin()) sstream << ", ";
sstream << *it;
}
sstream << "}";
@@ -332,27 +363,28 @@ class FieldOptionList : public FieldOption
}
};
-class FieldOptionListDouble : public FieldOption
-{
- public:
+class FieldOptionListDouble : public FieldOption {
+public:
std::list<double> &val;
- FieldOptionType getType(){ return FIELD_OPTION_LIST_DOUBLE; }
+ FieldOptionType getType() { return FIELD_OPTION_LIST_DOUBLE; }
FieldOptionListDouble(std::list<double> &_val, const std::string &_help,
bool *_status = 0)
- : FieldOption(_help, _status)
- , val(_val)
+ : FieldOption(_help, _status), val(_val)
+ {
+ }
+ void listdouble(std::list<double> value)
{
+ modified();
+ val = value;
}
- void listdouble(std::list<double> value){ modified(); val = value; }
- const std::list<double>& listdouble() const { return val; }
- void getTextRepresentation(std::string & v_str)
+ const std::list<double> &listdouble() const { return val; }
+ void getTextRepresentation(std::string &v_str)
{
std::ostringstream sstream;
sstream.precision(16);
sstream << "{";
for(std::list<double>::iterator it = val.begin(); it != val.end(); it++) {
- if(it != val.begin())
- sstream << ", ";
+ if(it != val.begin()) sstream << ", ";
sstream << *it;
}
sstream << "}";
@@ -360,11 +392,9 @@ class FieldOptionListDouble : public FieldOption
}
};
-
-class FieldOptionPath : public FieldOptionString
-{
- public:
- virtual FieldOptionType getType(){ return FIELD_OPTION_PATH; }
+class FieldOptionPath : public FieldOptionString {
+public:
+ virtual FieldOptionType getType() { return FIELD_OPTION_PATH; }
FieldOptionPath(std::string &_val, const std::string &_help,
bool *_status = 0)
: FieldOptionString(_val, _help, _status)
@@ -372,19 +402,21 @@ class FieldOptionPath : public FieldOptionString
}
};
-class FieldOptionBool : public FieldOption
-{
- public:
- bool & val;
- FieldOptionType getType(){ return FIELD_OPTION_BOOL; }
+class FieldOptionBool : public FieldOption {
+public:
+ bool &val;
+ FieldOptionType getType() { return FIELD_OPTION_BOOL; }
FieldOptionBool(bool &_val, const std::string &_help, bool *_status = 0)
- : FieldOption(_help, _status)
- , val(_val)
+ : FieldOption(_help, _status), val(_val)
{
}
double numericalValue() const { return val; }
- void numericalValue(double v){ modified(); val = v; }
- void getTextRepresentation(std::string & v_str)
+ void numericalValue(double v)
+ {
+ modified();
+ val = v;
+ }
+ void getTextRepresentation(std::string &v_str)
{
std::ostringstream sstream;
sstream << val;
@@ -392,16 +424,14 @@ class FieldOptionBool : public FieldOption
}
};
-template<class t>
-class FieldCallbackGeneric : public FieldCallback {
- t * _field;
+template <class t> class FieldCallbackGeneric : public FieldCallback {
+ t *_field;
void (t::*_callback)();
- public :
- void run()
- {
- (_field->*_callback)();
- }
- FieldCallbackGeneric( t *field, void (t::*callback)(), const std::string description)
+
+public:
+ void run() { (_field->*_callback)(); }
+ FieldCallbackGeneric(t *field, void (t::*callback)(),
+ const std::string description)
: FieldCallback(description)
{
_field = field;
@@ -409,33 +439,32 @@ class FieldCallbackGeneric : public FieldCallback {
}
};
-template<class F> class FieldFactoryT : public FieldFactory {
- public:
- Field * operator()() { return new F; }
+template <class F> class FieldFactoryT : public FieldFactory {
+public:
+ Field *operator()() { return new F; }
};
-
-
-// the class GenericField contains a set of void* functions, which give a mesh size
-// All these functions are called when calling operator() ; then, the minimum size is returned.
-class GenericField : public Field{
- public:
- // callback prototypes:
- // this callback is called with a void* previously given to the GenericField !
- typedef bool (*ptrfunction)(double, double, double, void*, double&);
-
- GenericField();
- ~GenericField();
- using Field::operator();
- virtual double operator() (double x, double y, double z, GEntity *ge=0);
- virtual const char *getName(){return "GenericField";};
-
- // sets the callbacks
- void setCallbackWithData(ptrfunction fct, void *data);
-
- private:
- std::vector<ptrfunction> cbs;// the callbacks
- std::vector<void*> user_data;// the data to be sent to the callbacks
+// the class GenericField contains a set of void* functions, which give a mesh
+// size All these functions are called when calling operator() ; then, the
+// minimum size is returned.
+class GenericField : public Field {
+public:
+ // callback prototypes:
+ // this callback is called with a void* previously given to the GenericField !
+ typedef bool (*ptrfunction)(double, double, double, void *, double &);
+
+ GenericField();
+ ~GenericField();
+ using Field::operator();
+ virtual double operator()(double x, double y, double z, GEntity *ge = 0);
+ virtual const char *getName() { return "GenericField"; };
+
+ // sets the callbacks
+ void setCallbackWithData(ptrfunction fct, void *data);
+
+private:
+ std::vector<ptrfunction> cbs; // the callbacks
+ std::vector<void *> user_data; // the data to be sent to the callbacks
};
#endif
diff --git a/Mesh/FieldPython.h b/Mesh/FieldPython.h
index 16af3bdfeed35f7af4b82291a38a64633b524254..e9472eea465e603807c0046345dc389dadcd1ce7 100644
--- a/Mesh/FieldPython.h
+++ b/Mesh/FieldPython.h
@@ -9,20 +9,13 @@
#include "Field.h"
#include "Python.h"
-class FieldPython : public Field
-{
+class FieldPython : public Field {
PyObject *_callback;
- public:
- const char *getName()
- {
- return "Python";
- }
+public:
+ const char *getName() { return "Python"; }
- std::string getDescription()
- {
- return "simple call to a python function";
- }
+ std::string getDescription() { return "simple call to a python function"; }
FieldPython(PyObject *cb, PyObject *arg = NULL)
{
@@ -30,34 +23,34 @@ class FieldPython : public Field
Py_INCREF(_callback);
}
- ~FieldPython()
- {
- Py_DECREF(_callback);
- }
+ ~FieldPython() { Py_DECREF(_callback); }
- double operator() (double x, double y, double z, GEntity *ge=0)
+ double operator()(double x, double y, double z, GEntity *ge = 0)
{
- PyObject *pyge = SWIG_NewPointerObj((void*) ge, SWIGTYPE_p_GEntity, 0);
- PyObject *args = Py_BuildValue("(dddO)", x, y, z, pyge);
+ PyObject *pyge = SWIG_NewPointerObj((void *)ge, SWIGTYPE_p_GEntity, 0);
+ PyObject *args = Py_BuildValue("(dddO)", x, y, z, pyge);
PyObject *result = PyEval_CallObject(_callback, args);
Py_DECREF(args);
- if (result) {
+ if(result) {
double r = PyFloat_AsDouble(result);
- if (PyErr_Occurred()) {
+ if(PyErr_Occurred()) {
PyErr_Print();
PyErr_Clear();
- Msg::Error("Result of python function of field %i cannot be interpreted as a float.", id);
+ Msg::Error("Result of python function of field %i cannot be "
+ "interpreted as a float.",
+ id);
r = MAX_LC;
}
Py_DECREF(result);
return r;
}
else {
- if (PyErr_Occurred()) {
+ if(PyErr_Occurred()) {
PyErr_Print();
PyErr_Clear();
}
- Msg::Error("An error occurs while evaluating python function of field %i.", id);
+ Msg::Error(
+ "An error occurs while evaluating python function of field %i.", id);
return MAX_LC;
}
}
diff --git a/Mesh/Generator.cpp b/Mesh/Generator.cpp
index b14c7ee08c17e626ac832e52d97dd15afa4d5a5d..50a1b66661593a6e05dbc8276d4c5621cd0cb5df 100644
--- a/Mesh/Generator.cpp
+++ b/Mesh/Generator.cpp
@@ -51,80 +51,99 @@
class TEST_IF_MESH_IS_COMPATIBLE_WITH_EMBEDDED_ENTITIES {
public:
- void operator () (GRegion *gr) {
- std::vector<GEdge*> const& e = gr->embeddedEdges();
- std::vector<GFace*> const& f = gr->embeddedFaces();
- if (e.empty() && f.empty())return;
- std::map<MEdge,GEdge*,Less_Edge> edges;
- std::map<MFace,GFace*,Less_Face> faces;
- std::vector<GEdge*>::const_iterator it = e.begin();
- std::vector<GFace*>::const_iterator itf = f.begin();
- for ( ; it != e.end() ; ++it){
- for (unsigned int i=0;i<(*it)->lines.size(); ++i){
- if (distance ((*it)->lines[i]->getVertex(0),(*it)->lines[i]->getVertex(1)) > 1.e-12)
- edges.insert(std::make_pair(MEdge((*it)->lines[i]->getVertex(0),(*it)->lines[i]->getVertex(1)),*it));
+ void operator()(GRegion *gr)
+ {
+ std::vector<GEdge *> const &e = gr->embeddedEdges();
+ std::vector<GFace *> const &f = gr->embeddedFaces();
+ if(e.empty() && f.empty()) return;
+ std::map<MEdge, GEdge *, Less_Edge> edges;
+ std::map<MFace, GFace *, Less_Face> faces;
+ std::vector<GEdge *>::const_iterator it = e.begin();
+ std::vector<GFace *>::const_iterator itf = f.begin();
+ for(; it != e.end(); ++it) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); ++i) {
+ if(distance((*it)->lines[i]->getVertex(0),
+ (*it)->lines[i]->getVertex(1)) > 1.e-12)
+ edges.insert(std::make_pair(
+ MEdge((*it)->lines[i]->getVertex(0), (*it)->lines[i]->getVertex(1)),
+ *it));
}
}
- for ( ; itf != f.end() ; ++itf){
- for (unsigned int i=0;i<(*itf)->triangles.size(); ++i){
- faces.insert(std::make_pair(MFace((*itf)->triangles[i]->getVertex(0),(*itf)->triangles[i]->getVertex(1),(*itf)->triangles[i]->getVertex(2)),*itf));
+ for(; itf != f.end(); ++itf) {
+ for(unsigned int i = 0; i < (*itf)->triangles.size(); ++i) {
+ faces.insert(std::make_pair(MFace((*itf)->triangles[i]->getVertex(0),
+ (*itf)->triangles[i]->getVertex(1),
+ (*itf)->triangles[i]->getVertex(2)),
+ *itf));
}
}
- Msg::Info ("Searching for %d embedded mesh edges and %d embedded mesh faces in region %d", edges.size(), faces.size(), gr->tag());
- for (unsigned int k=0;k<gr->getNumMeshElements();k++){
- for (int j=0;j<gr->getMeshElement(k)->getNumEdges();j++){
- edges.erase (gr->getMeshElement(k)->getEdge(j));
+ Msg::Info("Searching for %d embedded mesh edges and %d embedded mesh faces "
+ "in region %d",
+ edges.size(), faces.size(), gr->tag());
+ for(unsigned int k = 0; k < gr->getNumMeshElements(); k++) {
+ for(int j = 0; j < gr->getMeshElement(k)->getNumEdges(); j++) {
+ edges.erase(gr->getMeshElement(k)->getEdge(j));
}
- for (int j=0;j<gr->getMeshElement(k)->getNumFaces();j++){
- faces.erase (gr->getMeshElement(k)->getFace(j));
+ for(int j = 0; j < gr->getMeshElement(k)->getNumFaces(); j++) {
+ faces.erase(gr->getMeshElement(k)->getFace(j));
}
}
- if (edges.empty() && faces.empty()) {
- Msg::Info ("All embedded edges and faces are present in the final mesh");
+ if(edges.empty() && faces.empty()) {
+ Msg::Info("All embedded edges and faces are present in the final mesh");
}
- if (edges.size()) {
+ if(edges.size()) {
char name[256];
- sprintf(name,"missingEdgesOnRegion%d.pos",gr->tag());
- Msg::Error("Region %d : %d mesh edges that should be embedded are missing in the final mesh",gr->tag(), (int)edges.size());
- Msg::Error("Saving the missing edges in file %s",name);
- FILE *f = fopen(name,"w");
- fprintf(f,"View \" \" {\n");
- for (std::map<MEdge,GEdge*,Less_Edge>::iterator it = edges.begin() ; it != edges.end(); ++it){
- MVertex *v1 = it->first.getVertex(0);
- MVertex *v2 = it->first.getVertex(1);
- fprintf(f,"SL(%g,%g,%g,%g,%g,%g){%d,%d};\n",v1->x(),v1->y(),v1->z(),v2->x(),v2->y(),v2->z(), it->second->tag(),it->second->tag());
+ sprintf(name, "missingEdgesOnRegion%d.pos", gr->tag());
+ Msg::Error("Region %d : %d mesh edges that should be embedded are "
+ "missing in the final mesh",
+ gr->tag(), (int)edges.size());
+ Msg::Error("Saving the missing edges in file %s", name);
+ FILE *f = fopen(name, "w");
+ fprintf(f, "View \" \" {\n");
+ for(std::map<MEdge, GEdge *, Less_Edge>::iterator it = edges.begin();
+ it != edges.end(); ++it) {
+ MVertex *v1 = it->first.getVertex(0);
+ MVertex *v2 = it->first.getVertex(1);
+ fprintf(f, "SL(%g,%g,%g,%g,%g,%g){%d,%d};\n", v1->x(), v1->y(), v1->z(),
+ v2->x(), v2->y(), v2->z(), it->second->tag(),
+ it->second->tag());
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
fclose(f);
}
- if (faces.size()) {
+ if(faces.size()) {
char name[256];
- sprintf(name,"missingFacesOnRegion%d.pos",gr->tag());
- Msg::Error("Region %d : %d mesh faces that should be embedded are missing in the final mesh",gr->tag(), (int)faces.size());
- Msg::Error("Saving the missing faces in file %s",name);
- FILE *f = fopen(name,"w");
- fprintf(f,"View \" \" {\n");
- for (std::map<MFace,GFace*,Less_Face>::iterator it = faces.begin() ; it != faces.end(); ++it){
- MVertex *v1 = it->first.getVertex(0);
- MVertex *v2 = it->first.getVertex(1);
- MVertex *v3 = it->first.getVertex(2);
- fprintf(f,"ST(%g,%g,%g,%g,%g,%g,%g,%g,%g){%d,%d,%d};\n",v1->x(),v1->y(),v1->z(),v2->x(),v2->y(),v2->z(),
- v3->x(),v3->y(),v3->z(),it->second->tag(),it->second->tag(),it->second->tag());
+ sprintf(name, "missingFacesOnRegion%d.pos", gr->tag());
+ Msg::Error("Region %d : %d mesh faces that should be embedded are "
+ "missing in the final mesh",
+ gr->tag(), (int)faces.size());
+ Msg::Error("Saving the missing faces in file %s", name);
+ FILE *f = fopen(name, "w");
+ fprintf(f, "View \" \" {\n");
+ for(std::map<MFace, GFace *, Less_Face>::iterator it = faces.begin();
+ it != faces.end(); ++it) {
+ MVertex *v1 = it->first.getVertex(0);
+ MVertex *v2 = it->first.getVertex(1);
+ MVertex *v3 = it->first.getVertex(2);
+ fprintf(f, "ST(%g,%g,%g,%g,%g,%g,%g,%g,%g){%d,%d,%d};\n", v1->x(),
+ v1->y(), v1->z(), v2->x(), v2->y(), v2->z(), v3->x(), v3->y(),
+ v3->z(), it->second->tag(), it->second->tag(),
+ it->second->tag());
}
- fprintf(f,"};\n");
+ fprintf(f, "};\n");
fclose(f);
}
}
};
-template<class T>
-static void GetQualityMeasure(std::vector<T*> &ele,
- double &gamma, double &gammaMin, double &gammaMax,
- double &minSICN, double &minSICNMin, double &minSICNMax,
- double &minSIGE, double &minSIGEMin, double &minSIGEMax,
- double quality[3][100])
+template <class T>
+static void
+GetQualityMeasure(std::vector<T *> &ele, double &gamma, double &gammaMin,
+ double &gammaMax, double &minSICN, double &minSICNMin,
+ double &minSICNMax, double &minSIGE, double &minSIGEMin,
+ double &minSIGEMax, double quality[3][100])
{
- for(unsigned int i = 0; i < ele.size(); i++){
+ for(unsigned int i = 0; i < ele.size(); i++) {
double g = ele[i]->gammaShapeMeasure();
gamma += g;
gammaMin = std::min(gammaMin, g);
@@ -137,10 +156,10 @@ static void GetQualityMeasure(std::vector<T*> &ele,
minSIGE += e;
minSIGEMin = std::min(minSIGEMin, e);
minSIGEMax = std::max(minSIGEMax, e);
- for(int j = 0; j < 100; j++){
- if(s > (2*j-100) / 100. && s <= (2*j-98) / 100.) quality[0][j]++;
+ for(int j = 0; j < 100; j++) {
+ if(s > (2 * j - 100) / 100. && s <= (2 * j - 98) / 100.) quality[0][j]++;
if(g > j / 100. && g <= (j + 1) / 100.) quality[1][j]++;
- if(e > (2*j-100) / 100. && e <= (2*j-98) / 100.) quality[2][j]++;
+ if(e > (2 * j - 100) / 100. && e <= (2 * j - 98) / 100.) quality[2][j]++;
}
}
}
@@ -158,28 +177,28 @@ void GetStatistics(double stat[50], double quality[3][100])
stat[2] = m->getNumFaces();
stat[3] = m->getNumRegions();
- std::map<int, std::vector<GEntity*> > physicals[4];
+ std::map<int, std::vector<GEntity *> > physicals[4];
m->getPhysicalGroups(physicals);
- stat[45] = physicals[0].size() + physicals[1].size() +
- physicals[2].size() + physicals[3].size();
+ stat[45] = physicals[0].size() + physicals[1].size() + physicals[2].size() +
+ physicals[3].size();
- for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); ++it){
+ for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); ++it) {
stat[4] += (*it)->mesh_vertices.size();
stat[5] += (*it)->points.size();
}
- for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it){
+ for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it) {
stat[4] += (*it)->mesh_vertices.size();
stat[6] += (*it)->lines.size();
}
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
stat[4] += (*it)->mesh_vertices.size();
stat[7] += (*it)->triangles.size();
stat[8] += (*it)->quadrangles.size();
}
- for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it){
+ for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it) {
stat[4] += (*it)->mesh_vertices.size();
stat[9] += (*it)->tetrahedra.size();
stat[10] += (*it)->hexahedra.size();
@@ -192,46 +211,51 @@ void GetStatistics(double stat[50], double quality[3][100])
stat[15] = CTX::instance()->meshTimer[1];
stat[16] = CTX::instance()->meshTimer[2];
- if(quality){
+ if(quality) {
for(int i = 0; i < 3; i++)
- for(int j = 0; j < 100; j++)
- quality[i][j] = 0.;
+ for(int j = 0; j < 100; j++) quality[i][j] = 0.;
double minSICN = 0., minSICNMin = 1., minSICNMax = -1.;
double minSIGE = 0., minSIGEMin = 1., minSIGEMax = -1.;
double gamma = 0., gammaMin = 1., gammaMax = 0.;
double N = stat[9] + stat[10] + stat[11] + stat[12] + stat[13];
- if(N){ // if we have 3D elements
- for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it){
- GetQualityMeasure((*it)->tetrahedra, gamma, gammaMin, gammaMax,
- minSICN, minSICNMin, minSICNMax,
- minSIGE, minSIGEMin, minSIGEMax, quality);
- GetQualityMeasure((*it)->hexahedra, gamma, gammaMin, gammaMax,
- minSICN, minSICNMin, minSICNMax,
- minSIGE, minSIGEMin, minSIGEMax, quality);
- GetQualityMeasure((*it)->prisms, gamma, gammaMin, gammaMax,
- minSICN, minSICNMin, minSICNMax,
- minSIGE, minSIGEMin, minSIGEMax, quality);
- GetQualityMeasure((*it)->pyramids, gamma, gammaMin, gammaMax,
- minSICN, minSICNMin, minSICNMax,
- minSIGE, minSIGEMin, minSIGEMax, quality);
+ if(N) { // if we have 3D elements
+ for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it) {
+ GetQualityMeasure((*it)->tetrahedra, gamma, gammaMin, gammaMax, minSICN,
+ minSICNMin, minSICNMax, minSIGE, minSIGEMin,
+ minSIGEMax, quality);
+ GetQualityMeasure((*it)->hexahedra, gamma, gammaMin, gammaMax, minSICN,
+ minSICNMin, minSICNMax, minSIGE, minSIGEMin,
+ minSIGEMax, quality);
+ GetQualityMeasure((*it)->prisms, gamma, gammaMin, gammaMax, minSICN,
+ minSICNMin, minSICNMax, minSIGE, minSIGEMin,
+ minSIGEMax, quality);
+ GetQualityMeasure((*it)->pyramids, gamma, gammaMin, gammaMax, minSICN,
+ minSICNMin, minSICNMax, minSIGE, minSIGEMin,
+ minSIGEMax, quality);
}
}
- else{ // 2D elements
+ else { // 2D elements
N = stat[7] + stat[8];
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
GetQualityMeasure((*it)->quadrangles, gamma, gammaMin, gammaMax,
- minSICN, minSICNMin, minSICNMax,
- minSIGE, minSIGEMin, minSIGEMax, quality);
- GetQualityMeasure((*it)->triangles, gamma, gammaMin, gammaMax,
- minSICN, minSICNMin, minSICNMax,
- minSIGE, minSIGEMin, minSIGEMax, quality);
+ minSICN, minSICNMin, minSICNMax, minSIGE, minSIGEMin,
+ minSIGEMax, quality);
+ GetQualityMeasure((*it)->triangles, gamma, gammaMin, gammaMax, minSICN,
+ minSICNMin, minSICNMax, minSIGE, minSIGEMin,
+ minSIGEMax, quality);
}
}
- if(N){
- stat[18] = minSICN / N; stat[19] = minSICNMin; stat[20] = minSICNMax;
- stat[21] = gamma / N; stat[22] = gammaMin; stat[23] = gammaMax;
- stat[24] = minSIGE / N; stat[25] = minSIGEMin; stat[26] = minSIGEMax;
+ if(N) {
+ stat[18] = minSICN / N;
+ stat[19] = minSICNMin;
+ stat[20] = minSICNMax;
+ stat[21] = gamma / N;
+ stat[22] = gammaMin;
+ stat[23] = gammaMax;
+ stat[24] = minSIGE / N;
+ stat[25] = minSIGEMin;
+ stat[26] = minSIGEMax;
}
}
@@ -261,36 +285,38 @@ static bool TooManyElements(GModel *m, int dim)
// list)
double sumAllLc = 0.;
for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); ++it)
- sumAllLc += (*it)->prescribedMeshSizeAtVertex() * CTX::instance()->mesh.lcFactor;
+ sumAllLc +=
+ (*it)->prescribedMeshSizeAtVertex() * CTX::instance()->mesh.lcFactor;
sumAllLc /= (double)m->getNumVertices();
if(!sumAllLc || pow(CTX::instance()->lc / sumAllLc, dim) > 1.e10)
- return !Msg::GetAnswer
- ("Your choice of mesh element sizes will likely produce a very\n"
- "large mesh. Do you really want to continue?\n\n"
- "(To disable this warning in the future, select `Enable expert mode'\n"
- "in the option dialog.)", 1, "Cancel", "Continue");
+ return !Msg::GetAnswer(
+ "Your choice of mesh element sizes will likely produce a very\n"
+ "large mesh. Do you really want to continue?\n\n"
+ "(To disable this warning in the future, select `Enable expert mode'\n"
+ "in the option dialog.)",
+ 1, "Cancel", "Continue");
return false;
}
static void Mesh0D(GModel *m)
{
-
m->getFields()->initialize();
- for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); ++it){
+ for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); ++it) {
GVertex *gv = *it;
if(gv->mesh_vertices.empty())
gv->mesh_vertices.push_back(new MVertex(gv->x(), gv->y(), gv->z(), gv));
if(gv->points.empty())
gv->points.push_back(new MPoint(gv->mesh_vertices.back()));
}
- for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); ++it){
+ for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); ++it) {
GVertex *gv = *it;
- if (gv->meshMaster() != gv){
- if (gv->correspondingVertices.empty()){
- GVertex *master = dynamic_cast<GVertex*>(gv->meshMaster());
+ if(gv->meshMaster() != gv) {
+ if(gv->correspondingVertices.empty()) {
+ GVertex *master = dynamic_cast<GVertex *>(gv->meshMaster());
if(master)
- gv->correspondingVertices[gv->mesh_vertices[0]] = master->mesh_vertices[0];
+ gv->correspondingVertices[gv->mesh_vertices[0]] =
+ master->mesh_vertices[0];
}
}
}
@@ -309,8 +335,8 @@ static void Mesh1D(GModel *m)
CTX::instance()->mesh.maxNumThreads1D <= Msg::GetMaxThreads())
Msg::SetNumThreads(CTX::instance()->mesh.maxNumThreads1D);
- std::vector<GEdge*> temp;
- for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it){
+ std::vector<GEdge *> temp;
+ for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it) {
(*it)->meshStatistics.status = GEdge::PENDING;
temp.push_back(*it);
}
@@ -318,22 +344,22 @@ static void Mesh1D(GModel *m)
Msg::ResetProgressMeter();
int nIter = 0, nTot = m->getNumEdges();
- while(1){
+ while(1) {
int nPending = 0;
const size_t sss = temp.size();
#if defined(_OPENMP)
-#pragma omp parallel for schedule (dynamic)
+#pragma omp parallel for schedule(dynamic)
#endif
- for(size_t K = 0 ; K < sss ; K++){
+ for(size_t K = 0; K < sss; K++) {
GEdge *ed = temp[K];
- if (ed->meshStatistics.status == GEdge::PENDING){
- ed->mesh(true);
+ if(ed->meshStatistics.status == GEdge::PENDING) {
+ ed->mesh(true);
#if defined(_OPENMP)
#pragma omp critical
#endif
- {
- nPending++;
- }
+ {
+ nPending++;
+ }
}
if(!nIter) Msg::ProgressMeter(nPending, nTot, false, "Meshing 1D...");
}
@@ -359,7 +385,7 @@ static void PrintMesh2dStatistics(GModel *m)
else
return;
- if(!statreport){
+ if(!statreport) {
Msg::Error("Could not open file '%s'",
CTX::instance()->meshStatReportFileName.c_str());
return;
@@ -370,27 +396,28 @@ static void PrintMesh2dStatistics(GModel *m)
int nTotT = 0, nTotE = 0, nTotGoodLength = 0, nTotGoodQuality = 0;
int nUnmeshed = 0, numFaces = 0;
- if(CTX::instance()->createAppendMeshStatReport == 1){
+ if(CTX::instance()->createAppendMeshStatReport == 1) {
fprintf(statreport, "2D stats\tname\t\t#faces\t\t#fail\t\t"
- "#t\t\tQavg\t\tQbest\t\tQworst\t\t#Q>90\t\t#Q>90/#t\t"
- "#e\t\ttau\t\t#Egood\t\t#Egood/#e\tCPU\n");
- if(m->empty()){
+ "#t\t\tQavg\t\tQbest\t\tQworst\t\t#Q>90\t\t#Q>90/#t\t"
+ "#e\t\ttau\t\t#Egood\t\t#Egood/#e\tCPU\n");
+ if(m->empty()) {
fclose(statreport);
return;
}
}
- for(GModel::fiter it = m->firstFace() ; it != m->lastFace(); ++it){
- if((*it)->geomType() != GEntity::DiscreteSurface){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
+ if((*it)->geomType() != GEntity::DiscreteSurface) {
worst = std::min((*it)->meshStatistics.worst_element_shape, worst);
best = std::max((*it)->meshStatistics.best_element_shape, best);
avg += (*it)->meshStatistics.average_element_shape *
- (*it)->meshStatistics.nbTriangle;
+ (*it)->meshStatistics.nbTriangle;
e_avg += (*it)->meshStatistics.efficiency_index;
e_long = std::max((*it)->meshStatistics.longest_edge_length, e_long);
e_short = std::min((*it)->meshStatistics.smallest_edge_length, e_short);
- if ((*it)->meshStatistics.status == GFace::FAILED ||
- (*it)->meshStatistics.status == GFace::PENDING) nUnmeshed++;
+ if((*it)->meshStatistics.status == GFace::FAILED ||
+ (*it)->meshStatistics.status == GFace::PENDING)
+ nUnmeshed++;
nTotT += (*it)->meshStatistics.nbTriangle;
nTotE += (*it)->meshStatistics.nbEdge;
nTotGoodLength += (*it)->meshStatistics.nbGoodLength;
@@ -400,15 +427,15 @@ static void PrintMesh2dStatistics(GModel *m)
}
Msg::Info("*** Efficiency index for surface mesh tau=%g ",
- 100*exp(e_avg/(double)nTotE));
+ 100 * exp(e_avg / (double)nTotE));
- fprintf(statreport,"\t%16s\t%d\t\t%d\t\t", m->getName().c_str(), numFaces,
+ fprintf(statreport, "\t%16s\t%d\t\t%d\t\t", m->getName().c_str(), numFaces,
nUnmeshed);
- fprintf(statreport,"%d\t\t%8.7f\t%8.7f\t%8.7f\t%d\t\t%8.7f\t",
- nTotT, avg / (double)nTotT, best, worst, nTotGoodQuality,
+ fprintf(statreport, "%d\t\t%8.7f\t%8.7f\t%8.7f\t%d\t\t%8.7f\t", nTotT,
+ avg / (double)nTotT, best, worst, nTotGoodQuality,
(double)nTotGoodQuality / nTotT);
- fprintf(statreport,"%d\t\t%8.7f\t%d\t\t%8.7f\t%8.1f\n",
- nTotE, exp(e_avg / (double)nTotE), nTotGoodLength,
+ fprintf(statreport, "%d\t\t%8.7f\t%d\t\t%8.7f\t%8.1f\n", nTotE,
+ exp(e_avg / (double)nTotE), nTotGoodLength,
(double)nTotGoodLength / nTotE, CTX::instance()->meshTimer[1]);
fclose(statreport);
}
@@ -432,23 +459,23 @@ static void Mesh2D(GModel *m)
// boundary layers are special: their generation (including vertices and curve
// meshes) is global as it depends on a smooth normal field generated from the
// surface mesh of the source surfaces
- if(!Mesh2DWithBoundaryLayers(m)){
- std::set<GFace*, GEntityLessThan> f;
+ if(!Mesh2DWithBoundaryLayers(m)) {
+ std::set<GFace *, GEntityLessThan> f;
for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it)
f.insert(*it);
Msg::ResetProgressMeter();
int nIter = 0, nTot = m->getNumFaces();
- while(1){
+ while(1) {
int nPending = 0;
- std::vector<GFace*> temp;
+ std::vector<GFace *> temp;
temp.insert(temp.begin(), f.begin(), f.end());
#if defined(_OPENMP)
-#pragma omp parallel for schedule (dynamic)
+#pragma omp parallel for schedule(dynamic)
#endif
- for(size_t K = 0 ; K < temp.size() ; K++){
- if (temp[K]->meshStatistics.status == GFace::PENDING){
+ for(size_t K = 0; K < temp.size(); K++) {
+ if(temp[K]->meshStatistics.status == GFace::PENDING) {
backgroundMesh::current()->unset();
temp[K]->mesh(true);
#if defined(_OPENMP)
@@ -476,36 +503,41 @@ static void Mesh2D(GModel *m)
PrintMesh2dStatistics(m);
}
-static void FindConnectedRegions(const std::vector<GRegion*> &del,
- std::vector<std::vector<GRegion*> > &connected)
+static void
+FindConnectedRegions(const std::vector<GRegion *> &del,
+ std::vector<std::vector<GRegion *> > &connected)
{
- std::vector<GRegion*> delaunay = del;
+ std::vector<GRegion *> delaunay = del;
// test: connected.resize(1); connected[0] = delaunay; return;
const unsigned int nbVolumes = delaunay.size();
- if (!nbVolumes) return;
- while (delaunay.size()){
- std::set<GRegion*> oneDomain;
- std::stack<GRegion*> _stack;
+ if(!nbVolumes) return;
+ while(delaunay.size()) {
+ std::set<GRegion *> oneDomain;
+ std::stack<GRegion *> _stack;
GRegion *r = delaunay[0];
_stack.push(r);
- while(!_stack.empty()){
+ while(!_stack.empty()) {
r = _stack.top();
_stack.pop();
oneDomain.insert(r);
- std::vector<GFace*> faces = r->faces();
- for (std::vector<GFace*>::iterator it = faces.begin(); it != faces.end() ; ++it){
+ std::vector<GFace *> faces = r->faces();
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ ++it) {
GFace *gf = *it;
- GRegion *other = (gf->getRegion(0) == r) ? gf->getRegion(1) : gf->getRegion(0);
+ GRegion *other =
+ (gf->getRegion(0) == r) ? gf->getRegion(1) : gf->getRegion(0);
if(other != 0 && oneDomain.find(other) == oneDomain.end())
_stack.push(other);
}
}
- std::vector<GRegion*> temp1, temp2;
- for (unsigned int i = 0; i < delaunay.size(); i++){
+ std::vector<GRegion *> temp1, temp2;
+ for(unsigned int i = 0; i < delaunay.size(); i++) {
r = delaunay[i];
- if (oneDomain.find(r) == oneDomain.end()) temp1.push_back(r);
- else temp2.push_back(r);
+ if(oneDomain.find(r) == oneDomain.end())
+ temp1.push_back(r);
+ else
+ temp2.push_back(r);
}
connected.push_back(temp2);
delaunay = temp1;
@@ -515,13 +547,13 @@ static void FindConnectedRegions(const std::vector<GRegion*> &del,
}
template <class ITERATOR>
-void fillv_(std::multimap<MVertex*, MElement*> &vertexToElement,
- ITERATOR it_beg, ITERATOR it_end)
+void fillv_(std::multimap<MVertex *, MElement *> &vertexToElement,
+ ITERATOR it_beg, ITERATOR it_end)
{
- for (ITERATOR IT = it_beg; IT != it_end ; ++IT){
+ for(ITERATOR IT = it_beg; IT != it_end; ++IT) {
MElement *el = *IT;
for(std::size_t j = 0; j < el->getNumVertices(); j++) {
- MVertex* e = el->getVertex(j);
+ MVertex *e = el->getVertex(j);
vertexToElement.insert(std::make_pair(e, el));
}
}
@@ -529,39 +561,41 @@ void fillv_(std::multimap<MVertex*, MElement*> &vertexToElement,
int LaplaceSmoothing(GRegion *gr)
{
- std::multimap<MVertex*, MElement*> vertexToElement;
+ std::multimap<MVertex *, MElement *> vertexToElement;
fillv_(vertexToElement, (gr)->tetrahedra.begin(), (gr)->tetrahedra.end());
- fillv_(vertexToElement, (gr)->hexahedra.begin(), (gr)->hexahedra.end());
- fillv_(vertexToElement, (gr)->prisms.begin(), (gr)->prisms.end());
- fillv_(vertexToElement, (gr)->pyramids.begin(), (gr)->pyramids.end());
- int N=0;
- for (unsigned int i=0; i<gr->mesh_vertices.size();i++){
+ fillv_(vertexToElement, (gr)->hexahedra.begin(), (gr)->hexahedra.end());
+ fillv_(vertexToElement, (gr)->prisms.begin(), (gr)->prisms.end());
+ fillv_(vertexToElement, (gr)->pyramids.begin(), (gr)->pyramids.end());
+ int N = 0;
+ for(unsigned int i = 0; i < gr->mesh_vertices.size(); i++) {
MVertex *v = gr->mesh_vertices[i];
- std::multimap<MVertex*, MElement*>::iterator it = vertexToElement.lower_bound(v);
- std::multimap<MVertex*, MElement*>::iterator it_low = it;
- std::multimap<MVertex*, MElement*>::iterator it_up = vertexToElement.upper_bound(v);
+ std::multimap<MVertex *, MElement *>::iterator it =
+ vertexToElement.lower_bound(v);
+ std::multimap<MVertex *, MElement *>::iterator it_low = it;
+ std::multimap<MVertex *, MElement *>::iterator it_up =
+ vertexToElement.upper_bound(v);
double minQual = 1.e22;
double volTot = 0.0;
- double xold=v->x(), yold=v->y(), zold=v->z();
- SPoint3 pNew (0,0,0);
- for (; it != it_up; ++it) {
- minQual= std::min(minQual,it->second->minSICNShapeMeasure());
+ double xold = v->x(), yold = v->y(), zold = v->z();
+ SPoint3 pNew(0, 0, 0);
+ for(; it != it_up; ++it) {
+ minQual = std::min(minQual, it->second->minSICNShapeMeasure());
double vol = fabs(it->second->getVolume());
SPoint3 cog = it->second->barycenter();
pNew += cog * vol;
volTot += vol;
}
- pNew *= (1./volTot);
- v->setXYZ (pNew.x(),pNew.y(),pNew.z());
+ pNew *= (1. / volTot);
+ v->setXYZ(pNew.x(), pNew.y(), pNew.z());
double minQual2 = 1.e22;
- for (it = it_low; it != it_up; ++it) {
- minQual2 = std::min(minQual2,it->second->minSICNShapeMeasure());
- if (minQual2 < minQual){
- v->setXYZ (xold,yold,zold);
- break;
+ for(it = it_low; it != it_up; ++it) {
+ minQual2 = std::min(minQual2, it->second->minSICNShapeMeasure());
+ if(minQual2 < minQual) {
+ v->setXYZ(xold, yold, zold);
+ break;
}
}
- if (minQual < minQual2) N++;
+ if(minQual < minQual2) N++;
}
return N;
}
@@ -581,15 +615,17 @@ int LaplaceSmoothing(GRegion *gr)
v0 v1
*/
-void buildUniqueFaces (GRegion *gr, std::set<MFace,Less_Face> &bnd)
+void buildUniqueFaces(GRegion *gr, std::set<MFace, Less_Face> &bnd)
{
- for (unsigned int i=0;i<gr->getNumMeshElements();i++){
+ for(unsigned int i = 0; i < gr->getNumMeshElements(); i++) {
MElement *e = gr->getMeshElement(i);
- for(int j=0;j<e->getNumFaces();j++){
+ for(int j = 0; j < e->getNumFaces(); j++) {
MFace f = e->getFace(j);
- std::set<MFace,Less_Face>::iterator it = bnd.find(f);
- if (it == bnd.end())bnd.insert(f);
- else bnd.erase(it);
+ std::set<MFace, Less_Face>::iterator it = bnd.find(f);
+ if(it == bnd.end())
+ bnd.insert(f);
+ else
+ bnd.erase(it);
}
}
}
@@ -598,126 +634,134 @@ bool MakeMeshConformal(GModel *gm, int howto)
{
fs_cont search;
buildFaceSearchStructure(gm, search);
- std::set<MFace,Less_Face> bnd;
- for (GModel::riter rit = gm->firstRegion(); rit != gm->lastRegion(); ++rit){
+ std::set<MFace, Less_Face> bnd;
+ for(GModel::riter rit = gm->firstRegion(); rit != gm->lastRegion(); ++rit) {
GRegion *gr = *rit;
- buildUniqueFaces (gr,bnd);
+ buildUniqueFaces(gr, bnd);
}
// bnd2 contains non conforming faces
- std::set<MFace,Less_Face> bnd2;
- for (std::set<MFace,Less_Face>::iterator itf = bnd.begin(); itf != bnd.end(); ++itf){
- GFace *gfound = findInFaceSearchStructure (*itf,search);
- if (!gfound){
+ std::set<MFace, Less_Face> bnd2;
+ for(std::set<MFace, Less_Face>::iterator itf = bnd.begin(); itf != bnd.end();
+ ++itf) {
+ GFace *gfound = findInFaceSearchStructure(*itf, search);
+ if(!gfound) {
bnd2.insert(*itf);
}
}
bnd.clear();
- Msg::Info("%d hanging faces",bnd2.size());
+ Msg::Info("%d hanging faces", bnd2.size());
- std::set<MFace,Less_Face> ncf;
- for (std::set<MFace,Less_Face>::iterator itf = bnd2.begin(); itf != bnd2.end(); ++itf){
+ std::set<MFace, Less_Face> ncf;
+ for(std::set<MFace, Less_Face>::iterator itf = bnd2.begin();
+ itf != bnd2.end(); ++itf) {
const MFace &f = *itf;
- if (f.getNumVertices() == 4){ // quad face
- std::set<MFace,Less_Face>::iterator it1 =
- bnd2.find (MFace(f.getVertex(0),f.getVertex(1),f.getVertex(2)));
- std::set<MFace,Less_Face>::iterator it2 =
- bnd2.find (MFace(f.getVertex(2),f.getVertex(3),f.getVertex(0)));
- if (it1 != bnd2.end() && it2 != bnd2.end()){
- ncf.insert(MFace(f.getVertex(1), f.getVertex(2),
- f.getVertex(3),f.getVertex(0)));
+ if(f.getNumVertices() == 4) { // quad face
+ std::set<MFace, Less_Face>::iterator it1 =
+ bnd2.find(MFace(f.getVertex(0), f.getVertex(1), f.getVertex(2)));
+ std::set<MFace, Less_Face>::iterator it2 =
+ bnd2.find(MFace(f.getVertex(2), f.getVertex(3), f.getVertex(0)));
+ if(it1 != bnd2.end() && it2 != bnd2.end()) {
+ ncf.insert(MFace(f.getVertex(1), f.getVertex(2), f.getVertex(3),
+ f.getVertex(0)));
}
else {
- it1 = bnd2.find (MFace(f.getVertex(0),f.getVertex(1),f.getVertex(3)));
- it2 = bnd2.find (MFace(f.getVertex(3),f.getVertex(1),f.getVertex(2)));
- if (it1 != bnd2.end() && it2 != bnd2.end()){
- ncf.insert(MFace(f.getVertex(0), f.getVertex(1),
- f.getVertex(2), f.getVertex(3)));
- }
- else {
- Msg::Error("MakeMeshConformal: wrong mesh topology");
- return false;
- }
+ it1 = bnd2.find(MFace(f.getVertex(0), f.getVertex(1), f.getVertex(3)));
+ it2 = bnd2.find(MFace(f.getVertex(3), f.getVertex(1), f.getVertex(2)));
+ if(it1 != bnd2.end() && it2 != bnd2.end()) {
+ ncf.insert(MFace(f.getVertex(0), f.getVertex(1), f.getVertex(2),
+ f.getVertex(3)));
+ }
+ else {
+ Msg::Error("MakeMeshConformal: wrong mesh topology");
+ return false;
+ }
}
}
}
bnd2.clear();
- for (GModel::riter rit = gm->firstRegion(); rit != gm->lastRegion(); ++rit){
+ for(GModel::riter rit = gm->firstRegion(); rit != gm->lastRegion(); ++rit) {
GRegion *gr = *rit;
- std::vector<MHexahedron*> remainingHexes;
- for (unsigned int i=0;i<gr->hexahedra.size();i++){
+ std::vector<MHexahedron *> remainingHexes;
+ for(unsigned int i = 0; i < gr->hexahedra.size(); i++) {
MHexahedron *e = gr->hexahedra[i];
std::vector<MFace> faces;
- for(int j=0;j<e->getNumFaces();j++){
- MFace f = e->getFace(j);
- std::set<MFace,Less_Face>::iterator it = ncf.find(f);
- if (it == ncf.end()){
- faces.push_back(f);
- }
- else {
- faces.push_back(MFace(it->getVertex(0),it->getVertex(1),it->getVertex(3)));
- faces.push_back(MFace(it->getVertex(1),it->getVertex(2),it->getVertex(3)));
- }
+ for(int j = 0; j < e->getNumFaces(); j++) {
+ MFace f = e->getFace(j);
+ std::set<MFace, Less_Face>::iterator it = ncf.find(f);
+ if(it == ncf.end()) {
+ faces.push_back(f);
+ }
+ else {
+ faces.push_back(
+ MFace(it->getVertex(0), it->getVertex(1), it->getVertex(3)));
+ faces.push_back(
+ MFace(it->getVertex(1), it->getVertex(2), it->getVertex(3)));
+ }
}
// HEX IS ONLY SURROUNED BY COMPATIBLE ELEMENTS
- if ((int)faces.size() == e->getNumFaces()){
- remainingHexes.push_back(e);
+ if((int)faces.size() == e->getNumFaces()) {
+ remainingHexes.push_back(e);
}
else {
- SPoint3 pp = e->barycenter();
- MVertex *newv = new MVertex (pp.x(),pp.y(),pp.z(),gr);
- gr->mesh_vertices.push_back(newv);
- for (unsigned int j=0;j<faces.size();j++){
- MFace &f = faces[j];
- if (f.getNumVertices() == 4){
- gr->pyramids.push_back(new MPyramid(f.getVertex(0), f.getVertex(1),
- f.getVertex(2), f.getVertex(3), newv));
- }
- else {
- gr->tetrahedra.push_back(new MTetrahedron(f.getVertex(0), f.getVertex(1),
- f.getVertex(2), newv));
- }
- }
+ SPoint3 pp = e->barycenter();
+ MVertex *newv = new MVertex(pp.x(), pp.y(), pp.z(), gr);
+ gr->mesh_vertices.push_back(newv);
+ for(unsigned int j = 0; j < faces.size(); j++) {
+ MFace &f = faces[j];
+ if(f.getNumVertices() == 4) {
+ gr->pyramids.push_back(new MPyramid(f.getVertex(0), f.getVertex(1),
+ f.getVertex(2), f.getVertex(3),
+ newv));
+ }
+ else {
+ gr->tetrahedra.push_back(new MTetrahedron(
+ f.getVertex(0), f.getVertex(1), f.getVertex(2), newv));
+ }
+ }
}
}
gr->hexahedra = remainingHexes;
remainingHexes.clear();
- std::vector<MPrism*> remainingPrisms;
- for (unsigned int i=0;i<gr->prisms.size();i++){
+ std::vector<MPrism *> remainingPrisms;
+ for(unsigned int i = 0; i < gr->prisms.size(); i++) {
MPrism *e = gr->prisms[i];
std::vector<MFace> faces;
- for(int j=0;j<e->getNumFaces();j++){
- MFace f = e->getFace(j);
- std::set<MFace,Less_Face>::iterator it = ncf.find(f);
- if (it == ncf.end()){
- faces.push_back(f);
- }
- else {
- faces.push_back(MFace(it->getVertex(0),it->getVertex(1),it->getVertex(3)));
- faces.push_back(MFace(it->getVertex(1),it->getVertex(2),it->getVertex(3)));
- }
+ for(int j = 0; j < e->getNumFaces(); j++) {
+ MFace f = e->getFace(j);
+ std::set<MFace, Less_Face>::iterator it = ncf.find(f);
+ if(it == ncf.end()) {
+ faces.push_back(f);
+ }
+ else {
+ faces.push_back(
+ MFace(it->getVertex(0), it->getVertex(1), it->getVertex(3)));
+ faces.push_back(
+ MFace(it->getVertex(1), it->getVertex(2), it->getVertex(3)));
+ }
}
// HEX IS ONLY SURROUNED BY COMPATIBLE ELEMENTS
- if ((int)faces.size() == e->getNumFaces()){
- remainingPrisms.push_back(e);
+ if((int)faces.size() == e->getNumFaces()) {
+ remainingPrisms.push_back(e);
}
else {
- SPoint3 pp = e->barycenter();
- MVertex *newv = new MVertex (pp.x(),pp.y(),pp.z(),gr);
- gr->mesh_vertices.push_back(newv);
- for (unsigned int j=0;j<faces.size();j++){
- MFace &f = faces[j];
- if (f.getNumVertices() == 4){
- gr->pyramids.push_back(new MPyramid(f.getVertex(0), f.getVertex(1),
- f.getVertex(2), f.getVertex(3), newv));
- }
- else {
- gr->tetrahedra.push_back(new MTetrahedron(f.getVertex(0), f.getVertex(1),
- f.getVertex(2), newv));
- }
- }
+ SPoint3 pp = e->barycenter();
+ MVertex *newv = new MVertex(pp.x(), pp.y(), pp.z(), gr);
+ gr->mesh_vertices.push_back(newv);
+ for(unsigned int j = 0; j < faces.size(); j++) {
+ MFace &f = faces[j];
+ if(f.getNumVertices() == 4) {
+ gr->pyramids.push_back(new MPyramid(f.getVertex(0), f.getVertex(1),
+ f.getVertex(2), f.getVertex(3),
+ newv));
+ }
+ else {
+ gr->tetrahedra.push_back(new MTetrahedron(
+ f.getVertex(0), f.getVertex(1), f.getVertex(2), newv));
+ }
+ }
}
}
gr->prisms = remainingPrisms;
@@ -731,31 +775,36 @@ void TestConformity(GModel *gm)
fs_cont search;
buildFaceSearchStructure(gm, search);
int count = 0;
- for (GModel::riter rit = gm->firstRegion(); rit != gm->lastRegion(); ++rit){
+ for(GModel::riter rit = gm->firstRegion(); rit != gm->lastRegion(); ++rit) {
GRegion *gr = *rit;
- std::set<MFace,Less_Face> bnd;
+ std::set<MFace, Less_Face> bnd;
double vol = 0.0;
- for (unsigned int i=0;i<gr->getNumMeshElements();i++){
+ for(unsigned int i = 0; i < gr->getNumMeshElements(); i++) {
MElement *e = gr->getMeshElement(i);
vol += fabs(e->getVolume());
- for(int j=0;j<e->getNumFaces();j++){
- MFace f = e->getFace(j);
- std::set<MFace,Less_Face>::iterator it = bnd.find(f);
- if (it == bnd.end())bnd.insert(f);
- else bnd.erase(it);
+ for(int j = 0; j < e->getNumFaces(); j++) {
+ MFace f = e->getFace(j);
+ std::set<MFace, Less_Face>::iterator it = bnd.find(f);
+ if(it == bnd.end())
+ bnd.insert(f);
+ else
+ bnd.erase(it);
}
}
- printf("vol(%d) = %12.5E\n",gr->tag(),vol);
+ printf("vol(%d) = %12.5E\n", gr->tag(), vol);
- for (std::set<MFace,Less_Face>::iterator itf = bnd.begin(); itf != bnd.end(); ++itf){
- GFace *gfound = findInFaceSearchStructure (*itf,search);
- if (!gfound){
- count ++;
+ for(std::set<MFace, Less_Face>::iterator itf = bnd.begin();
+ itf != bnd.end(); ++itf) {
+ GFace *gfound = findInFaceSearchStructure(*itf, search);
+ if(!gfound) {
+ count++;
}
}
}
- if (!count) Msg::Info("Mesh Conformity: OK");
- else Msg::Error ("Mesh is not conforming (%d hanging faces)!",count);
+ if(!count)
+ Msg::Info("Mesh Conformity: OK");
+ else
+ Msg::Error("Mesh is not conforming (%d hanging faces)!", count);
}
static void Mesh3D(GModel *m)
@@ -771,8 +820,7 @@ static void Mesh3D(GModel *m)
CTX::instance()->mesh.maxNumThreads3D <= Msg::GetMaxThreads())
Msg::SetNumThreads(CTX::instance()->mesh.maxNumThreads3D);
- if(m->getNumRegions())
- Msg::ProgressMeter(0, 100, false, "Meshing 3D...");
+ if(m->getNumRegions()) Msg::ProgressMeter(0, 100, false, "Meshing 3D...");
// mesh the extruded volumes first
std::for_each(m->firstRegion(), m->lastRegion(), meshGRegionExtruded());
@@ -782,23 +830,24 @@ static void Mesh3D(GModel *m)
SubdivideExtrudedMesh(m);
// then mesh all the non-delaunay regions (front3D with netgen)
- std::vector<GRegion*> delaunay;
+ std::vector<GRegion *> delaunay;
std::for_each(m->firstRegion(), m->lastRegion(), meshGRegion(delaunay));
// and finally mesh the delaunay regions (again, this is global; but
// we mesh each connected part separately for performance and mesh
// quality reasons)
- std::vector<std::vector<GRegion*> > connected;
+ std::vector<std::vector<GRegion *> > connected;
FindConnectedRegions(delaunay, connected);
// remove quads elements for volumes that are recombined
// pragma OMP here ?
- for(unsigned int i = 0; i < connected.size(); i++){
- for(unsigned j = 0; j < connected[i].size(); j++){
+ for(unsigned int i = 0; i < connected.size(); i++) {
+ for(unsigned j = 0; j < connected[i].size(); j++) {
GRegion *gr = connected[i][j];
- if(CTX::instance()->mesh.recombine3DAll || gr->meshAttributes.recombine3D){
- std::vector<GFace*> f = gr->faces();
- for(std::vector<GFace*>::iterator it = f.begin(); it != f.end() ; ++it)
+ if(CTX::instance()->mesh.recombine3DAll ||
+ gr->meshAttributes.recombine3D) {
+ std::vector<GFace *> f = gr->faces();
+ for(std::vector<GFace *>::iterator it = f.begin(); it != f.end(); ++it)
quadsToTriangles(*it, 1000000);
}
}
@@ -809,55 +858,55 @@ static void Mesh3D(GModel *m)
int nb_elements_recombination = 0, nb_hexa_recombination = 0;
// pragma OMP here ?
- for(unsigned int i = 0; i < connected.size(); i++){
+ for(unsigned int i = 0; i < connected.size(); i++) {
MeshDelaunayVolume(connected[i]);
// additional code for experimental hex mesh
- for(unsigned j = 0; j < connected[i].size(); j++){
+ for(unsigned j = 0; j < connected[i].size(); j++) {
GRegion *gr = connected[i][j];
bool treat_region_ok = false;
- if(CTX::instance()->mesh.algo3d == ALGO_3D_RTREE){
- if (old_algo_hexa()){
+ if(CTX::instance()->mesh.algo3d == ALGO_3D_RTREE) {
+ if(old_algo_hexa()) {
Filler f;
f.treat_region(gr);
treat_region_ok = true;
}
- else{
+ else {
Filler3D f;
treat_region_ok = f.treat_region(gr);
}
}
if(treat_region_ok && (CTX::instance()->mesh.recombine3DAll ||
- gr->meshAttributes.recombine3D)){
- if (CTX::instance()->mesh.optimize){
+ gr->meshAttributes.recombine3D)) {
+ if(CTX::instance()->mesh.optimize) {
optimizeMeshGRegionGmsh opt;
opt(gr);
}
double a = Cpu();
- // CTX::instance()->mesh.recombine3DLevel = 2;
+ // CTX::instance()->mesh.recombine3DLevel = 2;
- if (CTX::instance()->mesh.recombine3DLevel >= 0){
+ if(CTX::instance()->mesh.recombine3DLevel >= 0) {
Recombinator rec;
rec.execute(gr);
}
- if (CTX::instance()->mesh.recombine3DLevel >= 1){
+ if(CTX::instance()->mesh.recombine3DLevel >= 1) {
Supplementary sup;
sup.execute(gr);
}
PostOp post;
- post.execute(gr,CTX::instance()->mesh.recombine3DLevel,
+ post.execute(gr, CTX::instance()->mesh.recombine3DLevel,
CTX::instance()->mesh.recombine3DConformity);
- // CTX::instance()->mesh.recombine3DConformity);
+ // CTX::instance()->mesh.recombine3DConformity);
// 0: no pyramid, 1: single-step, 2: two-steps (conforming),
// true: fill non-conformities with trihedra
- RelocateVertices(gr, CTX::instance()->mesh.nbSmoothing);
+ RelocateVertices(gr, CTX::instance()->mesh.nbSmoothing);
// while(LaplaceSmoothing (gr)){
// }
- nb_elements_recombination += post.get_nb_elements();
- nb_hexa_recombination += post.get_nb_hexahedra();
- vol_element_recombination += post.get_vol_elements();
- vol_hexa_recombination += post.get_vol_hexahedra();
+ nb_elements_recombination += post.get_nb_elements();
+ nb_hexa_recombination += post.get_nb_hexahedra();
+ vol_element_recombination += post.get_vol_elements();
+ vol_hexa_recombination += post.get_vol_hexahedra();
// partial export
// stringstream ss;
// ss << "yamakawa_part_";
@@ -869,14 +918,14 @@ static void Mesh3D(GModel *m)
}
}
- if(CTX::instance()->mesh.recombine3DAll){
+ if(CTX::instance()->mesh.recombine3DAll) {
Msg::Info("RECOMBINATION timing:");
Msg::Info(" --- CUMULATIVE TIME RECOMBINATION : %g s.", time_recombination);
Msg::Info("RECOMBINATION CUMULATIVE STATISTICS:");
Msg::Info(".... Percentage of hexahedra (#) : %g",
- nb_hexa_recombination*100./nb_elements_recombination);
+ nb_hexa_recombination * 100. / nb_elements_recombination);
Msg::Info(".... Percentage of hexahedra (Vol) : %g",
- vol_hexa_recombination*100./vol_element_recombination);
+ vol_hexa_recombination * 100. / vol_element_recombination);
// MakeMeshConformal (m, 1);
TestConformity(m);
}
@@ -884,7 +933,8 @@ static void Mesh3D(GModel *m)
// ensure that all volume Jacobians are positive
m->setAllVolumesPositive();
- // std::for_each(m->firstRegion(), m->lastRegion(), optimizeMeshGRegionNetgen());
+ // std::for_each(m->firstRegion(), m->lastRegion(),
+ // optimizeMeshGRegionNetgen());
if(Msg::GetVerbosity() > 98)
std::for_each(m->firstRegion(), m->lastRegion(),
TEST_IF_MESH_IS_COMPATIBLE_WITH_EMBEDDED_ENTITIES());
@@ -898,7 +948,7 @@ static void Mesh3D(GModel *m)
emptyRegionFound = true;
}
}
- if(emptyRegionFound){
+ if(emptyRegionFound) {
debugInfo << std::endl;
Msg::Error(debugInfo.str().c_str());
}
@@ -910,8 +960,7 @@ static void Mesh3D(GModel *m)
double t2 = Cpu();
CTX::instance()->meshTimer[2] = t2 - t1;
- if(m->getNumRegions())
- Msg::ProgressMeter(100, 100, false, "Meshing 3D...");
+ if(m->getNumRegions()) Msg::ProgressMeter(100, 100, false, "Meshing 3D...");
Msg::StatusBar(true, "Done meshing 3D (%g s)", CTX::instance()->meshTimer[2]);
}
@@ -925,7 +974,7 @@ void OptimizeMeshNetgen(GModel *m)
// Ensure that all volume Jacobians are positive
m->setAllVolumesPositive();
- if (Msg::GetVerbosity() > 98)
+ if(Msg::GetVerbosity() > 98)
std::for_each(m->firstRegion(), m->lastRegion(),
TEST_IF_MESH_IS_COMPATIBLE_WITH_EMBEDDED_ENTITIES());
@@ -942,8 +991,9 @@ void OptimizeMesh(GModel *m)
// Ensure that all volume Jacobians are positive
m->setAllVolumesPositive();
- if (Msg::GetVerbosity() > 98)
- std::for_each(m->firstRegion(), m->lastRegion(), TEST_IF_MESH_IS_COMPATIBLE_WITH_EMBEDDED_ENTITIES ());
+ if(Msg::GetVerbosity() > 98)
+ std::for_each(m->firstRegion(), m->lastRegion(),
+ TEST_IF_MESH_IS_COMPATIBLE_WITH_EMBEDDED_ENTITIES());
CTX::instance()->mesh.changed = ENT_ALL;
double t2 = Cpu();
@@ -955,7 +1005,7 @@ void SmoothMesh(GModel *m)
Msg::StatusBar(true, "Smoothing 2D mesh...");
double t1 = Cpu();
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
GFace *gf = *it;
laplaceSmoothing(gf);
}
@@ -983,9 +1033,9 @@ void RecombineMesh(GModel *m)
Msg::StatusBar(true, "Recombining 2D mesh...");
double t1 = Cpu();
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
GFace *gf = *it;
- recombineIntoQuads(gf,true,true,.01);
+ recombineIntoQuads(gf, true, true, .01);
}
CTX::instance()->mesh.changed = ENT_ALL;
@@ -997,7 +1047,6 @@ void RecombineMesh(GModel *m)
void GenerateMesh(GModel *m, int ask)
{
-
// ProfilerStart("gmsh.prof");
if(CTX::instance()->lock) {
Msg::Info("I'm busy! Ask me that later...");
@@ -1045,9 +1094,10 @@ void GenerateMesh(GModel *m, int ask)
std::for_each(m->firstFace(), m->lastFace(), orientMeshGFace());
// Optimize quality of 3D tet mesh
- if(m->getMeshStatus() == 3){
+ if(m->getMeshStatus() == 3) {
for(int i = 0; i < std::max(CTX::instance()->mesh.optimize,
- CTX::instance()->mesh.optimizeNetgen); i++){
+ CTX::instance()->mesh.optimizeNetgen);
+ i++) {
if(CTX::instance()->mesh.optimize > i) OptimizeMesh(m);
if(CTX::instance()->mesh.optimizeNetgen > i) OptimizeMeshNetgen(m);
}
@@ -1064,16 +1114,17 @@ void GenerateMesh(GModel *m, int ask)
// Create high order elements
if(m->getMeshStatus() && CTX::instance()->mesh.order > 1)
- SetOrderN(m, CTX::instance()->mesh.order, CTX::instance()->mesh.secondOrderLinear,
+ SetOrderN(m, CTX::instance()->mesh.order,
+ CTX::instance()->mesh.secondOrderLinear,
CTX::instance()->mesh.secondOrderIncomplete);
// Optimize high order elements
- if(CTX::instance()->mesh.hoOptimize){
+ if(CTX::instance()->mesh.hoOptimize) {
#if defined(HAVE_OPTHOM)
- if(CTX::instance()->mesh.hoOptimize < 0){
+ if(CTX::instance()->mesh.hoOptimize < 0) {
ElasticAnalogy(GModel::current(), false);
}
- else{
+ else {
OptHomParameters p;
p.nbLayers = CTX::instance()->mesh.hoNLayers;
p.BARRIER_MIN = CTX::instance()->mesh.hoThresholdMin;
@@ -1087,8 +1138,8 @@ void GenerateMesh(GModel *m, int ask)
#endif
}
- Msg::Info("%d vertices %d elements",
- m->getNumMeshVertices(), m->getNumMeshElements());
+ Msg::Info("%d vertices %d elements", m->getNumMeshVertices(),
+ m->getNumMeshElements());
Msg::PrintErrorCounter("Mesh generation error summary");
diff --git a/Mesh/Generator.h b/Mesh/Generator.h
index 71ab3feefdd8d5f0dad489f7738c174e122834fb..324eaa3819bd411bb5c882d1f51dd37b06499b20 100644
--- a/Mesh/Generator.h
+++ b/Mesh/Generator.h
@@ -10,17 +10,20 @@ class GModel;
class GRegion;
#include "fullMatrix.h"
-void GetStatistics(double stat[50], double quality[4][100]=0);
+void GetStatistics(double stat[50], double quality[4][100] = 0);
void AdaptMesh(GModel *m);
void GenerateMesh(GModel *m, int dimension);
void OptimizeMesh(GModel *m);
void OptimizeMeshNetgen(GModel *m);
void SmoothMesh(GModel *m);
-void RefineMesh(GModel *m, bool linear, bool splitIntoQuads=false,
- bool splitIntoHexas=false);
+void RefineMesh(GModel *m, bool linear, bool splitIntoQuads = false,
+ bool splitIntoHexas = false);
void BarycentricRefineMesh(GModel *m);
void RecombineMesh(GModel *m);
-GRegion * createTetrahedralMesh ( GModel *gm, fullMatrix<double> & pts, fullMatrix<int> &triangles, bool all_tets=false ) ;
- //GRegion * createTetrahedralMesh ( GModel *gm, unsigned int nbPts , double *pts, unsigned int nbTriangles, int *triangles );
+GRegion *createTetrahedralMesh(GModel *gm, fullMatrix<double> &pts,
+ fullMatrix<int> &triangles,
+ bool all_tets = false);
+// GRegion * createTetrahedralMesh ( GModel *gm, unsigned int nbPts , double
+// *pts, unsigned int nbTriangles, int *triangles );
#endif
diff --git a/Mesh/HighOrder.cpp b/Mesh/HighOrder.cpp
index 19f1b7c4b92182fe42a982e3e2c168ef9bec3908..c5e6934cd655a7cd10bea81e1b740b27271a8fb5 100644
--- a/Mesh/HighOrder.cpp
+++ b/Mesh/HighOrder.cpp
@@ -29,26 +29,27 @@
#include "OptHomPeriodicity.h"
#endif
-// --------- Functions that help optimizing placement of points on geometry -----------
+// --------- Functions that help optimizing placement of points on geometry
+// -----------
// The aim here is to build a polynomial representation that consist
// in polynomial segments of equal length
static double mylength(GEdge *ge, int i, double *u)
{
- return ge->length(u[i], u[i+1], 10);
+ return ge->length(u[i], u[i + 1], 10);
}
static void myresid(int N, GEdge *ge, double *u, fullVector<double> &r,
double *weight = NULL)
{
double L[100];
- for (int i = 0; i < N - 1; i++) L[i] = mylength(ge, i, u);
- if (weight)
- for (int i = 0; i < N - 2; i++) r(i) = L[i+1]/weight[i+1] - L[i]/weight[i];
+ for(int i = 0; i < N - 1; i++) L[i] = mylength(ge, i, u);
+ if(weight)
+ for(int i = 0; i < N - 2; i++)
+ r(i) = L[i + 1] / weight[i + 1] - L[i] / weight[i];
else
- for (int i = 0; i < N - 2; i++) r(i) = L[i+1] - L[i];
-
+ for(int i = 0; i < N - 2; i++) r(i) = L[i + 1] - L[i];
}
static bool computeEquidistantParameters(GEdge *ge, double u0, double uN, int N,
@@ -65,11 +66,11 @@ static bool computeEquidistantParameters(GEdge *ge, double u0, double uN, int N,
// initialize as equidistant in parameter space
u[0] = u0;
double du = (uN - u0) / (N - 1);
- for (int i = 1; i < N; i++){
+ for(int i = 1; i < N; i++) {
u[i] = u[i - 1] + du;
}
- //return true;
+ // return true;
// create the tangent matrix
const int M = N - 2;
@@ -80,33 +81,33 @@ static bool computeEquidistantParameters(GEdge *ge, double u0, double uN, int N,
int iter = 1;
- while (iter < MAX_ITER){
+ while(iter < MAX_ITER) {
iter++;
myresid(N, ge, u, R);
- for (int i = 0; i < M; i++){
+ for(int i = 0; i < M; i++) {
u[i + 1] += eps;
myresid(N, ge, u, Rp);
- for (int j = 0; j < M; j++){
+ for(int j = 0; j < M; j++) {
J(i, j) = (Rp(j) - R(j)) / eps;
}
- u[i+1] -= eps;
+ u[i + 1] -= eps;
}
- if (M == 1)
+ if(M == 1)
DU(0) = R(0) / J(0, 0);
else
J.luSolve(R, DU);
- for (int i = 0; i < M; i++){
- u[i+1] -= underRelax*DU(i);
+ for(int i = 0; i < M; i++) {
+ u[i + 1] -= underRelax * DU(i);
}
- if (u[1] < u0) break;
- if (u[N - 2] > uN) break;
+ if(u[1] < u0) break;
+ if(u[N - 2] > uN) break;
double newt_norm = DU.norm();
- if (newt_norm < PRECISION) {
+ if(newt_norm < PRECISION) {
return true;
}
}
@@ -116,16 +117,12 @@ static bool computeEquidistantParameters(GEdge *ge, double u0, double uN, int N,
static bool computeGLLParametersP6(GEdge *ge, double u0, double uN, int N,
double *u, double underRelax)
{
- static const double GLLQL[7] = {-1.000000000000000,
- -0.830223896278567,
- -0.468848793470714,
- 0,
- 0.468848793470714,
- 0.830223896278567,
- 1.000000000000000};
+ static const double GLLQL[7] = {
+ -1.000000000000000, -0.830223896278567, -0.468848793470714, 0,
+ 0.468848793470714, 0.830223896278567, 1.000000000000000};
double weight[6];
- for (int i = 0; i < 6; ++i) {
- weight[i] = GLLQL[i+1] - GLLQL[i];
+ for(int i = 0; i < 6; ++i) {
+ weight[i] = GLLQL[i + 1] - GLLQL[i];
}
const double PRECISION = 1.e-6;
@@ -138,10 +135,10 @@ static bool computeGLLParametersP6(GEdge *ge, double u0, double uN, int N,
// u[N-1] = uN;
// initialize as equidistant in parameter space
u[0] = u0;
- u[N-1] = uN;
+ u[N - 1] = uN;
double uMiddle = .5 * (u0 + uN);
double du = .5 * (uN - u0);
- for (int i = 1; i < N-1; i++){
+ for(int i = 1; i < N - 1; i++) {
u[i] = uMiddle + GLLQL[i] * du;
}
@@ -154,33 +151,33 @@ static bool computeGLLParametersP6(GEdge *ge, double u0, double uN, int N,
int iter = 1;
- while (iter < MAX_ITER){
+ while(iter < MAX_ITER) {
iter++;
myresid(N, ge, u, R, weight);
- for (int i = 0; i < M; i++){
+ for(int i = 0; i < M; i++) {
u[i + 1] += eps;
myresid(N, ge, u, Rp, weight);
- for (int j = 0; j < M; j++){
+ for(int j = 0; j < M; j++) {
J(i, j) = (Rp(j) - R(j)) / eps;
}
- u[i+1] -= eps;
+ u[i + 1] -= eps;
}
- if (M == 1)
+ if(M == 1)
DU(0) = R(0) / J(0, 0);
else
J.luSolve(R, DU);
- for (int i = 0; i < M; i++){
- u[i+1] -= underRelax*DU(i);
+ for(int i = 0; i < M; i++) {
+ u[i + 1] -= underRelax * DU(i);
}
- if (u[1] < u0) break;
- if (u[N - 2] > uN) break;
+ if(u[1] < u0) break;
+ if(u[N - 2] > uN) break;
double newt_norm = DU.norm();
- if (newt_norm < PRECISION) {
+ if(newt_norm < PRECISION) {
return true;
}
}
@@ -192,19 +189,21 @@ static bool computeEquidistantParameters(GFace *gf, double u0, double uN,
SPoint3 &pN, int N, bool geodesic,
double *u, double *v)
{
- const int NI = N-1;
- u[0] = u0; v[0] = v0;
- u[NI] = uN; v[NI] = vN;
- const double fact = 1./(double)NI;
- for (int i = 1; i < NI; i++){
- const double t = i*fact;
- u[i] = u0 + (uN-u0)*t;
- v[i] = v0 + (vN-v0)*t;
- if (geodesic) {
- SPoint3 pc(t*pN + (1.-t)*p0);
+ const int NI = N - 1;
+ u[0] = u0;
+ v[0] = v0;
+ u[NI] = uN;
+ v[NI] = vN;
+ const double fact = 1. / (double)NI;
+ for(int i = 1; i < NI; i++) {
+ const double t = i * fact;
+ u[i] = u0 + (uN - u0) * t;
+ v[i] = v0 + (vN - v0) * t;
+ if(geodesic) {
+ SPoint3 pc(t * pN + (1. - t) * p0);
double guess[2] = {u[i], v[i]};
GPoint gp = gf->closestPoint(pc, guess);
- if(gp.succeeded()){
+ if(gp.succeeded()) {
u[i] = gp.u();
v[i] = gp.v();
}
@@ -213,33 +212,23 @@ static bool computeEquidistantParameters(GFace *gf, double u0, double uN,
return true;
}
-
-
static fullMatrix<double> *lob2lagP6 = NULL;
void createMatLob2LagP6()
{
- const double lobPt[7] = {-1.000000000000000,
- -0.830223896278567,
- -0.468848793470714,
- 0,
- 0.468848793470714,
- 0.830223896278567,
- 1.000000000000000};
- const double lagPt[7] = {-1.000000000000000,
- -0.666666666666666,
- -0.333333333333333,
- 0,
- 0.333333333333333,
- 0.666666666666666,
- 1.000000000000000};
+ const double lobPt[7] = {
+ -1.000000000000000, -0.830223896278567, -0.468848793470714, 0,
+ 0.468848793470714, 0.830223896278567, 1.000000000000000};
+ const double lagPt[7] = {
+ -1.000000000000000, -0.666666666666666, -0.333333333333333, 0,
+ 0.333333333333333, 0.666666666666666, 1.000000000000000};
const int ndofs = 7;
const double monomial[7] = {0, 1, 2, 3, 4, 5, 6};
fullMatrix<double> Vandermonde(ndofs, ndofs);
- for (int i = 0; i < ndofs; i++) {
- for (int j = 0; j < ndofs; j++) {
+ for(int i = 0; i < ndofs; i++) {
+ for(int j = 0; j < ndofs; j++) {
Vandermonde(i, j) = pow_int(lobPt[i], monomial[j]);
}
}
@@ -249,19 +238,19 @@ void createMatLob2LagP6()
lob2lagP6 = new fullMatrix<double>(ndofs, ndofs);
- for (int i = 0; i < ndofs; i++) {
- for (int j = 0; j < ndofs; j++) {
+ for(int i = 0; i < ndofs; i++) {
+ for(int j = 0; j < ndofs; j++) {
Vandermonde(i, j) = pow_int(lagPt[i], monomial[j]);
}
}
- Vandermonde.mult(coefficient,(*lob2lagP6));
+ Vandermonde.mult(coefficient, (*lob2lagP6));
}
// --------- Creation of high-order edge vertices -----------
static bool getEdgeVerticesOnGeo(GEdge *ge, MVertex *v0, MVertex *v1,
- std::vector<MVertex*> &ve, int nPts = 1)
+ std::vector<MVertex *> &ve, int nPts = 1)
{
static bool GLLquad = false;
static const double relaxFail = 1e-2;
@@ -274,55 +263,57 @@ static bool getEdgeVerticesOnGeo(GEdge *ge, MVertex *v0, MVertex *v1,
else
reparamOK &= reparamMeshVertexOnEdge(v1, ge, u1);
- if (reparamOK) {
+ if(reparamOK) {
double uMin = std::min(u0, u1), uMax = std::max(u0, u1);
bool failed = true;
double relax = 1.;
- while (failed && (relax > relaxFail)) {
- if (GLLquad)
+ while(failed && (relax > relaxFail)) {
+ if(GLLquad)
failed = !computeGLLParametersP6(ge, uMin, uMax, nPts + 2, US, relax);
else
- failed = !computeEquidistantParameters(ge, uMin, uMax, nPts + 2, US, relax);
+ failed =
+ !computeEquidistantParameters(ge, uMin, uMax, nPts + 2, US, relax);
relax *= 0.5;
}
- if (failed) {
- Msg::Warning
- ("Failed to compute equidistant parameters (relax = %g, value = %g) "
- "for edge %d-%d parametrized with %g %g on GEdge %d",
- relax, US[1], v0->getNum(), v1->getNum(),u0,u1,ge->tag());
+ if(failed) {
+ Msg::Warning(
+ "Failed to compute equidistant parameters (relax = %g, value = %g) "
+ "for edge %d-%d parametrized with %g %g on GEdge %d",
+ relax, US[1], v0->getNum(), v1->getNum(), u0, u1, ge->tag());
US[0] = uMin;
- const double du = (uMax - uMin) / (nPts+1);
- for (int i = 1; i <= nPts; i++) US[i] = US[i - 1] + du;
+ const double du = (uMax - uMin) / (nPts + 1);
+ for(int i = 1; i <= nPts; i++) US[i] = US[i - 1] + du;
}
}
else
Msg::Error("Cannot reparam a mesh Vertex in high order meshing");
- if (!reparamOK) return false;
+ if(!reparamOK) return false;
- if (GLLquad) {
+ if(GLLquad) {
fullMatrix<double> M(7, 3);
- M(0, 0) = u0<u1 ? v0->x() : v1->x();
- M(0, 1) = u0<u1 ? v0->y() : v1->y();
- M(0, 2) = u0<u1 ? v0->z() : v1->z();
- M(6, 0) = u0<u1 ? v1->x() : v0->x();
- M(6, 1) = u0<u1 ? v1->y() : v0->y();
- M(6, 2) = u0<u1 ? v1->z() : v0->z();
+ M(0, 0) = u0 < u1 ? v0->x() : v1->x();
+ M(0, 1) = u0 < u1 ? v0->y() : v1->y();
+ M(0, 2) = u0 < u1 ? v0->z() : v1->z();
+ M(6, 0) = u0 < u1 ? v1->x() : v0->x();
+ M(6, 1) = u0 < u1 ? v1->y() : v0->y();
+ M(6, 2) = u0 < u1 ? v1->z() : v0->z();
for(int j = 0; j < nPts; j++) {
- int count = u0<u1? j + 1 : nPts + 1 - (j + 1);
+ int count = u0 < u1 ? j + 1 : nPts + 1 - (j + 1);
GPoint pc = ge->point(US[count]);
- M(j+1, 0) = pc.x();
- M(j+1, 1) = pc.y();
- M(j+1, 2) = pc.z();
+ M(j + 1, 0) = pc.x();
+ M(j + 1, 1) = pc.y();
+ M(j + 1, 2) = pc.z();
}
fullMatrix<double> Mlag(7, 3);
- if (!lob2lagP6) createMatLob2LagP6();
+ if(!lob2lagP6) createMatLob2LagP6();
lob2lagP6->mult(M, Mlag);
for(int j = 0; j < nPts; j++) {
MVertex *v;
- int count = u0<u1? j + 1 : nPts + 1 - (j + 1);
+ int count = u0 < u1 ? j + 1 : nPts + 1 - (j + 1);
// FIXME US[count] false!!!
- v = new MEdgeVertex(Mlag(count, 0), Mlag(count, 1), Mlag(count, 2), ge, US[count]);
+ v = new MEdgeVertex(Mlag(count, 0), Mlag(count, 1), Mlag(count, 2), ge,
+ US[count]);
// this destroys the ordering of the mesh vertices on the edge
ve.push_back(v);
}
@@ -330,7 +321,7 @@ static bool getEdgeVerticesOnGeo(GEdge *ge, MVertex *v0, MVertex *v1,
else {
for(int j = 0; j < nPts; j++) {
MVertex *v;
- int count = u0<u1? j + 1 : nPts + 1 - (j + 1);
+ int count = u0 < u1 ? j + 1 : nPts + 1 - (j + 1);
GPoint pc = ge->point(US[count]);
v = new MEdgeVertex(pc.x(), pc.y(), pc.z(), ge, US[count]);
// this destroys the ordering of the mesh vertices on the edge
@@ -338,28 +329,28 @@ static bool getEdgeVerticesOnGeo(GEdge *ge, MVertex *v0, MVertex *v1,
}
}
-// GLLquad = false;
+ // GLLquad = false;
return true;
}
static bool getEdgeVerticesOnGeo(GFace *gf, MVertex *v0, MVertex *v1,
- std::vector<MVertex*> &ve, int nPts = 1)
+ std::vector<MVertex *> &ve, int nPts = 1)
{
SPoint2 p0, p1;
double US[100], VS[100];
bool reparamOK = reparamMeshEdgeOnFace(v0, v1, gf, p0, p1);
if(reparamOK) {
SPoint3 pnt0, pnt1;
- if (nPts >= 30)
- computeEquidistantParameters(gf, p0[0], p1[0], p0[1], p1[1],
- pnt0, pnt1, nPts + 2, false, US, VS);
+ if(nPts >= 30)
+ computeEquidistantParameters(gf, p0[0], p1[0], p0[1], p1[1], pnt0, pnt1,
+ nPts + 2, false, US, VS);
else {
pnt0 = v0->point();
pnt1 = v1->point();
// FIXME: using the geodesic is sometimes a bad idea when the edge is "far
// away" from the surface (e.g. on the diameter of a circle!)
- computeEquidistantParameters(gf, p0[0], p1[0], p0[1], p1[1],
- pnt0, pnt1, nPts + 2, true, US, VS);
+ computeEquidistantParameters(gf, p0[0], p1[0], p0[1], p1[1], pnt0, pnt1,
+ nPts + 2, true, US, VS);
}
}
else {
@@ -367,9 +358,10 @@ static bool getEdgeVerticesOnGeo(GFace *gf, MVertex *v0, MVertex *v1,
return false;
}
- for(int j = 0; j < nPts; j++){
+ for(int j = 0; j < nPts; j++) {
GPoint pc = gf->point(US[j + 1], VS[j + 1]);
- MVertex *v = new MFaceVertex(pc.x(), pc.y(), pc.z(), gf, US[j + 1], VS[j + 1]);
+ MVertex *v =
+ new MFaceVertex(pc.x(), pc.y(), pc.z(), gf, US[j + 1], VS[j + 1]);
ve.push_back(v);
}
@@ -377,34 +369,40 @@ static bool getEdgeVerticesOnGeo(GFace *gf, MVertex *v0, MVertex *v1,
}
static void interpVerticesInExistingEdge(GEntity *ge, const MElement *edgeEl,
- std::vector<MVertex*> &veEdge, int nPts)
+ std::vector<MVertex *> &veEdge,
+ int nPts)
{
fullMatrix<double> points;
- points = edgeEl->getFunctionSpace(nPts+1)->points;
- for(int k = 2; k < nPts+2; k++) {
+ points = edgeEl->getFunctionSpace(nPts + 1)->points;
+ for(int k = 2; k < nPts + 2; k++) {
SPoint3 pos;
edgeEl->pnt(points(k, 0), 0., 0., pos);
- MVertex* v = new MVertex(pos.x(), pos.y(), pos.z(), ge);
+ MVertex *v = new MVertex(pos.x(), pos.y(), pos.z(), ge);
veEdge.push_back(v);
}
}
-inline static bool getMinMaxVert(MVertex *v0, MVertex *v1, MVertex *&vMin, MVertex *&vMax)
+inline static bool getMinMaxVert(MVertex *v0, MVertex *v1, MVertex *&vMin,
+ MVertex *&vMax)
{
const bool increasing = (v0->getNum() < v1->getNum());
- if (increasing) {
- vMin = v0; vMax = v1;
+ if(increasing) {
+ vMin = v0;
+ vMax = v1;
}
else {
- vMin = v1; vMax = v0;
+ vMin = v1;
+ vMax = v0;
}
return increasing;
}
// Get new interior vertices for a 1D element
-static void getEdgeVertices(GEdge *ge, MElement *ele, std::vector<MVertex*> &ve,
- std::vector<MVertex*> &newHOVert, edgeContainer &edgeVertices,
- bool linear, int nPts = 1)
+static void getEdgeVertices(GEdge *ge, MElement *ele,
+ std::vector<MVertex *> &ve,
+ std::vector<MVertex *> &newHOVert,
+ edgeContainer &edgeVertices, bool linear,
+ int nPts = 1)
{
if(ge->geomType() == GEntity::DiscreteCurve ||
ge->geomType() == GEntity::BoundaryLayerCurve ||
@@ -412,35 +410,40 @@ static void getEdgeVertices(GEdge *ge, MElement *ele, std::vector<MVertex*> &ve,
ge->geomType() == GEntity::PartitionCurve)
linear = true;
- std::vector<MVertex*> veOld;
+ std::vector<MVertex *> veOld;
ele->getVertices(veOld);
MVertex *vMin, *vMax;
const bool increasing = getMinMaxVert(veOld[0], veOld[1], vMin, vMax);
- std::pair<MVertex*, MVertex*> p(vMin, vMax);
- std::vector<MVertex*> veEdge;
+ std::pair<MVertex *, MVertex *> p(vMin, vMax);
+ std::vector<MVertex *> veEdge;
// Get vertices on geometry if asked
- bool gotVertOnGeo = linear ? false :
- getEdgeVerticesOnGeo(ge, veOld[0], veOld[1], veEdge, nPts);
+ bool gotVertOnGeo =
+ linear ? false : getEdgeVerticesOnGeo(ge, veOld[0], veOld[1], veEdge, nPts);
// If not on geometry, create from mesh interpolation
- if (!gotVertOnGeo)
- interpVerticesInExistingEdge(ge, ele, veEdge, nPts);
+ if(!gotVertOnGeo) interpVerticesInExistingEdge(ge, ele, veEdge, nPts);
newHOVert.insert(newHOVert.end(), veEdge.begin(), veEdge.end());
- if (edgeVertices.count(p) == 0) {
- if (increasing) // Add newly created vertices to list
- edgeVertices[p].insert(edgeVertices[p].end(), veEdge.begin(), veEdge.end());
+ if(edgeVertices.count(p) == 0) {
+ if(increasing) // Add newly created vertices to list
+ edgeVertices[p].insert(edgeVertices[p].end(), veEdge.begin(),
+ veEdge.end());
else
- edgeVertices[p].insert(edgeVertices[p].end(), veEdge.rbegin(), veEdge.rend());
+ edgeVertices[p].insert(edgeVertices[p].end(), veEdge.rbegin(),
+ veEdge.rend());
}
- else if (p.first != p.second) { // Vertices already exist and edge is not a degenerated edge
- Msg::Error("Edges from different entities share vertices: create a finer mesh");
+ else if(p.first != p.second) { // Vertices already exist and edge is not a
+ // degenerated edge
+ Msg::Error(
+ "Edges from different entities share vertices: create a finer mesh");
}
ve.insert(ve.end(), veEdge.begin(), veEdge.end());
}
// Get new interior vertices for an edge in a 2D element
-static void getEdgeVertices(GFace *gf, MElement *ele, std::vector<MVertex*> &ve,
- std::vector<MVertex*> &newHOVert, edgeContainer &edgeVertices,
- bool linear, int nPts = 1)
+static void getEdgeVertices(GFace *gf, MElement *ele,
+ std::vector<MVertex *> &ve,
+ std::vector<MVertex *> &newHOVert,
+ edgeContainer &edgeVertices, bool linear,
+ int nPts = 1)
{
if(gf->geomType() == GEntity::DiscreteSurface ||
gf->geomType() == GEntity::BoundaryLayerSurface ||
@@ -449,17 +452,17 @@ static void getEdgeVertices(GFace *gf, MElement *ele, std::vector<MVertex*> &ve,
linear = true;
for(int i = 0; i < ele->getNumEdges(); i++) {
- std::vector<MVertex*> veOld;
- ele->getEdgeVertices(i,veOld);
+ std::vector<MVertex *> veOld;
+ ele->getEdgeVertices(i, veOld);
MVertex *vMin, *vMax;
const bool increasing = getMinMaxVert(veOld[0], veOld[1], vMin, vMax);
- std::pair<MVertex*, MVertex*> p(vMin, vMax);
- std::vector<MVertex*> veEdge;
+ std::pair<MVertex *, MVertex *> p(vMin, vMax);
+ std::vector<MVertex *> veEdge;
edgeContainer::iterator eIter = edgeVertices.find(p);
- if(eIter!=edgeVertices.end()) { // Vertices already exist
- std::vector<MVertex*>& eVtcs = eIter->second;
+ if(eIter != edgeVertices.end()) { // Vertices already exist
+ std::vector<MVertex *> &eVtcs = eIter->second;
if(increasing)
veEdge.assign(eVtcs.begin(), eVtcs.end());
else
@@ -467,16 +470,17 @@ static void getEdgeVertices(GFace *gf, MElement *ele, std::vector<MVertex*> &ve,
}
else { // Vertices do not exist, create them
// Get vertices on geometry if asked
- bool gotVertOnGeo = linear ? false :
- getEdgeVerticesOnGeo(gf, veOld[0], veOld[1], veEdge, nPts);
- if (!gotVertOnGeo) {
+ bool gotVertOnGeo =
+ linear ? false :
+ getEdgeVerticesOnGeo(gf, veOld[0], veOld[1], veEdge, nPts);
+ if(!gotVertOnGeo) {
// If not on geometry, create from mesh interpolation
const MLineN edgeEl(veOld, ele->getPolynomialOrder());
interpVerticesInExistingEdge(gf, &edgeEl, veEdge, nPts);
}
newHOVert.insert(newHOVert.end(), veEdge.begin(), veEdge.end());
- std::vector<MVertex*>& eVtcs = edgeVertices[p];
+ std::vector<MVertex *> &eVtcs = edgeVertices[p];
if(increasing) // Add newly created vertices to list
eVtcs.insert(eVtcs.end(), veEdge.begin(), veEdge.end());
@@ -488,17 +492,18 @@ static void getEdgeVertices(GFace *gf, MElement *ele, std::vector<MVertex*> &ve,
}
// Get new interior vertices for an edge in a 3D element
-static void getEdgeVertices(GRegion *gr, MElement *ele, std::vector<MVertex*> &ve,
- std::vector<MVertex*> &newHOVert,
+static void getEdgeVertices(GRegion *gr, MElement *ele,
+ std::vector<MVertex *> &ve,
+ std::vector<MVertex *> &newHOVert,
edgeContainer &edgeVertices, int nPts = 1)
{
for(int i = 0; i < ele->getNumEdges(); i++) {
- std::vector<MVertex*> veOld;
- ele->getEdgeVertices(i,veOld);
+ std::vector<MVertex *> veOld;
+ ele->getEdgeVertices(i, veOld);
MVertex *vMin, *vMax;
const bool increasing = getMinMaxVert(veOld[0], veOld[1], vMin, vMax);
- std::pair<MVertex*, MVertex*> p(vMin, vMax);
- std::vector<MVertex*> veEdge;
+ std::pair<MVertex *, MVertex *> p(vMin, vMax);
+ std::vector<MVertex *> veEdge;
if(edgeVertices.count(p)) { // Vertices already exist
if(increasing)
veEdge.assign(edgeVertices[p].begin(), edgeVertices[p].end());
@@ -510,9 +515,11 @@ static void getEdgeVertices(GRegion *gr, MElement *ele, std::vector<MVertex*> &v
interpVerticesInExistingEdge(gr, &edgeEl, veEdge, nPts);
newHOVert.insert(newHOVert.end(), veEdge.begin(), veEdge.end());
if(increasing) // Add newly created vertices to list
- edgeVertices[p].insert(edgeVertices[p].end(), veEdge.begin(), veEdge.end());
+ edgeVertices[p].insert(edgeVertices[p].end(), veEdge.begin(),
+ veEdge.end());
else
- edgeVertices[p].insert(edgeVertices[p].end(), veEdge.rbegin(), veEdge.rend());
+ edgeVertices[p].insert(edgeVertices[p].end(), veEdge.rbegin(),
+ veEdge.rend());
}
ve.insert(ve.end(), veEdge.begin(), veEdge.end());
}
@@ -520,133 +527,181 @@ static void getEdgeVertices(GRegion *gr, MElement *ele, std::vector<MVertex*> &v
// --------- Creation of high-order face vertices -----------
-static void reorientTrianglePoints(std::vector<MVertex*> &vtcs, int orientation,
- bool swap)
+static void reorientTrianglePoints(std::vector<MVertex *> &vtcs,
+ int orientation, bool swap)
{
int nbPts = vtcs.size();
- if (nbPts <= 1) return;
- std::vector<MVertex*> tmp(nbPts);
+ if(nbPts <= 1) return;
+ std::vector<MVertex *> tmp(nbPts);
int interiorOrder = (int)((sqrt(1. + 8. * nbPts) - 3) / 2);
int pos = 0;
- for (int o = interiorOrder; o>0; o-=3) {
- if (swap) {
+ for(int o = interiorOrder; o > 0; o -= 3) {
+ if(swap) {
tmp[pos] = vtcs[pos];
- tmp[pos+1] = vtcs[pos+2];
- tmp[pos+2] = vtcs[pos+1];
- for (int i = 0; i < 3*(o-1); i++)
- tmp[pos+3+i] = vtcs[pos+3*o-i-1];
+ tmp[pos + 1] = vtcs[pos + 2];
+ tmp[pos + 2] = vtcs[pos + 1];
+ for(int i = 0; i < 3 * (o - 1); i++)
+ tmp[pos + 3 + i] = vtcs[pos + 3 * o - i - 1];
}
else {
- for (int i = 0; i < 3*o; i++)
- tmp[pos+i] = vtcs[pos+i];
+ for(int i = 0; i < 3 * o; i++) tmp[pos + i] = vtcs[pos + i];
}
- for (int i = 0; i < 3; i++) {
- int ri = (i+orientation)%3;
- vtcs[pos+ri] = tmp[pos+i];
- for (int j = 0; j < o-1; j++)
- vtcs[pos+3+(o-1)*ri+j] = tmp[pos+3+(o-1)*i+j];
+ for(int i = 0; i < 3; i++) {
+ int ri = (i + orientation) % 3;
+ vtcs[pos + ri] = tmp[pos + i];
+ for(int j = 0; j < o - 1; j++)
+ vtcs[pos + 3 + (o - 1) * ri + j] = tmp[pos + 3 + (o - 1) * i + j];
}
- pos += 3*o;
+ pos += 3 * o;
}
}
-static void reorientQuadPoints(std::vector<MVertex*> &vtcs, int orientation,
+static void reorientQuadPoints(std::vector<MVertex *> &vtcs, int orientation,
bool swap, int order)
{
int nbPts = vtcs.size();
- if (nbPts <= 1) return;
- std::vector<MVertex*> tmp(nbPts);
+ if(nbPts <= 1) return;
+ std::vector<MVertex *> tmp(nbPts);
int start = 0;
- while (1){
+ while(1) {
// CORNERS
int index = 0;
- if (order == 0){
+ if(order == 0) {
start++;
}
- else{
- int i1(0),i2(0),i3(0),i4(0);
- if (!swap){
- if (orientation == 0){ i1 = 0; i2 = 1; i3 = 2; i4 = 3; }
- else if (orientation == 1){ i1 = 3; i2 = 0; i3 = 1; i4 = 2; }
- else if (orientation == 2){ i1 = 2; i2 = 3; i3 = 0; i4 = 1; }
- else if (orientation == 3){ i1 = 1; i2 = 2; i3 = 3; i4 = 0; }
+ else {
+ int i1(0), i2(0), i3(0), i4(0);
+ if(!swap) {
+ if(orientation == 0) {
+ i1 = 0;
+ i2 = 1;
+ i3 = 2;
+ i4 = 3;
+ }
+ else if(orientation == 1) {
+ i1 = 3;
+ i2 = 0;
+ i3 = 1;
+ i4 = 2;
+ }
+ else if(orientation == 2) {
+ i1 = 2;
+ i2 = 3;
+ i3 = 0;
+ i4 = 1;
+ }
+ else if(orientation == 3) {
+ i1 = 1;
+ i2 = 2;
+ i3 = 3;
+ i4 = 0;
+ }
}
- else{
- if (orientation == 0){ i1 = 0; i2 = 3; i3 = 2; i4 = 1; }
- else if (orientation == 3){ i1 = 3; i2 = 2; i3 = 1; i4 = 0; }
- else if (orientation == 2){ i1 = 2; i2 = 1; i3 = 0; i4 = 3; }
- else if (orientation == 1){ i1 = 1; i2 = 0; i3 = 3; i4 = 2; }
+ else {
+ if(orientation == 0) {
+ i1 = 0;
+ i2 = 3;
+ i3 = 2;
+ i4 = 1;
+ }
+ else if(orientation == 3) {
+ i1 = 3;
+ i2 = 2;
+ i3 = 1;
+ i4 = 0;
+ }
+ else if(orientation == 2) {
+ i1 = 2;
+ i2 = 1;
+ i3 = 0;
+ i4 = 3;
+ }
+ else if(orientation == 1) {
+ i1 = 1;
+ i2 = 0;
+ i3 = 3;
+ i4 = 2;
+ }
}
int indices[4] = {i1, i2, i3, i4};
- for (int i = 0; i < 4; i++) tmp[i] = vtcs[start + indices[i]];
- for (int i = 0; i < 4; i++) vtcs[start + i] = tmp[i];
+ for(int i = 0; i < 4; i++) tmp[i] = vtcs[start + indices[i]];
+ for(int i = 0; i < 4; i++) vtcs[start + i] = tmp[i];
// EDGES
start += 4;
- for (int iEdge=0;iEdge<4;iEdge++){
+ for(int iEdge = 0; iEdge < 4; iEdge++) {
int p1 = indices[iEdge];
- int p2 = indices[(iEdge+1)%4];
- int nbP = order-1;
- if (p1 == 0 && p2 == 1){
- for (int i = start+0*nbP; i < start+1*nbP; i++) tmp[index++] = vtcs[i];
+ int p2 = indices[(iEdge + 1) % 4];
+ int nbP = order - 1;
+ if(p1 == 0 && p2 == 1) {
+ for(int i = start + 0 * nbP; i < start + 1 * nbP; i++)
+ tmp[index++] = vtcs[i];
}
- else if (p1 == 1 && p2 == 2){
- for (int i = start+1*nbP; i< start+2*nbP; i++) tmp[index++] = vtcs[i];
+ else if(p1 == 1 && p2 == 2) {
+ for(int i = start + 1 * nbP; i < start + 2 * nbP; i++)
+ tmp[index++] = vtcs[i];
}
- else if (p1 == 2 && p2 == 3){
- for (int i = start+2*nbP; i< start+3*nbP; i++) tmp[index++] = vtcs[i];
+ else if(p1 == 2 && p2 == 3) {
+ for(int i = start + 2 * nbP; i < start + 3 * nbP; i++)
+ tmp[index++] = vtcs[i];
}
- else if (p1 == 3 && p2 == 0){
- for (int i = start+3*nbP; i< start+4*nbP; i++) tmp[index++] = vtcs[i];
+ else if(p1 == 3 && p2 == 0) {
+ for(int i = start + 3 * nbP; i < start + 4 * nbP; i++)
+ tmp[index++] = vtcs[i];
}
- else if (p1 == 1 && p2 == 0){
- for (int i = start+1*nbP-1; i >= start+0*nbP; i--) tmp[index++] = vtcs[i];
+ else if(p1 == 1 && p2 == 0) {
+ for(int i = start + 1 * nbP - 1; i >= start + 0 * nbP; i--)
+ tmp[index++] = vtcs[i];
}
- else if (p1 == 2 && p2 == 1){
- for (int i = start+2*nbP-1; i >= start+1*nbP; i--) tmp[index++] = vtcs[i];
+ else if(p1 == 2 && p2 == 1) {
+ for(int i = start + 2 * nbP - 1; i >= start + 1 * nbP; i--)
+ tmp[index++] = vtcs[i];
}
- else if (p1 == 3 && p2 == 2){
- for (int i = start+3*nbP-1; i >= start+2*nbP; i--) tmp[index++] = vtcs[i];
+ else if(p1 == 3 && p2 == 2) {
+ for(int i = start + 3 * nbP - 1; i >= start + 2 * nbP; i--)
+ tmp[index++] = vtcs[i];
}
- else if (p1 == 0 && p2 == 3){
- for (int i = start+4*nbP-1; i >= start+3*nbP; i--) tmp[index++] = vtcs[i];
+ else if(p1 == 0 && p2 == 3) {
+ for(int i = start + 4 * nbP - 1; i >= start + 3 * nbP; i--)
+ tmp[index++] = vtcs[i];
}
- else Msg::Error("Something wrong in reorientQuadPoints");
+ else
+ Msg::Error("Something wrong in reorientQuadPoints");
}
- for (int i = 0; i < index; i++)vtcs[start+i] = tmp[i];
+ for(int i = 0; i < index; i++) vtcs[start + i] = tmp[i];
start += index;
}
order -= 2;
- if (start >= (int) vtcs.size()) break;
+ if(start >= (int)vtcs.size()) break;
}
}
static void getFaceVerticesOnGeo(GFace *gf,
const fullMatrix<double> &coefficients,
- const std::vector<MVertex*> &vertices,
- std::vector<MVertex*> &vf)
+ const std::vector<MVertex *> &vertices,
+ std::vector<MVertex *> &vf)
{
SPoint2 pts[1000];
bool reparamOK = true;
- for (unsigned int k = 0; k < vertices.size(); ++k)
+ for(unsigned int k = 0; k < vertices.size(); ++k)
reparamOK &= reparamMeshVertexOnFace(vertices[k], gf, pts[k]);
for(int k = 0; k < coefficients.size1(); k++) {
double X(0), Y(0), Z(0), GUESS[2] = {0, 0};
- for (int j = 0; j < coefficients.size2(); j++){
+ for(int j = 0; j < coefficients.size2(); j++) {
MVertex *vt = vertices[j];
X += coefficients(k, j) * vt->x();
Y += coefficients(k, j) * vt->y();
Z += coefficients(k, j) * vt->z();
- if (reparamOK){
+ if(reparamOK) {
GUESS[0] += coefficients(k, j) * pts[j][0];
GUESS[1] += coefficients(k, j) * pts[j][1];
}
}
MVertex *v;
- if(reparamOK){
+ if(reparamOK) {
// GPoint gp = gf->point(SPoint2(GUESS[0], GUESS[1]));
// closest point is not necessary (slow and for high quality HO
// meshes it should be optimized anyway afterwards + closest point
@@ -654,14 +709,14 @@ static void getFaceVerticesOnGeo(GFace *gf,
GPoint gp = gf->closestPoint(SPoint3(X, Y, Z), GUESS);
// AJ: ClosestPoint is absolutely necessary when the parameterization
// is degenerate...
- if (gp.g()){
+ if(gp.g()) {
v = new MFaceVertex(gp.x(), gp.y(), gp.z(), gf, gp.u(), gp.v());
}
- else{
+ else {
v = new MVertex(X, Y, Z, gf);
}
}
- else{
+ else {
GPoint gp = gf->closestPoint(SPoint3(X, Y, Z), GUESS);
if(gp.succeeded())
v = new MVertex(gp.x(), gp.y(), gp.z(), gf);
@@ -674,12 +729,12 @@ static void getFaceVerticesOnGeo(GFace *gf,
static void interpVerticesInExistingFace(GEntity *ge,
const fullMatrix<double> &coefficients,
- const std::vector<MVertex*> &vertices,
- std::vector<MVertex*> &vFace)
+ const std::vector<MVertex *> &vertices,
+ std::vector<MVertex *> &vFace)
{
- for (int k = 0; k < coefficients.size1(); k++) {
+ for(int k = 0; k < coefficients.size1(); k++) {
double x(0), y(0), z(0);
- for (int j = 0; j < coefficients.size2(); j++){
+ for(int j = 0; j < coefficients.size2(); j++) {
MVertex *v = vertices[j];
x += coefficients(k, j) * v->x();
y += coefficients(k, j) * v->y();
@@ -693,139 +748,146 @@ static void interpVerticesInExistingFace(GEntity *ge,
static void getFaceVertices(GFace *gf, MElement *ele,
std::vector<MVertex *> &newVertices,
std::vector<MVertex *> &newHOVert,
- faceContainer &faceVertices,
- bool linear, int nPts = 1)
+ faceContainer &faceVertices, bool linear,
+ int nPts = 1)
{
if(gf->geomType() == GEntity::DiscreteSurface ||
gf->geomType() == GEntity::BoundaryLayerSurface ||
gf->geomType() == GEntity::CompoundSurface)
linear = true;
- std::vector<MVertex*> boundaryVertices;
+ std::vector<MVertex *> boundaryVertices;
{
int nCorner = ele->getNumPrimaryVertices();
boundaryVertices.reserve(nCorner + newVertices.size());
ele->getVertices(boundaryVertices);
boundaryVertices.resize(nCorner);
- boundaryVertices.insert(boundaryVertices.end(),
- newVertices.begin(), newVertices.end());
+ boundaryVertices.insert(boundaryVertices.end(), newVertices.begin(),
+ newVertices.end());
}
int type = ele->getType();
- fullMatrix<double> *coefficients = getInnerVertexPlacement(type, nPts+1);
- std::vector<MVertex*> vFace;
- if (!linear) {// Get vertices on geometry if asked...
+ fullMatrix<double> *coefficients = getInnerVertexPlacement(type, nPts + 1);
+ std::vector<MVertex *> vFace;
+ if(!linear) { // Get vertices on geometry if asked...
getFaceVerticesOnGeo(gf, *coefficients, boundaryVertices, vFace);
}
- else {// ... otherwise, create from mesh interpolation
+ else { // ... otherwise, create from mesh interpolation
interpVerticesInExistingFace(gf, *coefficients, boundaryVertices, vFace);
}
MFace face = ele->getFace(0);
- faceVertices[face].insert(faceVertices[face].end(), vFace.begin(), vFace.end());
+ faceVertices[face].insert(faceVertices[face].end(), vFace.begin(),
+ vFace.end());
newVertices.insert(newVertices.end(), vFace.begin(), vFace.end());
newHOVert.insert(newHOVert.end(), vFace.begin(), vFace.end());
}
static int retrieveFaceBoundaryVertices(int k, int type, int nPts,
- const std::vector<MVertex*> &vCorner,
- const std::vector<MVertex*> &vEdges,
- std::vector<MVertex*> &v)
+ const std::vector<MVertex *> &vCorner,
+ const std::vector<MVertex *> &vEdges,
+ std::vector<MVertex *> &v)
{
v.clear();
int nCorner;
- switch (type) {
- case TYPE_TET:
- v.push_back(vCorner[MTetrahedron::faces_tetra(k, 0)]);
- v.push_back(vCorner[MTetrahedron::faces_tetra(k, 1)]);
- v.push_back(vCorner[MTetrahedron::faces_tetra(k, 2)]);
- for (int i = 0; i < 3; ++i) {
- int edge = MTetrahedron::faces2edge_tetra(k, i);
- int n = std::abs(edge) - 1;
- v.insert(v.end(), vEdges.begin() + n * nPts, vEdges.begin() + (n+1) * nPts);
- if (edge < 0) std::reverse(v.end() - nPts, v.end());
- }
- return TYPE_TRI;
- case TYPE_HEX:
- v.push_back(vCorner[MHexahedron::faces_hexa(k, 0)]);
- v.push_back(vCorner[MHexahedron::faces_hexa(k, 1)]);
- v.push_back(vCorner[MHexahedron::faces_hexa(k, 2)]);
- v.push_back(vCorner[MHexahedron::faces_hexa(k, 3)]);
- for (int i = 0; i < 4; ++i) {
- int edge = MHexahedron::faces2edge_hexa(k, i);
- int n = std::abs(edge) - 1;
- v.insert(v.end(), vEdges.begin() + n * nPts, vEdges.begin() + (n+1) * nPts);
- if (edge < 0) std::reverse(v.end() - nPts, v.end());
- }
- return TYPE_QUA;
- case TYPE_PRI:
- nCorner = k < 2 ? 3 : 4;
- v.push_back(vCorner[MPrism::faces_prism(k, 0)]);
- v.push_back(vCorner[MPrism::faces_prism(k, 1)]);
- v.push_back(vCorner[MPrism::faces_prism(k, 2)]);
- if (nCorner == 4) v.push_back(vCorner[MPrism::faces_prism(k, 3)]);
- for (int i = 0; i < nCorner; ++i) {
- int edge = MPrism::faces2edge_prism(k, i);
- int n = std::abs(edge) - 1;
- v.insert(v.end(), vEdges.begin() + n * nPts, vEdges.begin() + (n+1) * nPts);
- if (edge < 0) std::reverse(v.end() - nPts, v.end());
- }
- return nCorner == 3 ? TYPE_TRI : TYPE_QUA;
- case TYPE_PYR:
- nCorner = k < 4 ? 3 : 4;
- v.push_back(vCorner[MPyramid::faces_pyramid(k, 0)]);
- v.push_back(vCorner[MPyramid::faces_pyramid(k, 1)]);
- v.push_back(vCorner[MPyramid::faces_pyramid(k, 2)]);
- if (nCorner == 4) v.push_back(vCorner[MPyramid::faces_pyramid(k, 3)]);
- for (int i = 0; i < nCorner; ++i) {
- int edge = MPyramid::faces2edge_pyramid(k, i);
- int n = std::abs(edge) - 1;
- v.insert(v.end(), vEdges.begin() + n * nPts, vEdges.begin() + (n+1) * nPts);
- if (edge < 0) std::reverse(v.end() - nPts, v.end());
- }
- return nCorner == 3 ? TYPE_TRI : TYPE_QUA;
- default:
- return -1;
+ switch(type) {
+ case TYPE_TET:
+ v.push_back(vCorner[MTetrahedron::faces_tetra(k, 0)]);
+ v.push_back(vCorner[MTetrahedron::faces_tetra(k, 1)]);
+ v.push_back(vCorner[MTetrahedron::faces_tetra(k, 2)]);
+ for(int i = 0; i < 3; ++i) {
+ int edge = MTetrahedron::faces2edge_tetra(k, i);
+ int n = std::abs(edge) - 1;
+ v.insert(v.end(), vEdges.begin() + n * nPts,
+ vEdges.begin() + (n + 1) * nPts);
+ if(edge < 0) std::reverse(v.end() - nPts, v.end());
+ }
+ return TYPE_TRI;
+ case TYPE_HEX:
+ v.push_back(vCorner[MHexahedron::faces_hexa(k, 0)]);
+ v.push_back(vCorner[MHexahedron::faces_hexa(k, 1)]);
+ v.push_back(vCorner[MHexahedron::faces_hexa(k, 2)]);
+ v.push_back(vCorner[MHexahedron::faces_hexa(k, 3)]);
+ for(int i = 0; i < 4; ++i) {
+ int edge = MHexahedron::faces2edge_hexa(k, i);
+ int n = std::abs(edge) - 1;
+ v.insert(v.end(), vEdges.begin() + n * nPts,
+ vEdges.begin() + (n + 1) * nPts);
+ if(edge < 0) std::reverse(v.end() - nPts, v.end());
+ }
+ return TYPE_QUA;
+ case TYPE_PRI:
+ nCorner = k < 2 ? 3 : 4;
+ v.push_back(vCorner[MPrism::faces_prism(k, 0)]);
+ v.push_back(vCorner[MPrism::faces_prism(k, 1)]);
+ v.push_back(vCorner[MPrism::faces_prism(k, 2)]);
+ if(nCorner == 4) v.push_back(vCorner[MPrism::faces_prism(k, 3)]);
+ for(int i = 0; i < nCorner; ++i) {
+ int edge = MPrism::faces2edge_prism(k, i);
+ int n = std::abs(edge) - 1;
+ v.insert(v.end(), vEdges.begin() + n * nPts,
+ vEdges.begin() + (n + 1) * nPts);
+ if(edge < 0) std::reverse(v.end() - nPts, v.end());
+ }
+ return nCorner == 3 ? TYPE_TRI : TYPE_QUA;
+ case TYPE_PYR:
+ nCorner = k < 4 ? 3 : 4;
+ v.push_back(vCorner[MPyramid::faces_pyramid(k, 0)]);
+ v.push_back(vCorner[MPyramid::faces_pyramid(k, 1)]);
+ v.push_back(vCorner[MPyramid::faces_pyramid(k, 2)]);
+ if(nCorner == 4) v.push_back(vCorner[MPyramid::faces_pyramid(k, 3)]);
+ for(int i = 0; i < nCorner; ++i) {
+ int edge = MPyramid::faces2edge_pyramid(k, i);
+ int n = std::abs(edge) - 1;
+ v.insert(v.end(), vEdges.begin() + n * nPts,
+ vEdges.begin() + (n + 1) * nPts);
+ if(edge < 0) std::reverse(v.end() - nPts, v.end());
+ }
+ return nCorner == 3 ? TYPE_TRI : TYPE_QUA;
+ default: return -1;
}
}
// Get new face (excluding edge) vertices for a face of a 3D element
static void getFaceVertices(GRegion *gr, MElement *ele,
- std::vector<MVertex*> &newVertices,
- std::vector<MVertex*> &newHOVert,
+ std::vector<MVertex *> &newVertices,
+ std::vector<MVertex *> &newHOVert,
faceContainer &faceVertices, int nPts = 1)
{
- std::vector<MVertex*> vCorner;
+ std::vector<MVertex *> vCorner;
ele->getVertices(vCorner);
// NB: We can get more than corner vertices but we use only corners
for(int i = 0; i < ele->getNumFaces(); i++) {
MFace face = ele->getFace(i);
- std::vector<MVertex*> vFace;
+ std::vector<MVertex *> vFace;
faceContainer::iterator fIter = faceVertices.find(face);
- if(fIter != faceVertices.end()){ // Vertices already exist
- std::vector<MVertex*> vtcs = fIter->second;
+ if(fIter != faceVertices.end()) { // Vertices already exist
+ std::vector<MVertex *> vtcs = fIter->second;
int orientation;
bool swap;
- if (fIter->first.computeCorrespondence(face, orientation, swap)) {
+ if(fIter->first.computeCorrespondence(face, orientation, swap)) {
// Check correspondence and apply permutation if needed
if(face.getNumVertices() == 3 && nPts > 1)
reorientTrianglePoints(vtcs, orientation, swap);
else if(face.getNumVertices() == 4)
- reorientQuadPoints(vtcs, orientation, swap, nPts-1);
+ reorientQuadPoints(vtcs, orientation, swap, nPts - 1);
}
else
- Msg::Error("Error in face lookup for recuperation of high order face nodes");
+ Msg::Error(
+ "Error in face lookup for recuperation of high order face nodes");
vFace.assign(vtcs.begin(), vtcs.end());
}
else { // Vertices do not exist, create them by interpolation
- std::vector<MVertex*> faceBoundaryVertices;
- int type = retrieveFaceBoundaryVertices(i, ele->getType(), nPts,
- vCorner, newVertices,
- faceBoundaryVertices);
- fullMatrix<double> *coefficients = getInnerVertexPlacement(type, nPts+1);
- interpVerticesInExistingFace(gr, *coefficients, faceBoundaryVertices, vFace);
+ std::vector<MVertex *> faceBoundaryVertices;
+ int type = retrieveFaceBoundaryVertices(
+ i, ele->getType(), nPts, vCorner, newVertices, faceBoundaryVertices);
+ fullMatrix<double> *coefficients =
+ getInnerVertexPlacement(type, nPts + 1);
+ interpVerticesInExistingFace(gr, *coefficients, faceBoundaryVertices,
+ vFace);
newHOVert.insert(newHOVert.end(), vFace.begin(), vFace.end());
- faceVertices[face].insert(faceVertices[face].end(), vFace.begin(), vFace.end());
+ faceVertices[face].insert(faceVertices[face].end(), vFace.begin(),
+ vFace.end());
}
newVertices.insert(newVertices.end(), vFace.begin(), vFace.end());
}
@@ -833,9 +895,8 @@ static void getFaceVertices(GRegion *gr, MElement *ele,
// Get new interior vertices for a 3D element
static void getVolumeVertices(GRegion *gr, MElement *ele,
- std::vector<MVertex*> &newVertices,
- std::vector<MVertex*> &newHOVert,
- int nPts = 1)
+ std::vector<MVertex *> &newVertices,
+ std::vector<MVertex *> &newHOVert, int nPts = 1)
{
std::vector<MVertex *> boundaryVertices;
{
@@ -843,15 +904,15 @@ static void getVolumeVertices(GRegion *gr, MElement *ele,
boundaryVertices.reserve(nCorner + newVertices.size());
ele->getVertices(boundaryVertices);
boundaryVertices.resize(nCorner);
- boundaryVertices.insert(boundaryVertices.end(),
- newVertices.begin(), newVertices.end());
+ boundaryVertices.insert(boundaryVertices.end(), newVertices.begin(),
+ newVertices.end());
}
int type = ele->getType();
fullMatrix<double> &coefficients = *getInnerVertexPlacement(type, nPts + 1);
- for (int k = 0; k < coefficients.size1(); k++) {
+ for(int k = 0; k < coefficients.size1(); k++) {
double x(0), y(0), z(0);
- for (int j = 0; j < coefficients.size2(); j++) {
+ for(int j = 0; j < coefficients.size2(); j++) {
MVertex *v = boundaryVertices[j];
x += coefficients(k, j) * v->x();
y += coefficients(k, j) * v->y();
@@ -863,23 +924,23 @@ static void getVolumeVertices(GRegion *gr, MElement *ele,
}
}
-
// --------- Creation of high-order elements -----------
-static void setHighOrder(GEdge *ge, std::vector<MVertex*> &newHOVert,
- edgeContainer &edgeVertices, bool linear, int nbPts = 1)
+static void setHighOrder(GEdge *ge, std::vector<MVertex *> &newHOVert,
+ edgeContainer &edgeVertices, bool linear,
+ int nbPts = 1)
{
- std::vector<MLine*> lines2;
- for(unsigned int i = 0; i < ge->lines.size(); i++){
+ std::vector<MLine *> lines2;
+ for(unsigned int i = 0; i < ge->lines.size(); i++) {
MLine *l = ge->lines[i];
- std::vector<MVertex*> ve;
+ std::vector<MVertex *> ve;
getEdgeVertices(ge, l, ve, newHOVert, edgeVertices, linear, nbPts);
if(nbPts == 1)
- lines2.push_back(new MLine3(l->getVertex(0), l->getVertex(1),
- ve[0], l->getPartition()));
+ lines2.push_back(
+ new MLine3(l->getVertex(0), l->getVertex(1), ve[0], l->getPartition()));
else
- lines2.push_back(new MLineN(l->getVertex(0), l->getVertex(1),
- ve, l->getPartition()));
+ lines2.push_back(
+ new MLineN(l->getVertex(0), l->getVertex(1), ve, l->getPartition()));
delete l;
}
ge->lines = lines2;
@@ -887,66 +948,67 @@ static void setHighOrder(GEdge *ge, std::vector<MVertex*> &newHOVert,
}
static MTriangle *setHighOrder(MTriangle *t, GFace *gf,
- std::vector<MVertex*> &newHOVert,
+ std::vector<MVertex *> &newHOVert,
edgeContainer &edgeVertices,
- faceContainer &faceVertices,
- bool linear, bool incomplete, int nPts)
+ faceContainer &faceVertices, bool linear,
+ bool incomplete, int nPts)
{
- std::vector<MVertex*> v;
+ std::vector<MVertex *> v;
getEdgeVertices(gf, t, v, newHOVert, edgeVertices, linear, nPts);
- if(nPts == 1){
+ if(nPts == 1) {
return new MTriangle6(t->getVertex(0), t->getVertex(1), t->getVertex(2),
v[0], v[1], v[2], 0, t->getPartition());
}
- else{
+ else {
if(!incomplete)
getFaceVertices(gf, t, v, newHOVert, faceVertices, linear, nPts);
- return new MTriangleN(t->getVertex(0), t->getVertex(1), t->getVertex(2),
- v, nPts + 1, 0, t->getPartition());
+ return new MTriangleN(t->getVertex(0), t->getVertex(1), t->getVertex(2), v,
+ nPts + 1, 0, t->getPartition());
}
}
static MQuadrangle *setHighOrder(MQuadrangle *q, GFace *gf,
- std::vector<MVertex*> &newHOVert,
+ std::vector<MVertex *> &newHOVert,
edgeContainer &edgeVertices,
- faceContainer &faceVertices,
- bool linear, bool incomplete, int nPts)
+ faceContainer &faceVertices, bool linear,
+ bool incomplete, int nPts)
{
- std::vector<MVertex*> v;
+ std::vector<MVertex *> v;
getEdgeVertices(gf, q, v, newHOVert, edgeVertices, linear, nPts);
- if(incomplete){
- if(nPts == 1){
+ if(incomplete) {
+ if(nPts == 1) {
return new MQuadrangle8(q->getVertex(0), q->getVertex(1), q->getVertex(2),
- q->getVertex(3), v[0], v[1], v[2], v[3],
- 0, q->getPartition());
+ q->getVertex(3), v[0], v[1], v[2], v[3], 0,
+ q->getPartition());
}
- else{
+ else {
return new MQuadrangleN(q->getVertex(0), q->getVertex(1), q->getVertex(2),
- q->getVertex(3), v, nPts + 1,
- 0, q->getPartition());
+ q->getVertex(3), v, nPts + 1, 0,
+ q->getPartition());
}
}
else {
getFaceVertices(gf, q, v, newHOVert, faceVertices, linear, nPts);
- if(nPts == 1){
+ if(nPts == 1) {
return new MQuadrangle9(q->getVertex(0), q->getVertex(1), q->getVertex(2),
- q->getVertex(3), v[0], v[1], v[2], v[3], v[4],
- 0, q->getPartition());
+ q->getVertex(3), v[0], v[1], v[2], v[3], v[4], 0,
+ q->getPartition());
}
- else{
+ else {
return new MQuadrangleN(q->getVertex(0), q->getVertex(1), q->getVertex(2),
- q->getVertex(3), v, nPts + 1,
- 0, q->getPartition());
+ q->getVertex(3), v, nPts + 1, 0,
+ q->getPartition());
}
}
}
-static void setHighOrder(GFace *gf, std::vector<MVertex*> &newHOVert,
- edgeContainer &edgeVertices, faceContainer &faceVertices,
- bool linear, bool incomplete, int nPts = 1)
+static void setHighOrder(GFace *gf, std::vector<MVertex *> &newHOVert,
+ edgeContainer &edgeVertices,
+ faceContainer &faceVertices, bool linear,
+ bool incomplete, int nPts = 1)
{
- std::vector<MTriangle*> triangles2;
- for(unsigned int i = 0; i < gf->triangles.size(); i++){
+ std::vector<MTriangle *> triangles2;
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
MTriangle *t = gf->triangles[i];
MTriangle *tNew = setHighOrder(t, gf, newHOVert, edgeVertices, faceVertices,
linear, incomplete, nPts);
@@ -955,8 +1017,8 @@ static void setHighOrder(GFace *gf, std::vector<MVertex*> &newHOVert,
}
gf->triangles = triangles2;
- std::vector<MQuadrangle*> quadrangles2;
- for(unsigned int i = 0; i < gf->quadrangles.size(); i++){
+ std::vector<MQuadrangle *> quadrangles2;
+ for(unsigned int i = 0; i < gf->quadrangles.size(); i++) {
MQuadrangle *q = gf->quadrangles[i];
MQuadrangle *qNew = setHighOrder(q, gf, newHOVert, edgeVertices,
faceVertices, linear, incomplete, nPts);
@@ -968,62 +1030,62 @@ static void setHighOrder(GFace *gf, std::vector<MVertex*> &newHOVert,
}
static MTetrahedron *setHighOrder(MTetrahedron *t, GRegion *gr,
- std::vector<MVertex*> &newHOVert,
+ std::vector<MVertex *> &newHOVert,
edgeContainer &edgeVertices,
- faceContainer &faceVertices,
- bool incomplete, int nPts)
+ faceContainer &faceVertices, bool incomplete,
+ int nPts)
{
- std::vector<MVertex*> v;
+ std::vector<MVertex *> v;
getEdgeVertices(gr, t, v, newHOVert, edgeVertices, nPts);
- if(nPts == 1){
+ if(nPts == 1) {
return new MTetrahedron10(t->getVertex(0), t->getVertex(1), t->getVertex(2),
- t->getVertex(3), v[0], v[1], v[2], v[3], v[4], v[5],
- 0, t->getPartition());
+ t->getVertex(3), v[0], v[1], v[2], v[3], v[4],
+ v[5], 0, t->getPartition());
}
- else{
- if(!incomplete){
+ else {
+ if(!incomplete) {
getFaceVertices(gr, t, v, newHOVert, faceVertices, nPts);
getVolumeVertices(gr, t, v, newHOVert, nPts);
}
- return new MTetrahedronN(t->getVertex(0), t->getVertex(1),
- t->getVertex(2), t->getVertex(3), v, nPts + 1,
- 0, t->getPartition());
+ return new MTetrahedronN(t->getVertex(0), t->getVertex(1), t->getVertex(2),
+ t->getVertex(3), v, nPts + 1, 0,
+ t->getPartition());
}
}
static MHexahedron *setHighOrder(MHexahedron *h, GRegion *gr,
- std::vector<MVertex*> &newHOVert,
+ std::vector<MVertex *> &newHOVert,
edgeContainer &edgeVertices,
- faceContainer &faceVertices,
- bool incomplete, int nPts)
+ faceContainer &faceVertices, bool incomplete,
+ int nPts)
{
- std::vector<MVertex*> v;
+ std::vector<MVertex *> v;
getEdgeVertices(gr, h, v, newHOVert, edgeVertices, nPts);
- if(incomplete){
- if(nPts == 1){
- return new MHexahedron20(h->getVertex(0), h->getVertex(1), h->getVertex(2),
- h->getVertex(3), h->getVertex(4), h->getVertex(5),
- h->getVertex(6), h->getVertex(7), v[0], v[1], v[2],
- v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10],
- v[11], 0, h->getPartition());
+ if(incomplete) {
+ if(nPts == 1) {
+ return new MHexahedron20(
+ h->getVertex(0), h->getVertex(1), h->getVertex(2), h->getVertex(3),
+ h->getVertex(4), h->getVertex(5), h->getVertex(6), h->getVertex(7),
+ v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10],
+ v[11], 0, h->getPartition());
}
- else{
+ else {
return new MHexahedronN(h->getVertex(0), h->getVertex(1), h->getVertex(2),
h->getVertex(3), h->getVertex(4), h->getVertex(5),
h->getVertex(6), h->getVertex(7), v, nPts + 1, 0,
h->getPartition());
}
}
- else{
+ else {
getFaceVertices(gr, h, v, newHOVert, faceVertices, nPts);
getVolumeVertices(gr, h, v, newHOVert, nPts);
if(nPts == 1) {
- return new MHexahedron27(h->getVertex(0), h->getVertex(1), h->getVertex(2),
- h->getVertex(3), h->getVertex(4), h->getVertex(5),
- h->getVertex(6), h->getVertex(7), v[0], v[1], v[2],
- v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10],
- v[11], v[12], v[13], v[14], v[15], v[16], v[17], v[18],
- 0, h->getPartition());
+ return new MHexahedron27(
+ h->getVertex(0), h->getVertex(1), h->getVertex(2), h->getVertex(3),
+ h->getVertex(4), h->getVertex(5), h->getVertex(6), h->getVertex(7),
+ v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10],
+ v[11], v[12], v[13], v[14], v[15], v[16], v[17], v[18], 0,
+ h->getPartition());
}
else {
return new MHexahedronN(h->getVertex(0), h->getVertex(1), h->getVertex(2),
@@ -1035,69 +1097,69 @@ static MHexahedron *setHighOrder(MHexahedron *h, GRegion *gr,
}
static MPrism *setHighOrder(MPrism *p, GRegion *gr,
- std::vector<MVertex*> &newHOVert,
+ std::vector<MVertex *> &newHOVert,
edgeContainer &edgeVertices,
- faceContainer &faceVertices,
- bool incomplete, int nPts)
+ faceContainer &faceVertices, bool incomplete,
+ int nPts)
{
- std::vector<MVertex*> v;
+ std::vector<MVertex *> v;
getEdgeVertices(gr, p, v, newHOVert, edgeVertices, nPts);
- if(incomplete){
- if(nPts == 1){
+ if(incomplete) {
+ if(nPts == 1) {
return new MPrism15(p->getVertex(0), p->getVertex(1), p->getVertex(2),
p->getVertex(3), p->getVertex(4), p->getVertex(5),
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8],
0, p->getPartition());
}
- else{
+ else {
return new MPrismN(p->getVertex(0), p->getVertex(1), p->getVertex(2),
- p->getVertex(3), p->getVertex(4), p->getVertex(5),
- v, nPts + 1, 0, p->getPartition());
+ p->getVertex(3), p->getVertex(4), p->getVertex(5), v,
+ nPts + 1, 0, p->getPartition());
}
}
else {
getFaceVertices(gr, p, v, newHOVert, faceVertices, nPts);
- if (nPts == 1) {
+ if(nPts == 1) {
return new MPrism18(p->getVertex(0), p->getVertex(1), p->getVertex(2),
p->getVertex(3), p->getVertex(4), p->getVertex(5),
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8],
- v[9], v[10], v[11],
- 0, p->getPartition());
+ v[9], v[10], v[11], 0, p->getPartition());
}
else {
getVolumeVertices(gr, p, v, newHOVert, nPts);
return new MPrismN(p->getVertex(0), p->getVertex(1), p->getVertex(2),
- p->getVertex(3), p->getVertex(4), p->getVertex(5),
- v, nPts + 1, 0, p->getPartition());
+ p->getVertex(3), p->getVertex(4), p->getVertex(5), v,
+ nPts + 1, 0, p->getPartition());
}
}
}
static MPyramid *setHighOrder(MPyramid *p, GRegion *gr,
- std::vector<MVertex*> &newHOVert,
+ std::vector<MVertex *> &newHOVert,
edgeContainer &edgeVertices,
- faceContainer &faceVertices,
- bool incomplete, int nPts)
+ faceContainer &faceVertices, bool incomplete,
+ int nPts)
{
- std::vector<MVertex*> v;
+ std::vector<MVertex *> v;
getEdgeVertices(gr, p, v, newHOVert, edgeVertices, nPts);
if(!incomplete) {
getFaceVertices(gr, p, v, newHOVert, faceVertices, nPts);
- if (nPts > 1) {
+ if(nPts > 1) {
getVolumeVertices(gr, p, v, newHOVert, nPts);
}
}
return new MPyramidN(p->getVertex(0), p->getVertex(1), p->getVertex(2),
- p->getVertex(3), p->getVertex(4), v, nPts + 1,
- 0, p->getPartition());
+ p->getVertex(3), p->getVertex(4), v, nPts + 1, 0,
+ p->getPartition());
}
-static void setHighOrder(GRegion *gr, std::vector<MVertex*> &newHOVert,
- edgeContainer &edgeVertices, faceContainer &faceVertices,
- bool incomplete, int nPts = 1)
+static void setHighOrder(GRegion *gr, std::vector<MVertex *> &newHOVert,
+ edgeContainer &edgeVertices,
+ faceContainer &faceVertices, bool incomplete,
+ int nPts = 1)
{
- std::vector<MTetrahedron*> tetrahedra2;
- for(unsigned int i = 0; i < gr->tetrahedra.size(); i++){
+ std::vector<MTetrahedron *> tetrahedra2;
+ for(unsigned int i = 0; i < gr->tetrahedra.size(); i++) {
MTetrahedron *t = gr->tetrahedra[i];
MTetrahedron *tNew = setHighOrder(t, gr, newHOVert, edgeVertices,
faceVertices, incomplete, nPts);
@@ -1106,8 +1168,8 @@ static void setHighOrder(GRegion *gr, std::vector<MVertex*> &newHOVert,
}
gr->tetrahedra = tetrahedra2;
- std::vector<MHexahedron*> hexahedra2;
- for(unsigned int i = 0; i < gr->hexahedra.size(); i++){
+ std::vector<MHexahedron *> hexahedra2;
+ for(unsigned int i = 0; i < gr->hexahedra.size(); i++) {
MHexahedron *h = gr->hexahedra[i];
MHexahedron *hNew = setHighOrder(h, gr, newHOVert, edgeVertices,
faceVertices, incomplete, nPts);
@@ -1116,21 +1178,21 @@ static void setHighOrder(GRegion *gr, std::vector<MVertex*> &newHOVert,
}
gr->hexahedra = hexahedra2;
- std::vector<MPrism*> prisms2;
- for(unsigned int i = 0; i < gr->prisms.size(); i++){
+ std::vector<MPrism *> prisms2;
+ for(unsigned int i = 0; i < gr->prisms.size(); i++) {
MPrism *p = gr->prisms[i];
- MPrism *pNew = setHighOrder(p, gr, newHOVert, edgeVertices,
- faceVertices, incomplete, nPts);
+ MPrism *pNew = setHighOrder(p, gr, newHOVert, edgeVertices, faceVertices,
+ incomplete, nPts);
prisms2.push_back(pNew);
delete p;
}
gr->prisms = prisms2;
- std::vector<MPyramid*> pyramids2;
+ std::vector<MPyramid *> pyramids2;
for(unsigned int i = 0; i < gr->pyramids.size(); i++) {
MPyramid *p = gr->pyramids[i];
- MPyramid *pNew = setHighOrder(p, gr, newHOVert, edgeVertices,
- faceVertices, incomplete, nPts);
+ MPyramid *pNew = setHighOrder(p, gr, newHOVert, edgeVertices, faceVertices,
+ incomplete, nPts);
pyramids2.push_back(pNew);
delete p;
}
@@ -1139,18 +1201,18 @@ static void setHighOrder(GRegion *gr, std::vector<MVertex*> &newHOVert,
gr->deleteVertexArrays();
}
-
// --------- High-level functions -----------
-template<class T>
-static void setFirstOrder(GEntity *e, std::vector<T*> &elements, bool onlyVisible)
+template <class T>
+static void setFirstOrder(GEntity *e, std::vector<T *> &elements,
+ bool onlyVisible)
{
- if (onlyVisible && !e->getVisibility()) return;
- std::vector<T*> elements1;
- for(unsigned int i = 0; i < elements.size(); i++){
+ if(onlyVisible && !e->getVisibility()) return;
+ std::vector<T *> elements1;
+ for(unsigned int i = 0; i < elements.size(); i++) {
T *ele = elements[i];
int n = ele->getNumPrimaryVertices();
- std::vector<MVertex*> v1;
+ std::vector<MVertex *> v1;
v1.reserve(n);
for(int j = 0; j < n; j++) v1.push_back(ele->getVertex(j));
elements1.push_back(new T(v1, 0, ele->getPartition()));
@@ -1161,12 +1223,12 @@ static void setFirstOrder(GEntity *e, std::vector<T*> &elements, bool onlyVisibl
}
static void updateHighOrderVertices(GEntity *e,
- const std::vector<MVertex*> &newHOVert,
+ const std::vector<MVertex *> &newHOVert,
bool onlyVisible)
{
- if (onlyVisible && !e->getVisibility()) return;
- std::vector<MVertex*> v1;
- for(unsigned int i = 0; i < e->mesh_vertices.size(); i++){
+ if(onlyVisible && !e->getVisibility()) return;
+ std::vector<MVertex *> v1;
+ for(unsigned int i = 0; i < e->mesh_vertices.size(); i++) {
if(e->mesh_vertices[i]->getPolynomialOrder() > 1)
delete e->mesh_vertices[i];
else
@@ -1183,63 +1245,61 @@ static void updatePeriodicEdgesAndFaces(GModel *m)
for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it) {
GEdge *tgt = *it;
- GEdge *src = dynamic_cast<GEdge*>(tgt->meshMaster());
+ GEdge *src = dynamic_cast<GEdge *>(tgt->meshMaster());
- if (src != NULL && src != tgt) {
- std::map<MVertex*,MVertex*> &v2v = tgt->correspondingVertices;
- std::map<MVertex*,MVertex*> &p2p = tgt->correspondingHOPoints;
+ if(src != NULL && src != tgt) {
+ std::map<MVertex *, MVertex *> &v2v = tgt->correspondingVertices;
+ std::map<MVertex *, MVertex *> &p2p = tgt->correspondingHOPoints;
p2p.clear();
- Msg::Info("Constructing high order periodicity for edge connection %d - %d",
- tgt->tag(), src->tag());
+ Msg::Info(
+ "Constructing high order periodicity for edge connection %d - %d",
+ tgt->tag(), src->tag());
- std::map<MEdge,MLine*,Less_Edge> srcEdges;
- for (unsigned int i = 0; i < src->getNumMeshElements(); i++) {
- MLine* srcLine = dynamic_cast<MLine*>(src->getMeshElement(i));
- if (!srcLine){
+ std::map<MEdge, MLine *, Less_Edge> srcEdges;
+ for(unsigned int i = 0; i < src->getNumMeshElements(); i++) {
+ MLine *srcLine = dynamic_cast<MLine *>(src->getMeshElement(i));
+ if(!srcLine) {
Msg::Error("Master element %d is not an edge",
src->getMeshElement(i)->getNum());
return;
}
- srcEdges[MEdge(srcLine->getVertex(0),
- srcLine->getVertex(1))] = srcLine;
+ srcEdges[MEdge(srcLine->getVertex(0), srcLine->getVertex(1))] = srcLine;
}
- for (unsigned int i = 0; i < tgt->getNumMeshElements(); ++i) {
- MLine* tgtLine = dynamic_cast<MLine*> (tgt->getMeshElement(i));
- MVertex* vtcs[2];
- if (!tgtLine){
+ for(unsigned int i = 0; i < tgt->getNumMeshElements(); ++i) {
+ MLine *tgtLine = dynamic_cast<MLine *>(tgt->getMeshElement(i));
+ MVertex *vtcs[2];
+ if(!tgtLine) {
Msg::Error("Slave element %d is not an edge",
tgt->getMeshElement(i)->getNum());
return;
}
- for (int iVtx = 0; iVtx < 2; iVtx++) {
- MVertex* vtx = tgtLine->getVertex(iVtx);
- std::map<MVertex*,MVertex*>::iterator tIter = v2v.find(vtx);
- if (tIter == v2v.end()) {
+ for(int iVtx = 0; iVtx < 2; iVtx++) {
+ MVertex *vtx = tgtLine->getVertex(iVtx);
+ std::map<MVertex *, MVertex *>::iterator tIter = v2v.find(vtx);
+ if(tIter == v2v.end()) {
Msg::Error("Cannot find periodic counterpart of vertex %d"
" of edge %d on edge %d",
vtx->getNum(), tgt->tag(), src->tag());
}
- else vtcs[iVtx] = tIter->second;
+ else
+ vtcs[iVtx] = tIter->second;
}
- std::map<MEdge,MLine*,Less_Edge>::iterator srcIter =
- srcEdges.find(MEdge(vtcs[0],vtcs[1]));
- if (srcIter == srcEdges.end()) {
+ std::map<MEdge, MLine *, Less_Edge>::iterator srcIter =
+ srcEdges.find(MEdge(vtcs[0], vtcs[1]));
+ if(srcIter == srcEdges.end()) {
Msg::Error("Can't find periodic counterpart of edge %d-%d on edge %d"
", connected to edge %d-%d on %d",
tgtLine->getVertex(0)->getNum(),
- tgtLine->getVertex(1)->getNum(),
- tgt->tag(),
- vtcs[0]->getNum(),
- vtcs[1]->getNum(),
- src->tag());
+ tgtLine->getVertex(1)->getNum(), tgt->tag(),
+ vtcs[0]->getNum(), vtcs[1]->getNum(), src->tag());
}
else {
- MLine* srcLine = srcIter->second;
- if (tgtLine->getNumVertices() != srcLine->getNumVertices()) throw;
- for (unsigned int i = 2; i < tgtLine->getNumVertices(); i++)
+ MLine *srcLine = srcIter->second;
+ if(tgtLine->getNumVertices() != srcLine->getNumVertices()) throw;
+ for(unsigned int i = 2; i < tgtLine->getNumVertices(); i++)
p2p[tgtLine->getVertex(i)] = srcLine->getVertex(i);
}
}
@@ -1247,33 +1307,33 @@ static void updatePeriodicEdgesAndFaces(GModel *m)
}
#if defined(HAVE_OPTHOM)
- std::vector<GEntity*> modelEdges(m->firstEdge(),m->lastEdge());
+ std::vector<GEntity *> modelEdges(m->firstEdge(), m->lastEdge());
OptHomPeriodicity edgePeriodicity(modelEdges);
edgePeriodicity.fixPeriodicity();
edgePeriodicity.fixPeriodicity(); // apply twice for operation order effects
#endif
-
for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
GFace *tgt = *it;
- GFace *src = dynamic_cast<GFace*>(tgt->meshMaster());
- if (src != NULL && src != tgt) {
- Msg::Info("Constructing high order periodicity for face connection %d - %d",
- tgt->tag(),src->tag());
-
- std::map<MVertex*,MVertex*> &v2v = tgt->correspondingVertices;
- std::map<MVertex*,MVertex*> &p2p = tgt->correspondingHOPoints;
+ GFace *src = dynamic_cast<GFace *>(tgt->meshMaster());
+ if(src != NULL && src != tgt) {
+ Msg::Info(
+ "Constructing high order periodicity for face connection %d - %d",
+ tgt->tag(), src->tag());
+
+ std::map<MVertex *, MVertex *> &v2v = tgt->correspondingVertices;
+ std::map<MVertex *, MVertex *> &p2p = tgt->correspondingHOPoints;
p2p.clear();
- std::map<MFace,MElement*,Less_Face> srcFaces;
+ std::map<MFace, MElement *, Less_Face> srcFaces;
- for (unsigned int i = 0; i < src->getNumMeshElements(); ++i) {
- MElement* srcElmt = src->getMeshElement(i);
+ for(unsigned int i = 0; i < src->getNumMeshElements(); ++i) {
+ MElement *srcElmt = src->getMeshElement(i);
int nbVtcs = 0;
- if (dynamic_cast<MTriangle*> (srcElmt)) nbVtcs = 3;
- if (dynamic_cast<MQuadrangle*> (srcElmt)) nbVtcs = 4;
- std::vector<MVertex*> vtcs;
+ if(dynamic_cast<MTriangle *>(srcElmt)) nbVtcs = 3;
+ if(dynamic_cast<MQuadrangle *>(srcElmt)) nbVtcs = 4;
+ std::vector<MVertex *> vtcs;
vtcs.reserve(nbVtcs);
for(int iVtx = 0; iVtx < nbVtcs; iVtx++) {
vtcs.push_back(srcElmt->getVertex(iVtx));
@@ -1281,42 +1341,44 @@ static void updatePeriodicEdgesAndFaces(GModel *m)
srcFaces[MFace(vtcs)] = srcElmt;
}
- for (unsigned int i = 0; i < tgt->getNumMeshElements(); ++i) {
- MElement* tgtElmt = tgt->getMeshElement(i);
+ for(unsigned int i = 0; i < tgt->getNumMeshElements(); ++i) {
+ MElement *tgtElmt = tgt->getMeshElement(i);
// Msg::Info("Checking element %d in face %d",i,tgt->tag());
int nbVtcs = 0;
- if (dynamic_cast<MTriangle*> (tgtElmt)) nbVtcs = 3;
- if (dynamic_cast<MQuadrangle*> (tgtElmt)) nbVtcs = 4;
- std::vector<MVertex*> vtcs;
- for (int iVtx = 0; iVtx < nbVtcs; iVtx++) {
- MVertex* vtx = tgtElmt->getVertex(iVtx);
-
- std::map<MVertex*,MVertex*>::iterator tIter = v2v.find(vtx);
- if (tIter == v2v.end()) {
+ if(dynamic_cast<MTriangle *>(tgtElmt)) nbVtcs = 3;
+ if(dynamic_cast<MQuadrangle *>(tgtElmt)) nbVtcs = 4;
+ std::vector<MVertex *> vtcs;
+ for(int iVtx = 0; iVtx < nbVtcs; iVtx++) {
+ MVertex *vtx = tgtElmt->getVertex(iVtx);
+
+ std::map<MVertex *, MVertex *>::iterator tIter = v2v.find(vtx);
+ if(tIter == v2v.end()) {
Msg::Error("Cannot find periodic counterpart of vertex %d"
" of surface %d on surface %d",
- vtx->getNum(),tgt->tag(),src->tag());
+ vtx->getNum(), tgt->tag(), src->tag());
}
- else vtcs.push_back(tIter->second);
+ else
+ vtcs.push_back(tIter->second);
// GEntity* ge = vtx->onWhat();
// if (ge->meshMaster() == ge) throw;
// std::map<MVertex*,MVertex*>& v2v = ge->correspondingVertices;
- //vtcs.push_back(v2v[vtx]);
+ // vtcs.push_back(v2v[vtx]);
}
- std::map<MFace,MElement*>::iterator srcIter = srcFaces.find(MFace(vtcs));
- if (srcIter == srcFaces.end()) {
+ std::map<MFace, MElement *>::iterator srcIter =
+ srcFaces.find(MFace(vtcs));
+ if(srcIter == srcFaces.end()) {
std::ostringstream faceDef;
- for (int iVtx = 0; iVtx < nbVtcs; iVtx++)
+ for(int iVtx = 0; iVtx < nbVtcs; iVtx++)
faceDef << vtcs[iVtx]->getNum() << " ";
Msg::Error("Cannot find periodic counterpart of face %s in face %d "
- "connected to %d",faceDef.str().c_str(),
- tgt->tag(),src->tag());
+ "connected to %d",
+ faceDef.str().c_str(), tgt->tag(), src->tag());
}
else {
- MElement* srcElmt = srcIter->second;
- for (std::size_t i=nbVtcs;i<srcElmt->getNumVertices();i++) {
+ MElement *srcElmt = srcIter->second;
+ for(std::size_t i = nbVtcs; i < srcElmt->getNumVertices(); i++) {
p2p[tgtElmt->getVertex(i)] = srcElmt->getVertex(i);
}
}
@@ -1325,8 +1387,8 @@ static void updatePeriodicEdgesAndFaces(GModel *m)
}
#if defined(HAVE_OPTHOM)
- std::vector<GEntity*> modelFaces;
- modelFaces.insert(modelFaces.end(),m->firstFace(),m->lastFace());
+ std::vector<GEntity *> modelFaces;
+ modelFaces.insert(modelFaces.end(), m->firstFace(), m->lastFace());
OptHomPeriodicity facePeriodicity(modelFaces);
facePeriodicity.fixPeriodicity();
#endif
@@ -1339,14 +1401,14 @@ void SetOrder1(GModel *m, bool onlyVisible)
m->destroyMeshCaches();
// replace all elements with first order elements
- for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it){
+ for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it) {
setFirstOrder(*it, (*it)->lines, onlyVisible);
}
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
setFirstOrder(*it, (*it)->triangles, onlyVisible);
setFirstOrder(*it, (*it)->quadrangles, onlyVisible);
}
- for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it){
+ for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it) {
setFirstOrder(*it, (*it)->tetrahedra, onlyVisible);
setFirstOrder(*it, (*it)->hexahedra, onlyVisible);
setFirstOrder(*it, (*it)->prisms, onlyVisible);
@@ -1354,7 +1416,7 @@ void SetOrder1(GModel *m, bool onlyVisible)
}
// remove all high order vertices
- std::vector<MVertex*> newHOVert;
+ std::vector<MVertex *> newHOVert;
for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it)
updateHighOrderVertices(*it, newHOVert, onlyVisible);
for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it)
@@ -1365,25 +1427,28 @@ void SetOrder1(GModel *m, bool onlyVisible)
updatePeriodicEdgesAndFaces(m);
}
-void checkHighOrderTriangles(const char* cc, GModel *m,
- std::vector<MElement*> &bad, double &minJGlob)
+void checkHighOrderTriangles(const char *cc, GModel *m,
+ std::vector<MElement *> &bad, double &minJGlob)
{
bad.clear();
minJGlob = 1.0;
double minGGlob = 1.0;
double avg = 0.0;
int count = 0, nbfair = 0;
- for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it){
- for(unsigned int i = 0; i < (*it)->triangles.size(); i++){
+ for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
MTriangle *t = (*it)->triangles[i];
double disto_ = t->distoShapeMeasure();
double gamma_ = t->gammaShapeMeasure();
double disto = disto_;
minJGlob = std::min(minJGlob, disto);
minGGlob = std::min(minGGlob, gamma_);
- avg += disto; count++;
- if (disto < 0) bad.push_back(t);
- else if (disto < 0.2) nbfair++;
+ avg += disto;
+ count++;
+ if(disto < 0)
+ bad.push_back(t);
+ else if(disto < 0.2)
+ nbfair++;
}
/*
for(unsigned int i = 0; i < (*it)->quadrangles.size(); i++){
@@ -1400,40 +1465,46 @@ void checkHighOrderTriangles(const char* cc, GModel *m,
*/
}
if(!count) return;
- if (minJGlob > 0)
- Msg::Info("%s: worst distortion = %g (%d elements in ]0, 0.2]); worst gamma = %g",
- cc, minJGlob, nbfair, minGGlob);
+ if(minJGlob > 0)
+ Msg::Info(
+ "%s: worst distortion = %g (%d elements in ]0, 0.2]); worst gamma = %g",
+ cc, minJGlob, nbfair, minGGlob);
else
- Msg::Warning("%s: worst distortion = %g (avg = %g, %d elements with jac. < 0); "
- "worst gamma = %g", cc, minJGlob, avg / (count ? count : 1),
- bad.size(), minGGlob);
+ Msg::Warning(
+ "%s: worst distortion = %g (avg = %g, %d elements with jac. < 0); "
+ "worst gamma = %g",
+ cc, minJGlob, avg / (count ? count : 1), bad.size(), minGGlob);
}
-void checkHighOrderTetrahedron(const char* cc, GModel *m,
- std::vector<MElement*> &bad, double &minJGlob)
+void checkHighOrderTetrahedron(const char *cc, GModel *m,
+ std::vector<MElement *> &bad, double &minJGlob)
{
bad.clear();
minJGlob = 1.0;
double avg = 0.0;
int count = 0, nbfair = 0;
- for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it){
- for(unsigned int i = 0; i < (*it)->tetrahedra.size(); i++){
+ for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it) {
+ for(unsigned int i = 0; i < (*it)->tetrahedra.size(); i++) {
MTetrahedron *t = (*it)->tetrahedra[i];
double disto_ = t->distoShapeMeasure();
minJGlob = std::min(minJGlob, disto_);
- avg += disto_; count++;
- if (disto_ < 0) bad.push_back(t);
- else if (disto_ < 0.2) nbfair++;
+ avg += disto_;
+ count++;
+ if(disto_ < 0)
+ bad.push_back(t);
+ else if(disto_ < 0.2)
+ nbfair++;
}
}
if(!count) return;
- if (minJGlob > 0)
- Msg::Info("%s: worst distortion = %g (%d elements in ]0, 0.2])",
- cc, minJGlob, nbfair);
+ if(minJGlob > 0)
+ Msg::Info("%s: worst distortion = %g (%d elements in ]0, 0.2])", cc,
+ minJGlob, nbfair);
else
- Msg::Warning("%s: worst distortion = %g (avg = %g, %d elements with jac. < 0)",
- cc, minJGlob, avg / (count ? count : 1), bad.size());
+ Msg::Warning(
+ "%s: worst distortion = %g (avg = %g, %d elements with jac. < 0)", cc,
+ minJGlob, avg / (count ? count : 1), bad.size());
}
void getMeshInfoForHighOrder(GModel *gm, int &meshOrder, bool &complete,
@@ -1448,26 +1519,29 @@ void getMeshInfoForHighOrder(GModel *gm, int &meshOrder, bool &complete,
// and so on...
// But it is more likely that we want complete elements so always
// setting true to 'complete' variable is acceptable.
- for (GModel::riter itr = gm->firstRegion(); itr != gm->lastRegion(); ++itr) {
- if ((*itr)->getNumMeshElements()){
+ for(GModel::riter itr = gm->firstRegion(); itr != gm->lastRegion(); ++itr) {
+ if((*itr)->getNumMeshElements()) {
meshOrder = (*itr)->getMeshElement(0)->getPolynomialOrder();
-// complete = (meshOrder <= 2) ? 1 : (*itr)->getMeshElement(0)->getNumVolumeVertices();
+ // complete = (meshOrder <= 2) ? 1 :
+ // (*itr)->getMeshElement(0)->getNumVolumeVertices();
break;
}
}
- for (GModel::fiter itf = gm->firstFace(); itf != gm->lastFace(); ++itf) {
- if ((*itf)->getNumMeshElements()){
- if (meshOrder == -1) {
+ for(GModel::fiter itf = gm->firstFace(); itf != gm->lastFace(); ++itf) {
+ if((*itf)->getNumMeshElements()) {
+ if(meshOrder == -1) {
meshOrder = (*itf)->getMeshElement(0)->getPolynomialOrder();
-// complete = (meshOrder <= 2) ? 1 : (*itf)->getMeshElement(0)->getNumFaceVertices();
- if ((*itf)->geomType() == GEntity::DiscreteSurface)CAD = false;
+ // complete = (meshOrder <= 2) ? 1 :
+ // (*itf)->getMeshElement(0)->getNumFaceVertices();
+ if((*itf)->geomType() == GEntity::DiscreteSurface) CAD = false;
break;
}
}
}
}
-void SetOrderN(GModel *m, int order, bool linear, bool incomplete, bool onlyVisible)
+void SetOrderN(GModel *m, int order, bool linear, bool incomplete,
+ bool onlyVisible)
{
// replace all the elements in the mesh with second order elements
// by creating unique vertices on the edges/faces of the mesh:
@@ -1489,7 +1563,8 @@ void SetOrderN(GModel *m, int order, bool linear, bool incomplete, bool onlyVisi
int nPts = order - 1;
char msg[256];
- sprintf(msg, "Meshing order %d (curvilinear %s)...", order, linear ? "off" : "on");
+ sprintf(msg, "Meshing order %d (curvilinear %s)...", order,
+ linear ? "off" : "on");
Msg::StatusBar(true, msg);
@@ -1500,33 +1575,36 @@ void SetOrderN(GModel *m, int order, bool linear, bool incomplete, bool onlyVisi
// Keep track of vertex/entities created
edgeContainer edgeVertices;
faceContainer faceVertices;
- std::map<GEntity*,std::vector<MVertex*> > newHOVert;
+ std::map<GEntity *, std::vector<MVertex *> > newHOVert;
Msg::ResetProgressMeter();
- int counter = 0, nTot = m->getNumEdges() + m->getNumFaces() + m->getNumRegions();
+ int counter = 0,
+ nTot = m->getNumEdges() + m->getNumFaces() + m->getNumRegions();
for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); ++it) {
Msg::Info("Meshing curve %d order %d", (*it)->tag(), order);
Msg::ProgressMeter(++counter, nTot, false, msg);
- if (onlyVisible && !(*it)->getVisibility()) continue;
+ if(onlyVisible && !(*it)->getVisibility()) continue;
setHighOrder(*it, newHOVert[*it], edgeVertices, linear, nPts);
}
for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
Msg::Info("Meshing surface %d order %d", (*it)->tag(), order);
Msg::ProgressMeter(++counter, nTot, false, msg);
- if (onlyVisible && !(*it)->getVisibility()) continue;
- setHighOrder(*it, newHOVert[*it], edgeVertices, faceVertices, linear, incomplete, nPts);
- if ((*it)->getColumns() != 0) (*it)->getColumns()->clearElementData();
+ if(onlyVisible && !(*it)->getVisibility()) continue;
+ setHighOrder(*it, newHOVert[*it], edgeVertices, faceVertices, linear,
+ incomplete, nPts);
+ if((*it)->getColumns() != 0) (*it)->getColumns()->clearElementData();
}
for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it) {
Msg::Info("Meshing volume %d order %d", (*it)->tag(), order);
Msg::ProgressMeter(++counter, nTot, false, msg);
- if (onlyVisible && !(*it)->getVisibility())continue;
- setHighOrder(*it, newHOVert[*it], edgeVertices, faceVertices, incomplete, nPts);
- if ((*it)->getColumns() != 0) (*it)->getColumns()->clearElementData();
+ if(onlyVisible && !(*it)->getVisibility()) continue;
+ setHighOrder(*it, newHOVert[*it], edgeVertices, faceVertices, incomplete,
+ nPts);
+ if((*it)->getColumns() != 0) (*it)->getColumns()->clearElementData();
}
// Update all high order vertices
@@ -1544,11 +1622,17 @@ void SetOrderN(GModel *m, int order, bool linear, bool incomplete, bool onlyVisi
p.curveOuterBL = FastCurvingParameters::OUTER_CURVE;
p.thickness = false;
// p.optimizeGeometry = true;
- for (GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it)
- if ((*it)->getNumMeshElements() > 0) { p.dim = 3; break; }
- if (p.dim == 0)
+ for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); ++it)
+ if((*it)->getNumMeshElements() > 0) {
+ p.dim = 3;
+ break;
+ }
+ if(p.dim == 0)
for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it)
- if ((*it)->getNumMeshElements() > 0) { p.dim = 2; break; }
+ if((*it)->getNumMeshElements() > 0) {
+ p.dim = 2;
+ break;
+ }
// if (p.dim == 2)
// HighOrderMeshFastCurving(GModel::current(), p, true);
#endif
@@ -1557,7 +1641,7 @@ void SetOrderN(GModel *m, int order, bool linear, bool incomplete, bool onlyVisi
double t2 = Cpu();
- std::vector<MElement*> bad;
+ std::vector<MElement *> bad;
double worst;
checkHighOrderTriangles("Surface mesh", m, bad, worst);
checkHighOrderTetrahedron("Volume Mesh", m, bad, worst);
@@ -1570,48 +1654,53 @@ void SetHighOrderComplete(GModel *m, bool onlyVisible)
{
faceContainer faceVertices;
for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
- if (onlyVisible && !(*it)->getVisibility()) continue;
- std::vector<MVertex*> dumNewHOVert;
- std::vector<MTriangle*> newT;
- for (unsigned int i = 0; i < (*it)->triangles.size(); i++){
+ if(onlyVisible && !(*it)->getVisibility()) continue;
+ std::vector<MVertex *> dumNewHOVert;
+ std::vector<MTriangle *> newT;
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
MTriangle *t = (*it)->triangles[i];
- std::vector<MVertex*> vv;
- for (std::size_t j=3;j<t->getNumVertices()-t->getNumFaceVertices();j++)
+ std::vector<MVertex *> vv;
+ for(std::size_t j = 3; j < t->getNumVertices() - t->getNumFaceVertices();
+ j++)
vv.push_back(t->getVertex(j));
int nPts = t->getPolynomialOrder() - 1;
getFaceVertices(*it, t, vv, dumNewHOVert, faceVertices, false, nPts);
- newT.push_back(new MTriangleN(t->getVertex(0), t->getVertex(1), t->getVertex(2),
- vv, nPts + 1, 0, t->getPartition()));
+ newT.push_back(new MTriangleN(t->getVertex(0), t->getVertex(1),
+ t->getVertex(2), vv, nPts + 1, 0,
+ t->getPartition()));
delete t;
}
(*it)->triangles = newT;
- std::vector<MQuadrangle*> newQ;
- for (unsigned int i = 0; i < (*it)->quadrangles.size(); i++){
+ std::vector<MQuadrangle *> newQ;
+ for(unsigned int i = 0; i < (*it)->quadrangles.size(); i++) {
MQuadrangle *t = (*it)->quadrangles[i];
- std::vector<MVertex*> vv;
- vv.reserve(t->getNumVertices()-t->getNumFaceVertices() - 4);
+ std::vector<MVertex *> vv;
+ vv.reserve(t->getNumVertices() - t->getNumFaceVertices() - 4);
- for (std::size_t j=4;j<t->getNumVertices()-t->getNumFaceVertices();j++)
+ for(std::size_t j = 4; j < t->getNumVertices() - t->getNumFaceVertices();
+ j++)
vv.push_back(t->getVertex(j));
int nPts = t->getPolynomialOrder() - 1;
getFaceVertices(*it, t, vv, dumNewHOVert, faceVertices, false, nPts);
newQ.push_back(new MQuadrangleN(t->getVertex(0), t->getVertex(1),
- t->getVertex(2), t->getVertex(3),
- vv, nPts + 1, 0, t->getPartition()));
+ t->getVertex(2), t->getVertex(3), vv,
+ nPts + 1, 0, t->getPartition()));
delete t;
}
(*it)->quadrangles = newQ;
- std::set<MVertex*> newV;
- for (unsigned int i = 0; i < (*it)->getNumMeshElements(); ++i){
+ std::set<MVertex *> newV;
+ for(unsigned int i = 0; i < (*it)->getNumMeshElements(); ++i) {
MElement *e = (*it)->getMeshElement(i);
- for (std::size_t j=0;j<e->getNumVertices();j++) newV.insert(e->getVertex(j));
+ for(std::size_t j = 0; j < e->getNumVertices(); j++)
+ newV.insert(e->getVertex(j));
}
(*it)->mesh_vertices.clear();
- (*it)->mesh_vertices.insert((*it)->mesh_vertices.begin(), newV.begin(), newV.end());
+ (*it)->mesh_vertices.insert((*it)->mesh_vertices.begin(), newV.begin(),
+ newV.end());
}
updatePeriodicEdgesAndFaces(m);
@@ -1619,50 +1708,53 @@ void SetHighOrderComplete(GModel *m, bool onlyVisible)
void SetHighOrderIncomplete(GModel *m, bool onlyVisible)
{
- std::set<MVertex*> toDelete;
+ std::set<MVertex *> toDelete;
for(GModel::fiter it = m->firstFace(); it != m->lastFace(); ++it) {
- if (onlyVisible && !(*it)->getVisibility()) continue;
- std::vector<MTriangle*> newT;
+ if(onlyVisible && !(*it)->getVisibility()) continue;
+ std::vector<MTriangle *> newT;
- for (unsigned int i = 0; i < (*it)->triangles.size(); i++){
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
MTriangle *t = (*it)->triangles[i];
- std::vector<MVertex*> vt;
+ std::vector<MVertex *> vt;
int order = t->getPolynomialOrder();
- for (std::size_t j=3;j<t->getNumVertices()-t->getNumFaceVertices();j++)
+ for(std::size_t j = 3; j < t->getNumVertices() - t->getNumFaceVertices();
+ j++)
vt.push_back(t->getVertex(j));
- for (std::size_t j = t->getNumVertices()-t->getNumFaceVertices();
- j < t->getNumVertices(); j++)
+ for(std::size_t j = t->getNumVertices() - t->getNumFaceVertices();
+ j < t->getNumVertices(); j++)
toDelete.insert(t->getVertex(j));
- newT.push_back(new MTriangleN(t->getVertex(0), t->getVertex(1), t->getVertex(2),
- vt, order, 0, t->getPartition()));
+ newT.push_back(new MTriangleN(t->getVertex(0), t->getVertex(1),
+ t->getVertex(2), vt, order, 0,
+ t->getPartition()));
delete t;
}
(*it)->triangles = newT;
- std::vector<MQuadrangle*> newQ;
- for (unsigned int i = 0; i < (*it)->quadrangles.size(); i++){
+ std::vector<MQuadrangle *> newQ;
+ for(unsigned int i = 0; i < (*it)->quadrangles.size(); i++) {
MQuadrangle *q = (*it)->quadrangles[i];
- std::vector<MVertex*> vt;
+ std::vector<MVertex *> vt;
int nPts = q->getPolynomialOrder() - 1;
- for (std::size_t j = 4; j < q->getNumVertices()-q->getNumFaceVertices(); j++)
+ for(std::size_t j = 4; j < q->getNumVertices() - q->getNumFaceVertices();
+ j++)
vt.push_back(q->getVertex(j));
- for (std::size_t j = q->getNumVertices()-q->getNumFaceVertices();
- j < q->getNumVertices(); j++)
+ for(std::size_t j = q->getNumVertices() - q->getNumFaceVertices();
+ j < q->getNumVertices(); j++)
toDelete.insert(q->getVertex(j));
newQ.push_back(new MQuadrangleN(q->getVertex(0), q->getVertex(1),
- q->getVertex(2), q->getVertex(3),
- vt, nPts + 1, 0, q->getPartition()));
+ q->getVertex(2), q->getVertex(3), vt,
+ nPts + 1, 0, q->getPartition()));
delete q;
}
(*it)->quadrangles = newQ;
- std::vector<MVertex*> newV;
+ std::vector<MVertex *> newV;
int numd = 0;
- for (unsigned int i = 0; i < (*it)->mesh_vertices.size(); ++i){
- if (toDelete.find((*it)->mesh_vertices[i]) == toDelete.end())
+ for(unsigned int i = 0; i < (*it)->mesh_vertices.size(); ++i) {
+ if(toDelete.find((*it)->mesh_vertices[i]) == toDelete.end())
newV.push_back((*it)->mesh_vertices[i]);
- else{
- delete (*it)->mesh_vertices[i];
+ else {
+ delete(*it)->mesh_vertices[i];
numd++;
}
}
diff --git a/Mesh/HighOrder.h b/Mesh/HighOrder.h
index 3023341d65b7f8a09bc96fef8ae371461288de36..d1b16e4bca769e45857703b180af16bd21f251c1 100644
--- a/Mesh/HighOrder.h
+++ b/Mesh/HighOrder.h
@@ -13,24 +13,26 @@
// that are the high order representation of the edge. The ordering of
// vertices in the list is supposed to be (by construction) consistent
// with the ordering of the pair.
-typedef std::map<std::pair<MVertex*, MVertex*>, std::vector<MVertex*> > edgeContainer;
+typedef std::map<std::pair<MVertex *, MVertex *>, std::vector<MVertex *> >
+ edgeContainer;
// for each face (a list of vertices) we build a list of vertices that
// are the high order representation of the face
-typedef std::map<MFace, std::vector<MVertex*>, Less_Face> faceContainer;
+typedef std::map<MFace, std::vector<MVertex *>, Less_Face> faceContainer;
void SetOrder1(GModel *m, bool onlyVisible = false);
-void SetOrderN(GModel *m, int order, bool linear=true, bool incomplete=false,
- bool onlyVisible=false);
+void SetOrderN(GModel *m, int order, bool linear = true,
+ bool incomplete = false, bool onlyVisible = false);
void SetHighOrderComplete(GModel *m, bool onlyVisible);
void SetHighOrderIncomplete(GModel *m, bool onlyVisible);
-void checkHighOrderTriangles(const char* cc, GModel *m,
- std::vector<MElement*> &bad, double &minJGlob);
-void checkHighOrderTetrahedron(const char* cc, GModel *m,
- std::vector<MElement*> &bad, double &minJGlob);
+void checkHighOrderTriangles(const char *cc, GModel *m,
+ std::vector<MElement *> &bad, double &minJGlob);
+void checkHighOrderTetrahedron(const char *cc, GModel *m,
+ std::vector<MElement *> &bad, double &minJGlob);
-void getMeshInfoForHighOrder(GModel *gm, int &meshOrder, bool &complete, bool &CAD);
+void getMeshInfoForHighOrder(GModel *gm, int &meshOrder, bool &complete,
+ bool &CAD);
#endif
diff --git a/Mesh/Levy3D.cpp b/Mesh/Levy3D.cpp
index 0a830c96c68201a220042f0d419ff05dc1650ff4..0343c2af311d54f447267e31d837fe55c5104993 100644
--- a/Mesh/Levy3D.cpp
+++ b/Mesh/Levy3D.cpp
@@ -27,18 +27,19 @@
/*********definitions*********/
-class Wrap{
- private:
+class Wrap {
+private:
int p;
int dimension;
int iteration;
int max_iteration;
int offset;
double initial_energy;
- MElementOctree* octree;
+ MElementOctree *octree;
std::vector<SPoint3> bank;
std::vector<int> movability;
- public:
+
+public:
Wrap();
~Wrap();
int get_p();
@@ -47,7 +48,7 @@ class Wrap{
int get_max_iteration();
int get_offset();
double get_initial_energy();
- MElementOctree* get_octree();
+ MElementOctree *get_octree();
SPoint3 get_bank(int);
int get_movability(int);
int get_size();
@@ -57,14 +58,14 @@ class Wrap{
void set_max_iteration(int);
void set_offset(int);
void set_initial_energy(double);
- void set_octree(MElementOctree*);
+ void set_octree(MElementOctree *);
void set_bank(const SPoint3 &, int);
- void set_movability(int,int);
+ void set_movability(int, int);
void resize(int);
};
-class LpCVT{
- private:
+class LpCVT {
+private:
int gauss_num;
fullMatrix<double> gauss_points;
fullVector<double> gauss_weights;
@@ -77,26 +78,28 @@ class LpCVT{
std::vector<double> drho_dy_cache;
std::vector<double> drho_dz_cache;
std::vector<VoronoiElement> clipped;
- public:
+
+public:
LpCVT();
~LpCVT();
- void verification(std::vector<SPoint3>&,std::vector<int>&,int,int);
- void eval(std::vector<SPoint3>&,std::vector<int>&,int,std::vector<SVector3>&,double&,int);
+ void verification(std::vector<SPoint3> &, std::vector<int> &, int, int);
+ void eval(std::vector<SPoint3> &, std::vector<int> &, int,
+ std::vector<SVector3> &, double &, int);
void compute_parameters();
- double get_size(double,double,double);
- Tensor get_tensor(double,double,double);
- double get_drho_dx(double,double,double,int);
- double get_drho_dy(double,double,double,int);
- double get_drho_dz(double,double,double,int);
- double h_to_rho(double,int);
+ double get_size(double, double, double);
+ Tensor get_tensor(double, double, double);
+ double get_drho_dx(double, double, double, int);
+ double get_drho_dy(double, double, double, int);
+ double get_drho_dz(double, double, double, int);
+ double h_to_rho(double, int);
void swap();
void get_gauss();
- void init_caches(VoronoiElement,int);
- double F(VoronoiElement,int);
- SVector3 simple(VoronoiElement,int);
- SVector3 dF_dC1(VoronoiElement,int);
- SVector3 dF_dC2(VoronoiElement,int);
- SVector3 dF_dC3(VoronoiElement,int);
+ void init_caches(VoronoiElement, int);
+ double F(VoronoiElement, int);
+ SVector3 simple(VoronoiElement, int);
+ SVector3 dF_dC1(VoronoiElement, int);
+ SVector3 dF_dC2(VoronoiElement, int);
+ SVector3 dF_dC3(VoronoiElement, int);
double f(const SPoint3 &, const SPoint3 &, Tensor, int);
double df_dx(const SPoint3 &, const SPoint3 &, Tensor, int);
double df_dy(const SPoint3 &, const SPoint3 &, Tensor, int);
@@ -112,16 +115,19 @@ class LpCVT{
/*********functions*********/
-bool inside_domain(MElementOctree* octree,double x,double y,double z){
- MElement* element;
- element = (MElement*)octree->find(x,y,z,3,true);
- if(element!=NULL) return 1;
- else return 0;
+bool inside_domain(MElementOctree *octree, double x, double y, double z)
+{
+ MElement *element;
+ element = (MElement *)octree->find(x, y, z, 3, true);
+ if(element != NULL)
+ return 1;
+ else
+ return 0;
}
#if defined(HAVE_BFGS)
-void call_back(const alglib::real_1d_array& x,double& func,
- alglib::real_1d_array& grad,void* ptr)
+void call_back(const alglib::real_1d_array &x, double &func,
+ alglib::real_1d_array &grad, void *ptr)
{
int i;
int p;
@@ -136,13 +142,13 @@ void call_back(const alglib::real_1d_array& x,double& func,
double initial_energy;
double energy;
LpCVT obj;
- Wrap* w;
- MElementOctree* octree;
+ Wrap *w;
+ MElementOctree *octree;
std::vector<SPoint3> bank;
std::vector<int> movability;
std::vector<SVector3> gradients;
- w = static_cast<Wrap*>(ptr);
+ w = static_cast<Wrap *>(ptr);
p = w->get_p();
dimension = w->get_dimension();
iteration = w->get_iteration();
@@ -156,48 +162,51 @@ void call_back(const alglib::real_1d_array& x,double& func,
bank.resize(size);
movability.resize(size);
- for(i=0;i<size;i++){
+ for(i = 0; i < size; i++) {
bank[i] = w->get_bank(i);
movability[i] = w->get_movability(i);
}
- for(i=0;i<dimension/3;i++){
- bank[i+offset] = SPoint3(x[i],x[i+(dimension/3)],x[i+(2*dimension/3)]);
- flag = inside_domain(octree,x[i],x[i+(dimension/3)],x[i+(2*dimension/3)]);
- if(!flag){
- error1 = 1;
- printf("Vertices outside domain.\n");
- }
+ for(i = 0; i < dimension / 3; i++) {
+ bank[i + offset] =
+ SPoint3(x[i], x[i + (dimension / 3)], x[i + (2 * dimension / 3)]);
+ flag = inside_domain(octree, x[i], x[i + (dimension / 3)],
+ x[i + (2 * dimension / 3)]);
+ if(!flag) {
+ error1 = 1;
+ printf("Vertices outside domain.\n");
+ }
}
- if(iteration>max_iteration){
+ if(iteration > max_iteration) {
error2 = 1;
- printf("Maximum number of iterations reached.\n");
+ printf("Maximum number of iterations reached.\n");
}
- if(!error1 && !error2){
- gradients.resize(dimension/3);
+ if(!error1 && !error2) {
+ gradients.resize(dimension / 3);
obj.get_gauss();
- obj.eval(bank,movability,offset,gradients,energy,p);
+ obj.eval(bank, movability, offset, gradients, energy, p);
func = energy;
- for(i=0;i<dimension/3;i++){
+ for(i = 0; i < dimension / 3; i++) {
grad[i] = gradients[i].x();
- grad[i+(dimension/3)] = gradients[i].y();
- grad[i+(2*dimension/3)] = gradients[i].z();
+ grad[i + (dimension / 3)] = gradients[i].y();
+ grad[i + (2 * dimension / 3)] = gradients[i].z();
}
}
- else{
+ else {
func = 1000000000.0;
- for(i=0;i<dimension;i++){
- grad[i] = 0.0;
- }
+ for(i = 0; i < dimension; i++) {
+ grad[i] = 0.0;
+ }
}
- if(initial_energy>0.0 && !error1 && !error2){
- printf("%d %.9f\n",iteration,100.0*(initial_energy-energy)/initial_energy);
- w->set_iteration(iteration+1);
+ if(initial_energy > 0.0 && !error1 && !error2) {
+ printf("%d %.9f\n", iteration,
+ 100.0 * (initial_energy - energy) / initial_energy);
+ w->set_iteration(iteration + 1);
}
- else if(!error1 && !error2){
+ else if(!error1 && !error2) {
w->set_initial_energy(energy);
}
}
@@ -205,74 +214,47 @@ void call_back(const alglib::real_1d_array& x,double& func,
/*********class VoronoiVertex*********/
-VoronoiVertex::VoronoiVertex(){
+VoronoiVertex::VoronoiVertex()
+{
index1 = -1;
index2 = -1;
index3 = -1;
index4 = -1;
- normal1 = SVector3(0.0,0.0,0.0);
- normal2 = SVector3(0.0,0.0,0.0);
+ normal1 = SVector3(0.0, 0.0, 0.0);
+ normal2 = SVector3(0.0, 0.0, 0.0);
}
-VoronoiVertex::~VoronoiVertex(){}
+VoronoiVertex::~VoronoiVertex() {}
-SPoint3 VoronoiVertex::get_point(){
- return point;
-}
+SPoint3 VoronoiVertex::get_point() { return point; }
-int VoronoiVertex::get_category(){
- return category;
-}
+int VoronoiVertex::get_category() { return category; }
-int VoronoiVertex::get_index1(){
- return index1;
-}
+int VoronoiVertex::get_index1() { return index1; }
-int VoronoiVertex::get_index2(){
- return index2;
-}
+int VoronoiVertex::get_index2() { return index2; }
-int VoronoiVertex::get_index3(){
- return index3;
-}
+int VoronoiVertex::get_index3() { return index3; }
-int VoronoiVertex::get_index4(){
- return index4;
-}
+int VoronoiVertex::get_index4() { return index4; }
-SVector3 VoronoiVertex::get_normal1(){
- return normal1;
-}
+SVector3 VoronoiVertex::get_normal1() { return normal1; }
-SVector3 VoronoiVertex::get_normal2(){
- return normal2;
-}
+SVector3 VoronoiVertex::get_normal2() { return normal2; }
-double VoronoiVertex::get_h(){
- return h;
-}
+double VoronoiVertex::get_h() { return h; }
void VoronoiVertex::set_point(const SPoint3 &new_point) { point = new_point; }
-void VoronoiVertex::set_category(int new_category){
- category = new_category;
-}
+void VoronoiVertex::set_category(int new_category) { category = new_category; }
-void VoronoiVertex::set_index1(int new_index1){
- index1 = new_index1;
-}
+void VoronoiVertex::set_index1(int new_index1) { index1 = new_index1; }
-void VoronoiVertex::set_index2(int new_index2){
- index2 = new_index2;
-}
+void VoronoiVertex::set_index2(int new_index2) { index2 = new_index2; }
-void VoronoiVertex::set_index3(int new_index3){
- index3 = new_index3;
-}
+void VoronoiVertex::set_index3(int new_index3) { index3 = new_index3; }
-void VoronoiVertex::set_index4(int new_index4){
- index4 = new_index4;
-}
+void VoronoiVertex::set_index4(int new_index4) { index4 = new_index4; }
void VoronoiVertex::set_normal1(const SVector3 &new_normal1)
{
@@ -284,13 +266,12 @@ void VoronoiVertex::set_normal2(const SVector3 &new_normal2)
normal2 = new_normal2;
}
-void VoronoiVertex::set_h(double new_h){
- h = new_h;
-}
+void VoronoiVertex::set_h(double new_h) { h = new_h; }
/*********class Tensor*********/
-Tensor::Tensor(){
+Tensor::Tensor()
+{
t11 = 1.0;
t21 = 0.0;
t31 = 0.0;
@@ -302,121 +283,67 @@ Tensor::Tensor(){
t33 = 1.0;
}
-Tensor::~Tensor(){}
+Tensor::~Tensor() {}
-void Tensor::set_t11(double new_t11){
- t11 = new_t11;
-}
+void Tensor::set_t11(double new_t11) { t11 = new_t11; }
-void Tensor::set_t21(double new_t21){
- t21 = new_t21;
-}
+void Tensor::set_t21(double new_t21) { t21 = new_t21; }
-void Tensor::set_t31(double new_t31){
- t31 = new_t31;
-}
+void Tensor::set_t31(double new_t31) { t31 = new_t31; }
-void Tensor::set_t12(double new_t12){
- t12 = new_t12;
-}
+void Tensor::set_t12(double new_t12) { t12 = new_t12; }
-void Tensor::set_t22(double new_t22){
- t22 = new_t22;
-}
+void Tensor::set_t22(double new_t22) { t22 = new_t22; }
-void Tensor::set_t32(double new_t32){
- t32 = new_t32;
-}
+void Tensor::set_t32(double new_t32) { t32 = new_t32; }
-void Tensor::set_t13(double new_t13){
- t13 = new_t13;
-}
+void Tensor::set_t13(double new_t13) { t13 = new_t13; }
-void Tensor::set_t23(double new_t23){
- t23 = new_t23;
-}
+void Tensor::set_t23(double new_t23) { t23 = new_t23; }
-void Tensor::set_t33(double new_t33){
- t33 = new_t33;
-}
+void Tensor::set_t33(double new_t33) { t33 = new_t33; }
-double Tensor::get_t11(){
- return t11;
-}
+double Tensor::get_t11() { return t11; }
-double Tensor::get_t21(){
- return t21;
-}
+double Tensor::get_t21() { return t21; }
-double Tensor::get_t31(){
- return t31;
-}
+double Tensor::get_t31() { return t31; }
-double Tensor::get_t12(){
- return t12;
-}
+double Tensor::get_t12() { return t12; }
-double Tensor::get_t22(){
- return t22;
-}
+double Tensor::get_t22() { return t22; }
-double Tensor::get_t32(){
- return t32;
-}
+double Tensor::get_t32() { return t32; }
-double Tensor::get_t13(){
- return t13;
-}
+double Tensor::get_t13() { return t13; }
-double Tensor::get_t23(){
- return t23;
-}
+double Tensor::get_t23() { return t23; }
-double Tensor::get_t33(){
- return t33;
-}
+double Tensor::get_t33() { return t33; }
/*********class VoronoiElement*********/
-VoronoiElement::VoronoiElement(){}
+VoronoiElement::VoronoiElement() {}
-VoronoiElement::~VoronoiElement(){}
+VoronoiElement::~VoronoiElement() {}
-VoronoiVertex VoronoiElement::get_v1(){
- return v1;
-}
+VoronoiVertex VoronoiElement::get_v1() { return v1; }
-VoronoiVertex VoronoiElement::get_v2(){
- return v2;
-}
+VoronoiVertex VoronoiElement::get_v2() { return v2; }
-VoronoiVertex VoronoiElement::get_v3(){
- return v3;
-}
+VoronoiVertex VoronoiElement::get_v3() { return v3; }
-VoronoiVertex VoronoiElement::get_v4(){
- return v4;
-}
+VoronoiVertex VoronoiElement::get_v4() { return v4; }
-double VoronoiElement::get_jacobian(){
- return jacobian;
-}
+double VoronoiElement::get_jacobian() { return jacobian; }
-double VoronoiElement::get_dh_dx(){
- return dh_dx;
-}
+double VoronoiElement::get_dh_dx() { return dh_dx; }
-double VoronoiElement::get_dh_dy(){
- return dh_dy;
-}
+double VoronoiElement::get_dh_dy() { return dh_dy; }
-double VoronoiElement::get_dh_dz(){
- return dh_dz;
-}
+double VoronoiElement::get_dh_dz() { return dh_dz; }
-Tensor VoronoiElement::get_tensor(){
- return t;
-}
+Tensor VoronoiElement::get_tensor() { return t; }
void VoronoiElement::set_v1(const VoronoiVertex &new_v1) { v1 = new_v1; }
@@ -428,7 +355,8 @@ void VoronoiElement::set_v4(const VoronoiVertex &new_v4) { v4 = new_v4; }
void VoronoiElement::set_tensor(const Tensor &new_t) { t = new_t; }
-double VoronoiElement::get_h(double u,double v,double w){
+double VoronoiElement::get_h(double u, double v, double w)
+{
double h1;
double h2;
double h3;
@@ -439,25 +367,26 @@ double VoronoiElement::get_h(double u,double v,double w){
h2 = v2.get_h();
h3 = v3.get_h();
h4 = v4.get_h();
- h = T(u,v,w,h1,h2,h3,h4);
+ h = T(u, v, w, h1, h2, h3, h4);
return h;
}
-void VoronoiElement::deriv_h(){
+void VoronoiElement::deriv_h()
+{
double h1;
double h2;
double h3;
double h4;
- double x1,y1,z1;
- double x2,y2,z2;
- double x3,y3,z3;
- double x4,y4,z4;
- double t11,t12,t13;
- double t21,t22,t23;
- double t31,t32,t33;
- double b11,b12,b13;
- double b21,b22,b23;
- double b31,b32,b33;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double x3, y3, z3;
+ double x4, y4, z4;
+ double t11, t12, t13;
+ double t21, t22, t23;
+ double t31, t32, t33;
+ double b11, b12, b13;
+ double b21, b22, b23;
+ double b31, b32, b33;
double jacobian2;
double dh_du;
double dh_dv;
@@ -492,53 +421,55 @@ void VoronoiElement::deriv_h(){
x4 = p4.x();
y4 = p4.y();
z4 = p4.z();
- t11 = x2-x1;
- t12 = x3-x1;
- t13 = x4-x1;
- t21 = y2-y1;
- t22 = y3-y1;
- t23 = y4-y1;
- t31 = z2-z1;
- t32 = z3-z1;
- t33 = z4-z1;
- jacobian2 = t11*(t22*t33-t23*t32) - t12*(t21*t33-t31*t23) + t13*(t21*t32-t31*t22);
- b11 = t22*t33-t32*t23;
- b12 = t31*t23-t21*t33;
- b13 = t21*t32-t31*t22;
- b21 = t13*t32-t12*t33;
- b22 = t11*t33-t13*t31;
- b23 = t12*t31-t32*t11;
- b31 = t12*t23-t13*t22;
- b32 = t21*t13-t23*t11;
- b33 = t11*t22-t12*t21;
- du_dx = b11/jacobian2;
- dv_dx = b12/jacobian2;
- dw_dx = b13/jacobian2;
- du_dy = b21/jacobian2;
- dv_dy = b22/jacobian2;
- dw_dy = b23/jacobian2;
- du_dz = b31/jacobian2;
- dv_dz = b32/jacobian2;
- dw_dz = b33/jacobian2;
+ t11 = x2 - x1;
+ t12 = x3 - x1;
+ t13 = x4 - x1;
+ t21 = y2 - y1;
+ t22 = y3 - y1;
+ t23 = y4 - y1;
+ t31 = z2 - z1;
+ t32 = z3 - z1;
+ t33 = z4 - z1;
+ jacobian2 = t11 * (t22 * t33 - t23 * t32) - t12 * (t21 * t33 - t31 * t23) +
+ t13 * (t21 * t32 - t31 * t22);
+ b11 = t22 * t33 - t32 * t23;
+ b12 = t31 * t23 - t21 * t33;
+ b13 = t21 * t32 - t31 * t22;
+ b21 = t13 * t32 - t12 * t33;
+ b22 = t11 * t33 - t13 * t31;
+ b23 = t12 * t31 - t32 * t11;
+ b31 = t12 * t23 - t13 * t22;
+ b32 = t21 * t13 - t23 * t11;
+ b33 = t11 * t22 - t12 * t21;
+ du_dx = b11 / jacobian2;
+ dv_dx = b12 / jacobian2;
+ dw_dx = b13 / jacobian2;
+ du_dy = b21 / jacobian2;
+ dv_dy = b22 / jacobian2;
+ dw_dy = b23 / jacobian2;
+ du_dz = b31 / jacobian2;
+ dv_dz = b32 / jacobian2;
+ dw_dz = b33 / jacobian2;
h1 = v1.get_h();
h2 = v2.get_h();
h3 = v3.get_h();
h4 = v4.get_h();
- dh_du = h2-h1;
- dh_dv = h3-h1;
- dh_dw = h4-h1;
+ dh_du = h2 - h1;
+ dh_dv = h3 - h1;
+ dh_dw = h4 - h1;
- dh_dx = dh_du*du_dx + dh_dv*dv_dx + dh_dw*dw_dx;
- dh_dy = dh_du*du_dy + dh_dv*dv_dy + dh_dw*dw_dy;
- dh_dz = dh_du*du_dz + dh_dv*dv_dz + dh_dw*dw_dz;
+ dh_dx = dh_du * du_dx + dh_dv * dv_dx + dh_dw * dw_dx;
+ dh_dy = dh_du * du_dy + dh_dv * dv_dy + dh_dw * dw_dy;
+ dh_dz = dh_du * du_dz + dh_dv * dv_dz + dh_dw * dw_dz;
}
-void VoronoiElement::compute_jacobian(){
+void VoronoiElement::compute_jacobian()
+{
double jacobian2;
- double x1,x2,x3,x4;
- double y1,y2,y3,y4;
- double z1,z2,z3,z4;
+ double x1, x2, x3, x4;
+ double y1, y2, y3, y4;
+ double z1, z2, z3, z4;
SPoint3 p1;
SPoint3 p2;
SPoint3 p3;
@@ -560,30 +491,36 @@ void VoronoiElement::compute_jacobian(){
x4 = p4.x();
y4 = p4.y();
z4 = p4.z();
- jacobian2 = (x2-x1)*((y3-y1)*(z4-z1)-(y4-y1)*(z3-z1));
- jacobian2 = jacobian2 - (x3-x1)*((y2-y1)*(z4-z1)-(y4-y1)*(z2-z1));
- jacobian2 = jacobian2 + (x4-x1)*((y2-y1)*(z3-z1)-(y3-y1)*(z2-z1));
+ jacobian2 = (x2 - x1) * ((y3 - y1) * (z4 - z1) - (y4 - y1) * (z3 - z1));
+ jacobian2 =
+ jacobian2 - (x3 - x1) * ((y2 - y1) * (z4 - z1) - (y4 - y1) * (z2 - z1));
+ jacobian2 =
+ jacobian2 + (x4 - x1) * ((y2 - y1) * (z3 - z1) - (y3 - y1) * (z2 - z1));
jacobian = jacobian2;
}
-double VoronoiElement::T(double u,double v,double w,double val1,double val2,double val3,double val4){
- return (1.0-u-v-w)*val1 + u*val2 + v*val3 + w*val4;
+double VoronoiElement::T(double u, double v, double w, double val1, double val2,
+ double val3, double val4)
+{
+ return (1.0 - u - v - w) * val1 + u * val2 + v * val3 + w * val4;
}
-void VoronoiElement::swap(){
+void VoronoiElement::swap()
+{
VoronoiVertex v;
compute_jacobian();
- if(jacobian<0.0){
- v = v2;
- v2 = v3;
- v3 = v;
+ if(jacobian < 0.0) {
+ v = v2;
+ v2 = v3;
+ v3 = v;
}
}
-double VoronoiElement::get_quality(){
+double VoronoiElement::get_quality()
+{
int i;
double quality;
- double min_l,max_l;
+ double min_l, max_l;
double l[6];
l[0] = v1.get_point().distance(v2.get_point());
@@ -596,275 +533,304 @@ double VoronoiElement::get_quality(){
min_l = 1000000.0;
max_l = -1000000.0;
- for(i=0;i<6;i++){
- min_l = std::min(min_l,l[i]);
- max_l = std::max(max_l,l[i]);
+ for(i = 0; i < 6; i++) {
+ min_l = std::min(min_l, l[i]);
+ max_l = std::max(max_l, l[i]);
}
- quality = min_l/max_l;
+ quality = min_l / max_l;
return quality;
}
/*********class Wrap*********/
-Wrap::Wrap(){
+Wrap::Wrap()
+{
iteration = 0;
initial_energy = -1000000.0;
}
-Wrap::~Wrap(){}
+Wrap::~Wrap() {}
-int Wrap::get_p(){
- return p;
-}
+int Wrap::get_p() { return p; }
-int Wrap::get_dimension(){
- return dimension;
-}
+int Wrap::get_dimension() { return dimension; }
-int Wrap::get_iteration(){
- return iteration;
-}
+int Wrap::get_iteration() { return iteration; }
-int Wrap::get_max_iteration(){
- return max_iteration;
-}
+int Wrap::get_max_iteration() { return max_iteration; }
-int Wrap::get_offset(){
- return offset;
-}
+int Wrap::get_offset() { return offset; }
-double Wrap::get_initial_energy(){
- return initial_energy;
-}
+double Wrap::get_initial_energy() { return initial_energy; }
-MElementOctree* Wrap::get_octree(){
- return octree;
-}
+MElementOctree *Wrap::get_octree() { return octree; }
-SPoint3 Wrap::get_bank(int index){
- return bank[index];
-}
+SPoint3 Wrap::get_bank(int index) { return bank[index]; }
-int Wrap::get_movability(int index){
- return movability[index];
-}
+int Wrap::get_movability(int index) { return movability[index]; }
-int Wrap::get_size(){
- return bank.size();
-}
+int Wrap::get_size() { return bank.size(); }
-void Wrap::set_p(int new_p){
- p = new_p;
-}
+void Wrap::set_p(int new_p) { p = new_p; }
-void Wrap::set_dimension(int new_dimension){
- dimension = new_dimension;
-}
+void Wrap::set_dimension(int new_dimension) { dimension = new_dimension; }
-void Wrap::set_iteration(int new_iteration){
- iteration = new_iteration;
-}
+void Wrap::set_iteration(int new_iteration) { iteration = new_iteration; }
-void Wrap::set_max_iteration(int new_max_iteration){
+void Wrap::set_max_iteration(int new_max_iteration)
+{
max_iteration = new_max_iteration;
}
-void Wrap::set_offset(int new_offset){
- offset = new_offset;
-}
+void Wrap::set_offset(int new_offset) { offset = new_offset; }
-void Wrap::set_initial_energy(double new_initial_energy){
+void Wrap::set_initial_energy(double new_initial_energy)
+{
initial_energy = new_initial_energy;
}
-void Wrap::set_octree(MElementOctree* new_octree){
- octree = new_octree;
-}
+void Wrap::set_octree(MElementOctree *new_octree) { octree = new_octree; }
void Wrap::set_bank(const SPoint3 &point, int index) { bank[index] = point; }
-void Wrap::set_movability(int flag,int index){
- movability[index] = flag;
-}
+void Wrap::set_movability(int flag, int index) { movability[index] = flag; }
-void Wrap::resize(int size){
+void Wrap::resize(int size)
+{
bank.resize(size);
movability.resize(size);
}
/*********class LpCVT*********/
-LpCVT::LpCVT(){}
+LpCVT::LpCVT() {}
-LpCVT::~LpCVT(){}
+LpCVT::~LpCVT() {}
-void LpCVT::verification(std::vector<SPoint3>& bank,std::vector<int>& movability,int offset,int p){
+void LpCVT::verification(std::vector<SPoint3> &bank,
+ std::vector<int> &movability, int offset, int p)
+{
int index;
double energy;
- double up,down;
- double left,right;
- double front,back;
+ double up, down;
+ double left, right;
+ double front, back;
double e;
std::vector<SVector3> gradients;
- gradients.resize(bank.size()-offset);
+ gradients.resize(bank.size() - offset);
e = 0.0000001;
srand(time(NULL));
- index = rand()%(bank.size()-offset) + offset;
+ index = rand() % (bank.size() - offset) + offset;
- bank[index] = SPoint3(bank[index].x()+e,bank[index].y(),bank[index].z());
- eval(bank,movability,offset,gradients,right,p);
- bank[index] = SPoint3(bank[index].x()-e,bank[index].y(),bank[index].z());
+ bank[index] = SPoint3(bank[index].x() + e, bank[index].y(), bank[index].z());
+ eval(bank, movability, offset, gradients, right, p);
+ bank[index] = SPoint3(bank[index].x() - e, bank[index].y(), bank[index].z());
- bank[index] = SPoint3(bank[index].x()-e,bank[index].y(),bank[index].z());
- eval(bank,movability,offset,gradients,left,p);
- bank[index] = SPoint3(bank[index].x()+e,bank[index].y(),bank[index].z());
+ bank[index] = SPoint3(bank[index].x() - e, bank[index].y(), bank[index].z());
+ eval(bank, movability, offset, gradients, left, p);
+ bank[index] = SPoint3(bank[index].x() + e, bank[index].y(), bank[index].z());
- bank[index] = SPoint3(bank[index].x(),bank[index].y()+e,bank[index].z());
- eval(bank,movability,offset,gradients,up,p);
- bank[index] = SPoint3(bank[index].x(),bank[index].y()-e,bank[index].z());
+ bank[index] = SPoint3(bank[index].x(), bank[index].y() + e, bank[index].z());
+ eval(bank, movability, offset, gradients, up, p);
+ bank[index] = SPoint3(bank[index].x(), bank[index].y() - e, bank[index].z());
- bank[index] = SPoint3(bank[index].x(),bank[index].y()-e,bank[index].z());
- eval(bank,movability,offset,gradients,down,p);
- bank[index] = SPoint3(bank[index].x(),bank[index].y()+e,bank[index].z());
+ bank[index] = SPoint3(bank[index].x(), bank[index].y() - e, bank[index].z());
+ eval(bank, movability, offset, gradients, down, p);
+ bank[index] = SPoint3(bank[index].x(), bank[index].y() + e, bank[index].z());
- bank[index] = SPoint3(bank[index].x(),bank[index].y(),bank[index].z()+e);
- eval(bank,movability,offset,gradients,front,p);
- bank[index] = SPoint3(bank[index].x(),bank[index].y(),bank[index].z()-e);
+ bank[index] = SPoint3(bank[index].x(), bank[index].y(), bank[index].z() + e);
+ eval(bank, movability, offset, gradients, front, p);
+ bank[index] = SPoint3(bank[index].x(), bank[index].y(), bank[index].z() - e);
- bank[index] = SPoint3(bank[index].x(),bank[index].y(),bank[index].z()-e);
- eval(bank,movability,offset,gradients,back,p);
- bank[index] = SPoint3(bank[index].x(),bank[index].y(),bank[index].z()+e);
+ bank[index] = SPoint3(bank[index].x(), bank[index].y(), bank[index].z() - e);
+ eval(bank, movability, offset, gradients, back, p);
+ bank[index] = SPoint3(bank[index].x(), bank[index].y(), bank[index].z() + e);
- eval(bank,movability,offset,gradients,energy,p);
+ eval(bank, movability, offset, gradients, energy, p);
- printf("Finite difference : %f %f %f\n",(right-left)/(2.0*e),(up-down)/(2.0*e),(front-back)/(2.0*e));
- printf(" Gauss : %f %f %f\n",gradients[index-offset].x(),gradients[index-offset].y(),gradients[index-offset].z());
- printf("%d %d %d\n",index,(int)bank.size(),offset);
+ printf("Finite difference : %f %f %f\n", (right - left) / (2.0 * e),
+ (up - down) / (2.0 * e), (front - back) / (2.0 * e));
+ printf(" Gauss : %f %f %f\n", gradients[index - offset].x(),
+ gradients[index - offset].y(), gradients[index - offset].z());
+ printf("%d %d %d\n", index, (int)bank.size(), offset);
}
-void LpCVT::eval(std::vector<SPoint3>& bank,std::vector<int>& movability,int offset,std::vector<SVector3>& gradients,double& energy,int p){
+void LpCVT::eval(std::vector<SPoint3> &bank, std::vector<int> &movability,
+ int offset, std::vector<SVector3> &gradients, double &energy,
+ int p)
+{
unsigned int i;
int index;
- int index1,index2,index3;
- int index4,index5,index6;
- int index7,index8,index9;
+ int index1, index2, index3;
+ int index4, index5, index6;
+ int index7, index8, index9;
double e;
- SVector3 grad1,grad2,grad3;
+ SVector3 grad1, grad2, grad3;
clip approx;
- for(i=0;i<gradients.size();i++){
- gradients[i] = SVector3(0.0,0.0,0.0);
+ for(i = 0; i < gradients.size(); i++) {
+ gradients[i] = SVector3(0.0, 0.0, 0.0);
}
energy = 0.0;
e = 0.000001;
clipped.clear();
- approx.execute(bank,clipped);
+ approx.execute(bank, clipped);
swap();
compute_parameters();
- for(i=0;i<clipped.size();i++){
- if(clipped[i].get_quality()<e) continue; //not exact
- init_caches(clipped[i],p);
- energy = energy + F(clipped[i],p);
- grad1 = dF_dC1(clipped[i],p);
- grad2 = dF_dC2(clipped[i],p);
- grad3 = dF_dC3(clipped[i],p);
- index = clipped[i].get_v1().get_index1();
- index1 = clipped[i].get_v2().get_index2();
- index2 = clipped[i].get_v2().get_index3();
- index3 = clipped[i].get_v2().get_index4();
- index4 = clipped[i].get_v3().get_index2();
- index5 = clipped[i].get_v3().get_index3();
- index6 = clipped[i].get_v3().get_index4();
- index7 = clipped[i].get_v4().get_index2();
- index8 = clipped[i].get_v4().get_index3();
- index9 = clipped[i].get_v4().get_index4();
- if(movability[index]==1){
- gradients[index-offset] = gradients[index-offset] + simple(clipped[i],p);
- if(index1>0 && index2>0 && index3>0)
- gradients[index-offset] = gradients[index-offset] + bisectors3(grad1,clipped[i].get_v2().get_point(),bank[index],bank[index1],bank[index2],bank[index3]);
- if(index4>0 && index5>0 && index6>0)
- gradients[index-offset] = gradients[index-offset] + bisectors3(grad2,clipped[i].get_v3().get_point(),bank[index],bank[index4],bank[index5],bank[index6]);
- if(index7>0 && index8>0 && index9>0)
- gradients[index-offset] = gradients[index-offset] + bisectors3(grad3,clipped[i].get_v4().get_point(),bank[index],bank[index7],bank[index8],bank[index9]);
- }
- if(index1>0 && index2>0 && index3>0){
- if(movability[index1]==1){
- gradients[index1-offset] = gradients[index1-offset] + bisectors3(grad1,clipped[i].get_v2().get_point(),bank[index1],bank[index],bank[index2],bank[index3]);
- }
- if(movability[index2]==1){
- gradients[index2-offset] = gradients[index2-offset] + bisectors3(grad1,clipped[i].get_v2().get_point(),bank[index2],bank[index],bank[index1],bank[index3]);
- }
- if(movability[index3]==1){
- gradients[index3-offset] = gradients[index3-offset] + bisectors3(grad1,clipped[i].get_v2().get_point(),bank[index3],bank[index],bank[index1],bank[index2]);
- }
- }
- if(index4>0 && index5>0 && index6>0){
- if(movability[index4]==1){
- gradients[index4-offset] = gradients[index4-offset] + bisectors3(grad2,clipped[i].get_v3().get_point(),bank[index4],bank[index],bank[index5],bank[index6]);
- }
- if(movability[index5]==1){
- gradients[index5-offset] = gradients[index5-offset] + bisectors3(grad2,clipped[i].get_v3().get_point(),bank[index5],bank[index],bank[index4],bank[index6]);
- }
- if(movability[index6]==1){
- gradients[index6-offset] = gradients[index6-offset] + bisectors3(grad2,clipped[i].get_v3().get_point(),bank[index6],bank[index],bank[index4],bank[index5]);
- }
- }
- if(index7>0 && index8>0 && index9>0){
- if(movability[index7]==1){
- gradients[index7-offset] = gradients[index7-offset] + bisectors3(grad3,clipped[i].get_v4().get_point(),bank[index7],bank[index],bank[index8],bank[index9]);
- }
- if(movability[index8]==1){
- gradients[index8-offset] = gradients[index8-offset] + bisectors3(grad3,clipped[i].get_v4().get_point(),bank[index8],bank[index],bank[index7],bank[index9]);
- }
- if(movability[index9]==1){
- gradients[index9-offset] = gradients[index9-offset] + bisectors3(grad3,clipped[i].get_v4().get_point(),bank[index9],bank[index],bank[index7],bank[index8]);
- }
- }
+ for(i = 0; i < clipped.size(); i++) {
+ if(clipped[i].get_quality() < e) continue; // not exact
+ init_caches(clipped[i], p);
+ energy = energy + F(clipped[i], p);
+ grad1 = dF_dC1(clipped[i], p);
+ grad2 = dF_dC2(clipped[i], p);
+ grad3 = dF_dC3(clipped[i], p);
+ index = clipped[i].get_v1().get_index1();
+ index1 = clipped[i].get_v2().get_index2();
+ index2 = clipped[i].get_v2().get_index3();
+ index3 = clipped[i].get_v2().get_index4();
+ index4 = clipped[i].get_v3().get_index2();
+ index5 = clipped[i].get_v3().get_index3();
+ index6 = clipped[i].get_v3().get_index4();
+ index7 = clipped[i].get_v4().get_index2();
+ index8 = clipped[i].get_v4().get_index3();
+ index9 = clipped[i].get_v4().get_index4();
+ if(movability[index] == 1) {
+ gradients[index - offset] =
+ gradients[index - offset] + simple(clipped[i], p);
+ if(index1 > 0 && index2 > 0 && index3 > 0)
+ gradients[index - offset] =
+ gradients[index - offset] +
+ bisectors3(grad1, clipped[i].get_v2().get_point(), bank[index],
+ bank[index1], bank[index2], bank[index3]);
+ if(index4 > 0 && index5 > 0 && index6 > 0)
+ gradients[index - offset] =
+ gradients[index - offset] +
+ bisectors3(grad2, clipped[i].get_v3().get_point(), bank[index],
+ bank[index4], bank[index5], bank[index6]);
+ if(index7 > 0 && index8 > 0 && index9 > 0)
+ gradients[index - offset] =
+ gradients[index - offset] +
+ bisectors3(grad3, clipped[i].get_v4().get_point(), bank[index],
+ bank[index7], bank[index8], bank[index9]);
+ }
+ if(index1 > 0 && index2 > 0 && index3 > 0) {
+ if(movability[index1] == 1) {
+ gradients[index1 - offset] =
+ gradients[index1 - offset] +
+ bisectors3(grad1, clipped[i].get_v2().get_point(), bank[index1],
+ bank[index], bank[index2], bank[index3]);
+ }
+ if(movability[index2] == 1) {
+ gradients[index2 - offset] =
+ gradients[index2 - offset] +
+ bisectors3(grad1, clipped[i].get_v2().get_point(), bank[index2],
+ bank[index], bank[index1], bank[index3]);
+ }
+ if(movability[index3] == 1) {
+ gradients[index3 - offset] =
+ gradients[index3 - offset] +
+ bisectors3(grad1, clipped[i].get_v2().get_point(), bank[index3],
+ bank[index], bank[index1], bank[index2]);
+ }
+ }
+ if(index4 > 0 && index5 > 0 && index6 > 0) {
+ if(movability[index4] == 1) {
+ gradients[index4 - offset] =
+ gradients[index4 - offset] +
+ bisectors3(grad2, clipped[i].get_v3().get_point(), bank[index4],
+ bank[index], bank[index5], bank[index6]);
+ }
+ if(movability[index5] == 1) {
+ gradients[index5 - offset] =
+ gradients[index5 - offset] +
+ bisectors3(grad2, clipped[i].get_v3().get_point(), bank[index5],
+ bank[index], bank[index4], bank[index6]);
+ }
+ if(movability[index6] == 1) {
+ gradients[index6 - offset] =
+ gradients[index6 - offset] +
+ bisectors3(grad2, clipped[i].get_v3().get_point(), bank[index6],
+ bank[index], bank[index4], bank[index5]);
+ }
+ }
+ if(index7 > 0 && index8 > 0 && index9 > 0) {
+ if(movability[index7] == 1) {
+ gradients[index7 - offset] =
+ gradients[index7 - offset] +
+ bisectors3(grad3, clipped[i].get_v4().get_point(), bank[index7],
+ bank[index], bank[index8], bank[index9]);
+ }
+ if(movability[index8] == 1) {
+ gradients[index8 - offset] =
+ gradients[index8 - offset] +
+ bisectors3(grad3, clipped[i].get_v4().get_point(), bank[index8],
+ bank[index], bank[index7], bank[index9]);
+ }
+ if(movability[index9] == 1) {
+ gradients[index9 - offset] =
+ gradients[index9 - offset] +
+ bisectors3(grad3, clipped[i].get_v4().get_point(), bank[index9],
+ bank[index], bank[index7], bank[index8]);
+ }
+ }
}
}
-void LpCVT::compute_parameters(){
+void LpCVT::compute_parameters()
+{
unsigned int i;
- double h1,h2,h3,h4;
+ double h1, h2, h3, h4;
Tensor t;
- VoronoiVertex v1,v2,v3,v4;
+ VoronoiVertex v1, v2, v3, v4;
- for(i=0;i<clipped.size();i++){
+ for(i = 0; i < clipped.size(); i++) {
v1 = clipped[i].get_v1();
- v2 = clipped[i].get_v2();
- v3 = clipped[i].get_v3();
- v4 = clipped[i].get_v4();
- h1 = get_size(clipped[i].get_v1().get_point().x(),clipped[i].get_v1().get_point().y(),clipped[i].get_v1().get_point().z());
- h2 = get_size(clipped[i].get_v2().get_point().x(),clipped[i].get_v2().get_point().y(),clipped[i].get_v2().get_point().z());
- h3 = get_size(clipped[i].get_v3().get_point().x(),clipped[i].get_v3().get_point().y(),clipped[i].get_v3().get_point().z());
- h4 = get_size(clipped[i].get_v4().get_point().x(),clipped[i].get_v4().get_point().y(),clipped[i].get_v4().get_point().z());
- v1.set_h(h1);
- v2.set_h(h2);
- v3.set_h(h3);
- v4.set_h(h4);
- clipped[i].set_v1(v1);
- clipped[i].set_v2(v2);
- clipped[i].set_v3(v3);
- clipped[i].set_v4(v4);
- t = get_tensor(clipped[i].get_v1().get_point().x(),clipped[i].get_v1().get_point().y(),clipped[i].get_v1().get_point().z());
- clipped[i].set_tensor(t);
- clipped[i].compute_jacobian();
- clipped[i].deriv_h();
+ v2 = clipped[i].get_v2();
+ v3 = clipped[i].get_v3();
+ v4 = clipped[i].get_v4();
+ h1 = get_size(clipped[i].get_v1().get_point().x(),
+ clipped[i].get_v1().get_point().y(),
+ clipped[i].get_v1().get_point().z());
+ h2 = get_size(clipped[i].get_v2().get_point().x(),
+ clipped[i].get_v2().get_point().y(),
+ clipped[i].get_v2().get_point().z());
+ h3 = get_size(clipped[i].get_v3().get_point().x(),
+ clipped[i].get_v3().get_point().y(),
+ clipped[i].get_v3().get_point().z());
+ h4 = get_size(clipped[i].get_v4().get_point().x(),
+ clipped[i].get_v4().get_point().y(),
+ clipped[i].get_v4().get_point().z());
+ v1.set_h(h1);
+ v2.set_h(h2);
+ v3.set_h(h3);
+ v4.set_h(h4);
+ clipped[i].set_v1(v1);
+ clipped[i].set_v2(v2);
+ clipped[i].set_v3(v3);
+ clipped[i].set_v4(v4);
+ t = get_tensor(clipped[i].get_v1().get_point().x(),
+ clipped[i].get_v1().get_point().y(),
+ clipped[i].get_v1().get_point().z());
+ clipped[i].set_tensor(t);
+ clipped[i].compute_jacobian();
+ clipped[i].deriv_h();
}
}
-double LpCVT::get_size(double x,double y,double z){
- //if outside domain return 1.0 (or other value > 0.0)
- return Size_field::search(x,y,z);
+double LpCVT::get_size(double x, double y, double z)
+{
+ // if outside domain return 1.0 (or other value > 0.0)
+ return Size_field::search(x, y, z);
}
-Tensor LpCVT::get_tensor(double x,double y,double z){
+Tensor LpCVT::get_tensor(double x, double y, double z)
+{
Tensor t;
- STensor3 m = Frame_field::search(x,y,z);
+ STensor3 m = Frame_field::search(x, y, z);
t.set_t11(m.get_m11());
t.set_t21(m.get_m12());
@@ -881,7 +847,8 @@ Tensor LpCVT::get_tensor(double x,double y,double z){
return t;
}
-double LpCVT::get_drho_dx(double x,double y,double z,int p){
+double LpCVT::get_drho_dx(double x, double y, double z, int p)
+{
double e;
double less2;
double less1;
@@ -890,16 +857,17 @@ double LpCVT::get_drho_dx(double x,double y,double z,int p){
double val;
e = 0.000001;
- less2 = h_to_rho(get_size(x-2.0*e,y,z),p);
- less1 = h_to_rho(get_size(x-e,y,z),p);
- plus1 = h_to_rho(get_size(x+e,y,z),p);
- plus2 = h_to_rho(get_size(x+2.0*e,y,z),p);
+ less2 = h_to_rho(get_size(x - 2.0 * e, y, z), p);
+ less1 = h_to_rho(get_size(x - e, y, z), p);
+ plus1 = h_to_rho(get_size(x + e, y, z), p);
+ plus2 = h_to_rho(get_size(x + 2.0 * e, y, z), p);
- val = (less2 - 8.0*less1 + 8.0*plus1 - plus2)/(12.0*e);
+ val = (less2 - 8.0 * less1 + 8.0 * plus1 - plus2) / (12.0 * e);
return val;
}
-double LpCVT::get_drho_dy(double x,double y,double z,int p){
+double LpCVT::get_drho_dy(double x, double y, double z, int p)
+{
double e;
double less2;
double less1;
@@ -908,16 +876,17 @@ double LpCVT::get_drho_dy(double x,double y,double z,int p){
double val;
e = 0.000001;
- less2 = h_to_rho(get_size(x,y-2.0*e,z),p);
- less1 = h_to_rho(get_size(x,y-e,z),p);
- plus1 = h_to_rho(get_size(x,y+e,z),p);
- plus2 = h_to_rho(get_size(x,y+2.0*e,z),p);
+ less2 = h_to_rho(get_size(x, y - 2.0 * e, z), p);
+ less1 = h_to_rho(get_size(x, y - e, z), p);
+ plus1 = h_to_rho(get_size(x, y + e, z), p);
+ plus2 = h_to_rho(get_size(x, y + 2.0 * e, z), p);
- val = (less2 - 8.0*less1 + 8.0*plus1 - plus2)/(12.0*e);
+ val = (less2 - 8.0 * less1 + 8.0 * plus1 - plus2) / (12.0 * e);
return val;
}
-double LpCVT::get_drho_dz(double x,double y,double z,int p){
+double LpCVT::get_drho_dz(double x, double y, double z, int p)
+{
double e;
double less2;
double less1;
@@ -926,33 +895,36 @@ double LpCVT::get_drho_dz(double x,double y,double z,int p){
double val;
e = 0.000001;
- less2 = h_to_rho(get_size(x,y,z-2.0*e),p);
- less1 = h_to_rho(get_size(x,y,z-e),p);
- plus1 = h_to_rho(get_size(x,y,z+e),p);
- plus2 = h_to_rho(get_size(x,y,z+2.0*e),p);
+ less2 = h_to_rho(get_size(x, y, z - 2.0 * e), p);
+ less1 = h_to_rho(get_size(x, y, z - e), p);
+ plus1 = h_to_rho(get_size(x, y, z + e), p);
+ plus2 = h_to_rho(get_size(x, y, z + 2.0 * e), p);
- val = (less2 - 8.0*less1 + 8.0*plus1 - plus2)/(12.0*e);
+ val = (less2 - 8.0 * less1 + 8.0 * plus1 - plus2) / (12.0 * e);
return val;
}
-double LpCVT::h_to_rho(double h,int p){
+double LpCVT::h_to_rho(double h, int p)
+{
double rho;
- rho = pow_int(1.0/h,p+3);
+ rho = pow_int(1.0 / h, p + 3);
return rho;
}
-void LpCVT::swap(){
+void LpCVT::swap()
+{
unsigned int i;
- for(i=0;i<clipped.size();i++){
+ for(i = 0; i < clipped.size(); i++) {
clipped[i].swap();
}
}
-void LpCVT::get_gauss(){
+void LpCVT::get_gauss()
+{
int order;
order = 8;
- gaussIntegration::getTetrahedron(order,gauss_points,gauss_weights);
+ gaussIntegration::getTetrahedron(order, gauss_points, gauss_weights);
gauss_num = gauss_points.size1();
f_cache.resize(gauss_num);
@@ -965,12 +937,13 @@ void LpCVT::get_gauss(){
drho_dz_cache.resize(gauss_num);
}
-void LpCVT::init_caches(VoronoiElement element,int p){
+void LpCVT::init_caches(VoronoiElement element, int p)
+{
int i;
- double u,v,w;
- double x,y,z;
- SPoint3 point,generator,C1,C2,C3;
- VoronoiVertex v1,v2,v3,v4;
+ double u, v, w;
+ double x, y, z;
+ SPoint3 point, generator, C1, C2, C3;
+ VoronoiVertex v1, v2, v3, v4;
Tensor t;
v1 = element.get_v1();
@@ -983,44 +956,49 @@ void LpCVT::init_caches(VoronoiElement element,int p){
C3 = v4.get_point();
t = element.get_tensor();
- for(i=0;i<gauss_num;i++){
- u = gauss_points(i,0);
- v = gauss_points(i,1);
- w = gauss_points(i,2);
- x = element.T(u,v,w,generator.x(),C1.x(),C2.x(),C3.x());
- y = element.T(u,v,w,generator.y(),C1.y(),C2.y(),C3.y());
- z = element.T(u,v,w,generator.z(),C1.z(),C2.z(),C3.z());
- point = SPoint3(x,y,z);
- f_cache[i] = f(generator,point,t,p);
- df_dx_cache[i] = df_dx(generator,point,t,p);
- df_dy_cache[i] = df_dy(generator,point,t,p);
- df_dz_cache[i] = df_dz(generator,point,t,p);
- rho_cache[i] = h_to_rho(element.get_h(u,v,w),p);
- drho_dx_cache[i] = (-p-3)*rho_cache[i]*element.get_dh_dx()/element.get_h(u,v,w);
- drho_dy_cache[i] = (-p-3)*rho_cache[i]*element.get_dh_dy()/element.get_h(u,v,w);
- drho_dz_cache[i] = (-p-3)*rho_cache[i]*element.get_dh_dz()/element.get_h(u,v,w);
+ for(i = 0; i < gauss_num; i++) {
+ u = gauss_points(i, 0);
+ v = gauss_points(i, 1);
+ w = gauss_points(i, 2);
+ x = element.T(u, v, w, generator.x(), C1.x(), C2.x(), C3.x());
+ y = element.T(u, v, w, generator.y(), C1.y(), C2.y(), C3.y());
+ z = element.T(u, v, w, generator.z(), C1.z(), C2.z(), C3.z());
+ point = SPoint3(x, y, z);
+ f_cache[i] = f(generator, point, t, p);
+ df_dx_cache[i] = df_dx(generator, point, t, p);
+ df_dy_cache[i] = df_dy(generator, point, t, p);
+ df_dz_cache[i] = df_dz(generator, point, t, p);
+ rho_cache[i] = h_to_rho(element.get_h(u, v, w), p);
+ drho_dx_cache[i] =
+ (-p - 3) * rho_cache[i] * element.get_dh_dx() / element.get_h(u, v, w);
+ drho_dy_cache[i] =
+ (-p - 3) * rho_cache[i] * element.get_dh_dy() / element.get_h(u, v, w);
+ drho_dz_cache[i] =
+ (-p - 3) * rho_cache[i] * element.get_dh_dz() / element.get_h(u, v, w);
}
}
-double LpCVT::F(VoronoiElement element,int p){
+double LpCVT::F(VoronoiElement element, int p)
+{
int i;
double energy;
double weight;
double rho;
energy = 0.0;
- for(i=0;i<gauss_num;i++){
- weight = gauss_weights(i);
- rho = rho_cache[i];
- energy = energy + weight*rho*f_cache[i];
+ for(i = 0; i < gauss_num; i++) {
+ weight = gauss_weights(i);
+ rho = rho_cache[i];
+ energy = energy + weight * rho * f_cache[i];
}
- energy = element.get_jacobian()*energy;
+ energy = element.get_jacobian() * energy;
return energy;
}
-SVector3 LpCVT::simple(VoronoiElement element,int p){
+SVector3 LpCVT::simple(VoronoiElement element, int p)
+{
int i;
- double comp_x,comp_y,comp_z;
+ double comp_x, comp_y, comp_z;
double weight;
double rho;
double jacobian;
@@ -1030,31 +1008,32 @@ SVector3 LpCVT::simple(VoronoiElement element,int p){
comp_z = 0.0;
jacobian = element.get_jacobian();
- for(i=0;i<gauss_num;i++){
- weight = gauss_weights(i);
- rho = rho_cache[i];
- comp_x = comp_x + weight*rho*df_dx_cache[i];
- comp_y = comp_y + weight*rho*df_dy_cache[i];
- comp_z = comp_z + weight*rho*df_dz_cache[i];
+ for(i = 0; i < gauss_num; i++) {
+ weight = gauss_weights(i);
+ rho = rho_cache[i];
+ comp_x = comp_x + weight * rho * df_dx_cache[i];
+ comp_y = comp_y + weight * rho * df_dy_cache[i];
+ comp_z = comp_z + weight * rho * df_dz_cache[i];
}
- comp_x = jacobian*comp_x;
- comp_y = jacobian*comp_y;
- comp_z = jacobian*comp_z;
- return SVector3(comp_x,comp_y,comp_z);
+ comp_x = jacobian * comp_x;
+ comp_y = jacobian * comp_y;
+ comp_z = jacobian * comp_z;
+ return SVector3(comp_x, comp_y, comp_z);
}
-SVector3 LpCVT::dF_dC1(VoronoiElement element,int p){
+SVector3 LpCVT::dF_dC1(VoronoiElement element, int p)
+{
int i;
- double u;//,v,w;
- double comp_x,comp_y,comp_z;
+ double u; //,v,w;
+ double comp_x, comp_y, comp_z;
double weight;
double rho;
- double drho_dx,drho_dy,drho_dz;
+ double drho_dx, drho_dy, drho_dz;
double jacobian;
double distance;
- double gx,gy,gz;
- SPoint3 generator,C1,C2,C3;
- VoronoiVertex v1,v2,v3,v4;
+ double gx, gy, gz;
+ SPoint3 generator, C1, C2, C3;
+ VoronoiVertex v1, v2, v3, v4;
v1 = element.get_v1();
v2 = element.get_v2();
@@ -1072,41 +1051,48 @@ SVector3 LpCVT::dF_dC1(VoronoiElement element,int p){
gy = generator.y();
gz = generator.z();
- for(i=0;i<gauss_num;i++){
- u = gauss_points(i,0);
- //v = gauss_points(i,1);
- //w = gauss_points(i,2);
- weight = gauss_weights(i);
- rho = rho_cache[i];
- drho_dx = drho_dx_cache[i];
- drho_dy = drho_dy_cache[i];
- drho_dz = drho_dz_cache[i];
- distance = f_cache[i];
- comp_x = comp_x + weight*rho*df_dx_cache[i]*u*jacobian*(-1.0);
- comp_x = comp_x + weight*rho*distance*((C2.y()-gy)*(C3.z()-gz) - (C3.y()-gy)*(C2.z()-gz));
- comp_x = comp_x + weight*drho_dx*u*distance*jacobian;
- comp_y = comp_y + weight*rho*df_dy_cache[i]*u*jacobian*(-1.0);
- comp_y = comp_y + weight*rho*distance*((C2.z()-gz)*(C3.x()-gx) - (C2.x()-gx)*(C3.z()-gz));
- comp_y = comp_y + weight*drho_dy*u*distance*jacobian;
- comp_z = comp_z + weight*rho*df_dz_cache[i]*u*jacobian*(-1.0);
- comp_z = comp_z + weight*rho*distance*((C2.x()-gx)*(C3.y()-gy) - (C3.x()-gx)*(C2.y()-gy));
- comp_z = comp_z + weight*drho_dz*u*distance*jacobian;
+ for(i = 0; i < gauss_num; i++) {
+ u = gauss_points(i, 0);
+ // v = gauss_points(i,1);
+ // w = gauss_points(i,2);
+ weight = gauss_weights(i);
+ rho = rho_cache[i];
+ drho_dx = drho_dx_cache[i];
+ drho_dy = drho_dy_cache[i];
+ drho_dz = drho_dz_cache[i];
+ distance = f_cache[i];
+ comp_x = comp_x + weight * rho * df_dx_cache[i] * u * jacobian * (-1.0);
+ comp_x = comp_x +
+ weight * rho * distance *
+ ((C2.y() - gy) * (C3.z() - gz) - (C3.y() - gy) * (C2.z() - gz));
+ comp_x = comp_x + weight * drho_dx * u * distance * jacobian;
+ comp_y = comp_y + weight * rho * df_dy_cache[i] * u * jacobian * (-1.0);
+ comp_y = comp_y +
+ weight * rho * distance *
+ ((C2.z() - gz) * (C3.x() - gx) - (C2.x() - gx) * (C3.z() - gz));
+ comp_y = comp_y + weight * drho_dy * u * distance * jacobian;
+ comp_z = comp_z + weight * rho * df_dz_cache[i] * u * jacobian * (-1.0);
+ comp_z = comp_z +
+ weight * rho * distance *
+ ((C2.x() - gx) * (C3.y() - gy) - (C3.x() - gx) * (C2.y() - gy));
+ comp_z = comp_z + weight * drho_dz * u * distance * jacobian;
}
- return SVector3(comp_x,comp_y,comp_z);
+ return SVector3(comp_x, comp_y, comp_z);
}
-SVector3 LpCVT::dF_dC2(VoronoiElement element,int p){
+SVector3 LpCVT::dF_dC2(VoronoiElement element, int p)
+{
int i;
- double v;//u,v,w;
- double comp_x,comp_y,comp_z;
+ double v; // u,v,w;
+ double comp_x, comp_y, comp_z;
double weight;
double rho;
- double drho_dx,drho_dy,drho_dz;
+ double drho_dx, drho_dy, drho_dz;
double jacobian;
double distance;
- double gx,gy,gz;
- SPoint3 generator,C1,C2,C3;
- VoronoiVertex v1,v2,v3,v4;
+ double gx, gy, gz;
+ SPoint3 generator, C1, C2, C3;
+ VoronoiVertex v1, v2, v3, v4;
v1 = element.get_v1();
v2 = element.get_v2();
@@ -1124,41 +1110,48 @@ SVector3 LpCVT::dF_dC2(VoronoiElement element,int p){
gy = generator.y();
gz = generator.z();
- for(i=0;i<gauss_num;i++){
- //u = gauss_points(i,0);
- v = gauss_points(i,1);
- //w = gauss_points(i,2);
- weight = gauss_weights(i);
- rho = rho_cache[i];
- drho_dx = drho_dx_cache[i];
- drho_dy = drho_dy_cache[i];
- drho_dz = drho_dz_cache[i];
- distance = f_cache[i];
- comp_x = comp_x + weight*rho*df_dx_cache[i]*v*jacobian*(-1.0);
- comp_x = comp_x + weight*rho*distance*((C1.z()-gz)*(C3.y()-gy) - (C1.y()-gy)*(C3.z()-gz));
- comp_x = comp_x + weight*drho_dx*v*distance*jacobian;
- comp_y = comp_y + weight*rho*df_dy_cache[i]*v*jacobian*(-1.0);
- comp_y = comp_y + weight*rho*distance*((C1.x()-gx)*(C3.z()-gz) - (C3.x()-gx)*(C1.z()-gz));
- comp_y = comp_y + weight*drho_dy*v*distance*jacobian;
- comp_z = comp_z + weight*rho*df_dz_cache[i]*v*jacobian*(-1.0);
- comp_z = comp_z + weight*rho*distance*((C3.x()-gx)*(C1.y()-gy) - (C1.x()-gx)*(C3.y()-gy));
- comp_z = comp_z + weight*drho_dz*v*distance*jacobian;
+ for(i = 0; i < gauss_num; i++) {
+ // u = gauss_points(i,0);
+ v = gauss_points(i, 1);
+ // w = gauss_points(i,2);
+ weight = gauss_weights(i);
+ rho = rho_cache[i];
+ drho_dx = drho_dx_cache[i];
+ drho_dy = drho_dy_cache[i];
+ drho_dz = drho_dz_cache[i];
+ distance = f_cache[i];
+ comp_x = comp_x + weight * rho * df_dx_cache[i] * v * jacobian * (-1.0);
+ comp_x = comp_x +
+ weight * rho * distance *
+ ((C1.z() - gz) * (C3.y() - gy) - (C1.y() - gy) * (C3.z() - gz));
+ comp_x = comp_x + weight * drho_dx * v * distance * jacobian;
+ comp_y = comp_y + weight * rho * df_dy_cache[i] * v * jacobian * (-1.0);
+ comp_y = comp_y +
+ weight * rho * distance *
+ ((C1.x() - gx) * (C3.z() - gz) - (C3.x() - gx) * (C1.z() - gz));
+ comp_y = comp_y + weight * drho_dy * v * distance * jacobian;
+ comp_z = comp_z + weight * rho * df_dz_cache[i] * v * jacobian * (-1.0);
+ comp_z = comp_z +
+ weight * rho * distance *
+ ((C3.x() - gx) * (C1.y() - gy) - (C1.x() - gx) * (C3.y() - gy));
+ comp_z = comp_z + weight * drho_dz * v * distance * jacobian;
}
- return SVector3(comp_x,comp_y,comp_z);
+ return SVector3(comp_x, comp_y, comp_z);
}
-SVector3 LpCVT::dF_dC3(VoronoiElement element,int p){
+SVector3 LpCVT::dF_dC3(VoronoiElement element, int p)
+{
int i;
- double w;//u,v,w;
- double comp_x,comp_y,comp_z;
+ double w; // u,v,w;
+ double comp_x, comp_y, comp_z;
double weight;
double rho;
- double drho_dx,drho_dy,drho_dz;
+ double drho_dx, drho_dy, drho_dz;
double jacobian;
double distance;
- double gx,gy,gz;
- SPoint3 generator,C1,C2,C3;
- VoronoiVertex v1,v2,v3,v4;
+ double gx, gy, gz;
+ SPoint3 generator, C1, C2, C3;
+ VoronoiVertex v1, v2, v3, v4;
v1 = element.get_v1();
v2 = element.get_v2();
@@ -1176,37 +1169,43 @@ SVector3 LpCVT::dF_dC3(VoronoiElement element,int p){
gy = generator.y();
gz = generator.z();
- for(i=0;i<gauss_num;i++){
- //u = gauss_points(i,0);
- //v = gauss_points(i,1);
- w = gauss_points(i,2);
- weight = gauss_weights(i);
- rho = rho_cache[i];
- drho_dx = drho_dx_cache[i];
- drho_dy = drho_dy_cache[i];
- drho_dz = drho_dz_cache[i];
- distance = f_cache[i];
- comp_x = comp_x + weight*rho*df_dx_cache[i]*w*jacobian*(-1.0);
- comp_x = comp_x + weight*rho*distance*((C1.y()-gy)*(C2.z()-gz) - (C2.y()-gy)*(C1.z()-gz));
- comp_x = comp_x + weight*drho_dx*w*distance*jacobian;
- comp_y = comp_y + weight*rho*df_dy_cache[i]*w*jacobian*(-1.0);
- comp_y = comp_y + weight*rho*distance*((C2.x()-gx)*(C1.z()-gz) - (C1.x()-gx)*(C2.z()-gz));
- comp_y = comp_y + weight*drho_dy*w*distance*jacobian;
- comp_z = comp_z + weight*rho*df_dz_cache[i]*w*jacobian*(-1.0);
- comp_z = comp_z + weight*rho*distance*((C1.x()-gx)*(C2.y()-gy) - (C2.x()-gx)*(C1.y()-gy));
- comp_z = comp_z + weight*drho_dz*w*distance*jacobian;
+ for(i = 0; i < gauss_num; i++) {
+ // u = gauss_points(i,0);
+ // v = gauss_points(i,1);
+ w = gauss_points(i, 2);
+ weight = gauss_weights(i);
+ rho = rho_cache[i];
+ drho_dx = drho_dx_cache[i];
+ drho_dy = drho_dy_cache[i];
+ drho_dz = drho_dz_cache[i];
+ distance = f_cache[i];
+ comp_x = comp_x + weight * rho * df_dx_cache[i] * w * jacobian * (-1.0);
+ comp_x = comp_x +
+ weight * rho * distance *
+ ((C1.y() - gy) * (C2.z() - gz) - (C2.y() - gy) * (C1.z() - gz));
+ comp_x = comp_x + weight * drho_dx * w * distance * jacobian;
+ comp_y = comp_y + weight * rho * df_dy_cache[i] * w * jacobian * (-1.0);
+ comp_y = comp_y +
+ weight * rho * distance *
+ ((C2.x() - gx) * (C1.z() - gz) - (C1.x() - gx) * (C2.z() - gz));
+ comp_y = comp_y + weight * drho_dy * w * distance * jacobian;
+ comp_z = comp_z + weight * rho * df_dz_cache[i] * w * jacobian * (-1.0);
+ comp_z = comp_z +
+ weight * rho * distance *
+ ((C1.x() - gx) * (C2.y() - gy) - (C2.x() - gx) * (C1.y() - gy));
+ comp_z = comp_z + weight * drho_dz * w * distance * jacobian;
}
- return SVector3(comp_x,comp_y,comp_z);
+ return SVector3(comp_x, comp_y, comp_z);
}
double LpCVT::f(const SPoint3 &p1, const SPoint3 &p2, Tensor t, int p)
{
- double x1,y1,z1;
- double x2,y2,z2;
- double t11,t12,t13;
- double t21,t22,t23;
- double t31,t32,t33;
- double val1,val2,val3;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double t11, t12, t13;
+ double t21, t22, t23;
+ double t31, t32, t33;
+ double val1, val2, val3;
double val;
x1 = p1.x();
@@ -1224,21 +1223,21 @@ double LpCVT::f(const SPoint3 &p1, const SPoint3 &p2, Tensor t, int p)
t31 = t.get_t31();
t32 = t.get_t32();
t33 = t.get_t33();
- val1 = t11*x1 + t12*y1 + t13*z1 - t11*x2 - t12*y2 - t13*z2;
- val2 = t21*x1 + t22*y1 + t23*z1 - t21*x2 - t22*y2 - t23*z2;
- val3 = t31*x1 + t32*y1 + t33*z1 - t31*x2 - t32*y2 - t33*z2;
- val = pow_int(val1,p) + pow_int(val2,p) + pow_int(val3,p);
+ val1 = t11 * x1 + t12 * y1 + t13 * z1 - t11 * x2 - t12 * y2 - t13 * z2;
+ val2 = t21 * x1 + t22 * y1 + t23 * z1 - t21 * x2 - t22 * y2 - t23 * z2;
+ val3 = t31 * x1 + t32 * y1 + t33 * z1 - t31 * x2 - t32 * y2 - t33 * z2;
+ val = pow_int(val1, p) + pow_int(val2, p) + pow_int(val3, p);
return val;
}
double LpCVT::df_dx(const SPoint3 &p1, const SPoint3 &p2, Tensor t, int p)
{
- double x1,y1,z1;
- double x2,y2,z2;
- double t11,t12,t13;
- double t21,t22,t23;
- double t31,t32,t33;
- double val1,val2,val3;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double t11, t12, t13;
+ double t21, t22, t23;
+ double t31, t32, t33;
+ double val1, val2, val3;
double val;
x1 = p1.x();
@@ -1256,21 +1255,23 @@ double LpCVT::df_dx(const SPoint3 &p1, const SPoint3 &p2, Tensor t, int p)
t31 = t.get_t31();
t32 = t.get_t32();
t33 = t.get_t33();
- val1 = t11*x1 + t12*y1 + t13*z1 - t11*x2 - t12*y2 - t13*z2;
- val2 = t21*x1 + t22*y1 + t23*z1 - t21*x2 - t22*y2 - t23*z2;
- val3 = t31*x1 + t32*y1 + t33*z1 - t31*x2 - t32*y2 - t33*z2;
- val = ((double)p)*pow_int(val1,p-1)*t11 + ((double)p)*pow_int(val2,p-1)*t21 + ((double)p)*pow_int(val3,p-1)*t31;
+ val1 = t11 * x1 + t12 * y1 + t13 * z1 - t11 * x2 - t12 * y2 - t13 * z2;
+ val2 = t21 * x1 + t22 * y1 + t23 * z1 - t21 * x2 - t22 * y2 - t23 * z2;
+ val3 = t31 * x1 + t32 * y1 + t33 * z1 - t31 * x2 - t32 * y2 - t33 * z2;
+ val = ((double)p) * pow_int(val1, p - 1) * t11 +
+ ((double)p) * pow_int(val2, p - 1) * t21 +
+ ((double)p) * pow_int(val3, p - 1) * t31;
return val;
}
double LpCVT::df_dy(const SPoint3 &p1, const SPoint3 &p2, Tensor t, int p)
{
- double x1,y1,z1;
- double x2,y2,z2;
- double t11,t12,t13;
- double t21,t22,t23;
- double t31,t32,t33;
- double val1,val2,val3;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double t11, t12, t13;
+ double t21, t22, t23;
+ double t31, t32, t33;
+ double val1, val2, val3;
double val;
x1 = p1.x();
@@ -1288,21 +1289,23 @@ double LpCVT::df_dy(const SPoint3 &p1, const SPoint3 &p2, Tensor t, int p)
t31 = t.get_t31();
t32 = t.get_t32();
t33 = t.get_t33();
- val1 = t11*x1 + t12*y1 + t13*z1 - t11*x2 - t12*y2 - t13*z2;
- val2 = t21*x1 + t22*y1 + t23*z1 - t21*x2 - t22*y2 - t23*z2;
- val3 = t31*x1 + t32*y1 + t33*z1 - t31*x2 - t32*y2 - t33*z2;
- val = ((double)p)*pow_int(val1,p-1)*t12 + ((double)p)*pow_int(val2,p-1)*t22 + ((double)p)*pow_int(val3,p-1)*t32;
+ val1 = t11 * x1 + t12 * y1 + t13 * z1 - t11 * x2 - t12 * y2 - t13 * z2;
+ val2 = t21 * x1 + t22 * y1 + t23 * z1 - t21 * x2 - t22 * y2 - t23 * z2;
+ val3 = t31 * x1 + t32 * y1 + t33 * z1 - t31 * x2 - t32 * y2 - t33 * z2;
+ val = ((double)p) * pow_int(val1, p - 1) * t12 +
+ ((double)p) * pow_int(val2, p - 1) * t22 +
+ ((double)p) * pow_int(val3, p - 1) * t32;
return val;
}
double LpCVT::df_dz(const SPoint3 &p1, const SPoint3 &p2, Tensor t, int p)
{
- double x1,y1,z1;
- double x2,y2,z2;
- double t11,t12,t13;
- double t21,t22,t23;
- double t31,t32,t33;
- double val1,val2,val3;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double t11, t12, t13;
+ double t21, t22, t23;
+ double t31, t32, t33;
+ double val1, val2, val3;
double val;
x1 = p1.x();
@@ -1320,10 +1323,12 @@ double LpCVT::df_dz(const SPoint3 &p1, const SPoint3 &p2, Tensor t, int p)
t31 = t.get_t31();
t32 = t.get_t32();
t33 = t.get_t33();
- val1 = t11*x1 + t12*y1 + t13*z1 - t11*x2 - t12*y2 - t13*z2;
- val2 = t21*x1 + t22*y1 + t23*z1 - t21*x2 - t22*y2 - t23*z2;
- val3 = t31*x1 + t32*y1 + t33*z1 - t31*x2 - t32*y2 - t33*z2;
- val = ((double)p)*pow_int(val1,p-1)*t13 + ((double)p)*pow_int(val2,p-1)*t23 + ((double)p)*pow_int(val3,p-1)*t33;
+ val1 = t11 * x1 + t12 * y1 + t13 * z1 - t11 * x2 - t12 * y2 - t13 * z2;
+ val2 = t21 * x1 + t22 * y1 + t23 * z1 - t21 * x2 - t22 * y2 - t23 * z2;
+ val3 = t31 * x1 + t32 * y1 + t33 * z1 - t31 * x2 - t32 * y2 - t33 * z2;
+ val = ((double)p) * pow_int(val1, p - 1) * t13 +
+ ((double)p) * pow_int(val2, p - 1) * t23 +
+ ((double)p) * pow_int(val3, p - 1) * t33;
return val;
}
@@ -1332,173 +1337,172 @@ SVector3 LpCVT::bisectors3(const SVector3 &dIdC, const SPoint3 &C,
const SPoint3 &x2, const SPoint3 &x3)
{
double e;
- fullMatrix<double> A(3,3);
- fullMatrix<double> B(3,3);
- fullMatrix<double> M(3,3);
- fullMatrix<double> _dIdC(1,3);
- fullMatrix<double> _val(1,3);
-
- e = 0.000000001;
-
- A(0,0) = x1.x() - x0.x();
- A(0,1) = x1.y() - x0.y();
- A(0,2) = x1.z() - x0.z();
- A(1,0) = x2.x() - x0.x();
- A(1,1) = x2.y() - x0.y();
- A(1,2) = x2.z() - x0.z();
- A(2,0) = x3.x() - x0.x();
- A(2,1) = x3.y() - x0.y();
- A(2,2) = x3.z() - x0.z();
-
- if(fabs(A.determinant())<e){
+ fullMatrix<double> A(3, 3);
+ fullMatrix<double> B(3, 3);
+ fullMatrix<double> M(3, 3);
+ fullMatrix<double> _dIdC(1, 3);
+ fullMatrix<double> _val(1, 3);
+
+ e = 0.000000001;
+
+ A(0, 0) = x1.x() - x0.x();
+ A(0, 1) = x1.y() - x0.y();
+ A(0, 2) = x1.z() - x0.z();
+ A(1, 0) = x2.x() - x0.x();
+ A(1, 1) = x2.y() - x0.y();
+ A(1, 2) = x2.z() - x0.z();
+ A(2, 0) = x3.x() - x0.x();
+ A(2, 1) = x3.y() - x0.y();
+ A(2, 2) = x3.z() - x0.z();
+
+ if(fabs(A.determinant()) < e) {
srand(time(NULL));
- A(0,0) = A(0,0) + e*((double)rand())/((double)RAND_MAX);
- A(0,1) = A(0,1) + e*((double)rand())/((double)RAND_MAX);
- A(0,2) = A(0,2) + e*((double)rand())/((double)RAND_MAX);
- A(1,0) = A(1,0) + e*((double)rand())/((double)RAND_MAX);
- A(1,1) = A(1,1) + e*((double)rand())/((double)RAND_MAX);
- A(1,2) = A(1,2) + e*((double)rand())/((double)RAND_MAX);
- A(2,0) = A(2,0) + e*((double)rand())/((double)RAND_MAX);
- A(2,1) = A(2,1) + e*((double)rand())/((double)RAND_MAX);
- A(2,2) = A(2,2) + e*((double)rand())/((double)RAND_MAX);
+ A(0, 0) = A(0, 0) + e * ((double)rand()) / ((double)RAND_MAX);
+ A(0, 1) = A(0, 1) + e * ((double)rand()) / ((double)RAND_MAX);
+ A(0, 2) = A(0, 2) + e * ((double)rand()) / ((double)RAND_MAX);
+ A(1, 0) = A(1, 0) + e * ((double)rand()) / ((double)RAND_MAX);
+ A(1, 1) = A(1, 1) + e * ((double)rand()) / ((double)RAND_MAX);
+ A(1, 2) = A(1, 2) + e * ((double)rand()) / ((double)RAND_MAX);
+ A(2, 0) = A(2, 0) + e * ((double)rand()) / ((double)RAND_MAX);
+ A(2, 1) = A(2, 1) + e * ((double)rand()) / ((double)RAND_MAX);
+ A(2, 2) = A(2, 2) + e * ((double)rand()) / ((double)RAND_MAX);
}
A.invertInPlace();
- B(0,0) = C.x() - x0.x();
- B(0,1) = C.y() - x0.y();
- B(0,2) = C.z() - x0.z();
- B(1,0) = C.x() - x0.x();
- B(1,1) = C.y() - x0.y();
- B(1,2) = C.z() - x0.z();
- B(2,0) = C.x() - x0.x();
- B(2,1) = C.y() - x0.y();
- B(2,2) = C.z() - x0.z();
-
- A.mult_naive(B,M);
-
- _dIdC(0,0) = dIdC.x();
- _dIdC(0,1) = dIdC.y();
- _dIdC(0,2) = dIdC.z();
- _dIdC.mult_naive(M,_val);
-
- return SVector3(_val(0,0),_val(0,1),_val(0,2));
+ B(0, 0) = C.x() - x0.x();
+ B(0, 1) = C.y() - x0.y();
+ B(0, 2) = C.z() - x0.z();
+ B(1, 0) = C.x() - x0.x();
+ B(1, 1) = C.y() - x0.y();
+ B(1, 2) = C.z() - x0.z();
+ B(2, 0) = C.x() - x0.x();
+ B(2, 1) = C.y() - x0.y();
+ B(2, 2) = C.z() - x0.z();
+
+ A.mult_naive(B, M);
+
+ _dIdC(0, 0) = dIdC.x();
+ _dIdC(0, 1) = dIdC.y();
+ _dIdC(0, 2) = dIdC.z();
+ _dIdC.mult_naive(M, _val);
+
+ return SVector3(_val(0, 0), _val(0, 1), _val(0, 2));
}
SVector3 LpCVT::bisectors2(const SVector3 &dIdC, const SPoint3 &C,
const SPoint3 &x0, const SPoint3 &x1,
const SPoint3 &x2, const SVector3 &normal1)
{
- fullMatrix<double> A(3,3);
- fullMatrix<double> B(3,3);
- fullMatrix<double> M(3,3);
- fullMatrix<double> _dIdC(1,3);
- fullMatrix<double> _val(1,3);
-
- A(0,0) = x1.x() - x0.x();
- A(0,1) = x1.y() - x0.y();
- A(0,2) = x1.z() - x0.z();
- A(1,0) = x2.x() - x0.x();
- A(1,1) = x2.y() - x0.y();
- A(1,2) = x2.z() - x0.z();
- A(2,0) = normal1.x();
- A(2,1) = normal1.y();
- A(2,2) = normal1.z();
-
+ fullMatrix<double> A(3, 3);
+ fullMatrix<double> B(3, 3);
+ fullMatrix<double> M(3, 3);
+ fullMatrix<double> _dIdC(1, 3);
+ fullMatrix<double> _val(1, 3);
+
+ A(0, 0) = x1.x() - x0.x();
+ A(0, 1) = x1.y() - x0.y();
+ A(0, 2) = x1.z() - x0.z();
+ A(1, 0) = x2.x() - x0.x();
+ A(1, 1) = x2.y() - x0.y();
+ A(1, 2) = x2.z() - x0.z();
+ A(2, 0) = normal1.x();
+ A(2, 1) = normal1.y();
+ A(2, 2) = normal1.z();
+
A.invertInPlace();
-
- B(0,0) = C.x() - x0.x();
- B(0,1) = C.y() - x0.y();
- B(0,2) = C.z() - x0.z();
- B(1,0) = C.x() - x0.x();
- B(1,1) = C.y() - x0.y();
- B(1,2) = C.z() - x0.z();
- B(2,0) = 0.0;
- B(2,1) = 0.0;
- B(2,2) = 0.0;
-
- A.mult_naive(B,M);
-
- _dIdC(0,0) = dIdC.x();
- _dIdC(0,1) = dIdC.y();
- _dIdC(0,2) = dIdC.z();
- _dIdC.mult_naive(M,_val);
-
- return SVector3(_val(0,0),_val(0,1),_val(0,2));
+
+ B(0, 0) = C.x() - x0.x();
+ B(0, 1) = C.y() - x0.y();
+ B(0, 2) = C.z() - x0.z();
+ B(1, 0) = C.x() - x0.x();
+ B(1, 1) = C.y() - x0.y();
+ B(1, 2) = C.z() - x0.z();
+ B(2, 0) = 0.0;
+ B(2, 1) = 0.0;
+ B(2, 2) = 0.0;
+
+ A.mult_naive(B, M);
+
+ _dIdC(0, 0) = dIdC.x();
+ _dIdC(0, 1) = dIdC.y();
+ _dIdC(0, 2) = dIdC.z();
+ _dIdC.mult_naive(M, _val);
+
+ return SVector3(_val(0, 0), _val(0, 1), _val(0, 2));
}
SVector3 LpCVT::bisectors1(const SVector3 &dIdC, const SPoint3 &C,
const SPoint3 &x0, const SPoint3 &x1,
const SVector3 &normal1, const SVector3 &normal2)
{
- fullMatrix<double> A(3,3);
- fullMatrix<double> B(3,3);
- fullMatrix<double> M(3,3);
- fullMatrix<double> _dIdC(1,3);
- fullMatrix<double> _val(1,3);
-
- A(0,0) = x1.x() - x0.x();
- A(0,1) = x1.y() - x0.y();
- A(0,2) = x1.z() - x0.z();
- A(1,0) = normal1.x();
- A(1,1) = normal1.y();
- A(1,2) = normal1.z();
- A(2,0) = normal2.x();
- A(2,1) = normal2.y();
- A(2,2) = normal2.z();
-
+ fullMatrix<double> A(3, 3);
+ fullMatrix<double> B(3, 3);
+ fullMatrix<double> M(3, 3);
+ fullMatrix<double> _dIdC(1, 3);
+ fullMatrix<double> _val(1, 3);
+
+ A(0, 0) = x1.x() - x0.x();
+ A(0, 1) = x1.y() - x0.y();
+ A(0, 2) = x1.z() - x0.z();
+ A(1, 0) = normal1.x();
+ A(1, 1) = normal1.y();
+ A(1, 2) = normal1.z();
+ A(2, 0) = normal2.x();
+ A(2, 1) = normal2.y();
+ A(2, 2) = normal2.z();
+
A.invertInPlace();
-
- B(0,0) = C.x() - x0.x();
- B(0,1) = C.y() - x0.y();
- B(0,2) = C.z() - x0.z();
- B(1,0) = 0.0;
- B(1,1) = 0.0;
- B(1,2) = 0.0;
- B(2,0) = 0.0;
- B(2,1) = 0.0;
- B(2,2) = 0.0;
-
- A.mult_naive(B,M);
-
- _dIdC(0,0) = dIdC.x();
- _dIdC(0,1) = dIdC.y();
- _dIdC(0,2) = dIdC.z();
- _dIdC.mult_naive(M,_val);
-
- return SVector3(_val(0,0),_val(0,1),_val(0,2));
-}
-void LpCVT::clear(){
- clipped.clear();
+ B(0, 0) = C.x() - x0.x();
+ B(0, 1) = C.y() - x0.y();
+ B(0, 2) = C.z() - x0.z();
+ B(1, 0) = 0.0;
+ B(1, 1) = 0.0;
+ B(1, 2) = 0.0;
+ B(2, 0) = 0.0;
+ B(2, 1) = 0.0;
+ B(2, 2) = 0.0;
+
+ A.mult_naive(B, M);
+
+ _dIdC(0, 0) = dIdC.x();
+ _dIdC(0, 1) = dIdC.y();
+ _dIdC(0, 2) = dIdC.z();
+ _dIdC.mult_naive(M, _val);
+
+ return SVector3(_val(0, 0), _val(0, 1), _val(0, 2));
}
+void LpCVT::clear() { clipped.clear(); }
+
/*********class LpSmoother*********/
-LpSmoother::LpSmoother(int new_max_iter,int new_norm){
+LpSmoother::LpSmoother(int new_max_iter, int new_norm)
+{
max_iter = new_max_iter;
norm = new_norm;
}
-LpSmoother::~LpSmoother(){}
+LpSmoother::~LpSmoother() {}
-void LpSmoother::improve_model(){
- GRegion* gr;
- GModel* model = GModel::current();
+void LpSmoother::improve_model()
+{
+ GRegion *gr;
+ GModel *model = GModel::current();
GModel::riter it;
- for(it=model->firstRegion();it!=model->lastRegion();it++)
- {
+ for(it = model->firstRegion(); it != model->lastRegion(); it++) {
gr = *it;
- if(gr->getNumMeshElements()>0){
- improve_region(gr);
- }
+ if(gr->getNumMeshElements() > 0) {
+ improve_region(gr);
+ }
}
}
-void LpSmoother::improve_region(GRegion* gr)
+void LpSmoother::improve_region(GRegion *gr)
{
- #if defined(HAVE_BFGS)
+#if defined(HAVE_BFGS)
unsigned int i;
int offset;
double epsg;
@@ -1506,17 +1510,17 @@ void LpSmoother::improve_region(GRegion* gr)
double epsx;
double factor;
SPoint3 point;
- MVertex* vertex;
- MVertex *v1,*v2,*v3,*v4;
- MElement* element;
- MElementOctree* octree;
+ MVertex *vertex;
+ MVertex *v1, *v2, *v3, *v4;
+ MElement *element;
+ MElementOctree *octree;
deMeshGRegion deleter;
Wrap w;
- std::set<MVertex*> movable2;
- std::set<MVertex*> unmovable2;
- std::set<MVertex*>::iterator it;
- std::vector<MVertex*> movable;
- std::vector<MVertex*> unmovable;
+ std::set<MVertex *> movable2;
+ std::set<MVertex *> unmovable2;
+ std::set<MVertex *>::iterator it;
+ std::vector<MVertex *> movable;
+ std::vector<MVertex *> unmovable;
std::vector<SPoint3> bank;
std::vector<int> movability;
alglib::ae_int_t maxits;
@@ -1530,73 +1534,74 @@ void LpSmoother::improve_region(GRegion* gr)
Size_field::solve(gr);
octree = new MElementOctree(gr->model());
- for(i=0;i<gr->getNumMeshElements();i++){
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- v1 = element->getVertex(0);
- v2 = element->getVertex(1);
- v3 = element->getVertex(2);
- v4 = element->getVertex(3);
- if(v1->onWhat()->dim()<3 || v2->onWhat()->dim()<3 || v3->onWhat()->dim()<3 || v4->onWhat()->dim()<3){
- unmovable2.insert(v1);
- unmovable2.insert(v2);
- unmovable2.insert(v3);
- unmovable2.insert(v4);
- }
+ v1 = element->getVertex(0);
+ v2 = element->getVertex(1);
+ v3 = element->getVertex(2);
+ v4 = element->getVertex(3);
+ if(v1->onWhat()->dim() < 3 || v2->onWhat()->dim() < 3 ||
+ v3->onWhat()->dim() < 3 || v4->onWhat()->dim() < 3) {
+ unmovable2.insert(v1);
+ unmovable2.insert(v2);
+ unmovable2.insert(v3);
+ unmovable2.insert(v4);
+ }
}
- for(i=0;i<gr->getNumMeshElements();i++){
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- v1 = element->getVertex(0);
- v2 = element->getVertex(1);
- v3 = element->getVertex(2);
- v4 = element->getVertex(3);
- if(unmovable2.find(v1)==unmovable2.end()){
- movable2.insert(v1);
- }
- if(unmovable2.find(v2)==unmovable2.end()){
- movable2.insert(v2);
- }
- if(unmovable2.find(v3)==unmovable2.end()){
- movable2.insert(v3);
- }
- if(unmovable2.find(v4)==unmovable2.end()){
+ v1 = element->getVertex(0);
+ v2 = element->getVertex(1);
+ v3 = element->getVertex(2);
+ v4 = element->getVertex(3);
+ if(unmovable2.find(v1) == unmovable2.end()) {
+ movable2.insert(v1);
+ }
+ if(unmovable2.find(v2) == unmovable2.end()) {
+ movable2.insert(v2);
+ }
+ if(unmovable2.find(v3) == unmovable2.end()) {
+ movable2.insert(v3);
+ }
+ if(unmovable2.find(v4) == unmovable2.end()) {
movable2.insert(v4);
- }
+ }
}
- for(it=unmovable2.begin();it!=unmovable2.end();it++){
+ for(it = unmovable2.begin(); it != unmovable2.end(); it++) {
unmovable.push_back(*it);
}
- for(it=movable2.begin();it!=movable2.end();it++){
+ for(it = movable2.begin(); it != movable2.end(); it++) {
movable.push_back(*it);
}
offset = unmovable.size();
- for(i=0;i<unmovable.size();i++){
- point = SPoint3(unmovable[i]->x(),unmovable[i]->y(),unmovable[i]->z());
- bank.push_back(point);
- movability.push_back(0);
+ for(i = 0; i < unmovable.size(); i++) {
+ point = SPoint3(unmovable[i]->x(), unmovable[i]->y(), unmovable[i]->z());
+ bank.push_back(point);
+ movability.push_back(0);
}
- for(i=0;i<movable.size();i++){
- point = SPoint3(movable[i]->x(),movable[i]->y(),movable[i]->z());
- bank.push_back(point);
- movability.push_back(1);
+ for(i = 0; i < movable.size(); i++) {
+ point = SPoint3(movable[i]->x(), movable[i]->y(), movable[i]->z());
+ bank.push_back(point);
+ movability.push_back(1);
}
w = Wrap();
w.set_p(norm);
- w.set_dimension(3*(bank.size()-offset));
+ w.set_dimension(3 * (bank.size() - offset));
w.set_iteration(0);
- w.set_max_iteration(2*max_iter);
+ w.set_max_iteration(2 * max_iter);
w.set_offset(offset);
w.set_initial_energy(-1000000.0);
w.set_octree(octree);
w.resize(bank.size());
- for(i=0;i<bank.size();i++) w.set_bank(bank[i],i);
- for(i=0;i<bank.size();i++) w.set_movability(movability[i],i);
+ for(i = 0; i < bank.size(); i++) w.set_bank(bank[i], i);
+ for(i = 0; i < bank.size(); i++) w.set_movability(movability[i], i);
/*if((bank.size()-offset)>1){
LpCVT obj;
@@ -1609,68 +1614,73 @@ void LpSmoother::improve_region(GRegion* gr)
epsx = 0;
maxits = max_iter;
- double* initial_conditions = static_cast<double*>(malloc(3*(bank.size()-offset)*sizeof(double)));
- double* scales = static_cast<double*>(malloc(3*(bank.size()-offset)*sizeof(double)));
+ double *initial_conditions =
+ static_cast<double *>(malloc(3 * (bank.size() - offset) * sizeof(double)));
+ double *scales =
+ static_cast<double *>(malloc(3 * (bank.size() - offset) * sizeof(double)));
LpCVT instance;
factor = 0.5;
- for(i=0;i<(bank.size()-offset);i++){
- initial_conditions[i] = bank[i+offset].x();
- initial_conditions[i+(bank.size()-offset)] = bank[i+offset].y();
- initial_conditions[i+2*(bank.size()-offset)] = bank[i+offset].z();
- scales[i] = factor*instance.get_size(bank[i+offset].x(),bank[i+offset].y(),bank[i+offset].z());
- scales[i+(bank.size()-offset)] = factor*instance.get_size(bank[i+offset].x(),bank[i+offset].y(),bank[i+offset].z());
- scales[i+2*(bank.size()-offset)] = factor*instance.get_size(bank[i+offset].x(),bank[i+offset].y(),bank[i+offset].z());
+ for(i = 0; i < (bank.size() - offset); i++) {
+ initial_conditions[i] = bank[i + offset].x();
+ initial_conditions[i + (bank.size() - offset)] = bank[i + offset].y();
+ initial_conditions[i + 2 * (bank.size() - offset)] = bank[i + offset].z();
+ scales[i] =
+ factor * instance.get_size(bank[i + offset].x(), bank[i + offset].y(),
+ bank[i + offset].z());
+ scales[i + (bank.size() - offset)] =
+ factor * instance.get_size(bank[i + offset].x(), bank[i + offset].y(),
+ bank[i + offset].z());
+ scales[i + 2 * (bank.size() - offset)] =
+ factor * instance.get_size(bank[i + offset].x(), bank[i + offset].y(),
+ bank[i + offset].z());
}
- x.setcontent(3*(bank.size()-offset),initial_conditions);
- alglib_scales.setcontent(3*(bank.size()-offset),scales);
-
- if((bank.size()-offset)>1){
- minlbfgscreate(3*(bank.size()-offset),4,x,state);
- minlbfgssetscale(state,alglib_scales);
- minlbfgssetprecscale(state);
- minlbfgssetcond(state,epsg,epsf,epsx,maxits);
- minlbfgsoptimize(state,call_back,NULL,&w);
- minlbfgsresults(state,x,rep);
+ x.setcontent(3 * (bank.size() - offset), initial_conditions);
+ alglib_scales.setcontent(3 * (bank.size() - offset), scales);
+
+ if((bank.size() - offset) > 1) {
+ minlbfgscreate(3 * (bank.size() - offset), 4, x, state);
+ minlbfgssetscale(state, alglib_scales);
+ minlbfgssetprecscale(state);
+ minlbfgssetcond(state, epsg, epsf, epsx, maxits);
+ minlbfgsoptimize(state, call_back, NULL, &w);
+ minlbfgsresults(state, x, rep);
}
- for(i=0;i<(bank.size()-offset);i++){
- vertex = new MVertex(x[i],x[i+(bank.size()-offset)],x[i+2*(bank.size()-offset)],gr,0);
- interior_vertices.push_back(vertex);
+ for(i = 0; i < (bank.size() - offset); i++) {
+ vertex = new MVertex(x[i], x[i + (bank.size() - offset)],
+ x[i + 2 * (bank.size() - offset)], gr, 0);
+ interior_vertices.push_back(vertex);
}
- for(i=0;i<unmovable.size();i++){
- if(unmovable[i]->onWhat()->dim()==3){
- vertex = new MVertex(unmovable[i]->x(),unmovable[i]->y(),unmovable[i]->z(),gr,0);
- interior_vertices.push_back(vertex);
- }
+ for(i = 0; i < unmovable.size(); i++) {
+ if(unmovable[i]->onWhat()->dim() == 3) {
+ vertex = new MVertex(unmovable[i]->x(), unmovable[i]->y(),
+ unmovable[i]->z(), gr, 0);
+ interior_vertices.push_back(vertex);
+ }
}
deleter(gr);
- std::vector<GRegion*> regions;
+ std::vector<GRegion *> regions;
regions.push_back(gr);
meshGRegion mesher(regions); //?
mesher(gr); //?
MeshDelaunayVolume(regions);
- for(i=0;i<interior_vertices.size();i++) delete interior_vertices[i];
+ for(i = 0; i < interior_vertices.size(); i++) delete interior_vertices[i];
interior_vertices.clear();
delete octree;
free(initial_conditions);
free(scales);
Size_field::clear();
Frame_field::clear();
- #endif
+#endif
}
-int LpSmoother::get_nbr_interior_vertices(){
- return interior_vertices.size();
-}
+int LpSmoother::get_nbr_interior_vertices() { return interior_vertices.size(); }
-MVertex* LpSmoother::get_interior_vertex(int i){
- return interior_vertices[i];
-}
+MVertex *LpSmoother::get_interior_vertex(int i) { return interior_vertices[i]; }
/*********static declarations*********/
-std::vector<MVertex*> LpSmoother::interior_vertices;
-
+std::vector<MVertex *> LpSmoother::interior_vertices;
diff --git a/Mesh/Levy3D.h b/Mesh/Levy3D.h
index e7441a909a5be67e372b2055c803d0341e31887d..a805765a329dc2263f418d525d551a7b22963804 100644
--- a/Mesh/Levy3D.h
+++ b/Mesh/Levy3D.h
@@ -15,8 +15,8 @@
#include "GRegion.h"
#include "MElementOctree.h"
-class VoronoiVertex{
- private:
+class VoronoiVertex {
+private:
SPoint3 point;
int category;
int index1;
@@ -26,7 +26,8 @@ class VoronoiVertex{
SVector3 normal1;
SVector3 normal2;
double h;
- public:
+
+public:
VoronoiVertex();
~VoronoiVertex();
SPoint3 get_point();
@@ -49,10 +50,11 @@ class VoronoiVertex{
void set_h(double);
};
-class Tensor{
- private:
- double t11,t21,t31,t12,t22,t32,t13,t23,t33;
- public:
+class Tensor {
+private:
+ double t11, t21, t31, t12, t22, t32, t13, t23, t33;
+
+public:
Tensor();
~Tensor();
void set_t11(double);
@@ -75,8 +77,8 @@ class Tensor{
double get_t33();
};
-class VoronoiElement{
- private:
+class VoronoiElement {
+private:
VoronoiVertex v1;
VoronoiVertex v2;
VoronoiVertex v3;
@@ -86,7 +88,8 @@ class VoronoiElement{
double dh_dy;
double dh_dz;
Tensor t;
- public:
+
+public:
VoronoiElement();
~VoronoiElement();
VoronoiVertex get_v1();
@@ -103,26 +106,27 @@ class VoronoiElement{
void set_v3(const VoronoiVertex &);
void set_v4(const VoronoiVertex &);
void set_tensor(const Tensor &);
- double get_h(double,double,double);
+ double get_h(double, double, double);
void deriv_h();
void compute_jacobian();
- double T(double,double,double,double,double,double,double);
+ double T(double, double, double, double, double, double, double);
void swap();
double get_quality();
};
-class LpSmoother{
- private:
+class LpSmoother {
+private:
int max_iter;
int norm;
- static std::vector<MVertex*> interior_vertices;
- public:
- LpSmoother(int,int);
+ static std::vector<MVertex *> interior_vertices;
+
+public:
+ LpSmoother(int, int);
~LpSmoother();
void improve_model();
- void improve_region(GRegion*);
+ void improve_region(GRegion *);
static int get_nbr_interior_vertices();
- static MVertex* get_interior_vertex(int);
+ static MVertex *get_interior_vertex(int);
};
#endif
diff --git a/Mesh/QuadTriExtruded2D.cpp b/Mesh/QuadTriExtruded2D.cpp
index 2c598927b24a87d0d9da1386338e79be9ca228f5..898b5020183f6c187b96eaff471db66ade30e72b 100644
--- a/Mesh/QuadTriExtruded2D.cpp
+++ b/Mesh/QuadTriExtruded2D.cpp
@@ -36,10 +36,9 @@ PARTICULAR PURPOSE. See the GNU General Public License for more details.
#include "QuadTriExtruded2D.h"
// By Geuzaine, Remacle...
-static void addTriangle(MVertex* v1, MVertex* v2, MVertex* v3,
- GFace *to)
+static void addTriangle(MVertex *v1, MVertex *v2, MVertex *v3, GFace *to)
{
- MTriangle* newTri = new MTriangle(v1, v2, v3);
+ MTriangle *newTri = new MTriangle(v1, v2, v3);
to->triangles.push_back(newTri);
}
@@ -50,7 +49,8 @@ static void addTriangle(MVertex* v1, MVertex* v2, MVertex* v3,
// determins whether the surface should be meshed with triangles or quadrangles:
// tri_quad_values: 0 = no override, 1 = mesh as quads, 2 = mesh as triangles.
// Added 2010-12-09.
-int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag, bool *detectQuadToTriLateral)
+int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag,
+ bool *detectQuadToTriLateral)
{
(*tri_quad_flag) = 0;
(*detectQuadToTriLateral) = false;
@@ -59,14 +59,15 @@ int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag, bool *detectQuadToT
ExtrudeParams *ep = face->meshAttributes.extrude;
- if(!ep || !ep->mesh.ExtrudeMesh || !(ep->geo.Mode == EXTRUDED_ENTITY)){
- Msg::Error("In IsValidQuadToTriLateral(), face %d is not a structured extrusion.",
- face->tag() );
+ if(!ep || !ep->mesh.ExtrudeMesh || !(ep->geo.Mode == EXTRUDED_ENTITY)) {
+ Msg::Error(
+ "In IsValidQuadToTriLateral(), face %d is not a structured extrusion.",
+ face->tag());
return 0;
}
GEdge *face_source = model->getEdgeByTag(std::abs(ep->geo.Source));
- if(!face_source){
+ if(!face_source) {
Msg::Error("In IsValidQuadToTriLateral(), face %d has no source edge.",
face->tag());
}
@@ -85,37 +86,35 @@ int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag, bool *detectQuadToT
int numLateralRegions = 0;
numRegions = GetNeighborRegionsOfFace(face, adjacent_regions);
- for(int i_reg = 0; i_reg < numRegions; i_reg++){
+ for(int i_reg = 0; i_reg < numRegions; i_reg++) {
GRegion *region = adjacent_regions[i_reg];
// is the region mesh extruded?
if(!region->meshAttributes.extrude ||
- (region->meshAttributes.extrude &&
- !region->meshAttributes.extrude->mesh.ExtrudeMesh))
- continue;
- if(region->meshAttributes.extrude->geo.Mode != EXTRUDED_ENTITY)
+ (region->meshAttributes.extrude &&
+ !region->meshAttributes.extrude->mesh.ExtrudeMesh))
continue;
+ if(region->meshAttributes.extrude->geo.Mode != EXTRUDED_ENTITY) continue;
// Test whether the face is a lateral
- if(IsSurfaceALateralForRegion(region, face)){
+ if(IsSurfaceALateralForRegion(region, face)) {
lateral_regions.push_back(region);
numLateralRegions++;
if(region->meshAttributes.extrude->mesh.QuadToTri)
(*detectQuadToTriLateral) = true;
}
-
}
// MAIN test of whether this is even a quadToTri extrusion lateral
// the only return 0 path that is NOT an error
- if(!(*detectQuadToTriLateral))
- return 0;
+ if(!(*detectQuadToTriLateral)) return 0;
// now will start conflict checks
- if(numRegions > 2){
- Msg::Error("In IsValidQuadToTriLateral(), too many regions adjacent to surface %d.",
- face->tag() );
+ if(numRegions > 2) {
+ Msg::Error(
+ "In IsValidQuadToTriLateral(), too many regions adjacent to surface %d.",
+ face->tag());
return 0;
}
@@ -125,50 +124,59 @@ int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag, bool *detectQuadToT
// tri_quad_values: 0 = no override, 1 = mesh as quads, 2 = mesh as triangles.
// if this face is a free surface:
- if( adjacent_regions.size() == 1 ){
- if(lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri == QUADTRI_NOVERTS_1_RECOMB ||
- lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri == QUADTRI_ADDVERTS_1_RECOMB ){
+ if(adjacent_regions.size() == 1) {
+ if(lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri ==
+ QUADTRI_NOVERTS_1_RECOMB ||
+ lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri ==
+ QUADTRI_ADDVERTS_1_RECOMB) {
(*tri_quad_flag) = 1;
}
- if(lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri == QUADTRI_NOVERTS_1 ||
- lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri == QUADTRI_ADDVERTS_1 ){
+ if(lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri ==
+ QUADTRI_NOVERTS_1 ||
+ lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri ==
+ QUADTRI_ADDVERTS_1) {
(*tri_quad_flag) = 2;
}
else
(*tri_quad_flag) = 0;
}
- else if( adjacent_regions.size() > 1 ){
+ else if(adjacent_regions.size() > 1) {
GRegion *adj_region = NULL;
ExtrudeParams *adj_ep = NULL;
- if( lateral_regions[0] == adjacent_regions[0] )
+ if(lateral_regions[0] == adjacent_regions[0])
adj_region = adjacent_regions[1];
else
adj_region = adjacent_regions[0];
adj_ep = adj_region->meshAttributes.extrude;
- // if Neighbor is Transfinite, go with the default, non-QuadTri recombine for this surface
- if( adj_region && adj_region->meshAttributes.method == MESH_TRANSFINITE )
- (*tri_quad_flag) = 0;
+ // if Neighbor is Transfinite, go with the default, non-QuadTri recombine
+ // for this surface
+ if(adj_region && adj_region->meshAttributes.method == MESH_TRANSFINITE)
+ (*tri_quad_flag) = 0;
// if a neighbor
// has no extrusion structure,
// don't even consider QuadToTri Recomb on this face.
- else if( adj_region && !(adj_ep && adj_ep->mesh.ExtrudeMesh) )
+ else if(adj_region && !(adj_ep && adj_ep->mesh.ExtrudeMesh))
(*tri_quad_flag) = 2;
// This face is the source face of a second
// neighboring extrusion.
- else if( adj_ep && adj_ep->mesh.ExtrudeMesh &&
- model->getFaceByTag( std::abs( adj_ep->geo.Source ) ) == face ){
- if(lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri == QUADTRI_NOVERTS_1_RECOMB ||
- lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri == QUADTRI_ADDVERTS_1_RECOMB )
+ else if(adj_ep && adj_ep->mesh.ExtrudeMesh &&
+ model->getFaceByTag(std::abs(adj_ep->geo.Source)) == face) {
+ if(lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri ==
+ QUADTRI_NOVERTS_1_RECOMB ||
+ lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri ==
+ QUADTRI_ADDVERTS_1_RECOMB)
(*tri_quad_flag) = 1;
- else if(lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri == QUADTRI_NOVERTS_1 ||
- lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri == QUADTRI_ADDVERTS_1 )
+ else if(lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri ==
+ QUADTRI_NOVERTS_1 ||
+ lateral_regions[0]->meshAttributes.extrude->mesh.QuadToTri ==
+ QUADTRI_ADDVERTS_1)
(*tri_quad_flag) = 2;
else
(*tri_quad_flag) = 0;
}
// if both neighbors are structured but none of the previous apply:
- else if(adj_ep && adj_ep->mesh.ExtrudeMesh){
+ else if(adj_ep && adj_ep->mesh.ExtrudeMesh) {
if((adj_ep && !adj_ep->mesh.QuadToTri && adj_ep->mesh.Recombine) ||
(ep && !ep->mesh.QuadToTri && ep->mesh.Recombine))
(*tri_quad_flag) = 1;
@@ -181,22 +189,22 @@ int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag, bool *detectQuadToT
else
(*tri_quad_flag) = 0;
}
- // any other adjacent surface, just default to the QuadToTri region's non-QuadToTri
- // default recombination method. Any mistakes at this point are not this feature's.
+ // any other adjacent surface, just default to the QuadToTri region's
+ // non-QuadToTri default recombination method. Any mistakes at this point
+ // are not this feature's.
else
(*tri_quad_flag) = 0;
}
// if this executes, there's a mistake here :
- else{
- detect_conflict = true;
- (*tri_quad_flag) = 0;
+ else {
+ detect_conflict = true;
+ (*tri_quad_flag) = 0;
}
if(detect_conflict)
return 0;
else
return 1;
-
}
// The function that tests whether a surface is a QuadToTri top surface and
@@ -230,9 +238,9 @@ int IsValidQuadToTriTop(GFace *face, int *quadToTri, bool *detectQuadToTriTop)
// first determine if this is toroidal quadtotri
is_toroidal_quadtri = IsInToroidalQuadToTri(face);
- if( is_toroidal_quadtri )
+ if(is_toroidal_quadtri)
(*detectQuadToTriTop) = true;
- else{
+ else {
std::vector<GRegion *> top_regions;
std::vector<GRegion *> adjacent_regions;
std::vector<GRegion *> all_regions;
@@ -241,157 +249,158 @@ int IsValidQuadToTriTop(GFace *face, int *quadToTri, bool *detectQuadToTriTop)
std::set<GRegion *, GEntityLessThan>::iterator itreg;
for(itreg = model->firstRegion(); itreg != model->lastRegion(); itreg++)
- all_regions.push_back( (*itreg) );
-
- for(unsigned int i_reg = 0; i_reg < all_regions.size(); i_reg++ ){
+ all_regions.push_back((*itreg));
+ for(unsigned int i_reg = 0; i_reg < all_regions.size(); i_reg++) {
// save time
- if( numRegions >= 2 )
- break;
+ if(numRegions >= 2) break;
GRegion *region = all_regions[i_reg];
// does face belong to region?
std::vector<GFace *> region_faces = region->faces();
- if( std::find( region_faces.begin(), region_faces.end(), face ) !=
- region_faces.end() ){
- adjacent_regions.push_back(region);
- numRegions++;
+ if(std::find(region_faces.begin(), region_faces.end(), face) !=
+ region_faces.end()) {
+ adjacent_regions.push_back(region);
+ numRegions++;
}
else
- continue;
+ continue;
// is region a structured extruded?
- if( !(region->meshAttributes.extrude &&
- region->meshAttributes.extrude->mesh.ExtrudeMesh &&
- region->meshAttributes.extrude->geo.Mode == EXTRUDED_ENTITY) )
- continue;
+ if(!(region->meshAttributes.extrude &&
+ region->meshAttributes.extrude->mesh.ExtrudeMesh &&
+ region->meshAttributes.extrude->geo.Mode == EXTRUDED_ENTITY))
+ continue;
// Test whether the face is a top for the region
- if( IsSurfaceATopForRegion(region, face) ){
- top_regions.push_back(region);
- numTopRegions++;
- if( region->meshAttributes.extrude->mesh.QuadToTri )
- (*detectQuadToTriTop) = true;
+ if(IsSurfaceATopForRegion(region, face)) {
+ top_regions.push_back(region);
+ numTopRegions++;
+ if(region->meshAttributes.extrude->mesh.QuadToTri)
+ (*detectQuadToTriTop) = true;
}
-
}
// MAIN test of whether this is even a quadToTri extrusion lateral
// the only return 0 path that is NOT an error
- if( !(*detectQuadToTriTop) )
- return 0;
+ if(!(*detectQuadToTriTop)) return 0;
ExtrudeParams *ep = face->meshAttributes.extrude;
- if(!ep && !is_toroidal_quadtri){
+ if(!ep && !is_toroidal_quadtri) {
Msg::Error("In IsValidQuadToTriTop(), no extrude info for surface %d.",
- face->tag() );
+ face->tag());
return 0;
}
- if( ep->geo.Mode != COPIED_ENTITY ){
- Msg::Error("In IsValidQuadToTriTop(), surface %d is not copied from source.",
- face->tag() );
+ if(ep->geo.Mode != COPIED_ENTITY) {
+ Msg::Error(
+ "In IsValidQuadToTriTop(), surface %d is not copied from source.",
+ face->tag());
return 0;
}
- if( ep->mesh.QuadToTri == 0){
- Msg::Error("In IsValidQuadToTriTop(), surface %d was determined to be the "
- "top surface for a QuadToTri extrusion, but does not have "
- "QuadToTri parameters set within itself.",
- face->tag() );
+ if(ep->mesh.QuadToTri == 0) {
+ Msg::Error(
+ "In IsValidQuadToTriTop(), surface %d was determined to be the "
+ "top surface for a QuadToTri extrusion, but does not have "
+ "QuadToTri parameters set within itself.",
+ face->tag());
return 0;
}
GFace *face_source = model->getFaceByTag(std::abs(ep->geo.Source));
- if(!face_source){
+ if(!face_source) {
Msg::Error("In IsValidQuadToTriTop(), unknown source face number %d.",
- face->meshAttributes.extrude->geo.Source);
+ face->meshAttributes.extrude->geo.Source);
return 0;
}
- if(numRegions > 2){
- Msg::Error("In IsValidQuadToTriTop(), too many regions adjacent to surface %d.",
- face->tag() );
+ if(numRegions > 2) {
+ Msg::Error(
+ "In IsValidQuadToTriTop(), too many regions adjacent to surface %d.",
+ face->tag());
return 0;
}
- if(top_regions.size()){
+ if(top_regions.size()) {
(*quadToTri) = top_regions[0]->meshAttributes.extrude->mesh.QuadToTri;
}
- // Make sure that face is the top for only one region. if not, then there will likely
- // be conflicts (two regions extruded into each other).
- if(top_regions.size() > 1){
- Msg::Error("In IsValidQuadToTriTop(), QuadToTri top surface %d identified as top "
- "surface for more than one region. Likely conflict.", face->tag() );
+ // Make sure that face is the top for only one region. if not, then there
+ // will likely be conflicts (two regions extruded into each other).
+ if(top_regions.size() > 1) {
+ Msg::Error(
+ "In IsValidQuadToTriTop(), QuadToTri top surface %d identified as top "
+ "surface for more than one region. Likely conflict.",
+ face->tag());
return 0;
}
- } // end of else that executes if NOT toroidal extrusion
+ } // end of else that executes if NOT toroidal extrusion
- // this is technically redundant...but if changes are made, it's good to
- // keep this here at the end for safety
- if( !(*detectQuadToTriTop) )
- return 0;
+ // this is technically redundant...but if changes are made, it's good to
+ // keep this here at the end for safety
+ if(!(*detectQuadToTriTop)) return 0;
- if( !is_toroidal_quadtri )
+ if(!is_toroidal_quadtri)
return 1;
- else if( is_toroidal_quadtri == 1 )
- { return 2;} // for toroidal extrusion
+ else if(is_toroidal_quadtri == 1) {
+ return 2;
+ } // for toroidal extrusion
else
return 3;
-
}
// this function specifically meshes a quadToTri top in an unstructured way
// return 1 if success, return 0 if failed.
// Added 2010-12-20
-static int MeshQuadToTriTopUnstructured(GFace *from, GFace *to, MVertexRTree &pos)
+static int MeshQuadToTriTopUnstructured(GFace *from, GFace *to,
+ MVertexRTree &pos)
{
// if the source is all triangles, then just return 1.
- if(from->triangles.size() && !from->quadrangles.size())
- return 1;
+ if(from->triangles.size() && !from->quadrangles.size()) return 1;
if(!to->meshAttributes.extrude || !to->meshAttributes.extrude->mesh.QuadToTri)
return 0;
// in weird case of NO quads and NO tri
- if(!from->triangles.size() && !from->quadrangles.size())
- return 0;
+ if(!from->triangles.size() && !from->quadrangles.size()) return 0;
// make set of source edge vertices
- MVertexRTree pos_src_edge(CTX::instance()->geom.tolerance * CTX::instance()->lc);
+ MVertexRTree pos_src_edge(CTX::instance()->geom.tolerance *
+ CTX::instance()->lc);
QuadToTriInsertFaceEdgeVertices(from, pos_src_edge);
// Loop through all the quads and make the triangles with diagonals running
// in a selected direction.
- to->triangles.reserve(to->triangles.size()+from->quadrangles.size()*2);
+ to->triangles.reserve(to->triangles.size() + from->quadrangles.size() * 2);
- for(unsigned int i = 0; i < from->quadrangles.size(); i++){
- std::vector<MVertex*> verts;
- for(std::size_t j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
+ for(unsigned int i = 0; i < from->quadrangles.size(); i++) {
+ std::vector<MVertex *> verts;
+ for(std::size_t j = 0; j < from->quadrangles[i]->getNumVertices(); j++) {
MVertex *v = from->quadrangles[i]->getVertex(j);
double x = v->x(), y = v->y(), z = v->z();
ExtrudeParams *ep = to->meshAttributes.extrude;
- ep->Extrude(ep->mesh.NbLayer - 1, ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1],
- x, y, z);
+ ep->Extrude(ep->mesh.NbLayer - 1,
+ ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1], x, y, z);
MVertex *tmp = pos.find(x, y, z);
if(!tmp) {
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) in surface %d",
- x, y, z, to->tag());
+ Msg::Error(
+ "Could not find extruded vertex (%.16g, %.16g, %.16g) in surface %d",
+ x, y, z, to->tag());
to->triangles.reserve(to->triangles.size() + 1);
return 0;
}
verts.push_back(tmp);
}
- if(verts.size() != 4){
+ if(verts.size() != 4) {
Msg::Error("During mesh of QuadToTri surface %d, %d vertices found "
- "in quad of source surface %d.", to->tag(), verts.size(),
- from->tag() );
+ "in quad of source surface %d.",
+ to->tag(), verts.size(), from->tag());
return 0;
}
@@ -399,22 +408,22 @@ static int MeshQuadToTriTopUnstructured(GFace *from, GFace *to, MVertexRTree &po
// diagonal length, in quadrature
double mag_sq_ave = 0.0;
- for( int p = 0; p < 4; p++ ){
- int d_leg = verts[p]->distance(verts[(p+1)%4]);
- mag_sq_ave += d_leg*d_leg;
+ for(int p = 0; p < 4; p++) {
+ int d_leg = verts[p]->distance(verts[(p + 1) % 4]);
+ mag_sq_ave += d_leg * d_leg;
}
mag_sq_ave /= 4;
double d1 = verts[0]->distance(verts[2]);
double d2 = verts[1]->distance(verts[3]);
- if(fabs(d1*d1-mag_sq_ave) <= fabs(d2*d2-mag_sq_ave) ){
- addTriangle(verts[0],verts[1],verts[2],to);
- addTriangle(verts[0],verts[2],verts[3],to);
+ if(fabs(d1 * d1 - mag_sq_ave) <= fabs(d2 * d2 - mag_sq_ave)) {
+ addTriangle(verts[0], verts[1], verts[2], to);
+ addTriangle(verts[0], verts[2], verts[3], to);
}
- else{
- addTriangle(verts[1],verts[2],verts[3],to);
- addTriangle(verts[1],verts[3],verts[0],to);
+ else {
+ addTriangle(verts[1], verts[2], verts[3], to);
+ addTriangle(verts[1], verts[3], verts[0], to);
}
}
@@ -430,20 +439,20 @@ static int MeshQuadToTriTopUnstructured(GFace *from, GFace *to, MVertexRTree &po
int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
{
if(!to->meshAttributes.extrude || !to->meshAttributes.extrude->mesh.QuadToTri)
- return 0;
+ return 0;
- // if the source is all triangles, then just let this function is not needed. Return 1.
- if(from->triangles.size() && !from->quadrangles.size())
- return 1;
+ // if the source is all triangles, then just let this function is not needed.
+ // Return 1.
+ if(from->triangles.size() && !from->quadrangles.size()) return 1;
// in weird case of NO quads and NO tri
- if(!from->triangles.size() && !from->quadrangles.size())
- return 0;
+ if(!from->triangles.size() && !from->quadrangles.size()) return 0;
ExtrudeParams *ep = to->meshAttributes.extrude;
- if(!ep || !ep->mesh.ExtrudeMesh || !(ep->geo.Mode == COPIED_ENTITY)){
+ if(!ep || !ep->mesh.ExtrudeMesh || !(ep->geo.Mode == COPIED_ENTITY)) {
Msg::Error("In MeshQuadToTriTopSurface(), incomplete or no "
- "extrude information for top face %d.", to->tag() );
+ "extrude information for top face %d.",
+ to->tag());
return 0;
}
@@ -460,19 +469,20 @@ int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
// boundary. All interior quad, draw diagonal to vertex with lowest pointer
// number.
- if(!is_addverts){
- MVertexRTree pos_src_edge(CTX::instance()->geom.tolerance * CTX::instance()->lc);
+ if(!is_addverts) {
+ MVertexRTree pos_src_edge(CTX::instance()->geom.tolerance *
+ CTX::instance()->lc);
QuadToTriInsertFaceEdgeVertices(from, pos_src_edge);
// loop through each element source quadrangle and extrude
- for(unsigned int i = 0; i < from->quadrangles.size(); i++){
- std::vector<MVertex*> verts;
- for(std::size_t j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
+ for(unsigned int i = 0; i < from->quadrangles.size(); i++) {
+ std::vector<MVertex *> verts;
+ for(std::size_t j = 0; j < from->quadrangles[i]->getNumVertices(); j++) {
MVertex *v = from->quadrangles[i]->getVertex(j);
double x = v->x(), y = v->y(), z = v->z();
ExtrudeParams *ep = to->meshAttributes.extrude;
- ep->Extrude(ep->mesh.NbLayer - 1, ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1],
- x, y, z);
+ ep->Extrude(ep->mesh.NbLayer - 1,
+ ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1], x, y, z);
MVertex *tmp = pos.find(x, y, z);
if(!tmp) {
Msg::Error("In MeshQuadToTriTopSurface(), Could not find "
@@ -484,10 +494,10 @@ int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
verts.push_back(tmp);
}
- if(verts.size() != 4){
+ if(verts.size() != 4) {
Msg::Error("During mesh of QuadToTri surface %d, %d vertices found "
- "in quad of source surface %d.", to->tag(), verts.size(),
- from->tag());
+ "in quad of source surface %d.",
+ to->tag(), verts.size(), from->tag());
return 0;
}
@@ -496,27 +506,28 @@ int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
// count vertices that are on a boundary edge
int edge_verts_count = 0;
- //int skip_index = 0;
+ // int skip_index = 0;
int bnd_indices[4];
- for(std::size_t p = 0; p < element->getNumVertices(); p++){
+ for(std::size_t p = 0; p < element->getNumVertices(); p++) {
if(pos_src_edge.find(element->getVertex(p)->x(),
element->getVertex(p)->y(),
- element->getVertex(p)->z())){
+ element->getVertex(p)->z())) {
edge_verts_count++;
bnd_indices[p] = 1;
}
- else{
- //skip_index = p;
+ else {
+ // skip_index = p;
bnd_indices[p] = 0;
}
}
// Apply modified lowest vertex pointer diagonalization
int low_index = -1;
- if(edge_verts_count == 3 || edge_verts_count == 2 || edge_verts_count == 1){
- for(int p = 0; p < 4; p++ ){
- if(!bnd_indices[p] && verts[p] != element->getVertex(p)){
- if(low_index < 0 )
+ if(edge_verts_count == 3 || edge_verts_count == 2 ||
+ edge_verts_count == 1) {
+ for(int p = 0; p < 4; p++) {
+ if(!bnd_indices[p] && verts[p] != element->getVertex(p)) {
+ if(low_index < 0)
low_index = p;
else if(verts[p] < verts[low_index])
low_index = p;
@@ -531,41 +542,41 @@ int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
else if(edge_verts_count == 4 || edge_verts_count == 0)
low_index = getIndexForLowestVertexPointer(verts);
- addTriangle( verts[low_index],verts[(low_index+1)%verts.size()],
- verts[(low_index+2)%verts.size()],to);
- addTriangle( verts[low_index],verts[(low_index+2)%verts.size()],
- verts[(low_index+3)%verts.size()],to);
+ addTriangle(verts[low_index], verts[(low_index + 1) % verts.size()],
+ verts[(low_index + 2) % verts.size()], to);
+ addTriangle(verts[low_index], verts[(low_index + 2) % verts.size()],
+ verts[(low_index + 3) % verts.size()], to);
}
return 1;
}
-
// AFTER THIS POINT IN FUNCTION, CODE IS ALL FOR 'ADD INTERNAL VERTEX'
// EXTRUSIONS (Less restrictive).
- // if source face is unstructured, can try to make the top mesh a little neater
- GFace *root_source = findRootSourceFaceForFace( from );
+ // if source face is unstructured, can try to make the top mesh a little
+ // neater
+ GFace *root_source = findRootSourceFaceForFace(from);
ExtrudeParams *ep_src = root_source->meshAttributes.extrude;
bool struct_root = false;
- if(root_source &&
- ((ep_src && ep_src->mesh.ExtrudeMesh && ep_src->geo.Mode == EXTRUDED_ENTITY) ||
- root_source->meshAttributes.method == MESH_TRANSFINITE))
+ if(root_source && ((ep_src && ep_src->mesh.ExtrudeMesh &&
+ ep_src->geo.Mode == EXTRUDED_ENTITY) ||
+ root_source->meshAttributes.method == MESH_TRANSFINITE))
struct_root = true;
- if(!struct_root && MeshQuadToTriTopUnstructured(from, to, pos)){
+ if(!struct_root && MeshQuadToTriTopUnstructured(from, to, pos)) {
return 1;
}
- else{
+ else {
// And top surface for the 'added internal vertex' method can be meshed
// quite easily. Loop through each element source quadrangle and extrude
- for(unsigned int i = 0; i < from->quadrangles.size(); i++){
- std::vector<MVertex*> verts;
- for(std::size_t j = 0; j < from->quadrangles[i]->getNumVertices(); j++){
+ for(unsigned int i = 0; i < from->quadrangles.size(); i++) {
+ std::vector<MVertex *> verts;
+ for(std::size_t j = 0; j < from->quadrangles[i]->getNumVertices(); j++) {
MVertex *v = from->quadrangles[i]->getVertex(j);
double x = v->x(), y = v->y(), z = v->z();
ExtrudeParams *ep = to->meshAttributes.extrude;
- ep->Extrude(ep->mesh.NbLayer - 1, ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1],
- x, y, z);
+ ep->Extrude(ep->mesh.NbLayer - 1,
+ ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1], x, y, z);
MVertex *tmp = pos.find(x, y, z);
if(!tmp) {
Msg::Error("In MeshQuadToTriTopSurface(), Could not find "
@@ -577,16 +588,16 @@ int MeshQuadToTriTopSurface(GFace *from, GFace *to, MVertexRTree &pos)
verts.push_back(tmp);
}
- if(verts.size() != 4){
+ if(verts.size() != 4) {
Msg::Error("During mesh of QuadToTri surface %d, %d vertices found "
- "in quad of source surface %d.", to->tag(), verts.size(),
- from->tag() );
+ "in quad of source surface %d.",
+ to->tag(), verts.size(), from->tag());
return 0;
}
// make the elements
- addTriangle( verts[0],verts[2], verts[3],to);
- addTriangle( verts[0],verts[1], verts[2],to);
+ addTriangle(verts[0], verts[2], verts[3], to);
+ addTriangle(verts[0], verts[1], verts[2], to);
}
return 1;
}
diff --git a/Mesh/QuadTriExtruded2D.h b/Mesh/QuadTriExtruded2D.h
index 373da67a02a453789e0560f6719edcc62f2b82b9..6ac8d77de0caa8196234a3f8782e3e2148a16078 100644
--- a/Mesh/QuadTriExtruded2D.h
+++ b/Mesh/QuadTriExtruded2D.h
@@ -60,7 +60,8 @@ PARTICULAR PURPOSE. See the GNU General Public License for more details.
// determins whether the surface should be meshed with triangles or quadrangles:
// tri_quad_values: 0 = no override, 1 = mesh as quads, 2 = mesh as triangles.
// Added 2010-12-09.
-int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag, bool *detectQuadToTriLateral);
+int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag,
+ bool *detectQuadToTriLateral);
// The function that tests whether a surface is a QuadToTri top surface and
// whether there are conflicts. If surface is not a top for a valid QuadToTri
@@ -69,7 +70,6 @@ int IsValidQuadToTriLateral(GFace *face, int *tri_quad_flag, bool *detectQuadToT
// interface is placed into the pointer argument quadToTri. . Added 2010-12-09.
int IsValidQuadToTriTop(GFace *face, int *quadToTri, bool *detectQuadToTriTop);
-
// This function meshes the top surface of a QuadToTri extrusion. It returns 0
// if it is given a non-quadToTri extrusion or if it fails. Args: 'GFace *to'
// is the top surface to mesh, 'from' is the source surface, 'pos' is a tree
diff --git a/Mesh/QuadTriExtruded3D.cpp b/Mesh/QuadTriExtruded3D.cpp
index 3cf77e5946c8cd23c7094a362890b76b180bb947..d300dd420e25245a7fef9b8844595be78681c23c 100644
--- a/Mesh/QuadTriExtruded3D.cpp
+++ b/Mesh/QuadTriExtruded3D.cpp
@@ -36,122 +36,123 @@ PARTICULAR PURPOSE. See the GNU General Public License for more details.
#include "QuadTriExtruded3D.h"
// By Geuzaine, Remacle...
-static void addTetrahedron(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- GRegion *to, MElement* source)
+static void addTetrahedron(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ GRegion *to, MElement *source)
{
- MTetrahedron* newElem = new MTetrahedron(v1, v2, v3, v4);
+ MTetrahedron *newElem = new MTetrahedron(v1, v2, v3, v4);
to->tetrahedra.push_back(newElem);
}
// By Geuzaine, Remacle...
-static void addPyramid(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, GRegion *to, MElement* source)
+static void addPyramid(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, GRegion *to, MElement *source)
{
- MPyramid* newElem = new MPyramid(v1, v2, v3, v4, v5);
+ MPyramid *newElem = new MPyramid(v1, v2, v3, v4, v5);
to->pyramids.push_back(newElem);
}
// By Geuzaine, Remacle...
-static void addPrism(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, MVertex* v6, GRegion *to, MElement* source)
+static void addPrism(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, MVertex *v6, GRegion *to, MElement *source)
{
- MPrism* newElem = new MPrism(v1, v2, v3, v4, v5, v6);
+ MPrism *newElem = new MPrism(v1, v2, v3, v4, v5, v6);
to->prisms.push_back(newElem);
}
// By Geuzaine, Remacle...
-static void addHexahedron(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, MVertex* v6, MVertex* v7, MVertex* v8,
- GRegion *to, MElement* source)
+static void addHexahedron(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, MVertex *v6, MVertex *v7, MVertex *v8,
+ GRegion *to, MElement *source)
{
- MHexahedron* newElem = new MHexahedron(v1, v2, v3, v4, v5, v6, v7, v8);
+ MHexahedron *newElem = new MHexahedron(v1, v2, v3, v4, v5, v6, v7, v8);
to->hexahedra.push_back(newElem);
}
// Does the pair of MVertex pointers v1 and v2 exist in the set 'edges'?
static int edgeExists(MVertex *v1, MVertex *v2,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
- std::pair<MVertex*, MVertex*> p(std::min(v1, v2), std::max(v1, v2));
+ std::pair<MVertex *, MVertex *> p(std::min(v1, v2), std::max(v1, v2));
return edges.count(p);
}
// Create the pair of MVertex pointers v1 and v2 exist in the set 'edges.'
static void createEdge(MVertex *v1, MVertex *v2,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
- std::pair<MVertex*, MVertex*> p(std::min(v1, v2), std::max(v1, v2));
+ std::pair<MVertex *, MVertex *> p(std::min(v1, v2), std::max(v1, v2));
edges.insert(p);
}
// Create the entry for a forbidden edge in forbidden_edges (note that all four
// verts are forbidden, but only store two, using lowest vertex pointer
// diagonal).
-static void createForbidden(std::vector<MVertex*> v,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges)
+static void
+createForbidden(std::vector<MVertex *> v,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges)
{
- if( v.size() != 4 ){
+ if(v.size() != 4) {
Msg::Error("In createForbidden(), number of vertices not equal 4.");
return;
}
int ind_low = 0;
- if( v[1] < v[ind_low] ) ind_low = 1;
- if( v[2] < v[ind_low] ) ind_low = 2;
- if( v[3] < v[ind_low] ) ind_low = 3;
+ if(v[1] < v[ind_low]) ind_low = 1;
+ if(v[2] < v[ind_low]) ind_low = 2;
+ if(v[3] < v[ind_low]) ind_low = 3;
- std::pair<MVertex*, MVertex*> p( v[ind_low], v[(ind_low+2)%4] );
+ std::pair<MVertex *, MVertex *> p(v[ind_low], v[(ind_low + 2) % 4]);
forbidden_edges.insert(p);
}
-
// Is the given vector of quad vertices forbidden to diagonalize (it is in
// forbidden_edges)?
-static int forbiddenExists(std::vector<MVertex*> v,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges)
+static int
+forbiddenExists(std::vector<MVertex *> v,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges)
{
-
- if( v.size() != 4 ){
- Msg::Error("forbiddenExists() was passed a vector argument that was not of size 4.");
+ if(v.size() != 4) {
+ Msg::Error(
+ "forbiddenExists() was passed a vector argument that was not of size 4.");
return 0;
}
int ind_low = 0;
- if( v[1] < v[ind_low] ) ind_low = 1;
- if( v[2] < v[ind_low] ) ind_low = 2;
- if( v[3] < v[ind_low] ) ind_low = 3;
+ if(v[1] < v[ind_low]) ind_low = 1;
+ if(v[2] < v[ind_low]) ind_low = 2;
+ if(v[3] < v[ind_low]) ind_low = 3;
- std::pair<MVertex*, MVertex*> pair( v[ind_low], v[(ind_low+2)%4] );
+ std::pair<MVertex *, MVertex *> pair(v[ind_low], v[(ind_low + 2) % 4]);
return forbidden_edges.count(pair);
}
// delete a pair of vertex pointers v1 and v2 from 'edges.'
static void deleteEdge(MVertex *v1, MVertex *v2,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
- std::pair<MVertex*, MVertex*> p(std::min(v1, v2), std::max(v1, v2));
+ std::pair<MVertex *, MVertex *> p(std::min(v1, v2), std::max(v1, v2));
edges.erase(p);
}
// Get the two mesh vertices extruded from vertices v0 and v1 on a lateral face
// at layer j, element k. Added 2010-01-26
-static std::vector<MVertex*> getExtrudedLateralVertices(MVertex *v0, MVertex *v1,
- GEntity *entity,
- unsigned int j, unsigned int k,
- ExtrudeParams *loop_ep,
- MVertexRTree &pos)
+static std::vector<MVertex *>
+getExtrudedLateralVertices(MVertex *v0, MVertex *v1, GEntity *entity,
+ unsigned int j, unsigned int k,
+ ExtrudeParams *loop_ep, MVertexRTree &pos)
{
- std::vector<MVertex*> verts;
+ std::vector<MVertex *> verts;
double x[4] = {v0->x(), v1->x(), v0->x(), v1->x()};
double y[4] = {v0->y(), v1->y(), v0->y(), v1->y()};
double z[4] = {v0->z(), v1->z(), v0->z(), v1->z()};
- for(int p = 0; p < 2; p++){
+ for(int p = 0; p < 2; p++) {
loop_ep->Extrude(j, k, x[p], y[p], z[p]);
loop_ep->Extrude(j, k + 1, x[p + 2], y[p + 2], z[p + 2]);
}
- for(int p = 0; p < 4; p++){
+ for(int p = 0; p < 4; p++) {
MVertex *tmp = pos.find(x[p], y[p], z[p]);
- if(!tmp){
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) in geometrical entity %d",
+ if(!tmp) {
+ Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) in "
+ "geometrical entity %d",
x[p], y[p], z[p], entity->tag());
verts.clear();
return verts;
@@ -166,24 +167,25 @@ static std::vector<MVertex*> getExtrudedLateralVertices(MVertex *v0, MVertex *v1
// 2010-01-26
static int get2DExtrudedVertices(MElement *elem, ExtrudeParams *ep,
unsigned int j, unsigned int k,
- MVertexRTree &pos, std::vector<MVertex *> &verts)
+ MVertexRTree &pos,
+ std::vector<MVertex *> &verts)
{
- std::vector<MVertex*> source_verts;
+ std::vector<MVertex *> source_verts;
elem->getVertices(source_verts);
int sz = source_verts.size();
std::vector<double> x(sz), y(sz), z(sz);
- for( int p = 0; p < sz; p++ ){
+ for(int p = 0; p < sz; p++) {
x[p] = source_verts[p]->x();
y[p] = source_verts[p]->y();
z[p] = source_verts[p]->z();
}
- for(int p = 0; p < sz; p++){
+ for(int p = 0; p < sz; p++) {
ep->Extrude(j, k, x[p], y[p], z[p]);
MVertex *tmp = pos.find(x[p], y[p], z[p]);
- if(!tmp){
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g).",
- x[p], y[p], z[p]);
+ if(!tmp) {
+ Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g).", x[p],
+ y[p], z[p]);
verts.clear();
return verts.size();
}
@@ -196,25 +198,25 @@ static int get2DExtrudedVertices(MElement *elem, ExtrudeParams *ep,
// Copied from meshGRegionExtruded.cpp, By Geuzaine, Remacle... Extrudes a set
// of source vertices in 3D added 2010-01-18
static int getExtrudedVertices(MElement *ele, ExtrudeParams *ep, int j, int k,
- MVertexRTree &pos, std::vector<MVertex*> &verts)
+ MVertexRTree &pos, std::vector<MVertex *> &verts)
{
double x[8], y[8], z[8];
int n = ele->getNumVertices();
- for(int p = 0; p < n; p++){
+ for(int p = 0; p < n; p++) {
MVertex *v = ele->getVertex(p);
x[p] = x[p + n] = v->x();
y[p] = y[p + n] = v->y();
z[p] = z[p + n] = v->z();
}
- for(int p = 0; p < n; p++){
+ for(int p = 0; p < n; p++) {
ep->Extrude(j, k, x[p], y[p], z[p]);
ep->Extrude(j, k + 1, x[p + n], y[p + n], z[p + n]);
}
- for(int p = 0; p < 2 * n; p++){
+ for(int p = 0; p < 2 * n; p++) {
MVertex *tmp = pos.find(x[p], y[p], z[p]);
if(!tmp)
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g)",
- x[p], y[p], z[p]);
+ Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g)", x[p],
+ y[p], z[p]);
else
verts.push_back(tmp);
}
@@ -228,17 +230,16 @@ bool IsValidQuadToTriRegion(GRegion *region, bool *allNonGlobalSharedLaterals)
{
ExtrudeParams *ep = region->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh )
- return false;
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) return false;
GModel *model = region->model();
// find source face
GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
- if( !reg_source ){
+ if(!reg_source) {
Msg::Error("In IsValidQuadToTriRegion(), could not find source face "
- "%d for region %d.", std::abs(ep->geo.Source),
- region->tag());
+ "%d for region %d.",
+ std::abs(ep->geo.Source), region->tag());
return false;
}
@@ -251,145 +252,148 @@ bool IsValidQuadToTriRegion(GRegion *region, bool *allNonGlobalSharedLaterals)
// allNonGlobalSharedLaterals argument to true. If any lateral is
// unstructured, error.
- bool foundTop = false, foundSource = false,
- foundNoStruct = false, foundRoot = false;
+ bool foundTop = false, foundSource = false, foundNoStruct = false,
+ foundRoot = false;
std::vector<GFace *> faces = region->faces();
std::vector<GFace *>::iterator it = faces.begin();
(*allNonGlobalSharedLaterals) = true;
- for( it = faces.begin(); it != faces.end(); it++ ){
+ for(it = faces.begin(); it != faces.end(); it++) {
ExtrudeParams *face_tmp_ep = (*it)->meshAttributes.extrude;
- if( (*it) == root )
- foundRoot = true;
- if( (*it) == reg_source )
+ if((*it) == root) foundRoot = true;
+ if((*it) == reg_source)
foundSource = true;
- else if( face_tmp_ep && face_tmp_ep->geo.Mode ==
- COPIED_ENTITY ){
- GFace *top_source_tmp = model->getFaceByTag(
- std::abs( face_tmp_ep->geo.Source ) );
- if( !top_source_tmp ){
+ else if(face_tmp_ep && face_tmp_ep->geo.Mode == COPIED_ENTITY) {
+ GFace *top_source_tmp =
+ model->getFaceByTag(std::abs(face_tmp_ep->geo.Source));
+ if(!top_source_tmp) {
Msg::Error("In IsValidQuadToTriRegion(), could not find source face "
"%d for copied surface %d of region %d.",
- std::abs( face_tmp_ep->geo.Source ),
- (*it)->tag(), region->tag() );
+ std::abs(face_tmp_ep->geo.Source), (*it)->tag(),
+ region->tag());
return false;
}
- else if( top_source_tmp == reg_source &&
- !IsSurfaceALateralForRegion(region, *it) )
+ else if(top_source_tmp == reg_source &&
+ !IsSurfaceALateralForRegion(region, *it))
foundTop = true;
-
}
- // This is a check to see if there are lateral surface triangles that need to be edged globally in subdivide operation
- else if( IsSurfaceALateralForRegion(region, *it) ){
+ // This is a check to see if there are lateral surface triangles that need
+ // to be edged globally in subdivide operation
+ else if(IsSurfaceALateralForRegion(region, *it)) {
std::vector<GRegion *> neighbors;
- if( (*allNonGlobalSharedLaterals) && (*it)->triangles.size() && !(*it)->quadrangles.size()&&
- GetNeighborRegionsOfFace(*it, neighbors) > 1 ){
- GRegion *other_region = neighbors[0] != region ? neighbors[0] : neighbors[1];
+ if((*allNonGlobalSharedLaterals) && (*it)->triangles.size() &&
+ !(*it)->quadrangles.size() &&
+ GetNeighborRegionsOfFace(*it, neighbors) > 1) {
+ GRegion *other_region =
+ neighbors[0] != region ? neighbors[0] : neighbors[1];
ExtrudeParams *oth_ep = other_region->meshAttributes.extrude;
- if( (ep && ep->mesh.ExtrudeMesh && !ep->mesh.Recombine) ||
- (oth_ep && oth_ep->mesh.ExtrudeMesh && !oth_ep->mesh.Recombine &&
- IsSurfaceALateralForRegion(other_region, *it)) )
+ if((ep && ep->mesh.ExtrudeMesh && !ep->mesh.Recombine) ||
+ (oth_ep && oth_ep->mesh.ExtrudeMesh && !oth_ep->mesh.Recombine &&
+ IsSurfaceALateralForRegion(other_region, *it)))
(*allNonGlobalSharedLaterals) = false;
}
}
- else if( !is_toroidal )
+ else if(!is_toroidal)
foundNoStruct = true;
}
-
- // if didn't find the copied entity, maybe this is toroidal and the top has been replaced
- if( is_toroidal && !foundTop && foundRoot && root != reg_source )
+ // if didn't find the copied entity, maybe this is toroidal and the top has
+ // been replaced
+ if(is_toroidal && !foundTop && foundRoot && root != reg_source)
foundTop = true;
// test for errors
bool detectConflict = false;
- if( !foundTop ){
+ if(!foundTop) {
Msg::Error("In IsValidQuadToTriRegion(), could not find top face "
- "of region %d.", region->tag() );
+ "of region %d.",
+ region->tag());
detectConflict = true;
}
- if( !foundSource ){
+ if(!foundSource) {
Msg::Error("In IsValidQuadToTriRegion(), source "
"face %d of region %d was not found in region.",
- region->tag() );
+ region->tag());
detectConflict = true;
}
- if( foundNoStruct ){
+ if(foundNoStruct) {
Msg::Error("In IsValidQuadToTriRegion(), found unstructured "
- "lateral in QuadToTri region %d.", region->tag() );
+ "lateral in QuadToTri region %d.",
+ region->tag());
detectConflict = true;
}
- if( detectConflict )
- return false;
+ if(detectConflict) return false;
// no errors, return true
return true;
}
-
-// This function returns a vector of integer values, each of which are codes for the
-// status of each face of an undivided prism or hexahedron (including degenerate versions):
-// 0 = degenerate line, 1 = single triangle, 2 = recombined quad,
-// 3 = fixed diagonal, 4 = adjustable diagonal, 5 = totally free to diagonalize or not.
-// Ordering of faces starts with the lateral face containing verts[0] and verts[1], then goes in order
-// of increasing vertex index around element. Finally, the bottom, then the top.
-// Added 2010-01-21
-static std::map<std::string, std::vector<int> >
-getFaceTypes(GRegion *gr, MElement *elem, int j, int k,
- std::vector<MVertex *> &verts,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::vector<bool> &vert_bnd, std::vector<int> &nfix1,
- std::vector<int> &nfix2, std::vector<int> &nadj1,
- std::vector<int> &nadj2, std::vector<int> &free_flag )
+// This function returns a vector of integer values, each of which are codes for
+// the status of each face of an undivided prism or hexahedron (including
+// degenerate versions): 0 = degenerate line, 1 = single triangle, 2 =
+// recombined quad, 3 = fixed diagonal, 4 = adjustable diagonal, 5 = totally
+// free to diagonalize or not. Ordering of faces starts with the lateral face
+// containing verts[0] and verts[1], then goes in order of increasing vertex
+// index around element. Finally, the bottom, then the top. Added 2010-01-21
+static std::map<std::string, std::vector<int> > getFaceTypes(
+ GRegion *gr, MElement *elem, int j, int k, std::vector<MVertex *> &verts,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::vector<bool> &vert_bnd, std::vector<int> &nfix1, std::vector<int> &nfix2,
+ std::vector<int> &nadj1, std::vector<int> &nadj2, std::vector<int> &free_flag)
{
std::map<std::string, std::vector<int> > face_types;
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In getFaceTypes(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return face_types;
}
// get the starting indices of the top quadToTri layer
int j_top_start = 0, k_top_start = 0;
- j_top_start = ep->mesh.NbLayer-1;
- k_top_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer-1]-1;
-
-
+ j_top_start = ep->mesh.NbLayer - 1;
+ k_top_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1] - 1;
// check nature of each face
int n_lat_tmp = 0;
- if( verts.size() == 6 )
+ if(verts.size() == 6)
n_lat_tmp = 3;
- else if( verts.size() == 8 )
+ else if(verts.size() == 8)
n_lat_tmp = 4;
- else{
- Msg::Error("In getFaceTypes(), size of verts vector was not 6 or 8 (region %d).",
- gr->tag() );
+ else {
+ Msg::Error(
+ "In getFaceTypes(), size of verts vector was not 6 or 8 (region %d).",
+ gr->tag());
return face_types;
}
const int n_lat = n_lat_tmp;
- // set defaults for the nfix, nadj vectors that store the nodes for each fixed or adjustable diagonal
- // And set the defaults for free_flag which tells whether a face is free (0)
- nfix1.clear(); nfix1.assign(n_lat+2, 0);
- nfix2.clear(); nfix2.assign(n_lat+2, 0);
- nadj1.clear(); nadj1.assign(n_lat+2, 0);
- nadj2.clear(); nadj2.assign(n_lat+2, 0);
- free_flag.clear(); free_flag.assign(n_lat+2, 0);
- for( int p = 0; p < n_lat+2; p++ ){
- nfix1[p] = -p*p-p-1;
- nfix2[p] = -p*p-p-2;
- nadj1[p] = -p*p-p-1;
- nadj2[p] = -p*p-p-2;
+ // set defaults for the nfix, nadj vectors that store the nodes for each fixed
+ // or adjustable diagonal And set the defaults for free_flag which tells
+ // whether a face is free (0)
+ nfix1.clear();
+ nfix1.assign(n_lat + 2, 0);
+ nfix2.clear();
+ nfix2.assign(n_lat + 2, 0);
+ nadj1.clear();
+ nadj1.assign(n_lat + 2, 0);
+ nadj2.clear();
+ nadj2.assign(n_lat + 2, 0);
+ free_flag.clear();
+ free_flag.assign(n_lat + 2, 0);
+ for(int p = 0; p < n_lat + 2; p++) {
+ nfix1[p] = -p * p - p - 1;
+ nfix2[p] = -p * p - p - 2;
+ nadj1[p] = -p * p - p - 1;
+ nadj2[p] = -p * p - p - 2;
free_flag[p] = 0;
}
@@ -400,48 +404,51 @@ getFaceTypes(GRegion *gr, MElement *elem, int j, int k,
// Classify the laterals of each little mesh volume:
- for( int p = 0; p < n_lat; p++ ){
- int p2 = (p+1)%n_lat;
- std::vector<MVertex*> v_face;
- v_face.assign(4, (MVertex*)(0));
- v_face[0] = verts[p]; v_face[1] = verts[p2];
- v_face[2] = verts[p2+n_lat]; v_face[3] = verts[p+n_lat];
+ for(int p = 0; p < n_lat; p++) {
+ int p2 = (p + 1) % n_lat;
+ std::vector<MVertex *> v_face;
+ v_face.assign(4, (MVertex *)(0));
+ v_face[0] = verts[p];
+ v_face[1] = verts[p2];
+ v_face[2] = verts[p2 + n_lat];
+ v_face[3] = verts[p + n_lat];
// is the face a degenerate line:
- if( verts[p] == verts[n_lat+p] &&
- verts[p2] == verts[n_lat+p2] ){
+ if(verts[p] == verts[n_lat + p] && verts[p2] == verts[n_lat + p2]) {
face_types["degen"].push_back(p);
}
// is face a single triangle?
- else if( (verts[p] == verts[n_lat+p] &&
- verts[p2] != verts[n_lat+p2]) ||
- (verts[p] != verts[n_lat+p] &&
- verts[p2] == verts[n_lat+p2]) ){
+ else if((verts[p] == verts[n_lat + p] && verts[p2] != verts[n_lat + p2]) ||
+ (verts[p] != verts[n_lat + p] && verts[p2] == verts[n_lat + p2])) {
face_types["single_tri"].push_back(p);
}
// is face a recombined quad?
- else if( forbiddenExists( v_face, forbidden_edges ) )
+ else if(forbiddenExists(v_face, forbidden_edges))
face_types["recomb"].push_back(p);
// Does face contain a fixed diagonal edge?
- else if( edgeExists( verts[p], verts[p2+n_lat], quadToTri_edges ) ){
- nfix1[p] = p; nfix2[p] = p2+n_lat;
+ else if(edgeExists(verts[p], verts[p2 + n_lat], quadToTri_edges)) {
+ nfix1[p] = p;
+ nfix2[p] = p2 + n_lat;
face_types["fixed_diag"].push_back(p);
}
- else if( edgeExists( verts[n_lat+p], verts[p2], quadToTri_edges ) ){
- nfix1[p] = p+n_lat; nfix2[p] = p2;
+ else if(edgeExists(verts[n_lat + p], verts[p2], quadToTri_edges)) {
+ nfix1[p] = p + n_lat;
+ nfix2[p] = p2;
face_types["fixed_diag"].push_back(p);
}
// Does the face have an adjustable but required diagonal?
// ( this else if requires that the previous one about fixed diagonals
// comes FIRST )
- else if( edgeExists( verts[p], verts[p2+n_lat], lat_tri_diags ) ){
- nadj1[p] = p; nadj2[p] = p2+n_lat;
+ else if(edgeExists(verts[p], verts[p2 + n_lat], lat_tri_diags)) {
+ nadj1[p] = p;
+ nadj2[p] = p2 + n_lat;
face_types["adj_diag"].push_back(p);
}
- else if( edgeExists( verts[n_lat+p], verts[p2], lat_tri_diags ) ){
- nadj1[p] = p+n_lat; nadj2[p] = p2;
+ else if(edgeExists(verts[n_lat + p], verts[p2], lat_tri_diags)) {
+ nadj1[p] = p + n_lat;
+ nadj2[p] = p2;
face_types["adj_diag"].push_back(p);
}
@@ -449,92 +456,103 @@ getFaceTypes(GRegion *gr, MElement *elem, int j, int k,
// If this face has NO vertices on a lateral surface, and is a triangle or
// not in the top quadToTri layer:
- // then the face is a recombined quad (QuadToTri only used in recombined extrusions).
- else if( !touch_bnd[p] &&
- ( j < j_top_start || (j == j_top_start && k < k_top_start) ) )
+ // then the face is a recombined quad (QuadToTri only used in recombined
+ // extrusions).
+ else if(!touch_bnd[p] &&
+ (j < j_top_start || (j == j_top_start && k < k_top_start)))
face_types["recomb"].push_back(p);
- // Face is possibly free...will need to do tests after this loop is complete to
- // finalize that. But, for now....
- else{
+ // Face is possibly free...will need to do tests after this loop is complete
+ // to finalize that. But, for now....
+ else {
face_types["free"].push_back(p);
free_flag[p] = 1;
}
}
-
// set the bottom:
- if( n_lat == 3 )
+ if(n_lat == 3)
face_types["single_tri"].push_back(3);
- else{
+ else {
std::vector<MVertex *> v_bot;
- v_bot.assign(4, (MVertex*)(0));
- v_bot[0] = verts[0]; v_bot[1] = verts[1];
- v_bot[2] = verts[2]; v_bot[3] = verts[3];
+ v_bot.assign(4, (MVertex *)(0));
+ v_bot[0] = verts[0];
+ v_bot[1] = verts[1];
+ v_bot[2] = verts[2];
+ v_bot[3] = verts[3];
// is forbidden?
- if ( (j == 0 && k == 0) || forbiddenExists( v_bot, forbidden_edges ) )
+ if((j == 0 && k == 0) || forbiddenExists(v_bot, forbidden_edges))
face_types["recomb"].push_back(4);
- else if( edgeExists( verts[0], verts[2], quadToTri_edges ) ){
- nfix1[4] = 0; nfix2[4] = 2;
+ else if(edgeExists(verts[0], verts[2], quadToTri_edges)) {
+ nfix1[4] = 0;
+ nfix2[4] = 2;
face_types["fixed_diag"].push_back(4);
}
- else if( edgeExists( verts[1], verts[3], quadToTri_edges ) ){
- nfix1[4] = 1; nfix2[4] = 3;
+ else if(edgeExists(verts[1], verts[3], quadToTri_edges)) {
+ nfix1[4] = 1;
+ nfix2[4] = 3;
face_types["fixed_diag"].push_back(4);
}
// Does the face have an adjustable but required diagonal?
// ( this else if requires that the previous one about fixed diagonals
// comes FIRST )
// NOTE: THIS SITUATION SHOULD NEVER HAPPEN ON THIS FACE
- else if( edgeExists( verts[0], verts[2], lat_tri_diags ) ){
- nadj1[4] = 0; nadj2[4] = 2;
+ else if(edgeExists(verts[0], verts[2], lat_tri_diags)) {
+ nadj1[4] = 0;
+ nadj2[4] = 2;
face_types["adj_diag"].push_back(4);
}
- else if( edgeExists( verts[1], verts[3], lat_tri_diags ) ){
- nadj1[4] = 1; nadj2[4] = 3;
+ else if(edgeExists(verts[1], verts[3], lat_tri_diags)) {
+ nadj1[4] = 1;
+ nadj2[4] = 3;
face_types["adj_diag"].push_back(4);
}
- else{
+ else {
face_types["free"].push_back(4);
free_flag[4] = 1;
}
}
// set the top:
- if( n_lat == 3 )
- face_types["single_tri"].push_back(4);
+ if(n_lat == 3) face_types["single_tri"].push_back(4);
// if a hexahedron:
- else{
+ else {
std::vector<MVertex *> v_top;
- v_top.assign(4, (MVertex*)(0));
- v_top[0] = verts[4]; v_top[1] = verts[5];
- v_top[2] = verts[6]; v_top[3] = verts[7];
+ v_top.assign(4, (MVertex *)(0));
+ v_top[0] = verts[4];
+ v_top[1] = verts[5];
+ v_top[2] = verts[6];
+ v_top[3] = verts[7];
// is forbidden ?
- if( forbiddenExists(v_top, forbidden_edges) )
+ if(forbiddenExists(v_top, forbidden_edges))
face_types["recomb"].push_back(5);
// search for a fixed edge:
- else if( edgeExists( verts[4], verts[6], quadToTri_edges ) ){
- nfix1[5] = 4; nfix2[5] = 6;
+ else if(edgeExists(verts[4], verts[6], quadToTri_edges)) {
+ nfix1[5] = 4;
+ nfix2[5] = 6;
face_types["fixed_diag"].push_back(5);
}
- else if( edgeExists( verts[5], verts[7], quadToTri_edges ) ){
- nfix1[5] = 5; nfix2[5] = 7;
+ else if(edgeExists(verts[5], verts[7], quadToTri_edges)) {
+ nfix1[5] = 5;
+ nfix2[5] = 7;
face_types["fixed_diag"].push_back(5);
}
// Does the face have an adjustable but required diagonal?
// ( this else if requires that the previous one about fixed diagonals
// comes FIRST )
// NOTE: THIS SITUATION SHOULD NEVER HAPPEN ON THIS FACE
- else if( edgeExists( verts[4], verts[6], lat_tri_diags ) ){
- nadj1[5] = 4; nadj2[5] = 6;
+ else if(edgeExists(verts[4], verts[6], lat_tri_diags)) {
+ nadj1[5] = 4;
+ nadj2[5] = 6;
face_types["adj_diag"].push_back(5);
}
- else if( edgeExists( verts[5], verts[7], lat_tri_diags ) ){
- nadj1[5] = 5; nadj2[5] = 7;
+ else if(edgeExists(verts[5], verts[7], lat_tri_diags)) {
+ nadj1[5] = 5;
+ nadj2[5] = 7;
face_types["adj_diag"].push_back(5);
}
- else{
+ else {
face_types["free"].push_back(5);
free_flag[5] = 1;
}
@@ -542,67 +560,69 @@ getFaceTypes(GRegion *gr, MElement *elem, int j, int k,
// now return face_types
return face_types;
-
}
-
-// Generate face diagonals used to subdivide prisms by BRUTE FORCE...NOT RECOMMENDED for general use, but it
-// is required for some elements which have all vertices on an external region boundary.
-// Added 2010-01-29
-static void bruteForceEdgeQuadToTriPrism( GRegion *gr, MElement *elem,
- int j, int k, std::vector<MVertex *> verts,
- std::map<std::string, std::vector<int> > &face_types,
- std::set<std::pair<MVertex*, MVertex*> > &edges_new,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_new,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::vector<int> nfix1, std::vector<int> nfix2,
- std::vector<int> nadj1, std::vector<int> nadj2,
- std::vector<int> free_flag )
+// Generate face diagonals used to subdivide prisms by BRUTE FORCE...NOT
+// RECOMMENDED for general use, but it is required for some elements which have
+// all vertices on an external region boundary. Added 2010-01-29
+static void bruteForceEdgeQuadToTriPrism(
+ GRegion *gr, MElement *elem, int j, int k, std::vector<MVertex *> verts,
+ std::map<std::string, std::vector<int> > &face_types,
+ std::set<std::pair<MVertex *, MVertex *> > &edges_new,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_new,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::vector<int> nfix1, std::vector<int> nfix2, std::vector<int> nadj1,
+ std::vector<int> nadj2, std::vector<int> free_flag)
{
-
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In bruteForceEdgeQuadToTriPrism(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return;
}
GModel *model = gr->model();
- if( !model ){
+ if(!model) {
Msg::Error("In bruteForceEdgeQuadToTriPrism(), invalid model for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return;
}
// now find and verify the source of region
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
- Msg::Error("In bruteForceEdgeQuadToTriPrism(), invalid source face for region "
- "%d.", gr->tag() );
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
+ Msg::Error(
+ "In bruteForceEdgeQuadToTriPrism(), invalid source face for region "
+ "%d.",
+ gr->tag());
return;
}
// verify number of vertices
- //int n_lat;
- if( verts.size() != 6 ){
- Msg::Error("In bruteForceEdgeQuadToTriPrism(), number of vertices not equal "
- "6.");
+ // int n_lat;
+ if(verts.size() != 6) {
+ Msg::Error(
+ "In bruteForceEdgeQuadToTriPrism(), number of vertices not equal "
+ "6.");
return;
}
- //else
- //n_lat = 3;
+ // else
+ // n_lat = 3;
-
- // NOTE THAT FACES ARE NUMBERED CONSECUTIVELY FROM 0, starting from vertex 0 and moving around laterally.
- // Hence, the face after vertex 0 is face 0, and so forth. The bottom and top faces are numbered
- // (number of laterals + 1) and (number of laterals + 2), respectively.
+ // NOTE THAT FACES ARE NUMBERED CONSECUTIVELY FROM 0, starting from vertex 0
+ // and moving around laterally. Hence, the face after vertex 0 is face 0, and
+ // so forth. The bottom and top faces are numbered (number of laterals + 1)
+ // and (number of laterals + 2), respectively.
// numbers of each type of face
int num_degen = face_types["degen"].size();
@@ -612,118 +632,127 @@ static void bruteForceEdgeQuadToTriPrism( GRegion *gr, MElement *elem,
int num_adj_diag = face_types["adj_diag"].size();
int num_free = face_types["free"].size();
- // Make sure all faces marked forbidden in face_types have all diagonals in forbidden_edges;
- for( int p = 0; p < num_recomb; p++){
+ // Make sure all faces marked forbidden in face_types have all diagonals in
+ // forbidden_edges;
+ for(int p = 0; p < num_recomb; p++) {
int ind = face_types["recomb"][p];
- std::vector<MVertex*> v;
- v.push_back(verts[ind]); v.push_back(verts[(ind+1)%3]); v.push_back(verts[(ind+1)%3+3]);
- v.push_back(verts[ind+3]);
- createForbidden(v, forbidden_new );
- createForbidden(v, forbidden_edges );
+ std::vector<MVertex *> v;
+ v.push_back(verts[ind]);
+ v.push_back(verts[(ind + 1) % 3]);
+ v.push_back(verts[(ind + 1) % 3 + 3]);
+ v.push_back(verts[ind + 3]);
+ createForbidden(v, forbidden_new);
+ createForbidden(v, forbidden_edges);
}
// following must be true if this is a triangle extrusion
- if( find(face_types["single_tri"].begin(), face_types["single_tri"].end(), 3) ==
- face_types["single_tri"].end() ||
- find(face_types["single_tri"].begin(), face_types["single_tri"].end(), 4) ==
- face_types["single_tri"].end() ){
- Msg::Error("In bruteForceEdgeQuadToTriPrism(), invalid face code for top and/or "
- "bottom (region %d).", gr->tag() );
+ if(find(face_types["single_tri"].begin(), face_types["single_tri"].end(),
+ 3) == face_types["single_tri"].end() ||
+ find(face_types["single_tri"].begin(), face_types["single_tri"].end(),
+ 4) == face_types["single_tri"].end()) {
+ Msg::Error(
+ "In bruteForceEdgeQuadToTriPrism(), invalid face code for top and/or "
+ "bottom (region %d).",
+ gr->tag());
return;
}
-
// Take care of the trivial case: tetrahedron:
- if( num_single_tri == 4 && num_degen == 1 )
- return;
+ if(num_single_tri == 4 && num_degen == 1) return;
// Pyramid also very easy:
- else if ( num_single_tri == 4 ){
+ else if(num_single_tri == 4) {
int ind = 0;
- if( num_adj_diag ){
+ if(num_adj_diag) {
ind = face_types["adj_diag"][0];
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
}
return;
}
-
// A PRISM IS MORE DIFFICULT:
// First case, if exactly two laterals are forbidden to diagonalize:
- if( num_recomb == 2 ){
- if( num_free ){
- for( int p = 0; p < num_free; p++){
+ if(num_recomb == 2) {
+ if(num_free) {
+ for(int p = 0; p < num_free; p++) {
int ind = face_types["free"][p];
- std::vector<MVertex*> v;
- v.push_back(verts[ind]); v.push_back(verts[(ind+1)%3]);
- v.push_back(verts[(ind+1)%3+3]); v.push_back(verts[ind+3]);
- createForbidden(v, forbidden_new );
- createForbidden(v, forbidden_edges );
+ std::vector<MVertex *> v;
+ v.push_back(verts[ind]);
+ v.push_back(verts[(ind + 1) % 3]);
+ v.push_back(verts[(ind + 1) % 3 + 3]);
+ v.push_back(verts[ind + 3]);
+ createForbidden(v, forbidden_new);
+ createForbidden(v, forbidden_edges);
}
}
- else{
- if( num_adj_diag ){
+ else {
+ if(num_adj_diag) {
int ind = face_types["adj_diag"][0];
- createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
- createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
}
- std::pair<unsigned int, unsigned int> jkpair(j,k);
+ std::pair<unsigned int, unsigned int> jkpair(j, k);
problems[elem].insert(jkpair);
problems_new[elem].insert(jkpair);
}
return;
}
- // If 1 lateral is forbidden to diagonalize and two free, diagonalize to lowest point vector on free edge:
- if( num_recomb == 1 && num_free == 2 ){
+ // If 1 lateral is forbidden to diagonalize and two free, diagonalize to
+ // lowest point vector on free edge:
+ if(num_recomb == 1 && num_free == 2) {
int p_recomb = face_types["recomb"][0];
- int p_free = (p_recomb + 2)%3;
- int ind_low = verts[p_free] < verts[p_free+3]
- ? p_free : p_free+3;
+ int p_free = (p_recomb + 2) % 3;
+ int ind_low = verts[p_free] < verts[p_free + 3] ? p_free : p_free + 3;
int add = ind_low < 3 ? 0 : 3;
- createEdge( verts[ind_low], verts[(ind_low-add+1)%3+3-add], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+1)%3+3-add], edges_new );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%3+3-add], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%3+3-add], edges_new );
+ createEdge(verts[ind_low], verts[(ind_low - add + 1) % 3 + 3 - add],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 1) % 3 + 3 - add],
+ edges_new);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 3 + 3 - add],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 3 + 3 - add],
+ edges_new);
return;
}
-
- // If all faces are free, then diagonalize TWO faces based on smallest vertex pointer
- if( num_free >= 3 ){
+ // If all faces are free, then diagonalize TWO faces based on smallest vertex
+ // pointer
+ if(num_free >= 3) {
int ind_low;
ind_low = 0;
- for( int p = 1; p < 6; p++ ){
- if( verts[ind_low] > verts[p] )
- ind_low = p;
+ for(int p = 1; p < 6; p++) {
+ if(verts[ind_low] > verts[p]) ind_low = p;
}
int add = ind_low < 3 ? 0 : 3;
- createEdge( verts[ind_low], verts[(ind_low-add+1)%3+3-add], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+1)%3+3-add], edges_new );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%3+3-add], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%3+3-add], edges_new );
+ createEdge(verts[ind_low], verts[(ind_low - add + 1) % 3 + 3 - add],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 1) % 3 + 3 - add],
+ edges_new);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 3 + 3 - add],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 3 + 3 - add],
+ edges_new);
return;
}
-
- // If reach this point, then go through the loop of progressively permitting more face types
- // to be considered for diagonalization. This loop could be slow, that's why previous special cases were
- // tried first.
- // t=0, fixed and preferred diagonals only.
- // t=1, allow preferred diagonals to be meshed with lowest vertex pointer in diagonal
- // t=2, allow free faces to be meshed with lowest vertex pointer in diagonal
- // t=3, allow any diagonal that works
+ // If reach this point, then go through the loop of progressively permitting
+ // more face types to be considered for diagonalization. This loop could be
+ // slow, that's why previous special cases were tried first. t=0, fixed and
+ // preferred diagonals only. t=1, allow preferred diagonals to be meshed with
+ // lowest vertex pointer in diagonal t=2, allow free faces to be meshed with
+ // lowest vertex pointer in diagonal t=3, allow any diagonal that works
bool valid_division = false;
- int face_done[2]={0,0}; // holds the face numbers for the two faces that are done
- for( int t = 0; t < 4; t++ ){
-
+ int face_done[2] = {
+ 0, 0}; // holds the face numbers for the two faces that are done
+ for(int t = 0; t < 4; t++) {
// variables that hold the face diagonal nodes.
int n1[3], n2[3];
@@ -732,143 +761,145 @@ static void bruteForceEdgeQuadToTriPrism( GRegion *gr, MElement *elem,
// set default values of the n variables
// to unique negative numbers; bool to false.
- for( int p = 0; p < 3; p++ ){
- n1[p] = -p*p-p-1;
- n2[p] = -p*p-p-2;
+ for(int p = 0; p < 3; p++) {
+ n1[p] = -p * p - p - 1;
+ n2[p] = -p * p - p - 2;
face_is_free[p] = false;
}
- for( int p = 0; p < 3; p++ ){
+ for(int p = 0; p < 3; p++) {
// fixed diagonals
- if( nfix1[p] >= 0 ){
- n1[p] = nfix1[p]; n2[p] = nfix2[p];
+ if(nfix1[p] >= 0) {
+ n1[p] = nfix1[p];
+ n2[p] = nfix2[p];
}
// preferred adjustable diagonals
- else if( !t && nadj1[p] >= 0 ){
- n1[p] = nadj1[p]; n2[p] = nadj2[p];
+ else if(!t && nadj1[p] >= 0) {
+ n1[p] = nadj1[p];
+ n2[p] = nadj2[p];
}
// choose lowest vertex for t < 3, any vertex for t == 3
- else if( (t >= 1 && t < 3 && nadj1[p] >= 0) ||
- (t == 2 && free_flag[p]) ){
- if( (verts[p] < verts[(p+1)%3] &&
- verts[p] < verts[p+3]) ||
- (verts[(p+1)%3+3] < verts[(p+1)%3] &&
- verts[(p+1)%3+3] < verts[p+3]) ){
- n1[p] = p; n2[p] = (p+1)%3+3;
+ else if((t >= 1 && t < 3 && nadj1[p] >= 0) || (t == 2 && free_flag[p])) {
+ if((verts[p] < verts[(p + 1) % 3] && verts[p] < verts[p + 3]) ||
+ (verts[(p + 1) % 3 + 3] < verts[(p + 1) % 3] &&
+ verts[(p + 1) % 3 + 3] < verts[p + 3])) {
+ n1[p] = p;
+ n2[p] = (p + 1) % 3 + 3;
}
- else{
- n1[p] = p+3; n2[p] = (p+1)%3;
+ else {
+ n1[p] = p + 3;
+ n2[p] = (p + 1) % 3;
}
}
- else if( (t==3 && (nadj1[p] >= 0)) || free_flag[p] )
+ else if((t == 3 && (nadj1[p] >= 0)) || free_flag[p])
face_is_free[p] = true;
}
// search for two faces that have diagonals which meet at a vertex
- for( int p = 0; p < 3; p++ ){
+ for(int p = 0; p < 3; p++) {
// if both faces are free, fix one by using lowest vertex pointer
- if( face_is_free[p] && face_is_free[(p+1)%3] ){
+ if(face_is_free[p] && face_is_free[(p + 1) % 3]) {
face_is_free[p] = false;
- if( verts[(p+1)%3] < verts[(p+1)%3+3] ){
- n1[p] = p+3;
- n2[p] = (p+1)%3;
+ if(verts[(p + 1) % 3] < verts[(p + 1) % 3 + 3]) {
+ n1[p] = p + 3;
+ n2[p] = (p + 1) % 3;
}
- else{
+ else {
n1[p] = p;
- n2[p] = (p+1)%3+3;
+ n2[p] = (p + 1) % 3 + 3;
}
}
// if first face is free and the other has a definite diagonal
- if( face_is_free[p] && n1[(p+1)%3] >= 0 ){
+ if(face_is_free[p] && n1[(p + 1) % 3] >= 0) {
valid_division = true;
face_done[0] = p;
- face_done[1] = (p+1)%3;
- if( n1[(p+1)%3] == (p+1)%3 || n2[(p+1)%3] == (p+1)%3 ){
- n1[p] = p+3;
- n2[p] = (p+1)%3;
+ face_done[1] = (p + 1) % 3;
+ if(n1[(p + 1) % 3] == (p + 1) % 3 || n2[(p + 1) % 3] == (p + 1) % 3) {
+ n1[p] = p + 3;
+ n2[p] = (p + 1) % 3;
}
- else{
+ else {
n1[p] = p;
- n2[p] = (p+1)%3+3;
+ n2[p] = (p + 1) % 3 + 3;
}
}
// if second face is free and the other has a definite diagonal
- else if( face_is_free[(p+1)%3] && n1[p] >= 0 ){
+ else if(face_is_free[(p + 1) % 3] && n1[p] >= 0) {
valid_division = true;
face_done[0] = p;
- face_done[1] = (p+1)%3;
- if( n2[p] == (p+1)%3 || n1[p] == (p+1)%3 ){
- n1[(p+1)%3] = (p+1)%3;
- n2[(p+1)%3] = (p+2)%3+3;
+ face_done[1] = (p + 1) % 3;
+ if(n2[p] == (p + 1) % 3 || n1[p] == (p + 1) % 3) {
+ n1[(p + 1) % 3] = (p + 1) % 3;
+ n2[(p + 1) % 3] = (p + 2) % 3 + 3;
}
- else{
- n1[(p+1)%3] = (p+1)%3+3;
- n2[(p+1)%3] = (p+2)%3;
+ else {
+ n1[(p + 1) % 3] = (p + 1) % 3 + 3;
+ n2[(p + 1) % 3] = (p + 2) % 3;
}
}
// if both faces had definite diagonals
- else if( n2[p] == n1[(p+1)%3] || n2[p] == n2[(p+1)%3] ||
- n1[p] == n1[(p+1)%3] || n1[p] == n2[(p+1)%3] ){
+ else if(n2[p] == n1[(p + 1) % 3] || n2[p] == n2[(p + 1) % 3] ||
+ n1[p] == n1[(p + 1) % 3] || n1[p] == n2[(p + 1) % 3]) {
valid_division = true;
face_done[0] = p;
- face_done[1] = (p+1)%3;
+ face_done[1] = (p + 1) % 3;
}
- if( valid_division ){
- createEdge( verts[n1[p]], verts[n2[p]], quadToTri_edges );
- createEdge( verts[n1[p]], verts[n2[p]], edges_new );
- createEdge( verts[n1[(p+1)%3]], verts[n2[(p+1)%3]], quadToTri_edges );
- createEdge( verts[n1[(p+1)%3]], verts[n2[(p+1)%3]], edges_new );
+ if(valid_division) {
+ createEdge(verts[n1[p]], verts[n2[p]], quadToTri_edges);
+ createEdge(verts[n1[p]], verts[n2[p]], edges_new);
+ createEdge(verts[n1[(p + 1) % 3]], verts[n2[(p + 1) % 3]],
+ quadToTri_edges);
+ createEdge(verts[n1[(p + 1) % 3]], verts[n2[(p + 1) % 3]], edges_new);
break;
}
}
- // At this point, can break out if valid_division... OR if there is NO valid division AND
- // if num_fixed_diag == 3, or 2 and a recomb
- // break out of loop. This will need an internal vertex.
- if( valid_division || (!valid_division && num_fixed_diag + num_recomb == 3) )
+ // At this point, can break out if valid_division... OR if there is NO valid
+ // division AND if num_fixed_diag == 3, or 2 and a recomb break out of loop.
+ // This will need an internal vertex.
+ if(valid_division || (!valid_division && num_fixed_diag + num_recomb == 3))
break;
} // end of outer t-loop
// create adjustable but required diagonals that weren't yet added
- for( int s = 0; s < num_adj_diag; s++ ){
+ for(int s = 0; s < num_adj_diag; s++) {
int ind = face_types["adj_diag"][s];
- if( ind != face_done[0] && ind != face_done[1] ){
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
+ if(ind != face_done[0] && ind != face_done[1]) {
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
}
}
- if( !valid_division ){
- std::pair<unsigned int, unsigned int> jk_pair(j,k);
+ if(!valid_division) {
+ std::pair<unsigned int, unsigned int> jk_pair(j, k);
problems[elem].insert(jk_pair);
problems_new[elem].insert(jk_pair);
}
return;
-
}
-
-// Divide hexahedron degenerated at two points (degenerate face is a line) by brute force
-static void addEdgesForQuadToTriTwoPtDegenHexa(GRegion *gr, MElement *elem, ExtrudeParams *ep,
- int j, int k, std::vector<MVertex *> verts,
- std::map<std::string, std::vector<int> > &face_types,
- std::set<std::pair<MVertex*, MVertex*> > &edges_new,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_new,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::vector<int> nfix1, std::vector<int> nfix2,
- std::vector<int> nadj1, std::vector<int> nadj2,
- std::vector<int> free_flag )
+// Divide hexahedron degenerated at two points (degenerate face is a line) by
+// brute force
+static void addEdgesForQuadToTriTwoPtDegenHexa(
+ GRegion *gr, MElement *elem, ExtrudeParams *ep, int j, int k,
+ std::vector<MVertex *> verts,
+ std::map<std::string, std::vector<int> > &face_types,
+ std::set<std::pair<MVertex *, MVertex *> > &edges_new,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_new,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::vector<int> nfix1, std::vector<int> nfix2, std::vector<int> nadj1,
+ std::vector<int> nadj2, std::vector<int> free_flag)
{
-
- if( !ep )
- return;
+ if(!ep) return;
// numbers of each type of face
// int num_degen = face_types["degen"].size();
@@ -880,43 +911,47 @@ static void addEdgesForQuadToTriTwoPtDegenHexa(GRegion *gr, MElement *elem, Extr
int degen_face = face_types["degen"][0];
- // If all faces are free, then diagonalize TWO faces based on smallest vertex pointer
- if( num_free >= 3 ){
+ // If all faces are free, then diagonalize TWO faces based on smallest vertex
+ // pointer
+ if(num_free >= 3) {
int ind_low;
ind_low = 0;
- for( int p = 1; p < 8; p++ ){
- if( verts[ind_low] > verts[p] )
- ind_low = p;
+ for(int p = 1; p < 8; p++) {
+ if(verts[ind_low] > verts[p]) ind_low = p;
}
int add = ind_low < 4 ? 0 : 4;
- if( verts[ind_low-add] == verts[ind_low+4-add] ){
- createEdge( verts[ind_low], verts[(ind_low-add+2)%4], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%4], edges_new );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%4+4], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%4+4], edges_new );
- }
- else{
- createEdge( verts[ind_low], verts[(ind_low-add+2)%4+4-add], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%4+4-add], edges_new );
+ if(verts[ind_low - add] == verts[ind_low + 4 - add]) {
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 4],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 4], edges_new);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 4 + 4],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 4 + 4], edges_new);
+ }
+ else {
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 4 + 4 - add],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 4 + 4 - add],
+ edges_new);
int ind2;
- if( verts[(ind_low-add+1)%4] == verts[(ind_low-add+1)%4+4] )
- ind2 = (ind_low-add+3)%4+4-add;
+ if(verts[(ind_low - add + 1) % 4] == verts[(ind_low - add + 1) % 4 + 4])
+ ind2 = (ind_low - add + 3) % 4 + 4 - add;
else
- ind2 = (ind_low-add+1)%4+4-add;
- createEdge( verts[ind_low], verts[ind2], quadToTri_edges );
- createEdge( verts[ind_low], verts[ind2], edges_new );
+ ind2 = (ind_low - add + 1) % 4 + 4 - add;
+ createEdge(verts[ind_low], verts[ind2], quadToTri_edges);
+ createEdge(verts[ind_low], verts[ind2], edges_new);
}
return;
}
- // If faces of prism not all free, look for a way to diagonalize and subdivide.
- // t = 0, fixed and preferred adjustable diagonals
- // t >= 1 < 3, lowest pointer on adjustables
- // t = 2, include free faces, lowest vertex pointer diagonal on adjustable and free
- // t = 3, not lowest vertex pointer diagonal on adjustable and free
+ // If faces of prism not all free, look for a way to diagonalize and
+ // subdivide. t = 0, fixed and preferred adjustable diagonals t >= 1 < 3,
+ // lowest pointer on adjustables t = 2, include free faces, lowest vertex
+ // pointer diagonal on adjustable and free t = 3, not lowest vertex pointer
+ // diagonal on adjustable and free
int face_done[2];
face_done[0] = -1;
@@ -925,30 +960,30 @@ static void addEdgesForQuadToTriTwoPtDegenHexa(GRegion *gr, MElement *elem, Extr
// valid_division tells whether a valid division was found
bool valid_division = false;
- for( int t = 0; t < 4; t++ ){
+ for(int t = 0; t < 4; t++) {
// these variables hold the faces and their diagonal nodes in (n1,n2)
int p_top = 5, n1_top = -2, n2_top = -3;
bool p_top_is_free = false;
int p_bot = 4, n1_bot = -4, n2_bot = -5;
bool p_bot_is_free = false;
- int p_lat = (degen_face+2)%4, n1_lat = -10, n2_lat = -11;
+ int p_lat = (degen_face + 2) % 4, n1_lat = -10, n2_lat = -11;
bool p_lat_is_free = false;
- for( int s = 0; s < 3; s++ ){
- int p_tmp=0, *n1_tmp=0, *n2_tmp=0;
- bool *p_is_free_tmp=0;
- if( !s ){
+ for(int s = 0; s < 3; s++) {
+ int p_tmp = 0, *n1_tmp = 0, *n2_tmp = 0;
+ bool *p_is_free_tmp = 0;
+ if(!s) {
p_tmp = p_bot;
n1_tmp = &n1_bot;
n2_tmp = &n2_bot;
p_is_free_tmp = &p_bot_is_free;
}
- if( s==1 ){
+ if(s == 1) {
p_tmp = p_top;
n1_tmp = &n1_top;
n2_tmp = &n2_top;
p_is_free_tmp = &p_top_is_free;
}
- if( s==2 ){
+ if(s == 2) {
p_tmp = p_lat;
n1_tmp = &n1_lat;
n2_tmp = &n2_lat;
@@ -956,243 +991,240 @@ static void addEdgesForQuadToTriTwoPtDegenHexa(GRegion *gr, MElement *elem, Extr
}
// fixed diagonals
- if( nfix1[p_tmp] >= 0 ){
- *n1_tmp = nfix1[p_tmp]; *n2_tmp = nfix2[p_tmp];
+ if(nfix1[p_tmp] >= 0) {
+ *n1_tmp = nfix1[p_tmp];
+ *n2_tmp = nfix2[p_tmp];
}
// preferred adjustable diagonals
- else if( !t && nadj1[p_tmp] >= 0 ){
- *n1_tmp = nadj1[p_tmp]; *n2_tmp = nadj2[p_tmp];
+ else if(!t && nadj1[p_tmp] >= 0) {
+ *n1_tmp = nadj1[p_tmp];
+ *n2_tmp = nadj2[p_tmp];
}
// choose lowest vertex for t < 3, non-lowest vertex for t == 3
- else if( (t >= 1 && t < 3 && nadj1[p_tmp] >= 0) ||
- (t == 2 && free_flag[p_tmp]) ){
- if( p_tmp < 4 ){
- if( (verts[p_tmp] < verts[(p_tmp+1)%4] &&
- verts[p_tmp] < verts[p_tmp+4]) ||
- (verts[(p_tmp+1)%4+4] < verts[(p_tmp+1)%4] &&
- verts[(p_tmp+1)%4+4] < verts[p_tmp+4]) ){
- *n1_tmp = p_tmp; *n2_tmp = (p_tmp+1)%4+4;
+ else if((t >= 1 && t < 3 && nadj1[p_tmp] >= 0) ||
+ (t == 2 && free_flag[p_tmp])) {
+ if(p_tmp < 4) {
+ if((verts[p_tmp] < verts[(p_tmp + 1) % 4] &&
+ verts[p_tmp] < verts[p_tmp + 4]) ||
+ (verts[(p_tmp + 1) % 4 + 4] < verts[(p_tmp + 1) % 4] &&
+ verts[(p_tmp + 1) % 4 + 4] < verts[p_tmp + 4])) {
+ *n1_tmp = p_tmp;
+ *n2_tmp = (p_tmp + 1) % 4 + 4;
}
- else{
- *n1_tmp = p_tmp+4; *n2_tmp = (p_tmp+1)%4;
+ else {
+ *n1_tmp = p_tmp + 4;
+ *n2_tmp = (p_tmp + 1) % 4;
}
}
- else{
- int add = p_tmp==4 ? 0 : 4;
- if( (verts[0+add] < verts[1+add] && verts[0+add] < verts[3+add]) ||
- (verts[2+add] < verts[1+add] && verts[2+add] < verts[3+add]) ){
- *n1_tmp = 0+add; *n2_tmp = 2+add;
+ else {
+ int add = p_tmp == 4 ? 0 : 4;
+ if((verts[0 + add] < verts[1 + add] &&
+ verts[0 + add] < verts[3 + add]) ||
+ (verts[2 + add] < verts[1 + add] &&
+ verts[2 + add] < verts[3 + add])) {
+ *n1_tmp = 0 + add;
+ *n2_tmp = 2 + add;
}
- else{
- *n1_tmp = 1+add; *n2_tmp = 3+add;
+ else {
+ *n1_tmp = 1 + add;
+ *n2_tmp = 3 + add;
}
}
}
- else if( t==3 && (nadj1[p_tmp] >= 0 || free_flag[p_tmp]) )
+ else if(t == 3 && (nadj1[p_tmp] >= 0 || free_flag[p_tmp]))
*p_is_free_tmp = true;
-
}
// Find any diagonals that meet at a vertex:
// start with top surface and bottom surface
- if( ( n1_top >= 0 || p_top_is_free ) &&
- ( n1_bot >= 0 || p_bot_is_free ) ){
- if( p_top_is_free && p_bot_is_free ){
- if( (verts[4] < verts[5] && verts[4] < verts[7]) ||
- (verts[6] < verts[5] && verts[6] < verts[7]) ){
- n1_top = 4; n2_top = 6;
+ if((n1_top >= 0 || p_top_is_free) && (n1_bot >= 0 || p_bot_is_free)) {
+ if(p_top_is_free && p_bot_is_free) {
+ if((verts[4] < verts[5] && verts[4] < verts[7]) ||
+ (verts[6] < verts[5] && verts[6] < verts[7])) {
+ n1_top = 4;
+ n2_top = 6;
}
- else{
- n1_top = 5; n2_top = 7;
+ else {
+ n1_top = 5;
+ n2_top = 7;
}
- n1_bot = n1_top-4;
- n2_bot = n2_top-4;
+ n1_bot = n1_top - 4;
+ n2_bot = n2_top - 4;
}
- else if( n1_top >= 0 && p_bot_is_free ){
- n1_bot = n1_top-4;
- n2_bot = n2_top-4;
+ else if(n1_top >= 0 && p_bot_is_free) {
+ n1_bot = n1_top - 4;
+ n2_bot = n2_top - 4;
}
- else if( n1_bot >= 0 && p_top_is_free ){
- n1_top = n1_bot+4;
- n2_top = n2_bot+4;
+ else if(n1_bot >= 0 && p_top_is_free) {
+ n1_top = n1_bot + 4;
+ n2_top = n2_bot + 4;
}
- if( verts[n1_top] == verts[n1_bot] ||
- verts[n1_top] == verts[n2_bot] ||
- verts[n2_top] == verts[n1_bot] ||
- verts[n2_top] == verts[n2_bot] ){
+ if(verts[n1_top] == verts[n1_bot] || verts[n1_top] == verts[n2_bot] ||
+ verts[n2_top] == verts[n1_bot] || verts[n2_top] == verts[n2_bot]) {
valid_division = true;
face_done[0] = p_top;
face_done[1] = p_bot;
- createEdge( verts[n1_top], verts[n2_top], quadToTri_edges );
- createEdge( verts[n1_top], verts[n2_top], edges_new );
- createEdge( verts[n1_bot], verts[n2_bot], quadToTri_edges );
- createEdge( verts[n1_bot], verts[n2_bot], edges_new );
+ createEdge(verts[n1_top], verts[n2_top], quadToTri_edges);
+ createEdge(verts[n1_top], verts[n2_top], edges_new);
+ createEdge(verts[n1_bot], verts[n2_bot], quadToTri_edges);
+ createEdge(verts[n1_bot], verts[n2_bot], edges_new);
}
}
// Top surface and lateral surface
- if( !valid_division &&
- ( n1_top >= 0 || p_top_is_free ) &&
- ( n1_lat >= 0 || p_lat_is_free ) ){
-
- if( p_top_is_free && p_lat_is_free ){
- if( (verts[4] < verts[5] && verts[4] < verts[7]) ||
- (verts[6] < verts[5] && verts[6] < verts[7]) ){
- n1_top = 4; n2_top = 6;
+ if(!valid_division && (n1_top >= 0 || p_top_is_free) &&
+ (n1_lat >= 0 || p_lat_is_free)) {
+ if(p_top_is_free && p_lat_is_free) {
+ if((verts[4] < verts[5] && verts[4] < verts[7]) ||
+ (verts[6] < verts[5] && verts[6] < verts[7])) {
+ n1_top = 4;
+ n2_top = 6;
}
- else{
- n1_top = 5; n2_top = 7;
+ else {
+ n1_top = 5;
+ n2_top = 7;
}
- if( n1_top == (degen_face+2)%4+4 ||
- n2_top == (degen_face+2)%4+4 ){
- n1_lat = (degen_face+2)%4+4;
- n2_lat = (n1_lat-4+1)%4;
+ if(n1_top == (degen_face + 2) % 4 + 4 ||
+ n2_top == (degen_face + 2) % 4 + 4) {
+ n1_lat = (degen_face + 2) % 4 + 4;
+ n2_lat = (n1_lat - 4 + 1) % 4;
}
- else{
- n1_lat = (degen_face+3)%4+4;
- n2_lat = (n1_lat-4+3)%4;
+ else {
+ n1_lat = (degen_face + 3) % 4 + 4;
+ n2_lat = (n1_lat - 4 + 3) % 4;
}
}
- else if( n1_top >= 0 && p_lat_is_free ){
- if( n1_top == (degen_face+2)%4+4 ||
- n2_top == (degen_face+2)%4+4 ){
- n1_lat = (degen_face+2)%4+4;
- n2_lat = (n1_lat-4+1)%4;
+ else if(n1_top >= 0 && p_lat_is_free) {
+ if(n1_top == (degen_face + 2) % 4 + 4 ||
+ n2_top == (degen_face + 2) % 4 + 4) {
+ n1_lat = (degen_face + 2) % 4 + 4;
+ n2_lat = (n1_lat - 4 + 1) % 4;
}
- else{
- n1_lat = (degen_face+3)%4+4;
- n2_lat = (n1_lat-4+3)%4;
+ else {
+ n1_lat = (degen_face + 3) % 4 + 4;
+ n2_lat = (n1_lat - 4 + 3) % 4;
}
}
- else if( n1_lat >= 0 && p_top_is_free ){
- if( n1_lat == (degen_face+2)%4+4 ||
- n2_lat == (degen_face+2)%4+4 ){
- n1_top = (degen_face+2)%4+4;
- n2_top = (n1_top-4+2)%4+4;
+ else if(n1_lat >= 0 && p_top_is_free) {
+ if(n1_lat == (degen_face + 2) % 4 + 4 ||
+ n2_lat == (degen_face + 2) % 4 + 4) {
+ n1_top = (degen_face + 2) % 4 + 4;
+ n2_top = (n1_top - 4 + 2) % 4 + 4;
}
- else{
- n1_top = (degen_face+3)%4+4;
- n2_top = (n1_top-4+2)%4+4;
+ else {
+ n1_top = (degen_face + 3) % 4 + 4;
+ n2_top = (n1_top - 4 + 2) % 4 + 4;
}
}
- if( verts[n1_top] == verts[n1_lat] ||
- verts[n1_top] == verts[n2_lat] ||
- verts[n2_top] == verts[n1_lat] ||
- verts[n2_top] == verts[n2_lat] ){
+ if(verts[n1_top] == verts[n1_lat] || verts[n1_top] == verts[n2_lat] ||
+ verts[n2_top] == verts[n1_lat] || verts[n2_top] == verts[n2_lat]) {
valid_division = true;
face_done[0] = p_top;
face_done[1] = p_lat;
- createEdge( verts[n1_top], verts[n2_top], quadToTri_edges );
- createEdge( verts[n1_top], verts[n2_top], edges_new );
- createEdge( verts[n1_lat], verts[n2_lat], quadToTri_edges );
- createEdge( verts[n1_lat], verts[n2_lat], edges_new );
+ createEdge(verts[n1_top], verts[n2_top], quadToTri_edges);
+ createEdge(verts[n1_top], verts[n2_top], edges_new);
+ createEdge(verts[n1_lat], verts[n2_lat], quadToTri_edges);
+ createEdge(verts[n1_lat], verts[n2_lat], edges_new);
}
}
// Bottom surface and lateral surface
- if( !valid_division &&
- ( n1_bot >= 0 || p_bot_is_free ) &&
- ( n1_lat >= 0 || p_lat_is_free ) ){
-
- if( p_bot_is_free && p_lat_is_free ){
- if( (verts[0] < verts[1] && verts[0] < verts[3]) ||
- (verts[2] < verts[1] && verts[2] < verts[3]) ){
- n1_bot = 0; n2_bot = 2;
+ if(!valid_division && (n1_bot >= 0 || p_bot_is_free) &&
+ (n1_lat >= 0 || p_lat_is_free)) {
+ if(p_bot_is_free && p_lat_is_free) {
+ if((verts[0] < verts[1] && verts[0] < verts[3]) ||
+ (verts[2] < verts[1] && verts[2] < verts[3])) {
+ n1_bot = 0;
+ n2_bot = 2;
}
- else{
- n1_bot = 1; n2_bot = 3;
+ else {
+ n1_bot = 1;
+ n2_bot = 3;
}
- if( n1_bot == (degen_face+2)%4 ||
- n2_bot == (degen_face+2)%4 ){
- n1_lat = (degen_face+2)%4;
- n2_lat = (n1_lat+1)%4+4;
+ if(n1_bot == (degen_face + 2) % 4 || n2_bot == (degen_face + 2) % 4) {
+ n1_lat = (degen_face + 2) % 4;
+ n2_lat = (n1_lat + 1) % 4 + 4;
}
- else{
- n1_lat = (degen_face+3)%4;
- n2_lat = (n1_lat+3)%4+4;
+ else {
+ n1_lat = (degen_face + 3) % 4;
+ n2_lat = (n1_lat + 3) % 4 + 4;
}
}
- else if( n1_bot >= 0 && p_lat_is_free ){
- if( n1_bot == (degen_face+2)%4 ||
- n2_bot == (degen_face+2)%4 ){
- n1_lat = (degen_face+2)%4;
- n2_lat = (n1_lat+1)%4+4;
+ else if(n1_bot >= 0 && p_lat_is_free) {
+ if(n1_bot == (degen_face + 2) % 4 || n2_bot == (degen_face + 2) % 4) {
+ n1_lat = (degen_face + 2) % 4;
+ n2_lat = (n1_lat + 1) % 4 + 4;
}
- else{
- n1_lat = (degen_face+3)%4;
- n2_lat = (n1_lat+3)%4+4;
+ else {
+ n1_lat = (degen_face + 3) % 4;
+ n2_lat = (n1_lat + 3) % 4 + 4;
}
}
- else if( n1_lat >= 0 && p_bot_is_free ){
- if( n1_lat == (degen_face+2)%4 ||
- n2_lat == (degen_face+2)%4 ){
- n1_bot = (degen_face+2)%4;
- n2_bot = (n1_bot+2)%4;
+ else if(n1_lat >= 0 && p_bot_is_free) {
+ if(n1_lat == (degen_face + 2) % 4 || n2_lat == (degen_face + 2) % 4) {
+ n1_bot = (degen_face + 2) % 4;
+ n2_bot = (n1_bot + 2) % 4;
}
- else{
- n1_bot = (degen_face+3)%4;
- n2_bot = (n1_bot+2)%4;
+ else {
+ n1_bot = (degen_face + 3) % 4;
+ n2_bot = (n1_bot + 2) % 4;
}
}
- if( verts[n1_bot] == verts[n1_lat] ||
- verts[n1_bot] == verts[n2_lat] ||
- verts[n2_bot] == verts[n1_lat] ||
- verts[n2_bot] == verts[n2_lat] ){
+ if(verts[n1_bot] == verts[n1_lat] || verts[n1_bot] == verts[n2_lat] ||
+ verts[n2_bot] == verts[n1_lat] || verts[n2_bot] == verts[n2_lat]) {
valid_division = true;
face_done[0] = p_bot;
face_done[1] = p_lat;
- createEdge( verts[n1_bot], verts[n2_bot], quadToTri_edges );
- createEdge( verts[n1_bot], verts[n2_bot], edges_new );
- createEdge( verts[n1_lat], verts[n2_lat], quadToTri_edges );
- createEdge( verts[n1_lat], verts[n2_lat], edges_new );
+ createEdge(verts[n1_bot], verts[n2_bot], quadToTri_edges);
+ createEdge(verts[n1_bot], verts[n2_bot], edges_new);
+ createEdge(verts[n1_lat], verts[n2_lat], quadToTri_edges);
+ createEdge(verts[n1_lat], verts[n2_lat], edges_new);
}
}
- if( valid_division )
- break;
+ if(valid_division) break;
- } // end of t-loop (outer loop)
+ } // end of t-loop (outer loop)
// take care of any adjustable but required diagonals not yet added
- for(unsigned int s = 0; s < face_types["adj_diag"].size(); s++ ){
+ for(unsigned int s = 0; s < face_types["adj_diag"].size(); s++) {
int ind = face_types["adj_diag"][s];
- if( ind != face_done[0] && ind != face_done[1] ){
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
+ if(ind != face_done[0] && ind != face_done[1]) {
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
}
}
// if no division top found, need internal vertex.
- if( !valid_division ){
- std::pair<unsigned int, unsigned int> jkpair(j,k);
+ if(!valid_division) {
+ std::pair<unsigned int, unsigned int> jkpair(j, k);
problems[elem].insert(jkpair);
problems_new[elem].insert(jkpair);
}
return;
-
}
-
-// Divide a hexahedron degenerate at one point (one degenerate corner) by brute force.
-static void addEdgesForQuadToTriOnePtDegenHexa( GRegion *gr, MElement *elem, ExtrudeParams *ep,
- int j, int k, std::vector<MVertex *> verts,
- std::map<std::string, std::vector<int> > &face_types,
- std::set<std::pair<MVertex*, MVertex*> > &edges_new,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_new,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::vector<int> nfix1, std::vector<int> nfix2,
- std::vector<int> nadj1, std::vector<int> nadj2,
- std::vector<int> free_flag )
+// Divide a hexahedron degenerate at one point (one degenerate corner) by brute
+// force.
+static void addEdgesForQuadToTriOnePtDegenHexa(
+ GRegion *gr, MElement *elem, ExtrudeParams *ep, int j, int k,
+ std::vector<MVertex *> verts,
+ std::map<std::string, std::vector<int> > &face_types,
+ std::set<std::pair<MVertex *, MVertex *> > &edges_new,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_new,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::vector<int> nfix1, std::vector<int> nfix2, std::vector<int> nadj1,
+ std::vector<int> nadj2, std::vector<int> free_flag)
{
-
- if( !ep )
- return;
+ if(!ep) return;
// numbers of each type of face
// int num_degen = face_types["degen"].size();
@@ -1203,16 +1235,18 @@ static void addEdgesForQuadToTriOnePtDegenHexa( GRegion *gr, MElement *elem, Ext
int num_free = face_types["free"].size();
// index of the degenerate corner
- int degen_ind = verts[face_types["single_tri"][0]]
- == verts[face_types["single_tri"][0]+4]
- ? face_types["single_tri"][0] : face_types["single_tri"][1];
+ int degen_ind = verts[face_types["single_tri"][0]] ==
+ verts[face_types["single_tri"][0] + 4] ?
+ face_types["single_tri"][0] :
+ face_types["single_tri"][1];
// If all faces are free, slice from degen corner top and bottom. done.
- if( num_free >= 4 ){
- createEdge( verts[degen_ind], verts[(degen_ind+2)%4], quadToTri_edges );
- createEdge( verts[degen_ind], verts[(degen_ind+2)%4], edges_new );
- createEdge( verts[degen_ind], verts[(degen_ind+2)%4+4], quadToTri_edges );
- createEdge( verts[degen_ind], verts[(degen_ind+2)%4+4], edges_new );
+ if(num_free >= 4) {
+ createEdge(verts[degen_ind], verts[(degen_ind + 2) % 4], quadToTri_edges);
+ createEdge(verts[degen_ind], verts[(degen_ind + 2) % 4], edges_new);
+ createEdge(verts[degen_ind], verts[(degen_ind + 2) % 4 + 4],
+ quadToTri_edges);
+ createEdge(verts[degen_ind], verts[(degen_ind + 2) % 4 + 4], edges_new);
return;
}
@@ -1220,318 +1254,341 @@ static void addEdgesForQuadToTriOnePtDegenHexa( GRegion *gr, MElement *elem, Ext
// look for a way to diagonalize and subdivide.
// t = 0, fixed and preferred adjustable diagonals
// t >= 1 < 3, lowest pointer on adjustables
- // t = 2, include free faces, lowest vertex pointer diagonal on adjustable and free
- // t = 3, not lowest vertex pointer diagonal on adjustable and free
+ // t = 2, include free faces, lowest vertex pointer diagonal on adjustable and
+ // free t = 3, not lowest vertex pointer diagonal on adjustable and free
int face_done[3];
face_done[0] = -1;
face_done[1] = -2;
face_done[2] = -3;
bool valid_division = false;
- for( int t = 0; t < 4; t++ ){
+ for(int t = 0; t < 4; t++) {
// first test for top bottom parallel diagonals (g=0), then pyramid with
- // top on corner opposite degen corner (g=1), then pyramid with top on a corner
- // NOT opposite to the degenerate corner (g=2), then test for non-adjoining
- // lateral face diagonals (g=3).
+ // top on corner opposite degen corner (g=1), then pyramid with top on a
+ // corner NOT opposite to the degenerate corner (g=2), then test for
+ // non-adjoining lateral face diagonals (g=3).
int p_top = 5, n1_top = -2, n2_top = -3;
bool p_top_is_free = false;
int p_bot = 4, n1_bot = -4, n2_bot = -5;
bool p_bot_is_free = false;
- int p_lat1 = (degen_ind+1)%4, n1_lat1 = -10, n2_lat1 = -11;
+ int p_lat1 = (degen_ind + 1) % 4, n1_lat1 = -10, n2_lat1 = -11;
bool p_lat1_is_free = false;
- int p_lat2 = (degen_ind+2)%4, n1_lat2 = -12, n2_lat2 = -13;
+ int p_lat2 = (degen_ind + 2) % 4, n1_lat2 = -12, n2_lat2 = -13;
bool p_lat2_is_free = false;
// get diagonals:
- for( int s = 0; s < 4; s++ ){
+ for(int s = 0; s < 4; s++) {
int *n1_tmp, *n2_tmp, p_tmp;
bool *p_tmp_is_free;
- if( !s ){
+ if(!s) {
p_tmp = p_top;
n1_tmp = &n1_top;
n2_tmp = &n2_top;
p_tmp_is_free = &p_top_is_free;
}
- else if( s==1 ){
+ else if(s == 1) {
p_tmp = p_bot;
n1_tmp = &n1_bot;
n2_tmp = &n2_bot;
p_tmp_is_free = &p_bot_is_free;
}
- else if( s==2 ){
+ else if(s == 2) {
p_tmp = p_lat1;
n1_tmp = &n1_lat1;
n2_tmp = &n2_lat1;
p_tmp_is_free = &p_lat1_is_free;
}
- else{
+ else {
p_tmp = p_lat2;
n1_tmp = &n1_lat2;
n2_tmp = &n2_lat2;
p_tmp_is_free = &p_lat2_is_free;
}
// fixed diagonals
- if( nfix1[p_tmp] >= 0 ){
- *n1_tmp = nfix1[p_tmp]; *n2_tmp = nfix2[p_tmp];
+ if(nfix1[p_tmp] >= 0) {
+ *n1_tmp = nfix1[p_tmp];
+ *n2_tmp = nfix2[p_tmp];
}
// preferred adjustable diagonals
- else if( !t && nadj1[p_tmp] >= 0 ){
- *n1_tmp = nadj1[p_tmp]; *n2_tmp = nadj2[p_tmp];
+ else if(!t && nadj1[p_tmp] >= 0) {
+ *n1_tmp = nadj1[p_tmp];
+ *n2_tmp = nadj2[p_tmp];
}
// choose lowest vertex for t < 3, any vertex for t == 3
- else if( (t >= 1 && t < 3 && nadj1[p_tmp] >= 0) ||
- (t == 2 && free_flag[p_tmp]) ){
- if( p_tmp < 4 ){
- if( (verts[p_tmp] < verts[(p_tmp+1)%4] &&
- verts[p_tmp] < verts[p_tmp+4]) ||
- (verts[(p_tmp+1)%4+4] < verts[(p_tmp+1)%4] &&
- verts[(p_tmp+1)%4+4] < verts[p_tmp+4]) ){
- *n1_tmp = p_tmp; *n2_tmp = (p_tmp+1)%4+4;
+ else if((t >= 1 && t < 3 && nadj1[p_tmp] >= 0) ||
+ (t == 2 && free_flag[p_tmp])) {
+ if(p_tmp < 4) {
+ if((verts[p_tmp] < verts[(p_tmp + 1) % 4] &&
+ verts[p_tmp] < verts[p_tmp + 4]) ||
+ (verts[(p_tmp + 1) % 4 + 4] < verts[(p_tmp + 1) % 4] &&
+ verts[(p_tmp + 1) % 4 + 4] < verts[p_tmp + 4])) {
+ *n1_tmp = p_tmp;
+ *n2_tmp = (p_tmp + 1) % 4 + 4;
}
- else{
- *n1_tmp = p_tmp+4; *n2_tmp = (p_tmp+1)%4;
+ else {
+ *n1_tmp = p_tmp + 4;
+ *n2_tmp = (p_tmp + 1) % 4;
}
}
- else{
- int add = p_tmp==4 ? 0 : 4;
- if( (verts[0+add] < verts[1+add] && verts[0+add] < verts[3+add]) ||
- (verts[2+add] < verts[1+add] && verts[2+add] < verts[3+add]) ){
- *n1_tmp = 0+add; *n2_tmp = 2+add;
+ else {
+ int add = p_tmp == 4 ? 0 : 4;
+ if((verts[0 + add] < verts[1 + add] &&
+ verts[0 + add] < verts[3 + add]) ||
+ (verts[2 + add] < verts[1 + add] &&
+ verts[2 + add] < verts[3 + add])) {
+ *n1_tmp = 0 + add;
+ *n2_tmp = 2 + add;
}
- else{
- *n1_tmp = 1+add; *n2_tmp = 3+add;
+ else {
+ *n1_tmp = 1 + add;
+ *n2_tmp = 3 + add;
}
}
}
- else if( t==3 && (nadj1[p_tmp] >= 0 || free_flag[p_tmp]) )
+ else if(t == 3 && (nadj1[p_tmp] >= 0 || free_flag[p_tmp]))
*p_tmp_is_free = true;
}
// Look for valid diagonalizations
// look for aligned top and bottom diags.
- if( !valid_division ){
+ if(!valid_division) {
// assign diagonals to the 'free' faces from above
- if( p_top_is_free && p_bot_is_free ){
- if( (verts[0] < verts[1] && verts[0] < verts[3]) ||
- (verts[2] < verts[1] && verts[2] < verts[3]) ){
- n1_bot = 0; n2_bot = 2;
+ if(p_top_is_free && p_bot_is_free) {
+ if((verts[0] < verts[1] && verts[0] < verts[3]) ||
+ (verts[2] < verts[1] && verts[2] < verts[3])) {
+ n1_bot = 0;
+ n2_bot = 2;
}
- else{
- n1_bot = 1; n2_bot = 3;
+ else {
+ n1_bot = 1;
+ n2_bot = 3;
}
- n1_top = n1_bot+4;
- n2_top = n2_bot+4;
+ n1_top = n1_bot + 4;
+ n2_top = n2_bot + 4;
}
- else if( p_top_is_free && n1_bot >= 0 ){
- n1_top = n1_bot+4; n2_top = n2_bot+4;
+ else if(p_top_is_free && n1_bot >= 0) {
+ n1_top = n1_bot + 4;
+ n2_top = n2_bot + 4;
}
- else if( p_bot_is_free && n1_top >= 0 ){
- n1_bot = n1_top-4; n2_bot = n2_top-4;
+ else if(p_bot_is_free && n1_top >= 0) {
+ n1_bot = n1_top - 4;
+ n2_bot = n2_top - 4;
}
// test for valid division
- if( n1_top-4 == n1_bot || n2_top-4 == n1_bot ||
- n1_top-4 == n2_bot || n2_top-4 == n2_bot ){
+ if(n1_top - 4 == n1_bot || n2_top - 4 == n1_bot || n1_top - 4 == n2_bot ||
+ n2_top - 4 == n2_bot) {
valid_division = true;
- face_done[0] = 4; face_done[1] = 5;
- createEdge( verts[n1_top], verts[n2_top], quadToTri_edges );
- createEdge( verts[n1_top], verts[n2_top], edges_new );
- createEdge( verts[n1_bot], verts[n2_bot], quadToTri_edges );
- createEdge( verts[n1_bot], verts[n2_bot], edges_new );
+ face_done[0] = 4;
+ face_done[1] = 5;
+ createEdge(verts[n1_top], verts[n2_top], quadToTri_edges);
+ createEdge(verts[n1_top], verts[n2_top], edges_new);
+ createEdge(verts[n1_bot], verts[n2_bot], quadToTri_edges);
+ createEdge(verts[n1_bot], verts[n2_bot], edges_new);
}
}
// pyramid with top opposite degenerate corner
- if( !valid_division ){
- if( ( n1_top == (degen_ind+2)%4+4 || n2_top == (degen_ind+2)%4+4 ||
- p_top_is_free ) &&
- ( n2_lat1 == (degen_ind+2)%4+4 || p_lat1_is_free ) &&
- ( n1_lat2 == (degen_ind+2)%4+4 || p_lat2_is_free ) ){
+ if(!valid_division) {
+ if((n1_top == (degen_ind + 2) % 4 + 4 ||
+ n2_top == (degen_ind + 2) % 4 + 4 || p_top_is_free) &&
+ (n2_lat1 == (degen_ind + 2) % 4 + 4 || p_lat1_is_free) &&
+ (n1_lat2 == (degen_ind + 2) % 4 + 4 || p_lat2_is_free)) {
valid_division = true;
- if( p_top_is_free ){
- n1_top = degen_ind+4; n2_top = (degen_ind+2)%4+4;
+ if(p_top_is_free) {
+ n1_top = degen_ind + 4;
+ n2_top = (degen_ind + 2) % 4 + 4;
}
- if( p_lat1_is_free ){
- n1_lat1 = (degen_ind+1)%4; n2_lat1 = (degen_ind+2)%4+4;
+ if(p_lat1_is_free) {
+ n1_lat1 = (degen_ind + 1) % 4;
+ n2_lat1 = (degen_ind + 2) % 4 + 4;
}
- if( p_lat2_is_free ){
- n1_lat2 = (degen_ind+2)%4+4; n2_lat2 = (degen_ind+3)%4;
+ if(p_lat2_is_free) {
+ n1_lat2 = (degen_ind + 2) % 4 + 4;
+ n2_lat2 = (degen_ind + 3) % 4;
}
face_done[0] = 5;
- face_done[1] = (degen_ind+1)%4;
- face_done[2] = (degen_ind+2)%4;
- createEdge( verts[n1_top], verts[n2_top], quadToTri_edges );
- createEdge( verts[n1_top], verts[n2_top], edges_new );
- }
- else if( ( n1_bot == (degen_ind+2)%4 || n2_bot == (degen_ind+2)%4 ||
- p_bot_is_free ) &&
- ( n2_lat1 == (degen_ind+2)%4 || p_lat1_is_free ) &&
- ( n1_lat2 == (degen_ind+2)%4 || p_lat2_is_free ) ){
+ face_done[1] = (degen_ind + 1) % 4;
+ face_done[2] = (degen_ind + 2) % 4;
+ createEdge(verts[n1_top], verts[n2_top], quadToTri_edges);
+ createEdge(verts[n1_top], verts[n2_top], edges_new);
+ }
+ else if((n1_bot == (degen_ind + 2) % 4 || n2_bot == (degen_ind + 2) % 4 ||
+ p_bot_is_free) &&
+ (n2_lat1 == (degen_ind + 2) % 4 || p_lat1_is_free) &&
+ (n1_lat2 == (degen_ind + 2) % 4 || p_lat2_is_free)) {
valid_division = true;
- if( p_bot_is_free ){
- n1_bot = degen_ind; n2_bot = (degen_ind+2)%4;
+ if(p_bot_is_free) {
+ n1_bot = degen_ind;
+ n2_bot = (degen_ind + 2) % 4;
}
- if( p_lat1_is_free ){
- n1_lat1 = (degen_ind+1)%4+4; n2_lat1 = (degen_ind+2)%4;
+ if(p_lat1_is_free) {
+ n1_lat1 = (degen_ind + 1) % 4 + 4;
+ n2_lat1 = (degen_ind + 2) % 4;
}
- if( p_lat2_is_free ){
- n1_lat2 = (degen_ind+2)%4; n2_lat2 = (degen_ind+3)%4+4;
+ if(p_lat2_is_free) {
+ n1_lat2 = (degen_ind + 2) % 4;
+ n2_lat2 = (degen_ind + 3) % 4 + 4;
}
face_done[0] = 4;
- face_done[1] = (degen_ind+1)%4;
- face_done[2] = (degen_ind+2)%4;
- createEdge( verts[n1_bot], verts[n2_bot], quadToTri_edges );
- createEdge( verts[n1_bot], verts[n2_bot], edges_new );
-
+ face_done[1] = (degen_ind + 1) % 4;
+ face_done[2] = (degen_ind + 2) % 4;
+ createEdge(verts[n1_bot], verts[n2_bot], quadToTri_edges);
+ createEdge(verts[n1_bot], verts[n2_bot], edges_new);
}
- if( valid_division ){
- createEdge( verts[n1_lat1], verts[n2_lat1], quadToTri_edges );
- createEdge( verts[n1_lat1], verts[n2_lat1], edges_new );
- createEdge( verts[n1_lat2], verts[n2_lat2], quadToTri_edges );
- createEdge( verts[n1_lat2], verts[n2_lat2], edges_new );
+ if(valid_division) {
+ createEdge(verts[n1_lat1], verts[n2_lat1], quadToTri_edges);
+ createEdge(verts[n1_lat1], verts[n2_lat1], edges_new);
+ createEdge(verts[n1_lat2], verts[n2_lat2], quadToTri_edges);
+ createEdge(verts[n1_lat2], verts[n2_lat2], edges_new);
}
}
// Pyramid top on corner NOT opposite to degenerate corner
- if( !valid_division ){
+ if(!valid_division) {
// pyramid top on top face
- if( (n1_top >= 0 && n1_top != (degen_ind+2)%4+4 && n2_top != (degen_ind+2)%4+4) ||
- p_top_is_free ){
- if( n1_lat1 == (degen_ind+1)%4+4 || p_lat1_is_free ){
+ if((n1_top >= 0 && n1_top != (degen_ind + 2) % 4 + 4 &&
+ n2_top != (degen_ind + 2) % 4 + 4) ||
+ p_top_is_free) {
+ if(n1_lat1 == (degen_ind + 1) % 4 + 4 || p_lat1_is_free) {
valid_division = true;
- face_done[0] = (degen_ind+1)%4;
- if( p_lat1_is_free ){
- n1_lat1 = (degen_ind+1)%4+4; n2_lat1 = (degen_ind+2)%4;
+ face_done[0] = (degen_ind + 1) % 4;
+ if(p_lat1_is_free) {
+ n1_lat1 = (degen_ind + 1) % 4 + 4;
+ n2_lat1 = (degen_ind + 2) % 4;
}
- createEdge( verts[n1_lat1], verts[n2_lat1], quadToTri_edges );
- createEdge( verts[n1_lat1], verts[n2_lat1], edges_new );
+ createEdge(verts[n1_lat1], verts[n2_lat1], quadToTri_edges);
+ createEdge(verts[n1_lat1], verts[n2_lat1], edges_new);
}
- else if( n2_lat2 == (degen_ind+3)%4+4 || p_lat2_is_free ){
+ else if(n2_lat2 == (degen_ind + 3) % 4 + 4 || p_lat2_is_free) {
valid_division = true;
- face_done[0] = (degen_ind+2)%4;
- if( p_lat2_is_free ){
- n1_lat2 = (degen_ind+2)%4; n2_lat2 = (degen_ind+3)%4+4;
+ face_done[0] = (degen_ind + 2) % 4;
+ if(p_lat2_is_free) {
+ n1_lat2 = (degen_ind + 2) % 4;
+ n2_lat2 = (degen_ind + 3) % 4 + 4;
}
- createEdge( verts[n1_lat2], verts[n2_lat2], quadToTri_edges );
- createEdge( verts[n1_lat2], verts[n2_lat2], edges_new );
+ createEdge(verts[n1_lat2], verts[n2_lat2], quadToTri_edges);
+ createEdge(verts[n1_lat2], verts[n2_lat2], edges_new);
}
- if( valid_division ){
+ if(valid_division) {
face_done[1] = 5;
- if( p_top_is_free ){
- n1_top = (degen_ind+1)%4+4; n2_top = (degen_ind+3)%4+4;
+ if(p_top_is_free) {
+ n1_top = (degen_ind + 1) % 4 + 4;
+ n2_top = (degen_ind + 3) % 4 + 4;
}
- createEdge( verts[n1_top], verts[n2_top], quadToTri_edges );
- createEdge( verts[n1_top], verts[n2_top], edges_new );
+ createEdge(verts[n1_top], verts[n2_top], quadToTri_edges);
+ createEdge(verts[n1_top], verts[n2_top], edges_new);
}
}
// pyramid top on bottom face
- if( (!valid_division && n1_bot >= 0 &&
- n1_bot != (degen_ind+2)%4 && n2_bot != (degen_ind+2)%4) ||
- p_bot_is_free ){
- if( n1_lat1 == (degen_ind+1)%4 || p_lat1_is_free ){
+ if((!valid_division && n1_bot >= 0 && n1_bot != (degen_ind + 2) % 4 &&
+ n2_bot != (degen_ind + 2) % 4) ||
+ p_bot_is_free) {
+ if(n1_lat1 == (degen_ind + 1) % 4 || p_lat1_is_free) {
valid_division = true;
- face_done[0] = (degen_ind+1)%4;
- if( p_lat1_is_free ){
- n1_lat1 = (degen_ind+1)%4; n2_lat1 = (degen_ind+2)%4+4;
+ face_done[0] = (degen_ind + 1) % 4;
+ if(p_lat1_is_free) {
+ n1_lat1 = (degen_ind + 1) % 4;
+ n2_lat1 = (degen_ind + 2) % 4 + 4;
}
- createEdge( verts[n1_lat1], verts[n2_lat1], quadToTri_edges );
- createEdge( verts[n1_lat1], verts[n2_lat1], edges_new );
+ createEdge(verts[n1_lat1], verts[n2_lat1], quadToTri_edges);
+ createEdge(verts[n1_lat1], verts[n2_lat1], edges_new);
}
- else if( n2_lat2 == (degen_ind+3)%4 || p_lat2_is_free ){
+ else if(n2_lat2 == (degen_ind + 3) % 4 || p_lat2_is_free) {
valid_division = true;
- face_done[0] = (degen_ind+2)%4;
- if( p_lat2_is_free ){
- n1_lat2 = (degen_ind+2)%4+4; n2_lat2 = (degen_ind+3)%4;
+ face_done[0] = (degen_ind + 2) % 4;
+ if(p_lat2_is_free) {
+ n1_lat2 = (degen_ind + 2) % 4 + 4;
+ n2_lat2 = (degen_ind + 3) % 4;
}
- createEdge( verts[n1_lat2], verts[n2_lat2], quadToTri_edges );
- createEdge( verts[n1_lat2], verts[n2_lat2], edges_new );
+ createEdge(verts[n1_lat2], verts[n2_lat2], quadToTri_edges);
+ createEdge(verts[n1_lat2], verts[n2_lat2], edges_new);
}
- if( valid_division ){
+ if(valid_division) {
face_done[1] = 4;
- if( p_bot_is_free ){
- n1_bot = (degen_ind+1)%4; n2_bot = (degen_ind+3)%4;
+ if(p_bot_is_free) {
+ n1_bot = (degen_ind + 1) % 4;
+ n2_bot = (degen_ind + 3) % 4;
}
- createEdge( verts[n1_bot], verts[n2_bot], quadToTri_edges );
- createEdge( verts[n1_bot], verts[n2_bot], edges_new );
+ createEdge(verts[n1_bot], verts[n2_bot], quadToTri_edges);
+ createEdge(verts[n1_bot], verts[n2_bot], edges_new);
}
}
}
// see if the lateral diagonals have non-adjoining diagonals
- if( !valid_division ){
- if( ( n1_lat1 == (degen_ind+1)%4 || p_lat1_is_free ) &&
- ( n1_lat2 == (degen_ind+2)%4 || p_lat2_is_free ) ){
+ if(!valid_division) {
+ if((n1_lat1 == (degen_ind + 1) % 4 || p_lat1_is_free) &&
+ (n1_lat2 == (degen_ind + 2) % 4 || p_lat2_is_free)) {
valid_division = true;
- n1_lat1 = (degen_ind+1)%4;
- n2_lat1 = (degen_ind+2)%4+4;
- n1_lat2 = (degen_ind+2)%4;
- n2_lat2 = (degen_ind+3)%4+4;
+ n1_lat1 = (degen_ind + 1) % 4;
+ n2_lat1 = (degen_ind + 2) % 4 + 4;
+ n1_lat2 = (degen_ind + 2) % 4;
+ n2_lat2 = (degen_ind + 3) % 4 + 4;
}
- else if( ( n1_lat1 == (degen_ind+1)%4+4 || p_lat1_is_free ) &&
- ( n1_lat2 == (degen_ind+2)%4+4 || p_lat2_is_free ) ){
+ else if((n1_lat1 == (degen_ind + 1) % 4 + 4 || p_lat1_is_free) &&
+ (n1_lat2 == (degen_ind + 2) % 4 + 4 || p_lat2_is_free)) {
valid_division = true;
- n1_lat1 = (degen_ind+1)%4+4;
- n2_lat1 = (degen_ind+2)%4;
- n1_lat2 = (degen_ind+2)%4+4;
- n2_lat2 = (degen_ind+3)%4;
+ n1_lat1 = (degen_ind + 1) % 4 + 4;
+ n2_lat1 = (degen_ind + 2) % 4;
+ n1_lat2 = (degen_ind + 2) % 4 + 4;
+ n2_lat2 = (degen_ind + 3) % 4;
}
- if( valid_division ){
- face_done[0] = (degen_ind+1)%4;
- face_done[1] = (degen_ind+2)%4;
- createEdge( verts[n1_lat1], verts[n2_lat1], quadToTri_edges );
- createEdge( verts[n1_lat1], verts[n2_lat1], edges_new );
- createEdge( verts[n1_lat2], verts[n2_lat2], quadToTri_edges );
- createEdge( verts[n1_lat2], verts[n2_lat2], edges_new );
+ if(valid_division) {
+ face_done[0] = (degen_ind + 1) % 4;
+ face_done[1] = (degen_ind + 2) % 4;
+ createEdge(verts[n1_lat1], verts[n2_lat1], quadToTri_edges);
+ createEdge(verts[n1_lat1], verts[n2_lat1], edges_new);
+ createEdge(verts[n1_lat2], verts[n2_lat2], quadToTri_edges);
+ createEdge(verts[n1_lat2], verts[n2_lat2], edges_new);
}
}
- if( valid_division )
- break;
+ if(valid_division) break;
}
-
- // if no subdivisiion, still take care of any adjustable but required diagonals not yet added
- for(unsigned int s = 0; s < face_types["adj_diag"].size(); s++ ){
+ // if no subdivisiion, still take care of any adjustable but required
+ // diagonals not yet added
+ for(unsigned int s = 0; s < face_types["adj_diag"].size(); s++) {
int ind = face_types["adj_diag"][s];
- if( ind != face_done[0] && ind != face_done[1] && ind != face_done[2] ){
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
+ if(ind != face_done[0] && ind != face_done[1] && ind != face_done[2]) {
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
}
}
// if no division top found, need internal vertex.
- if( !valid_division ){
- std::pair<unsigned int, unsigned int> jkpair(j,k);
+ if(!valid_division) {
+ std::pair<unsigned int, unsigned int> jkpair(j, k);
problems[elem].insert(jkpair);
problems_new[elem].insert(jkpair);
}
-
}
-
// Divide a fully non-degenerate hexahedron by brute force.
-static void addEdgesForQuadToTriFullHexa(GRegion *gr, MElement *elem, ExtrudeParams *ep,
- int j, int k, std::vector<MVertex *> verts,
- std::map<std::string, std::vector<int> > &face_types,
- std::set<std::pair<MVertex*, MVertex*> > &edges_new,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_new,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::vector<int> nfix1, std::vector<int> nfix2,
- std::vector<int> nadj1, std::vector<int> nadj2,
- std::vector<int> free_flag)
+static void addEdgesForQuadToTriFullHexa(
+ GRegion *gr, MElement *elem, ExtrudeParams *ep, int j, int k,
+ std::vector<MVertex *> verts,
+ std::map<std::string, std::vector<int> > &face_types,
+ std::set<std::pair<MVertex *, MVertex *> > &edges_new,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_new,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::vector<int> nfix1, std::vector<int> nfix2, std::vector<int> nadj1,
+ std::vector<int> nadj2, std::vector<int> free_flag)
{
-
// There are 4 main possibilities for minimum diags to guarantee slice:
// 1. Three diagonals at a corner
// 2. One PAIR of opposite diagonals, ABSOLUTELY ALL OTHER FACES FORBIDDEN
// 2. Two PAIRS of opposite diags
- // 3. One PAIR of opposite diags PLUS a vertex with two ADDITIONAL diags meeting on it.
+ // 3. One PAIR of opposite diags PLUS a vertex with two ADDITIONAL diags
+ // meeting on it.
- if( !ep )
- return;
+ if(!ep) return;
// numbers of each type of face
// int num_degen = face_types["degen"].size();
@@ -1541,46 +1598,49 @@ static void addEdgesForQuadToTriFullHexa(GRegion *gr, MElement *elem, ExtrudePar
int num_adj_diag = face_types["adj_diag"].size();
int num_free = face_types["free"].size();
- // If all faces are free, then diagonalize the three faces adjacent to vertex with
+ // If all faces are free, then diagonalize the three faces adjacent to vertex
+ // with
// smallest vertex pointer
- if( num_free >= 6 ){
+ if(num_free >= 6) {
int ind_low = getIndexForLowestVertexPointer(verts);
int add = ind_low < 4 ? 0 : 4;
- createEdge( verts[ind_low], verts[(ind_low-add+2)%4+add], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+2)%4+add], edges_new );
- createEdge( verts[ind_low], verts[(ind_low-add+1)%4+4-add], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+1)%4+4-add], edges_new );
- createEdge( verts[ind_low], verts[(ind_low-add+3)%4+4-add], quadToTri_edges );
- createEdge( verts[ind_low], verts[(ind_low-add+3)%4+4-add], edges_new );
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 4 + add],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 2) % 4 + add], edges_new);
+ createEdge(verts[ind_low], verts[(ind_low - add + 1) % 4 + 4 - add],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 1) % 4 + 4 - add],
+ edges_new);
+ createEdge(verts[ind_low], verts[(ind_low - add + 3) % 4 + 4 - add],
+ quadToTri_edges);
+ createEdge(verts[ind_low], verts[(ind_low - add + 3) % 4 + 4 - add],
+ edges_new);
return;
}
-
- // Start the loop to progressively become more permissive in what diagonals to allow for
- // subdivision.
- // On t-loop, select types of diagonals to look for.
- // t = 0, fixed and preferred adjustables.
- // t = 1, include non-preferred adjustables with lowest vertex.
- // t = 2, include free face diagonal, lowest vertex.
- // t = 3, on adjustable or free faces, take any diagonal that works.
+ // Start the loop to progressively become more permissive in what diagonals to
+ // allow for subdivision. On t-loop, select types of diagonals to look for. t
+ // = 0, fixed and preferred adjustables. t = 1, include non-preferred
+ // adjustables with lowest vertex. t = 2, include free face diagonal, lowest
+ // vertex. t = 3, on adjustable or free faces, take any diagonal that works.
// this variable records the faces selected for diagonalization
int face_done[4];
- for(int p = 0; p < 4; p++ )
- face_done[p] = -1-p;
-
- // if find just two diagonals that could slice a prism with no other diags, remember ('hold') those diagonals until
- // end of loop in the following 'hold' variables.
- // Might have to resort to forbidding free surfaces and cutting two prisms only.
- // don't really want to forbid surfaces, though...that's why two prisms are not immediately
- // cut when found.
- int p1_hold = -1, p2_hold = -2; // if found two opposite diags that could work alone
- int n1_hold[2]={0,0}, n2_hold[2]={0,0}; // hold diag nodes for p1_hold, p2_hold.
+ for(int p = 0; p < 4; p++) face_done[p] = -1 - p;
+
+ // if find just two diagonals that could slice a prism with no other diags,
+ // remember ('hold') those diagonals until end of loop in the following 'hold'
+ // variables. Might have to resort to forbidding free surfaces and cutting two
+ // prisms only. don't really want to forbid surfaces, though...that's why two
+ // prisms are not immediately cut when found.
+ int p1_hold = -1,
+ p2_hold = -2; // if found two opposite diags that could work alone
+ int n1_hold[2] = {0, 0},
+ n2_hold[2] = {0, 0}; // hold diag nodes for p1_hold, p2_hold.
bool valid_division = false;
- for( int t = 0; t < 4; t++ ){
-
+ for(int t = 0; t < 4; t++) {
// variables that hold the face diagonal nodes.
int n1[6], n2[6];
@@ -1589,165 +1649,177 @@ static void addEdgesForQuadToTriFullHexa(GRegion *gr, MElement *elem, ExtrudePar
// set default values of the n variables
// to unique negative numbers; bool to false.
- for( int p = 0; p < 6; p++ ){
- n1[p] = -p*p-p-1;
- n2[p] = -p*p-p-2;
+ for(int p = 0; p < 6; p++) {
+ n1[p] = -p * p - p - 1;
+ n2[p] = -p * p - p - 2;
face_is_free[p] = false;
}
- for( int p = 0; p < 6; p++ ){
+ for(int p = 0; p < 6; p++) {
// fixed diagonals
- if( nfix1[p] >= 0 ){
- n1[p] = nfix1[p]; n2[p] = nfix2[p];
+ if(nfix1[p] >= 0) {
+ n1[p] = nfix1[p];
+ n2[p] = nfix2[p];
}
// preferred adjustable diagonals
- else if( !t && nadj1[p] >= 0 ){
- n1[p] = nadj1[p]; n2[p] = nadj2[p];
+ else if(!t && nadj1[p] >= 0) {
+ n1[p] = nadj1[p];
+ n2[p] = nadj2[p];
}
// choose lowest vertex for t < 3, any vertex for t == 3
- else if( (t >= 1 && t < 3 && nadj1[p] >= 0) ||
- (t == 2 && free_flag[p]) ){
- if( p < 4 ){
- if( (verts[p] < verts[(p+1)%4] &&
- verts[p] < verts[p+4]) ||
- (verts[(p+1)%4+4] < verts[(p+1)%4] &&
- verts[(p+1)%4+4] < verts[p+4]) ){
- n1[p] = p; n2[p] = (p+1)%4+4;
+ else if((t >= 1 && t < 3 && nadj1[p] >= 0) || (t == 2 && free_flag[p])) {
+ if(p < 4) {
+ if((verts[p] < verts[(p + 1) % 4] && verts[p] < verts[p + 4]) ||
+ (verts[(p + 1) % 4 + 4] < verts[(p + 1) % 4] &&
+ verts[(p + 1) % 4 + 4] < verts[p + 4])) {
+ n1[p] = p;
+ n2[p] = (p + 1) % 4 + 4;
}
- else{
- n1[p] = p+4; n2[p] = (p+1)%4;
+ else {
+ n1[p] = p + 4;
+ n2[p] = (p + 1) % 4;
}
}
- else{
- int add = p==4 ? 0 : 4;
- if( (verts[0+add] < verts[1+add] && verts[0+add] < verts[3+add]) ||
- (verts[2+add] < verts[1+add] && verts[2+add] < verts[3+add]) ){
- n1[p] = 0+add; n2[p] = 2+add;
+ else {
+ int add = p == 4 ? 0 : 4;
+ if((verts[0 + add] < verts[1 + add] &&
+ verts[0 + add] < verts[3 + add]) ||
+ (verts[2 + add] < verts[1 + add] &&
+ verts[2 + add] < verts[3 + add])) {
+ n1[p] = 0 + add;
+ n2[p] = 2 + add;
}
- else{
- n1[p] = 1+add; n2[p] = 3+add;
+ else {
+ n1[p] = 1 + add;
+ n2[p] = 3 + add;
}
}
}
- else if( t==3 && (nadj1[p] >= 0 || free_flag[p]) )
+ else if(t == 3 && (nadj1[p] >= 0 || free_flag[p]))
face_is_free[p] = true;
}
// Now perform the tests to find the valid subdivision
- // first, do the test to find opposite aligned diagonals for "prism slice through"
- // Not verified, but I believe this gives better quality elements than 3-diag corners
- if( !valid_division ){
- for( int p = 0; p < 3; p++ ){
+ // first, do the test to find opposite aligned diagonals for "prism slice
+ // through" Not verified, but I believe this gives better quality elements
+ // than 3-diag corners
+ if(!valid_division) {
+ for(int p = 0; p < 3; p++) {
int p1 = -1, p2 = -2;
// prism slicing faces
- if( p > 1){
- p1 = 4; p2 = 5;
+ if(p > 1) {
+ p1 = 4;
+ p2 = 5;
}
- else{
- p1 = p; p2 = (p+2)%4;
+ else {
+ p1 = p;
+ p2 = (p + 2) % 4;
}
- // if these two faces do not work for opposite aligned diagonals, continue
- if( (n1[p1] < 0 && !face_is_free[p1]) ||
- (n1[p2] < 0 && !face_is_free[p2]) )
+ // if these two faces do not work for opposite aligned diagonals,
+ // continue
+ if((n1[p1] < 0 && !face_is_free[p1]) ||
+ (n1[p2] < 0 && !face_is_free[p2]))
continue;
- if( n1[p1] >= 0 && n1[p2] >= 0 ){
- if( p1 < 4 ){
- if( ( ( n1[p1] == p1 || n2[p1] == p1 ) &&
- n1[p2] != p2+4 && n2[p2] != p2+4 ) ||
- ( ( n1[p1] == p1+4 || n2[p1] == p1+4 ) &&
- n1[p2] != p2 && n2[p2] != p2 ) )
+ if(n1[p1] >= 0 && n1[p2] >= 0) {
+ if(p1 < 4) {
+ if(((n1[p1] == p1 || n2[p1] == p1) && n1[p2] != p2 + 4 &&
+ n2[p2] != p2 + 4) ||
+ ((n1[p1] == p1 + 4 || n2[p1] == p1 + 4) && n1[p2] != p2 &&
+ n2[p2] != p2))
continue;
}
- else{
- int add = p1==4 ? 4 : -4;
- if( n1[p1]+add != n1[p2] && n2[p1]+add != n1[p2] )
- continue;
+ else {
+ int add = p1 == 4 ? 4 : -4;
+ if(n1[p1] + add != n1[p2] && n2[p1] + add != n1[p2]) continue;
}
}
// if TWO faces are free, set one to the lowest pointer
- if( face_is_free[p1] && face_is_free[p2] ){
+ if(face_is_free[p1] && face_is_free[p2]) {
face_is_free[p1] = false;
- if( p1 < 4 ){
- if( (verts[p1] < verts[p1+4] && verts[p1] < verts[(p1+1)%4]) ||
- (verts[(p1+1)%4+4] < verts[p1+4] &&
- verts[(p1+1)%4+4] < verts[(p1+1)%4]) ){
+ if(p1 < 4) {
+ if((verts[p1] < verts[p1 + 4] && verts[p1] < verts[(p1 + 1) % 4]) ||
+ (verts[(p1 + 1) % 4 + 4] < verts[p1 + 4] &&
+ verts[(p1 + 1) % 4 + 4] < verts[(p1 + 1) % 4])) {
n1[p1] = p1;
- n2[p1] = (p1+1)%4+4;
+ n2[p1] = (p1 + 1) % 4 + 4;
}
- else{
- n1[p1] = (p1+4);
- n2[p1] = (p1+1)%4;
+ else {
+ n1[p1] = (p1 + 4);
+ n2[p1] = (p1 + 1) % 4;
}
}
- else{
- int add = p1==4 ? 0 : 4;
- if( (verts[0+add] < verts[1+add] && verts[0+add] < verts[3+add]) ||
- (verts[2+add] < verts[1+add] && verts[2+add] < verts[3+add]) ){
- n1[p1] = 0+add;
- n2[p1] = 2+add;
+ else {
+ int add = p1 == 4 ? 0 : 4;
+ if((verts[0 + add] < verts[1 + add] &&
+ verts[0 + add] < verts[3 + add]) ||
+ (verts[2 + add] < verts[1 + add] &&
+ verts[2 + add] < verts[3 + add])) {
+ n1[p1] = 0 + add;
+ n2[p1] = 2 + add;
}
- else{
- n1[p1] = 1+add;
- n2[p1] = 3+add;
+ else {
+ n1[p1] = 1 + add;
+ n2[p1] = 3 + add;
}
}
}
- // if one and ONLY one face is free, go ahead and set it to match the other now.
- if( n1[p1] >= 0 && face_is_free[p2] ){
- if( p1 < 4 ){
- if( n1[p1] == p1 || n2[p1] == p1 ){
- n1[p2] = p2+4;
- n2[p2] = (p2+1)%4;
+ // if one and ONLY one face is free, go ahead and set it to match the
+ // other now.
+ if(n1[p1] >= 0 && face_is_free[p2]) {
+ if(p1 < 4) {
+ if(n1[p1] == p1 || n2[p1] == p1) {
+ n1[p2] = p2 + 4;
+ n2[p2] = (p2 + 1) % 4;
}
- else{
+ else {
n1[p2] = p2;
- n2[p2] = (p2+1)%4+4;
+ n2[p2] = (p2 + 1) % 4 + 4;
}
}
- else{
- int add = p1==4 ? 4 : -4;
- n1[p2] = n1[p1]+add;
- n2[p2] = n2[p1]+add;
+ else {
+ int add = p1 == 4 ? 4 : -4;
+ n1[p2] = n1[p1] + add;
+ n2[p2] = n2[p1] + add;
}
face_is_free[p2] = false;
}
- else if( n1[p2] >= 0 && face_is_free[p1] ){
- if( p1 < 4 ){
- if( n1[p2] == p2 || n2[p2] == p2 ){
- n1[p1] = p1+4;
- n2[p1] = (p1+1)%4;
+ else if(n1[p2] >= 0 && face_is_free[p1]) {
+ if(p1 < 4) {
+ if(n1[p2] == p2 || n2[p2] == p2) {
+ n1[p1] = p1 + 4;
+ n2[p1] = (p1 + 1) % 4;
}
- else{
+ else {
n1[p1] = p1;
- n2[p1] = (p1+1)%4+4;
+ n2[p1] = (p1 + 1) % 4 + 4;
}
}
- else{
- int add = p2==4 ? 4 : -4;
- n1[p1] = n1[p2]+add;
- n2[p1] = n2[p2]+add;
+ else {
+ int add = p2 == 4 ? 4 : -4;
+ n1[p1] = n1[p2] + add;
+ n2[p1] = n2[p2] + add;
}
face_is_free[p1] = false;
}
// In case the whole loop finishes and
- // cannot make further diagonalizations on any faces to make the prism slice work,
- // AND if there are no oter required diagonals other than among these two diagonals,
- // then it will be possible to come back to these two opposing diagonals to make a
- // simple two-prism slice. So, if there are no other diags, hold these two valid opposing
- // diagonals in case we want to come back to them later to just have two
- // opposing diagonals with the other faces forbidden.
- if( p1_hold < 0 || p2_hold < 0 ){
+ // cannot make further diagonalizations on any faces to make the prism
+ // slice work, AND if there are no oter required diagonals other than
+ // among these two diagonals, then it will be possible to come back to
+ // these two opposing diagonals to make a simple two-prism slice. So,
+ // if there are no other diags, hold these two valid opposing diagonals
+ // in case we want to come back to them later to just have two opposing
+ // diagonals with the other faces forbidden.
+ if(p1_hold < 0 || p2_hold < 0) {
int required_diag_count = 0;
- if( nfix1[p1] >= 0 || nadj1[p1] >= 0 )
- required_diag_count++;
- if( nfix1[p2] >= 0 || nadj1[p2] >= 0 )
- required_diag_count++;
- if( p1_hold < 0 && num_fixed_diag + num_adj_diag <= required_diag_count ){
+ if(nfix1[p1] >= 0 || nadj1[p1] >= 0) required_diag_count++;
+ if(nfix1[p2] >= 0 || nadj1[p2] >= 0) required_diag_count++;
+ if(p1_hold < 0 &&
+ num_fixed_diag + num_adj_diag <= required_diag_count) {
p1_hold = p1;
p2_hold = p2;
n1_hold[0] = n1[p1];
@@ -1761,34 +1833,34 @@ static void addEdgesForQuadToTriFullHexa(GRegion *gr, MElement *elem, ExtrudePar
// 1: if there is another set of opposing faces with aligned diagonals.
// 2: if two diagonals on one of the remaining 4 faces meet, valid.
-
// Test 1: Another set of opposite, aligned diagonals.
- for( int s = 0; s < 3; s++ ){
- if( s == p1 || (s>1 && (p1==4 || p1==5)) )
- continue;
+ for(int s = 0; s < 3; s++) {
+ if(s == p1 || (s > 1 && (p1 == 4 || p1 == 5))) continue;
int s1, s2;
- if( s > 1){
- s1 = 4; s2 = 5;
+ if(s > 1) {
+ s1 = 4;
+ s2 = 5;
}
- else{
- s1 = s; s2 = (s+2)%4;
+ else {
+ s1 = s;
+ s2 = (s + 2) % 4;
}
- // if these two faces do not work for opposite aligned diagonals, continue
- if( (n1[s1] < 0 && !face_is_free[s1]) ||
- (n1[s2] < 0 && !face_is_free[s2]) )
+ // if these two faces do not work for opposite aligned diagonals,
+ // continue
+ if((n1[s1] < 0 && !face_is_free[s1]) ||
+ (n1[s2] < 0 && !face_is_free[s2]))
continue;
- if( n1[s1] >= 0 && n1[s2] >= 0 ){
- if( s1 < 4 ){
- if( ( ( n1[s1] == s1 || n2[s1] == s1 ) &&
- n1[s2] != s2+4 && n2[s2] != s2+4 ) ||
- ( ( n1[s1] == s1+4 || n2[s1] == s1+4 ) &&
- n1[s2] != s2 && n2[s2] != s2 ) )
+ if(n1[s1] >= 0 && n1[s2] >= 0) {
+ if(s1 < 4) {
+ if(((n1[s1] == s1 || n2[s1] == s1) && n1[s2] != s2 + 4 &&
+ n2[s2] != s2 + 4) ||
+ ((n1[s1] == s1 + 4 || n2[s1] == s1 + 4) && n1[s2] != s2 &&
+ n2[s2] != s2))
continue;
}
- else{
- int add = s1==4 ? 4 : -4;
- if( n1[s1]+add != n1[s2] && n2[s1]+add != n1[s2] )
- continue;
+ else {
+ int add = s1 == 4 ? 4 : -4;
+ if(n1[s1] + add != n1[s2] && n2[s1] + add != n1[s2]) continue;
}
}
@@ -1799,105 +1871,109 @@ static void addEdgesForQuadToTriFullHexa(GRegion *gr, MElement *elem, ExtrudePar
face_done[3] = s2;
// if TWO faces are free, set one to the lowest pointer
- if( face_is_free[s1] && face_is_free[s2] ){
+ if(face_is_free[s1] && face_is_free[s2]) {
face_is_free[s1] = false;
- if( s1 < 4 ){
- if( (verts[s1] < verts[s1+4] && verts[s1] < verts[(s1+1)%4]) ||
- (verts[(s1+1)%4+4] < verts[s1+4] &&
- verts[(s1+1)%4+4] < verts[(s1+1)%4]) ){
+ if(s1 < 4) {
+ if((verts[s1] < verts[s1 + 4] &&
+ verts[s1] < verts[(s1 + 1) % 4]) ||
+ (verts[(s1 + 1) % 4 + 4] < verts[s1 + 4] &&
+ verts[(s1 + 1) % 4 + 4] < verts[(s1 + 1) % 4])) {
n1[s1] = s1;
- n2[s1] = (s1+1)%4+4;
+ n2[s1] = (s1 + 1) % 4 + 4;
}
- else{
- n1[s1] = (s1+4);
- n2[s1] = (s1+1)%4;
+ else {
+ n1[s1] = (s1 + 4);
+ n2[s1] = (s1 + 1) % 4;
}
}
- else{
- int add = s1==4 ? 0 : 4;
- if( (verts[0+add] < verts[1+add] && verts[0+add] < verts[3+add]) ||
- (verts[2+add] < verts[1+add] && verts[2+add] < verts[3+add]) ){
- n1[s1] = 0+add;
- n2[s1] = 2+add;
+ else {
+ int add = s1 == 4 ? 0 : 4;
+ if((verts[0 + add] < verts[1 + add] &&
+ verts[0 + add] < verts[3 + add]) ||
+ (verts[2 + add] < verts[1 + add] &&
+ verts[2 + add] < verts[3 + add])) {
+ n1[s1] = 0 + add;
+ n2[s1] = 2 + add;
}
- else{
- n1[s1] = 1+add;
- n2[s1] = 3+add;
+ else {
+ n1[s1] = 1 + add;
+ n2[s1] = 3 + add;
}
}
}
- // if ONLY one face is free, go ahead and set it to match the other now.
- if( n1[s1] >= 0 && face_is_free[s2] ){
- if( s1 < 4 ){
- if( n1[s1] == s1 || n2[s1] == s1 ){
- n1[s2] = s2+4;
- n2[s2] = (s2+1)%4;
+ // if ONLY one face is free, go ahead and set it to match the other
+ // now.
+ if(n1[s1] >= 0 && face_is_free[s2]) {
+ if(s1 < 4) {
+ if(n1[s1] == s1 || n2[s1] == s1) {
+ n1[s2] = s2 + 4;
+ n2[s2] = (s2 + 1) % 4;
}
- else{
+ else {
n1[s2] = s2;
- n2[s2] = (s2+1)%4+4;
+ n2[s2] = (s2 + 1) % 4 + 4;
}
}
- else{
- int add = s1==4 ? 4 : -4;
- n1[s2] = n1[s1]+add;
- n2[s2] = n2[s1]+add;
+ else {
+ int add = s1 == 4 ? 4 : -4;
+ n1[s2] = n1[s1] + add;
+ n2[s2] = n2[s1] + add;
}
face_is_free[s2] = false;
}
- else if( n1[s2] >= 0 && face_is_free[s1] ){
- if( s1 < 4 ){
- if( n1[s2] == s2 || n2[s2] == s2 ){
- n1[s1] = s1+4;
- n2[s1] = (s1+1)%4;
+ else if(n1[s2] >= 0 && face_is_free[s1]) {
+ if(s1 < 4) {
+ if(n1[s2] == s2 || n2[s2] == s2) {
+ n1[s1] = s1 + 4;
+ n2[s1] = (s1 + 1) % 4;
}
- else{
+ else {
n1[s1] = s1;
- n2[s1] = (s1+1)%4+4;
+ n2[s1] = (s1 + 1) % 4 + 4;
}
}
- else{
- int add = s2==4 ? 4 : -4;
- n1[s1] = n1[s2]+add;
- n2[s1] = n2[s2]+add;
+ else {
+ int add = s2 == 4 ? 4 : -4;
+ n1[s1] = n1[s2] + add;
+ n2[s1] = n2[s2] + add;
}
face_is_free[s1] = false;
}
- if( valid_division )
- break;
+ if(valid_division) break;
}
-
- // Test 2: any vertex has two diagonals meeting at it, NOT including the diagonals on
- // p1, p2;
- if( !valid_division ){
- for( int s = 0; s < 8; s++ ){ // looping over vertices now, be careful
- int add = s<4 ? 0 : 4;
+ // Test 2: any vertex has two diagonals meeting at it, NOT including the
+ // diagonals on p1, p2;
+ if(!valid_division) {
+ for(int s = 0; s < 8; s++) { // looping over vertices now, be careful
+ int add = s < 4 ? 0 : 4;
std::vector<int> faces;
- faces.assign(2,-1);
- int third_face = s<4 ? 4 : 5;
+ faces.assign(2, -1);
+ int third_face = s < 4 ? 4 : 5;
int count_diags = 0;
- if( s-add != p1 && s-add != p2 &&
- ( n1[(s-add)] == s || n2[(s-add)] == s || face_is_free[(s-add)] ) ){
- faces[count_diags] = s-add;
+ if(s - add != p1 && s - add != p2 &&
+ (n1[(s - add)] == s || n2[(s - add)] == s ||
+ face_is_free[(s - add)])) {
+ faces[count_diags] = s - add;
count_diags++;
}
- if( (s-add+3)%4 != p1 && (s-add+3)%4 != p2 &&
- ( n1[(s-add+3)%4] == s || n2[(s-add+3)%4] == s || face_is_free[(s-add+3)%4] ) ){
- faces[count_diags] = (s-add+3)%4;
+ if((s - add + 3) % 4 != p1 && (s - add + 3) % 4 != p2 &&
+ (n1[(s - add + 3) % 4] == s || n2[(s - add + 3) % 4] == s ||
+ face_is_free[(s - add + 3) % 4])) {
+ faces[count_diags] = (s - add + 3) % 4;
count_diags++;
}
- if( count_diags < 2 && third_face != p1 && third_face != p2 &&
- ( n1[third_face] == s || n2[third_face] == s || face_is_free[third_face] ) ){
+ if(count_diags < 2 && third_face != p1 && third_face != p2 &&
+ (n1[third_face] == s || n2[third_face] == s ||
+ face_is_free[third_face])) {
faces[count_diags] = third_face;
count_diags++;
}
// if valid subdivision NOT found
- if( count_diags < 2 )
- continue;
+ if(count_diags < 2) continue;
// if valid subdivision found
@@ -1908,133 +1984,148 @@ static void addEdgesForQuadToTriFullHexa(GRegion *gr, MElement *elem, ExtrudePar
face_done[2] = faces[0];
face_done[3] = faces[1];
- if( face_is_free[s-add] ){
- n1[s-add] = s;
- n2[s-add] = (s-add+1)%4+4-add;
+ if(face_is_free[s - add]) {
+ n1[s - add] = s;
+ n2[s - add] = (s - add + 1) % 4 + 4 - add;
}
- if( face_is_free[(s-add+3)%4] ){
- n1[(s-add+3)%4] = s;
- n2[(s-add+3)%4] = (s-add+3)%4+4-add;
+ if(face_is_free[(s - add + 3) % 4]) {
+ n1[(s - add + 3) % 4] = s;
+ n2[(s - add + 3) % 4] = (s - add + 3) % 4 + 4 - add;
}
- if( face_is_free[third_face] ){
+ if(face_is_free[third_face]) {
n1[third_face] = s;
- n2[third_face] = (s-add+2)%4+add;
+ n2[third_face] = (s - add + 2) % 4 + add;
}
- if( valid_division )
- break;
+ if(valid_division) break;
}
- } // end of test 2
-
- if( valid_division ){
- createEdge( verts[n1[face_done[0]]], verts[n2[face_done[0]]], quadToTri_edges );
- createEdge( verts[n1[face_done[0]]], verts[n2[face_done[0]]], edges_new );
- createEdge( verts[n1[face_done[1]]], verts[n2[face_done[1]]], quadToTri_edges );
- createEdge( verts[n1[face_done[1]]], verts[n2[face_done[1]]], edges_new );
- createEdge( verts[n1[face_done[2]]], verts[n2[face_done[2]]], quadToTri_edges );
- createEdge( verts[n1[face_done[2]]], verts[n2[face_done[2]]], edges_new );
- createEdge( verts[n1[face_done[3]]], verts[n2[face_done[3]]], quadToTri_edges );
- createEdge( verts[n1[face_done[3]]], verts[n2[face_done[3]]], edges_new );
+ } // end of test 2
+
+ if(valid_division) {
+ createEdge(verts[n1[face_done[0]]], verts[n2[face_done[0]]],
+ quadToTri_edges);
+ createEdge(verts[n1[face_done[0]]], verts[n2[face_done[0]]],
+ edges_new);
+ createEdge(verts[n1[face_done[1]]], verts[n2[face_done[1]]],
+ quadToTri_edges);
+ createEdge(verts[n1[face_done[1]]], verts[n2[face_done[1]]],
+ edges_new);
+ createEdge(verts[n1[face_done[2]]], verts[n2[face_done[2]]],
+ quadToTri_edges);
+ createEdge(verts[n1[face_done[2]]], verts[n2[face_done[2]]],
+ edges_new);
+ createEdge(verts[n1[face_done[3]]], verts[n2[face_done[3]]],
+ quadToTri_edges);
+ createEdge(verts[n1[face_done[3]]], verts[n2[face_done[3]]],
+ edges_new);
break;
}
- } // end of p loop over first set of opposite faces
+ } // end of p loop over first set of opposite faces
}
// Test for 3 diagonals on a corner.
- if( !valid_division ){
- for( int p = 0; p < 8; p++ ){ // looping over vertices now, be careful
- int add = p<4 ? 0 : 4;
- int third_face = p<4 ? 4 : 5;
- if( ( n1[(p-add)] == p || n2[(p-add)] == p || face_is_free[(p-add)] ) &&
- ( n1[(p-add+3)%4] == p || n2[(p-add+3)%4] == p || face_is_free[(p-add+3)%4] ) &&
- ( n1[third_face] == p || n2[third_face] == p || face_is_free[third_face] ) ){
+ if(!valid_division) {
+ for(int p = 0; p < 8; p++) { // looping over vertices now, be careful
+ int add = p < 4 ? 0 : 4;
+ int third_face = p < 4 ? 4 : 5;
+ if((n1[(p - add)] == p || n2[(p - add)] == p ||
+ face_is_free[(p - add)]) &&
+ (n1[(p - add + 3) % 4] == p || n2[(p - add + 3) % 4] == p ||
+ face_is_free[(p - add + 3) % 4]) &&
+ (n1[third_face] == p || n2[third_face] == p ||
+ face_is_free[third_face])) {
valid_division = true;
- if( face_is_free[p-add] ){
- n1[p-add] = p;
- n2[p-add] = (p-add+1)%4+4-add;
+ if(face_is_free[p - add]) {
+ n1[p - add] = p;
+ n2[p - add] = (p - add + 1) % 4 + 4 - add;
}
- if( face_is_free[(p-add+3)%4] ){
- n1[(p-add+3)%4] = p;
- n2[(p-add+3)%4] = (p-add+3)%4+4-add;
+ if(face_is_free[(p - add + 3) % 4]) {
+ n1[(p - add + 3) % 4] = p;
+ n2[(p - add + 3) % 4] = (p - add + 3) % 4 + 4 - add;
}
- if( face_is_free[third_face] ){
+ if(face_is_free[third_face]) {
n1[third_face] = p;
- n2[third_face] = (p-add+2)%4+add;
+ n2[third_face] = (p - add + 2) % 4 + add;
}
- face_done[0] = (p-add);
- face_done[1] = (p-add+3)%4;
+ face_done[0] = (p - add);
+ face_done[1] = (p - add + 3) % 4;
face_done[2] = third_face;
- createEdge( verts[n1[(p-add)]], verts[n2[(p-add)]], quadToTri_edges );
- createEdge( verts[n1[(p-add)]], verts[n2[(p-add)]], edges_new );
- createEdge( verts[n1[(p-add+3)%4]], verts[n2[(p-add+3)%4]], quadToTri_edges );
- createEdge( verts[n1[(p-add+3)%4]], verts[n2[(p-add+3)%4]], edges_new );
- createEdge( verts[n1[third_face]], verts[n2[third_face]], quadToTri_edges );
- createEdge( verts[n1[third_face]], verts[n2[third_face]], edges_new );
+ createEdge(verts[n1[(p - add)]], verts[n2[(p - add)]],
+ quadToTri_edges);
+ createEdge(verts[n1[(p - add)]], verts[n2[(p - add)]], edges_new);
+ createEdge(verts[n1[(p - add + 3) % 4]], verts[n2[(p - add + 3) % 4]],
+ quadToTri_edges);
+ createEdge(verts[n1[(p - add + 3) % 4]], verts[n2[(p - add + 3) % 4]],
+ edges_new);
+ createEdge(verts[n1[third_face]], verts[n2[third_face]],
+ quadToTri_edges);
+ createEdge(verts[n1[third_face]], verts[n2[third_face]], edges_new);
break;
}
}
}
- if( valid_division )
- break;
+ if(valid_division) break;
- } // end of t loop (outer loop)
+ } // end of t loop (outer loop)
// If no valid division yet but yet there were two opposite faces once
// ( if this won't work, should be the case that p1_hold < 0 here )
- if( !valid_division && p1_hold >= 0 ){
+ if(!valid_division && p1_hold >= 0) {
valid_division = true;
face_done[0] = p1_hold;
face_done[1] = p2_hold;
- createEdge( verts[n1_hold[0]], verts[n2_hold[0]], quadToTri_edges );
- createEdge( verts[n1_hold[0]], verts[n2_hold[0]], edges_new );
- createEdge( verts[n1_hold[1]], verts[n2_hold[1]], quadToTri_edges );
- createEdge( verts[n1_hold[1]], verts[n2_hold[1]], edges_new );
+ createEdge(verts[n1_hold[0]], verts[n2_hold[0]], quadToTri_edges);
+ createEdge(verts[n1_hold[0]], verts[n2_hold[0]], edges_new);
+ createEdge(verts[n1_hold[1]], verts[n2_hold[1]], quadToTri_edges);
+ createEdge(verts[n1_hold[1]], verts[n2_hold[1]], edges_new);
// create forbidden faces
- for(unsigned int s = 0; s < face_types["free"].size(); s++ ){
+ for(unsigned int s = 0; s < face_types["free"].size(); s++) {
int s_tmp = face_types["free"][s];
- std::vector<MVertex*> v_free;
- if( s_tmp == p1_hold || s_tmp == p2_hold )
- continue;
- if( s_tmp < 4 ){
- v_free.push_back(verts[s_tmp]); v_free.push_back(verts[(s_tmp+1)%4]);
- v_free.push_back(verts[(s_tmp+1)%4+4]); v_free.push_back(verts[s_tmp+4]);
- }
- else{
- int add = s_tmp==4 ? 0 : 4;
- v_free.push_back(verts[add]); v_free.push_back(verts[add+1]);
- v_free.push_back(verts[add+2]); v_free.push_back(verts[add+3]);
+ std::vector<MVertex *> v_free;
+ if(s_tmp == p1_hold || s_tmp == p2_hold) continue;
+ if(s_tmp < 4) {
+ v_free.push_back(verts[s_tmp]);
+ v_free.push_back(verts[(s_tmp + 1) % 4]);
+ v_free.push_back(verts[(s_tmp + 1) % 4 + 4]);
+ v_free.push_back(verts[s_tmp + 4]);
+ }
+ else {
+ int add = s_tmp == 4 ? 0 : 4;
+ v_free.push_back(verts[add]);
+ v_free.push_back(verts[add + 1]);
+ v_free.push_back(verts[add + 2]);
+ v_free.push_back(verts[add + 3]);
}
- createForbidden( v_free, forbidden_edges );
- createForbidden( v_free, forbidden_new );
+ createForbidden(v_free, forbidden_edges);
+ createForbidden(v_free, forbidden_new);
}
}
// take care of any adjustable but required diagonals not yet added
- for(unsigned int s = 0; s < face_types["adj_diag"].size(); s++ ){
+ for(unsigned int s = 0; s < face_types["adj_diag"].size(); s++) {
int ind = face_types["adj_diag"][s];
- if( ind == face_done[0] || ind == face_done[1] || ind == face_done[2] || ind == face_done[3] )
+ if(ind == face_done[0] || ind == face_done[1] || ind == face_done[2] ||
+ ind == face_done[3])
continue;
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
}
// if no valid division found, problematic.
- if( !valid_division ){
- std::pair<unsigned int, unsigned int> jkpair(j,k);
+ if(!valid_division) {
+ std::pair<unsigned int, unsigned int> jkpair(j, k);
problems[elem].insert(jkpair);
problems_new[elem].insert(jkpair);
}
-
}
-
-// Generate face diagonals to subdivide hexahedra by BRUTE FORCE. Not recommended for general use, but it
-// is required for some elements which have all vertices on an external region boundary.
-// Added 2010-01-29
+// Generate face diagonals to subdivide hexahedra by BRUTE FORCE. Not
+// recommended for general use, but it is required for some elements which have
+// all vertices on an external region boundary. Added 2010-01-29
static void bruteForceEdgeQuadToTriHexa(
GRegion *gr, MElement *elem, int j, int k, std::vector<MVertex *> verts,
std::map<std::string, std::vector<int> > &face_types,
@@ -2051,155 +2142,165 @@ static void bruteForceEdgeQuadToTriHexa(
std::vector<int> nadj1, std::vector<int> nadj2,
const std::vector<int> &free_flag)
{
-
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In bruteForceEdgeQuadToTriHexa(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return;
}
GModel *model = gr->model();
- if( !model ){
+ if(!model) {
Msg::Error("In bruteForceEdgeQuadToTriHexa(), invalid model for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return;
}
// now find and verify the source and the top of region
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
- Msg::Error("In bruteForceEdgeQuadToTriHexa(), invalid source face for region "
- "%d.", gr->tag() );
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
+ Msg::Error(
+ "In bruteForceEdgeQuadToTriHexa(), invalid source face for region "
+ "%d.",
+ gr->tag());
return;
}
// verify number of vertices
- //int n_lat;
- if( verts.size() != 8 ){
- Msg::Error("In bruteForceEdgeQuadToTriHexa(), number of vertices not equal 8.");
+ // int n_lat;
+ if(verts.size() != 8) {
+ Msg::Error(
+ "In bruteForceEdgeQuadToTriHexa(), number of vertices not equal 8.");
return;
}
- //else
- //n_lat = 4;
+ // else
+ // n_lat = 4;
// numbers of each type of face
- //int num_degen = face_types["degen"].size();
- //int num_single_tri = face_types["single_tri"].size();
+ // int num_degen = face_types["degen"].size();
+ // int num_single_tri = face_types["single_tri"].size();
int num_recomb = face_types["recomb"].size();
- //int num_fixed_diag = face_types["fixed_diag"].size();
+ // int num_fixed_diag = face_types["fixed_diag"].size();
int num_adj_diag = face_types["adj_diag"].size();
- //int num_free = face_types["free"].size();
-
+ // int num_free = face_types["free"].size();
- // Make sure all faces marked forbidden in face_types have all diagonals in forbidden_edges;
- for( int p = 0; p < num_recomb; p++){
+ // Make sure all faces marked forbidden in face_types have all diagonals in
+ // forbidden_edges;
+ for(int p = 0; p < num_recomb; p++) {
int ind = face_types["recomb"][p];
- std::vector<MVertex*> v;
- if( ind == 4 || ind == 5 ){
- int add = (ind == 4 ) ? 0 : 4;
- v.push_back(verts[0+add]); v.push_back(verts[1+add]); v.push_back(verts[2+add]);
- v.push_back(verts[3+add]);
- }
- else{
- v.push_back(verts[ind]); v.push_back(verts[(ind+1)%4]); v.push_back(verts[(ind+1)%4+4]);
- v.push_back(verts[ind+4]);
- }
-
- createForbidden(v, forbidden_new );
- createForbidden(v, forbidden_edges );
- }
-
-
- // If this element is marked problematic, make all the adjustable diags (none should exist if it's already
- // marked as a problem, but just make sure) and return.
- std::pair<unsigned int, unsigned int> jkpair(j,k);
- if( problems.find(elem) != problems.end() && problems[elem].count(jkpair) ){
- for( int s = 0; s < num_adj_diag; s++ ){
+ std::vector<MVertex *> v;
+ if(ind == 4 || ind == 5) {
+ int add = (ind == 4) ? 0 : 4;
+ v.push_back(verts[0 + add]);
+ v.push_back(verts[1 + add]);
+ v.push_back(verts[2 + add]);
+ v.push_back(verts[3 + add]);
+ }
+ else {
+ v.push_back(verts[ind]);
+ v.push_back(verts[(ind + 1) % 4]);
+ v.push_back(verts[(ind + 1) % 4 + 4]);
+ v.push_back(verts[ind + 4]);
+ }
+
+ createForbidden(v, forbidden_new);
+ createForbidden(v, forbidden_edges);
+ }
+
+ // If this element is marked problematic, make all the adjustable diags (none
+ // should exist if it's already marked as a problem, but just make sure) and
+ // return.
+ std::pair<unsigned int, unsigned int> jkpair(j, k);
+ if(problems.find(elem) != problems.end() && problems[elem].count(jkpair)) {
+ for(int s = 0; s < num_adj_diag; s++) {
int ind = face_types["adj_diag"][s];
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
}
return;
}
// test for right number of triangles with degenerate edges
- if( (face_types["single_tri"].size() != 0 && face_types["single_tri"].size() != 2) ||
- (face_types["degen"].size() && face_types["single_tri"].size() != 2) ){
- Msg::Error("In bruteForceEdgeQuadToTriHexa(), bad degenerated extrusion encountered.");
- std::pair<unsigned int, unsigned int> jkpair(j,k);
+ if((face_types["single_tri"].size() != 0 &&
+ face_types["single_tri"].size() != 2) ||
+ (face_types["degen"].size() && face_types["single_tri"].size() != 2)) {
+ Msg::Error("In bruteForceEdgeQuadToTriHexa(), bad degenerated extrusion "
+ "encountered.");
+ std::pair<unsigned int, unsigned int> jkpair(j, k);
problems[elem].insert(jkpair);
problems_new[elem].insert(jkpair);
- if( num_adj_diag ){
+ if(num_adj_diag) {
int ind = face_types["adj_diag"][0];
- if( nadj1[ind] >= 0 ){
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
+ if(nadj1[ind] >= 0) {
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
}
}
return;
}
// if there are not enough diagonals:
- if( 6 - face_types["single_tri"].size() - face_types["recomb"].size() < 2 ){
+ if(6 - face_types["single_tri"].size() - face_types["recomb"].size() < 2) {
// Can't be meshed without internal vertex
- if( face_types["adj_diag"].size() + face_types["fixed_diag"].size() ){
- std::pair<unsigned int, unsigned int> jkpair(j,k);
+ if(face_types["adj_diag"].size() + face_types["fixed_diag"].size()) {
+ std::pair<unsigned int, unsigned int> jkpair(j, k);
problems[elem].insert(jkpair);
problems_new[elem].insert(jkpair);
- for(unsigned int s = 0; s < face_types["adj_diag"].size(); s++ ){
+ for(unsigned int s = 0; s < face_types["adj_diag"].size(); s++) {
int ind = face_types["adj_diag"][s];
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges );
- createEdge( verts[nadj1[ind]], verts[nadj2[ind]], edges_new );
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], quadToTri_edges);
+ createEdge(verts[nadj1[ind]], verts[nadj2[ind]], edges_new);
}
}
// set the (at most) one free surface to forbidden and return
- else if( face_types["free"].size() ){
+ else if(face_types["free"].size()) {
int p_tmp = face_types["free"][0];
- std::vector<MVertex*> v_free;
- if( p_tmp < 4 ){
+ std::vector<MVertex *> v_free;
+ if(p_tmp < 4) {
v_free.push_back(verts[p_tmp]);
- v_free.push_back(verts[(p_tmp+1)%4]);
- v_free.push_back(verts[(p_tmp+1)%4+4]);
- v_free.push_back(verts[p_tmp+4]);
+ v_free.push_back(verts[(p_tmp + 1) % 4]);
+ v_free.push_back(verts[(p_tmp + 1) % 4 + 4]);
+ v_free.push_back(verts[p_tmp + 4]);
}
- else{
- int add = p_tmp==4 ? 0 : 4;
+ else {
+ int add = p_tmp == 4 ? 0 : 4;
v_free.push_back(verts[add]);
- v_free.push_back(verts[add+1]);
- v_free.push_back(verts[add+2]);
- v_free.push_back(verts[add+3]);
+ v_free.push_back(verts[add + 1]);
+ v_free.push_back(verts[add + 2]);
+ v_free.push_back(verts[add + 3]);
}
- createForbidden( v_free, forbidden_edges );
- createForbidden( v_free, forbidden_new );
+ createForbidden(v_free, forbidden_edges);
+ createForbidden(v_free, forbidden_new);
}
return;
}
-
// Start looking at the different shape possibilities:
-
// First shape: A PRISM
- // Only two possibilities. Either the bottom can be divided along same diagonal as the top,
- // or the one quad side can be divided joining the top diagonal. Otherwise, problem.
- if(face_types["degen"].size()){
- addEdgesForQuadToTriTwoPtDegenHexa(gr, elem, ep, j, k, verts, face_types, edges_new, forbidden_new,
- quadToTri_edges, forbidden_edges, lat_tri_diags, problems_new,
- problems, nfix1, nfix2, nadj1, nadj2, free_flag);
+ // Only two possibilities. Either the bottom can be divided along same
+ // diagonal as the top, or the one quad side can be divided joining the top
+ // diagonal. Otherwise, problem.
+ if(face_types["degen"].size()) {
+ addEdgesForQuadToTriTwoPtDegenHexa(
+ gr, elem, ep, j, k, verts, face_types, edges_new, forbidden_new,
+ quadToTri_edges, forbidden_edges, lat_tri_diags, problems_new, problems,
+ nfix1, nfix2, nadj1, nadj2, free_flag);
return;
}
// Second shape type: DEGENERATED HEXAHEDRON
// Since this shape can be divided to create legitimate tets and/or pyramids,
// let us try it.
- if( !face_types["degen"].size() && face_types["single_tri"].size() == 2 ){
- addEdgesForQuadToTriOnePtDegenHexa(gr, elem, ep, j, k, verts, face_types, edges_new, forbidden_new,
- quadToTri_edges, forbidden_edges, lat_tri_diags, problems_new,
- problems, nfix1, nfix2, nadj1, nadj2, free_flag);
+ if(!face_types["degen"].size() && face_types["single_tri"].size() == 2) {
+ addEdgesForQuadToTriOnePtDegenHexa(
+ gr, elem, ep, j, k, verts, face_types, edges_new, forbidden_new,
+ quadToTri_edges, forbidden_edges, lat_tri_diags, problems_new, problems,
+ nfix1, nfix2, nadj1, nadj2, free_flag);
return;
}
@@ -2208,47 +2309,51 @@ static void bruteForceEdgeQuadToTriHexa(
// 1. Three diagonals at a corner
// 2. One PAIR of opposite diagonals, ABSOLUTELY ALL OTHER FACES FORBIDDEN
// 2. Two PAIRS of opposite diags
- // 3. One PAIR of opposite diags PLUS a vertex with two ADDITIONAL diags meeting on it.
- if(!face_types["single_tri"].size() && !face_types["degen"].size()){
- addEdgesForQuadToTriFullHexa(gr, elem, ep, j, k, verts, face_types, edges_new, forbidden_new,
- quadToTri_edges, forbidden_edges, lat_tri_diags, problems_new,
- problems, nfix1, nfix2, nadj1, nadj2, free_flag);
+ // 3. One PAIR of opposite diags PLUS a vertex with two ADDITIONAL diags
+ // meeting on it.
+ if(!face_types["single_tri"].size() && !face_types["degen"].size()) {
+ addEdgesForQuadToTriFullHexa(
+ gr, elem, ep, j, k, verts, face_types, edges_new, forbidden_new,
+ quadToTri_edges, forbidden_edges, lat_tri_diags, problems_new, problems,
+ nfix1, nfix2, nadj1, nadj2, free_flag);
return;
}
}
-
-// This is a shortcut function to simply copy face diagonals all the way up a vertical column of extruded elements.
-// This function may not save very many operations, but it is going to stay...
-static int ExtrudeDiags(GRegion *gr, std::vector<MVertex*> v, unsigned int j_start,
- unsigned int k_start, unsigned int j_top, unsigned int k_top,
- MElement *elem, ExtrudeParams *loop_ep,
- std::set<std::pair<MVertex*, MVertex*> > &edges_new,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_new,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- MVertexRTree &pos)
+// This is a shortcut function to simply copy face diagonals all the way up a
+// vertical column of extruded elements. This function may not save very many
+// operations, but it is going to stay...
+static int ExtrudeDiags(
+ GRegion *gr, std::vector<MVertex *> v, unsigned int j_start,
+ unsigned int k_start, unsigned int j_top, unsigned int k_top, MElement *elem,
+ ExtrudeParams *loop_ep, std::set<std::pair<MVertex *, MVertex *> > &edges_new,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_new,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ MVertexRTree &pos)
{
-
- if( !loop_ep || !loop_ep->mesh.QuadToTri || !loop_ep->mesh.ExtrudeMesh ){
+ if(!loop_ep || !loop_ep->mesh.QuadToTri || !loop_ep->mesh.ExtrudeMesh) {
Msg::Error("In ExtrudeDiags(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return 0;
}
GModel *model = gr->model();
- if( !model ){
+ if(!model) {
Msg::Error("In ExtrudeDiags(), invalid model for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
int elem_size = elem->getNumVertices();
- if( !( (v.size() == 6 && elem_size == 3) ||
- (v.size() == 8 && elem_size == 4) ) ){
+ if(!((v.size() == 6 && elem_size == 3) ||
+ (v.size() == 8 && elem_size == 4))) {
Msg::Error("In ExtrudeDiags(), vertex number mismatch "
"between 2D source element and extruded volume.");
return 0;
@@ -2256,48 +2361,51 @@ static int ExtrudeDiags(GRegion *gr, std::vector<MVertex*> v, unsigned int j_sta
// first add the forbidden edges, then the new quadToTri_edges
// w = 0 forbidden, w = 1 quadToTri_edges (fixed)
- for( int w = 0; w < 2; w++ ){
- std::set<std::pair<MVertex*, MVertex*> >::iterator it;
- std::set<std::pair<MVertex*, MVertex*> >::iterator it_start;
- std::set<std::pair<MVertex*, MVertex*> >::iterator it_end;
+ for(int w = 0; w < 2; w++) {
+ std::set<std::pair<MVertex *, MVertex *> >::iterator it;
+ std::set<std::pair<MVertex *, MVertex *> >::iterator it_start;
+ std::set<std::pair<MVertex *, MVertex *> >::iterator it_end;
it_start = (!w) ? forbidden_new.begin() : edges_new.begin();
- it_end = (!w) ? forbidden_new.end() : edges_new.end();
+ it_end = (!w) ? forbidden_new.end() : edges_new.end();
- for( it = it_start; it != it_end; it++ ){
+ for(it = it_start; it != it_end; it++) {
MVertex *v1, *v2;
- v1 = (*it).first; v2 = (*it).second;
+ v1 = (*it).first;
+ v2 = (*it).second;
// find indices in v vector
int ind1 = -1, ind2 = -1;
- for(unsigned int p = 0; p < v.size(); p++){
- if( v[p] == v1 )
- ind1 = p;
- if( v[p] == v2 )
- ind2 = p;
+ for(unsigned int p = 0; p < v.size(); p++) {
+ if(v[p] == v1) ind1 = p;
+ if(v[p] == v2) ind2 = p;
}
- if( ind1 < 0 || ind2 < 0 ){
+ if(ind1 < 0 || ind2 < 0) {
Msg::Error("Error in ExtrudeDiags(): could not find vertex indices.");
return 0;
}
// source verts:
- MVertex *sv1 = (ind1 < elem_size ) ? elem->getVertex(ind1) : elem->getVertex(ind1-elem_size);
- MVertex *sv2 = (ind2 < elem_size ) ? elem->getVertex(ind2) : elem->getVertex(ind2-elem_size);
+ MVertex *sv1 = (ind1 < elem_size) ? elem->getVertex(ind1) :
+ elem->getVertex(ind1 - elem_size);
+ MVertex *sv2 = (ind2 < elem_size) ? elem->getVertex(ind2) :
+ elem->getVertex(ind2 - elem_size);
// extrude these two verts
- for( unsigned int j = j_start; j <= j_top; j++ ){
- int k_start_tmp = (j == j_start ) ? k_start+1 : 0;
- int k_stop = ( j == j_top ) ? k_top : loop_ep->mesh.NbElmLayer[j];
- for(int k = k_start_tmp; k < k_stop; k++ ){
- std::vector<MVertex*> v_extr = getExtrudedLateralVertices(sv1, sv2, gr, j, k, loop_ep, pos);
- if( v_extr.size() != 4 )
- return 0;
- if( !w ){
+ for(unsigned int j = j_start; j <= j_top; j++) {
+ int k_start_tmp = (j == j_start) ? k_start + 1 : 0;
+ int k_stop = (j == j_top) ? k_top : loop_ep->mesh.NbElmLayer[j];
+ for(int k = k_start_tmp; k < k_stop; k++) {
+ std::vector<MVertex *> v_extr =
+ getExtrudedLateralVertices(sv1, sv2, gr, j, k, loop_ep, pos);
+ if(v_extr.size() != 4) return 0;
+ if(!w) {
// reorder v_ext
- MVertex *tmp = v_extr[2]; v_extr[2] = v_extr[3]; v_extr[3] = tmp;
- createForbidden( v_extr, forbidden_edges );
+ MVertex *tmp = v_extr[2];
+ v_extr[2] = v_extr[3];
+ v_extr[3] = tmp;
+ createForbidden(v_extr, forbidden_edges);
}
- else{
+ else {
MVertex *v_final_1 = (ind1 < elem_size) ? v_extr[0] : v_extr[2];
MVertex *v_final_2 = (ind2 < elem_size) ? v_extr[1] : v_extr[3];
- createEdge( v_final_1, v_final_2, quadToTri_edges );
+ createEdge(v_final_1, v_final_2, quadToTri_edges);
}
}
}
@@ -2305,16 +2413,17 @@ static int ExtrudeDiags(GRegion *gr, std::vector<MVertex*> v, unsigned int j_sta
}
// add problem elements
- std::pair<unsigned int, unsigned int> jk_start (j_start, k_start);
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > >::iterator itprob;
-
- if( problems_new.size() ){
- for( itprob = problems_new.begin(); itprob != problems_new.end(); itprob++ ){
- for( unsigned int j = j_start; j <= j_top; j++ ){
- int k_start_tmp = (j == j_start ) ? k_start+1 : 0;
- int k_stop = ( j == j_top ) ? k_top : loop_ep->mesh.NbElmLayer[j];
- for(int k = k_start_tmp; k < k_stop; k++ ){
- std::pair<unsigned int, unsigned int> pair_tmp (j, k);
+ std::pair<unsigned int, unsigned int> jk_start(j_start, k_start);
+ std::map<MElement *,
+ std::set<std::pair<unsigned int, unsigned int> > >::iterator itprob;
+
+ if(problems_new.size()) {
+ for(itprob = problems_new.begin(); itprob != problems_new.end(); itprob++) {
+ for(unsigned int j = j_start; j <= j_top; j++) {
+ int k_start_tmp = (j == j_start) ? k_start + 1 : 0;
+ int k_stop = (j == j_top) ? k_top : loop_ep->mesh.NbElmLayer[j];
+ for(int k = k_start_tmp; k < k_stop; k++) {
+ std::pair<unsigned int, unsigned int> pair_tmp(j, k);
problems[(*itprob).first].insert(pair_tmp);
}
}
@@ -2324,34 +2433,31 @@ static int ExtrudeDiags(GRegion *gr, std::vector<MVertex*> v, unsigned int j_sta
return 1;
}
-
-// Get set of locally fixed edges, forbidden edges, and all lateral surface diagonals.
-// Fixed edges include top surface diagonals and any lateral surface diagonals that cannot be swapped.
-// Added 2010-01-24
-static bool QuadToTriGetRegionDiags(GRegion *gr,
- std::set<std::pair<MVertex*,MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*,MVertex*> > &forbidden_edges,
- std::set<std::pair<MVertex*,MVertex*> > &lat_tri_diags,
- MVertexRTree &pos)
+// Get set of locally fixed edges, forbidden edges, and all lateral surface
+// diagonals. Fixed edges include top surface diagonals and any lateral surface
+// diagonals that cannot be swapped. Added 2010-01-24
+static bool QuadToTriGetRegionDiags(
+ GRegion *gr, std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags, MVertexRTree &pos)
{
-
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh )
- return false;
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) return false;
GModel *model = gr->model();
// find source face
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
Msg::Error("In QuadToTriGetRegionDiags(), could not find source face "
- "%d for region %d.", std::abs( ep->geo.Source ),
- gr->tag() );
+ "%d for region %d.",
+ std::abs(ep->geo.Source), gr->tag());
return false;
}
- // Find a source surface, find a COPIED_ENTITY that is the top surface, or if toroidal, find what is now the top
+ // Find a source surface, find a COPIED_ENTITY that is the top surface, or if
+ // toroidal, find what is now the top
bool foundSource = false, foundTop = false, foundRoot = false;
GFace *reg_top = NULL;
@@ -2361,57 +2467,52 @@ static bool QuadToTriGetRegionDiags(GRegion *gr,
// top faces in toroidal quadtri need special treatment
bool is_toroidal = IsInToroidalQuadToTri(reg_source);
- if( is_toroidal )
- root_face = findRootSourceFaceForFace(reg_source);
+ if(is_toroidal) root_face = findRootSourceFaceForFace(reg_source);
- for( it = faces.begin(); it != faces.end(); it++ ){
+ for(it = faces.begin(); it != faces.end(); it++) {
ExtrudeParams *face_tmp_ep = (*it)->meshAttributes.extrude;
- if( (*it) == root_face )
- foundRoot = true;
- if( (*it) == reg_source )
+ if((*it) == root_face) foundRoot = true;
+ if((*it) == reg_source)
foundSource = true;
- else if( face_tmp_ep && face_tmp_ep->geo.Mode ==
- COPIED_ENTITY ){
- GFace *top_source_tmp = model->getFaceByTag(
- std::abs( face_tmp_ep->geo.Source ) );
- if( !top_source_tmp ){
- Msg::Error("In QuadToTriGetRegionDiags(), could not find source face "
- "%d for copied surface %d of region %d.",
- std::abs( face_tmp_ep->geo.Source ),
- (*it)->tag(), gr->tag() );
+ else if(face_tmp_ep && face_tmp_ep->geo.Mode == COPIED_ENTITY) {
+ GFace *top_source_tmp =
+ model->getFaceByTag(std::abs(face_tmp_ep->geo.Source));
+ if(!top_source_tmp) {
+ Msg::Error("In QuadToTriGetRegionDiags(), could not find source face "
+ "%d for copied surface %d of region %d.",
+ std::abs(face_tmp_ep->geo.Source), (*it)->tag(), gr->tag());
}
- else if( top_source_tmp == reg_source ){
- foundTop = true;
- reg_top = (*it);
+ else if(top_source_tmp == reg_source) {
+ foundTop = true;
+ reg_top = (*it);
}
}
}
- if( !foundTop && is_toroidal && foundRoot && root_face != reg_source ){
+ if(!foundTop && is_toroidal && foundRoot && root_face != reg_source) {
foundTop = true;
reg_top = root_face;
}
- if( !foundTop )
+ if(!foundTop)
Msg::Warning("In QuadToTriGetRegionDiags(), could not find top face "
- "for region %d.", gr->tag() );
+ "for region %d.",
+ gr->tag());
-
- if( !foundSource ){
+ if(!foundSource) {
Msg::Error("In QuadToTriGetRegionDiags(), source face "
- "for region %d is not found in region face list.", gr->tag() );
+ "for region %d is not found in region face list.",
+ gr->tag());
return false;
}
-
// Get Fixed and adjustable lateral diagonal element edges
int counter = 0;
- for( it = faces.begin(); it != faces.end(); it++ ){
+ for(it = faces.begin(); it != faces.end(); it++) {
counter++;
// true if surface is a lateral...
// ...The conditional is redundant for a reason.
- if( (*it) != reg_top && (*it) != reg_source &&
- IsSurfaceALateralForRegion(gr, *it) ){
-
+ if((*it) != reg_top && (*it) != reg_source &&
+ IsSurfaceALateralForRegion(gr, *it)) {
// take care of forbidden edges
// test whether this surface is a lateral bounded by two quadtri regions.
// if so, and the other is not already meshed,
@@ -2421,23 +2522,27 @@ static bool QuadToTriGetRegionDiags(GRegion *gr,
int numNeighbors = 0;
numNeighbors = GetNeighborRegionsOfFace((*it), adj_regions);
int ind_notcurrent = adj_regions[0] == gr ? 1 : 0;
- if(!(numNeighbors == 2 && adj_regions[0]->meshAttributes.extrude && adj_regions[1]->meshAttributes.extrude &&
- adj_regions[0]->meshAttributes.extrude->mesh.ExtrudeMesh && adj_regions[1]->meshAttributes.extrude->mesh.ExtrudeMesh &&
- adj_regions[0]->meshAttributes.extrude->geo.Mode == EXTRUDED_ENTITY &&
- adj_regions[1]->meshAttributes.extrude->geo.Mode == EXTRUDED_ENTITY &&
- adj_regions[0]->meshAttributes.extrude->mesh.QuadToTri && adj_regions[1]->meshAttributes.extrude->mesh.QuadToTri &&
+ if(!(numNeighbors == 2 && adj_regions[0]->meshAttributes.extrude &&
+ adj_regions[1]->meshAttributes.extrude &&
+ adj_regions[0]->meshAttributes.extrude->mesh.ExtrudeMesh &&
+ adj_regions[1]->meshAttributes.extrude->mesh.ExtrudeMesh &&
+ adj_regions[0]->meshAttributes.extrude->geo.Mode ==
+ EXTRUDED_ENTITY &&
+ adj_regions[1]->meshAttributes.extrude->geo.Mode ==
+ EXTRUDED_ENTITY &&
+ adj_regions[0]->meshAttributes.extrude->mesh.QuadToTri &&
+ adj_regions[1]->meshAttributes.extrude->mesh.QuadToTri &&
IsSurfaceALateralForRegion(adj_regions[ind_notcurrent], *it) &&
- !adj_regions[ind_notcurrent]->getNumMeshElements())){
- for(unsigned int i = 0; i < (*it)->quadrangles.size(); i++){
- std::vector<MVertex*> v;
- (*it)->quadrangles[i]->getVertices(v);
- createForbidden(v, forbidden_edges );
- }
+ !adj_regions[ind_notcurrent]->getNumMeshElements())) {
+ for(unsigned int i = 0; i < (*it)->quadrangles.size(); i++) {
+ std::vector<MVertex *> v;
+ (*it)->quadrangles[i]->getVertices(v);
+ createForbidden(v, forbidden_edges);
+ }
}
// at this point, if there are no triangles, continue
- if( !(*it)->triangles.size() )
- continue;
+ if(!(*it)->triangles.size()) continue;
ExtrudeParams *face_ep_tmp = (*it)->meshAttributes.extrude;
// If face is shared with a neighbor region that ALREADY has elements,
@@ -2448,175 +2553,186 @@ static bool QuadToTriGetRegionDiags(GRegion *gr,
GRegion *other_region = NULL;
ExtrudeParams *oth_ep = NULL;
ExtrudeParams *face_ep = (*it)->meshAttributes.extrude;
- if(neighbors.size() > 1){
+ if(neighbors.size() > 1) {
other_region = neighbors[0] != gr ? neighbors[0] : neighbors[1];
oth_ep = other_region->meshAttributes.extrude;
}
bool is_fixed = false;
// see if neighbor has already been meshed
- if( other_region &&
- ( other_region->pyramids.size() ||
- other_region->tetrahedra.size() ||
- other_region->hexahedra.size() ||
- other_region->prisms.size() ||
- other_region->polyhedra.size() ||
- other_region->getNumMeshElements() ) ){
+ if(other_region &&
+ (other_region->pyramids.size() || other_region->tetrahedra.size() ||
+ other_region->hexahedra.size() || other_region->prisms.size() ||
+ other_region->polyhedra.size() ||
+ other_region->getNumMeshElements())) {
is_fixed = true;
}
// see if the diagonals are fixed for other reasons
- if( !( face_ep_tmp && face_ep_tmp->mesh.ExtrudeMesh &&
- face_ep_tmp->geo.Mode == EXTRUDED_ENTITY ) ||
- (other_region && oth_ep && oth_ep->mesh.ExtrudeMesh &&
- (*it) == model->getFaceByTag( std::abs( oth_ep->geo.Source ) ) ) ||
- (other_region && other_region->meshAttributes.method == MESH_TRANSFINITE) ){
+ if(!(face_ep_tmp && face_ep_tmp->mesh.ExtrudeMesh &&
+ face_ep_tmp->geo.Mode == EXTRUDED_ENTITY) ||
+ (other_region && oth_ep && oth_ep->mesh.ExtrudeMesh &&
+ (*it) == model->getFaceByTag(std::abs(oth_ep->geo.Source))) ||
+ (other_region &&
+ other_region->meshAttributes.method == MESH_TRANSFINITE)) {
is_fixed = true;
}
// Now extrude all vertices and find diagonal edges.
// NOTE: This seems like the "hard way" because it is written to work
- // even if the original lateral for the region is replaced by another structured
- // surface.
- // (first find common edge between source and this lateral)
- std::vector<GEdge*> const& source_edges = reg_source->edges();
- std::vector<GEdge*> const& face_edges = (*it)->edges();
- std::vector<GEdge*>::const_iterator itse;
+ // even if the original lateral for the region is replaced by another
+ // structured surface. (first find common edge between source and this
+ // lateral)
+ std::vector<GEdge *> const &source_edges = reg_source->edges();
+ std::vector<GEdge *> const &face_edges = (*it)->edges();
+ std::vector<GEdge *>::const_iterator itse;
GEdge *common = NULL;
int common_count = 0;
- for( itse = source_edges.begin(); itse != source_edges.end(); itse++ ){
- if( std::find( face_edges.begin(), face_edges.end(), (*itse) ) !=
- face_edges.end() ){
+ for(itse = source_edges.begin(); itse != source_edges.end(); itse++) {
+ if(std::find(face_edges.begin(), face_edges.end(), (*itse)) !=
+ face_edges.end()) {
common = (*itse);
common_count++;
}
}
- if( !common || common_count != 1 )
- Msg::Error("In QuadToTriGetRegionDiags(), lateral surface and "
- "source surface of region %d do not share one and only one edge.",
- gr->tag() );
-
+ if(!common || common_count != 1)
+ Msg::Error(
+ "In QuadToTriGetRegionDiags(), lateral surface and "
+ "source surface of region %d do not share one and only one edge.",
+ gr->tag());
// now find face source edge, if it exists:
GEdge *face_source = NULL;
- if( face_ep && face_ep->mesh.ExtrudeMesh &&
- face_ep->geo.Mode == EXTRUDED_ENTITY ){
- face_source = model->getEdgeByTag( std::abs( face_ep->geo.Source ) );
- if( !face_source ){
+ if(face_ep && face_ep->mesh.ExtrudeMesh &&
+ face_ep->geo.Mode == EXTRUDED_ENTITY) {
+ face_source = model->getEdgeByTag(std::abs(face_ep->geo.Source));
+ if(!face_source) {
Msg::Error("In QuadToTriGetRegionDiags(), extruded face %d "
- "has invalid source.", (*it)->tag() );
+ "has invalid source.",
+ (*it)->tag());
}
}
// set up vertex finding loops according to whether this surface
- // is extruded or not (alternative to extruded is unrecombined transfinite surf with vertices
- // coincidentally in the right place).
+ // is extruded or not (alternative to extruded is unrecombined transfinite
+ // surf with vertices coincidentally in the right place).
unsigned int num_lines = 0;
std::vector<MLine *> *source_lines = NULL;
ExtrudeParams *loop_ep = NULL;
- if( face_source ){
+ if(face_source) {
num_lines = face_source->lines.size();
source_lines = &face_source->lines;
loop_ep = face_ep;
}
- else{
+ else {
num_lines = common->lines.size();
source_lines = &common->lines;
loop_ep = ep;
}
unsigned int index_guess = 0;
- for( unsigned int i = 0; i < num_lines; i++ ){
+ for(unsigned int i = 0; i < num_lines; i++) {
MVertex *v0 = (*source_lines)[i]->getVertex(0);
MVertex *v1 = (*source_lines)[i]->getVertex(1);
- std::vector<MVertex*> verts;
- // test to see if this is a degenerate quad as triangle. If so, continue.
+ std::vector<MVertex *> verts;
+ // test to see if this is a degenerate quad as triangle. If so,
+ // continue.
verts = getExtrudedLateralVertices(v0, v1, (*it), 0, 0, loop_ep, pos);
- if( verts[0]==verts[2] || verts[1]==verts[3] ){
- for( int p = 0; p < loop_ep->mesh.NbLayer; p++ )
+ if(verts[0] == verts[2] || verts[1] == verts[3]) {
+ for(int p = 0; p < loop_ep->mesh.NbLayer; p++)
index_guess += loop_ep->mesh.NbElmLayer[p];
continue;
}
for(int j = 0; j < loop_ep->mesh.NbLayer; j++) {
for(int k = 0; k < loop_ep->mesh.NbElmLayer[j]; k++) {
verts.clear();
- verts = getExtrudedLateralVertices(v0, v1, (*it), j, k, loop_ep, pos);
+ verts =
+ getExtrudedLateralVertices(v0, v1, (*it), j, k, loop_ep, pos);
// Find diagonal:
- std::pair<int,int> diag (0,0);
- diag = FindDiagonalEdgeIndices( verts, (*it), true, index_guess );
- if( diag.first || diag.second ){
+ std::pair<int, int> diag(0, 0);
+ diag = FindDiagonalEdgeIndices(verts, (*it), true, index_guess);
+ if(diag.first || diag.second) {
int add = diag.first < 2 ? 1 : -1;
- // have to test if conflicting edge already exists in quadToTri_edges in case of global subdivide
- if( !edgeExists( verts[diag.first+add], verts[diag.second-add], quadToTri_edges ) ){
- createEdge( verts[diag.first], verts[diag.second], lat_tri_diags );
- if( is_fixed )
- createEdge( verts[diag.first], verts[diag.second], quadToTri_edges );
+ // have to test if conflicting edge already exists in
+ // quadToTri_edges in case of global subdivide
+ if(!edgeExists(verts[diag.first + add], verts[diag.second - add],
+ quadToTri_edges)) {
+ createEdge(verts[diag.first], verts[diag.second],
+ lat_tri_diags);
+ if(is_fixed)
+ createEdge(verts[diag.first], verts[diag.second],
+ quadToTri_edges);
}
else
- createEdge( verts[diag.first+add], verts[diag.second-add], lat_tri_diags );
+ createEdge(verts[diag.first + add], verts[diag.second - add],
+ lat_tri_diags);
}
- else if( !(*it)->quadrangles.size() )
- Msg::Error("In QuadToTriGetRegionDiags(), failed to find a diagonal in lateral surface %d.", (*it)->tag() );
+ else if(!(*it)->quadrangles.size())
+ Msg::Error("In QuadToTriGetRegionDiags(), failed to find a "
+ "diagonal in lateral surface %d.",
+ (*it)->tag());
index_guess += 2;
- /*
-
- std::vector<MVertex*> vface;
- vface.push_back(verts[0]);
- vface.push_back(verts[1]);
- vface.push_back(verts[3]);
- vface.push_back(verts[2]);
- if( k==2 && ( counter == 3 || counter == 3) ){
- if( k==0 || k ){
- createEdge( verts[1], verts[2], lat_tri_diags );
- createEdge( verts[1], verts[2], quadToTri_edges );
- }
- else{
- createEdge( verts[0], verts[3], lat_tri_diags );
- createEdge( verts[0], verts[3], quadToTri_edges );
- }
- }
- else if( k==2 && (counter == 5 || counter == 4 || counter == 6 ) ){
- createEdge( verts[0], verts[3], lat_tri_diags );
- createEdge( verts[0], verts[3], quadToTri_edges );
- }
- else if( k<2 )
- createForbidden(vface, forbidden_edges);
- else
- createEdge( elemEdge_tmp.first, elemEdge_tmp.second, lat_tri_diags );
- */
-
+ /*
+
+ std::vector<MVertex*> vface;
+ vface.push_back(verts[0]);
+ vface.push_back(verts[1]);
+ vface.push_back(verts[3]);
+ vface.push_back(verts[2]);
+ if( k==2 && ( counter == 3 || counter == 3) ){
+ if( k==0 || k ){
+ createEdge( verts[1], verts[2], lat_tri_diags );
+ createEdge( verts[1], verts[2], quadToTri_edges );
+ }
+ else{
+ createEdge( verts[0], verts[3], lat_tri_diags );
+ createEdge( verts[0], verts[3], quadToTri_edges );
+ }
+ }
+ else if( k==2 && (counter == 5 || counter == 4 || counter == 6 ) ){
+ createEdge( verts[0], verts[3], lat_tri_diags );
+ createEdge( verts[0], verts[3], quadToTri_edges );
+ }
+ else if( k<2 )
+ createForbidden(vface, forbidden_edges);
+ else
+ createEdge( elemEdge_tmp.first, elemEdge_tmp.second,
+ lat_tri_diags );
+ */
}
}
}
-
}
}
// Insert diagonals of the top surface into quadToTri_edges;
unsigned int index_guess = reg_source->triangles.size();
- if( reg_top->quadrangles.size() && !is_toroidal ){
+ if(reg_top->quadrangles.size() && !is_toroidal) {
Msg::Error("In QuadToTriGetRegionDiags(), top surface of region "
- "%d has quads in a non-toroidal QuadToTri extrusion.", gr->tag() );
+ "%d has quads in a non-toroidal QuadToTri extrusion.",
+ gr->tag());
return false;
}
- for(unsigned int i = 0; i < reg_source->quadrangles.size(); i++){
- int j_top = ep->mesh.NbLayer-1;
- int k_top = ep->mesh.NbElmLayer[ep->mesh.NbLayer-1];
+ for(unsigned int i = 0; i < reg_source->quadrangles.size(); i++) {
+ int j_top = ep->mesh.NbLayer - 1;
+ int k_top = ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1];
MElement *elem = reg_source->quadrangles[i];
std::vector<MVertex *> verts;
get2DExtrudedVertices(elem, ep, j_top, k_top, pos, verts);
if(verts.size() != 4) break;
- if(!is_toroidal){
+ if(!is_toroidal) {
// Find diagonal:
- std::pair<int,int> diag(0,0);
+ std::pair<int, int> diag(0, 0);
diag = FindDiagonalEdgeIndices(verts, reg_top, false, index_guess);
if(diag.first || diag.second)
- createEdge( verts[diag.first], verts[diag.second], quadToTri_edges);
+ createEdge(verts[diag.first], verts[diag.second], quadToTri_edges);
else
- Msg::Error("In QuadToTriGetRegionDiags(), failed to find a diagonal on top surface %d, but should have.", reg_top->tag() );
+ Msg::Error("In QuadToTriGetRegionDiags(), failed to find a diagonal on "
+ "top surface %d, but should have.",
+ reg_top->tag());
index_guess += 2;
}
else
@@ -2625,103 +2741,121 @@ static bool QuadToTriGetRegionDiags(GRegion *gr,
return true;
}
-
-// For use in QuadToTriEdgeGenerator: Controls BRUTE FORCE edging of elements with ALL vertices
-// on a lateral boundary surface.
-// Added 04/08/2011
-static int makeEdgesForElemsWithAllVertsOnBnd(GRegion *gr, bool is_addverts,
- CategorizedSourceElements &cat_src_elems,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- MVertexRTree &pos)
+// For use in QuadToTriEdgeGenerator: Controls BRUTE FORCE edging of elements
+// with ALL vertices on a lateral boundary surface. Added 04/08/2011
+static int makeEdgesForElemsWithAllVertsOnBnd(
+ GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ MVertexRTree &pos)
{
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In makeEdgesForElemsWithAllVertsOnBnd(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return 0;
}
GModel *model = gr->model();
- if(!model){
- Msg::Error("In makeEdgesForElemsWithAllVertsOnBnd(), invalid model for region "
- "%d.", gr->tag() );
+ if(!model) {
+ Msg::Error(
+ "In makeEdgesForElemsWithAllVertsOnBnd(), invalid model for region "
+ "%d.",
+ gr->tag());
return 0;
}
GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
- if(!reg_source){
- Msg::Error("In makeEdgesForElemsWithAllVertsOnBnd(), invalid source face for region "
- "%d.", gr->tag());
+ if(!reg_source) {
+ Msg::Error(
+ "In makeEdgesForElemsWithAllVertsOnBnd(), invalid source face for region "
+ "%d.",
+ gr->tag());
return 0;
}
- if(gr != cat_src_elems.region || reg_source != cat_src_elems.source_face){
- Msg::Error("In makeEdgesForElemsWithAllVertsOnBnd(), too many elements in the "
- "CategorizedSourceElements structure for given source face %d.",
- reg_source->tag());
+ if(gr != cat_src_elems.region || reg_source != cat_src_elems.source_face) {
+ Msg::Error(
+ "In makeEdgesForElemsWithAllVertsOnBnd(), too many elements in the "
+ "CategorizedSourceElements structure for given source face %d.",
+ reg_source->tag());
return 0;
}
// find edge verts of source face
- MVertexRTree pos_src_edge(CTX::instance()->geom.tolerance * CTX::instance()->lc);
+ MVertexRTree pos_src_edge(CTX::instance()->geom.tolerance *
+ CTX::instance()->lc);
QuadToTriInsertFaceEdgeVertices(reg_source, pos_src_edge);
- // while Loop to diagonalize 3-boundary point triangles and 4-boundary point quadrangles:
+ // while Loop to diagonalize 3-boundary point triangles and 4-boundary point
+ // quadrangles:
bool finish_all_tri = false;
- // can afford temporary copies since these sets should be relatively small for all cases.
+ // can afford temporary copies since these sets should be relatively small for
+ // all cases.
std::set<unsigned int> tri_tmp, quad_tmp;
tri_tmp = cat_src_elems.three_bnd_pt_tri;
// if is_addverts, then don't track the quads
- if( !is_addverts )
- quad_tmp = cat_src_elems.four_bnd_pt_quad;
+ if(!is_addverts) quad_tmp = cat_src_elems.four_bnd_pt_quad;
- while( tri_tmp.size() || quad_tmp.size() ){
+ while(tri_tmp.size() || quad_tmp.size()) {
std::set<unsigned int>::iterator it;
std::vector<unsigned int> done;
// 3 bnd point triangle and 4 bnd point quad loop
// s = 0 for triangles, s = 1 for quads
- for( int s = 0; s < 2; s++ ){
+ for(int s = 0; s < 2; s++) {
std::set<unsigned int> *set_elems;
- std::set<std::pair<MVertex*,MVertex*> > edges_new, forbidden_new;
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > problems_new;
- if( !s ) set_elems = &tri_tmp;
- else set_elems = &quad_tmp;
+ std::set<std::pair<MVertex *, MVertex *> > edges_new, forbidden_new;
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ problems_new;
+ if(!s)
+ set_elems = &tri_tmp;
+ else
+ set_elems = &quad_tmp;
- for( it = set_elems->begin(); it != set_elems->end(); it++ ){
+ for(it = set_elems->begin(); it != set_elems->end(); it++) {
MElement *elem;
- if( !s ) elem = reg_source->triangles[(*it)];
- else elem = reg_source->quadrangles[(*it)];
+ if(!s)
+ elem = reg_source->triangles[(*it)];
+ else
+ elem = reg_source->quadrangles[(*it)];
// int elem_size = elem->getNumVertices();
std::vector<bool> vert_bnd;
- if( !s ) vert_bnd.insert( vert_bnd.begin(), cat_src_elems.tri_bool.begin()+(4*(*it)+1),
- cat_src_elems.tri_bool.begin()+(4*(*it)+4) );
- else vert_bnd.insert( vert_bnd.begin(), cat_src_elems.quad_bool.begin()+(5*(*it)+1),
- cat_src_elems.quad_bool.begin()+(5*(*it)+5) );
+ if(!s)
+ vert_bnd.insert(vert_bnd.begin(),
+ cat_src_elems.tri_bool.begin() + (4 * (*it) + 1),
+ cat_src_elems.tri_bool.begin() + (4 * (*it) + 4));
+ else
+ vert_bnd.insert(vert_bnd.begin(),
+ cat_src_elems.quad_bool.begin() + (5 * (*it) + 1),
+ cat_src_elems.quad_bool.begin() + (5 * (*it) + 5));
int j_start, k_start;
- // if has lat_tri_diags or is a rotation with quads (may have to do the one point bnd quads to
- // get rid of degenerate hexahedra...they are invalid mesh volumes.
- if( lat_tri_diags.size() || ( reg_source->quadrangles.size() && (
- ep->geo.Type == ROTATE || ep->geo.Type == TRANSLATE_ROTATE ) ) ){
+ // if has lat_tri_diags or is a rotation with quads (may have to do the
+ // one point bnd quads to get rid of degenerate hexahedra...they are
+ // invalid mesh volumes.
+ if(lat_tri_diags.size() ||
+ (reg_source->quadrangles.size() &&
+ (ep->geo.Type == ROTATE || ep->geo.Type == TRANSLATE_ROTATE))) {
j_start = 0;
k_start = 0;
}
- else{
- j_start = ep->mesh.NbLayer-1;
- k_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer-1]-1;
+ else {
+ j_start = ep->mesh.NbLayer - 1;
+ k_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1] - 1;
}
int num_levels = 0;
- if( lat_tri_diags.size() || ( reg_source->quadrangles.size() && (
- ep->geo.Type == ROTATE || ep->geo.Type == TRANSLATE_ROTATE ) ) ){
- for( int p = 0; p < ep->mesh.NbLayer; p++ )
+ if(lat_tri_diags.size() ||
+ (reg_source->quadrangles.size() &&
+ (ep->geo.Type == ROTATE || ep->geo.Type == TRANSLATE_ROTATE))) {
+ for(int p = 0; p < ep->mesh.NbLayer; p++)
num_levels += ep->mesh.NbElmLayer[p];
}
else
@@ -2734,529 +2868,568 @@ static int makeEdgesForElemsWithAllVertsOnBnd(GRegion *gr, bool is_addverts,
// (will need this below)
std::vector<MVertex *> verts_top;
int ntop1 = -1, ntop2 = -2;
- getExtrudedVertices( elem, ep, ep->mesh.NbLayer-1,
- ep->mesh.NbElmLayer[ep->mesh.NbLayer-1]-1, pos, verts_top);
- if( edgeExists( verts_top[4], verts_top[6], quadToTri_edges ) ){
- ntop1 = 4; ntop2 = 6;
+ getExtrudedVertices(elem, ep, ep->mesh.NbLayer - 1,
+ ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1] - 1, pos,
+ verts_top);
+ if(edgeExists(verts_top[4], verts_top[6], quadToTri_edges)) {
+ ntop1 = 4;
+ ntop2 = 6;
}
- else if( edgeExists( verts_top[5], verts_top[7], quadToTri_edges ) ){
- ntop1 = 5; ntop2 = 7;
+ else if(edgeExists(verts_top[5], verts_top[7], quadToTri_edges)) {
+ ntop1 = 5;
+ ntop2 = 7;
}
// start extrusion loop
- for( int j = j_start; j < ep->mesh.NbLayer; j++ ){
+ for(int j = j_start; j < ep->mesh.NbLayer; j++) {
int k_start_tmp, k_stop;
- if( j == j_start )
+ if(j == j_start)
k_start_tmp = k_start;
else
k_start_tmp = 0;
k_stop = ep->mesh.NbElmLayer[j];
- for( int k = k_start_tmp; k < k_stop; k++ ){
- std::vector<MVertex*> verts;
+ for(int k = k_start_tmp; k < k_stop; k++) {
+ std::vector<MVertex *> verts;
std::map<std::string, std::vector<int> > face_types;
std::vector<int> nfix1, nfix2, nadj1, nadj2, free_flag;
int vert_num = getExtrudedVertices(elem, ep, j, k, pos, verts);
// if just starting and there is no diagonal on the bottom edge,
// forbid it (this prevents some conflicts)
- if( vert_num == 8 && j==j_start && k==k_start &&
- !edgeExists(verts[0], verts[2], quadToTri_edges) &&
- !edgeExists(verts[1], verts[3], quadToTri_edges) ){
+ if(vert_num == 8 && j == j_start && k == k_start &&
+ !edgeExists(verts[0], verts[2], quadToTri_edges) &&
+ !edgeExists(verts[1], verts[3], quadToTri_edges)) {
std::vector<MVertex *> v_bot;
- v_bot.assign(4, (MVertex*)(0));
- v_bot[0] = verts[0]; v_bot[1] = verts[1];
- v_bot[2] = verts[2]; v_bot[3] = verts[3];
+ v_bot.assign(4, (MVertex *)(0));
+ v_bot[0] = verts[0];
+ v_bot[1] = verts[1];
+ v_bot[2] = verts[2];
+ v_bot[3] = verts[3];
createForbidden(v_bot, forbidden_edges);
createForbidden(v_bot, forbidden_new);
}
- if( !s ){
- face_types = getFaceTypes( gr, elem, j, k, verts, quadToTri_edges,
- forbidden_edges, lat_tri_diags, vert_bnd, nfix1, nfix2,
- nadj1, nadj2, free_flag);
-
- if( finish_all_tri || face_types["free"].size() + face_types["adj_diag"].size() < 2 ){
- bruteForceEdgeQuadToTriPrism( gr, elem, j, k, verts, face_types, edges_new,
- forbidden_new, quadToTri_edges, forbidden_edges,
- lat_tri_diags, problems_new, problems, nfix1, nfix2,
- nadj1, nadj2, free_flag);
- //IMPORTANT
+ if(!s) {
+ face_types = getFaceTypes(
+ gr, elem, j, k, verts, quadToTri_edges, forbidden_edges,
+ lat_tri_diags, vert_bnd, nfix1, nfix2, nadj1, nadj2, free_flag);
+
+ if(finish_all_tri ||
+ face_types["free"].size() + face_types["adj_diag"].size() <
+ 2) {
+ bruteForceEdgeQuadToTriPrism(
+ gr, elem, j, k, verts, face_types, edges_new, forbidden_new,
+ quadToTri_edges, forbidden_edges, lat_tri_diags, problems_new,
+ problems, nfix1, nfix2, nadj1, nadj2, free_flag);
+ // IMPORTANT
num_edged++;
}
}
- else if( s ){
- // a loop to try to force the top diagonal to align with the diagonal in the region's
- // top surface above this element.
+ else if(s) {
+ // a loop to try to force the top diagonal to align with the
+ // diagonal in the region's top surface above this element.
bool changed_diag = false;
- for( int g=0; g < 2; g++ ){
+ for(int g = 0; g < 2; g++) {
// on first step, see if can put in the aligned top diagonal
- if( g==0 && ntop1 >=0 && ntop2 >= 0 &&
- !edgeExists( verts[4], verts[6], quadToTri_edges ) &&
- !edgeExists( verts[5], verts[7], quadToTri_edges ) ){
+ if(g == 0 && ntop1 >= 0 && ntop2 >= 0 &&
+ !edgeExists(verts[4], verts[6], quadToTri_edges) &&
+ !edgeExists(verts[5], verts[7], quadToTri_edges)) {
std::vector<MVertex *> v_top;
- v_top.assign(4, (MVertex*)(0));
- v_top[0] = verts[4]; v_top[1] = verts[5];
- v_top[2] = verts[6]; v_top[3] = verts[7];
- if( !forbiddenExists( v_top, forbidden_edges ) ){
+ v_top.assign(4, (MVertex *)(0));
+ v_top[0] = verts[4];
+ v_top[1] = verts[5];
+ v_top[2] = verts[6];
+ v_top[3] = verts[7];
+ if(!forbiddenExists(v_top, forbidden_edges)) {
changed_diag = true;
- createEdge( verts[ntop1], verts[ntop2], quadToTri_edges );
+ createEdge(verts[ntop1], verts[ntop2], quadToTri_edges);
}
}
- // on second step, see if a problem was created from inserting aligned diagonal
- // if so, remove it and try again.
- std::pair<unsigned int, unsigned int> jk_pair(j,k);
- if( g==1 && changed_diag &&
- problems[elem].find( jk_pair ) != problems[elem].end() ){
- problems[elem].erase( jk_pair );
- if( !problems[elem].size() )
- problems.erase( elem );
- deleteEdge( verts[ntop1], verts[ntop2], quadToTri_edges );
+ // on second step, see if a problem was created from inserting
+ // aligned diagonal if so, remove it and try again.
+ std::pair<unsigned int, unsigned int> jk_pair(j, k);
+ if(g == 1 && changed_diag &&
+ problems[elem].find(jk_pair) != problems[elem].end()) {
+ problems[elem].erase(jk_pair);
+ if(!problems[elem].size()) problems.erase(elem);
+ deleteEdge(verts[ntop1], verts[ntop2], quadToTri_edges);
}
- else if( g==1 ){
- if( !problems[elem].size() )
- problems.erase( elem );
+ else if(g == 1) {
+ if(!problems[elem].size()) problems.erase(elem);
break;
}
- face_types = getFaceTypes(gr, elem, j, k, verts, quadToTri_edges,
- forbidden_edges, lat_tri_diags, vert_bnd, nfix1, nfix2,
- nadj1, nadj2, free_flag);
-
- bruteForceEdgeQuadToTriHexa(gr, elem, j, k, verts, face_types, edges_new,
- forbidden_new, quadToTri_edges, forbidden_edges,
- lat_tri_diags, problems_new, problems, nfix1, nfix2,
- nadj1, nadj2, free_flag);
+ face_types =
+ getFaceTypes(gr, elem, j, k, verts, quadToTri_edges,
+ forbidden_edges, lat_tri_diags, vert_bnd, nfix1,
+ nfix2, nadj1, nadj2, free_flag);
+
+ bruteForceEdgeQuadToTriHexa(
+ gr, elem, j, k, verts, face_types, edges_new, forbidden_new,
+ quadToTri_edges, forbidden_edges, lat_tri_diags, problems_new,
+ problems, nfix1, nfix2, nadj1, nadj2, free_flag);
}
- //IMPORTANT
+ // IMPORTANT
num_edged++;
}
}
}
// IMPORTANT
- if( num_edged == num_levels )
- done.push_back((*it));
+ if(num_edged == num_levels) done.push_back((*it));
- // If quads, break ( only do quads one at a time so can keep 3 bnd point triangles from
- // being trapped so that they can't be meshed without an internal vertex)
- if( s )
- break;
+ // If quads, break ( only do quads one at a time so can keep 3 bnd point
+ // triangles from being trapped so that they can't be meshed without an
+ // internal vertex)
+ if(s) break;
- } // end loop over set of element indices (tri or quad)
+ } // end loop over set of element indices (tri or quad)
// remove elements that are done from list
- if( done.size() ){
- for(unsigned int i = 0; i < done.size(); i++ )
- set_elems->erase( done[i] );
+ if(done.size()) {
+ for(unsigned int i = 0; i < done.size(); i++) set_elems->erase(done[i]);
done.clear();
}
- // skip over quads on this iteration if some modifications were made to triangle extrusion elements
- // ( need to make sure no triangles left with only one adjustable or free face or else
- // meshing a quad might trap them so they can't be meshed without internal vertex ).
- if( !s && ( edges_new.size() || problems_new.size() ) )
- s = -1;
+ // skip over quads on this iteration if some modifications were made to
+ // triangle extrusion elements ( need to make sure no triangles left with
+ // only one adjustable or free face or else
+ // meshing a quad might trap them so they can't be meshed without
+ // internal vertex ).
+ if(!s && (edges_new.size() || problems_new.size())) s = -1;
// if quads are done, finish all triangles
- if( !quad_tmp.size() )
- finish_all_tri = true;
+ if(!quad_tmp.size()) finish_all_tri = true;
- } // end of s-loop to choose between tri or quad
+ } // end of s-loop to choose between tri or quad
- } // end of while
+ } // end of while
return 1;
-
}
-
-// For use in QuadToTriEdgeGenerator: Does the edging of prisms with some but not all vertices
-// on a lateral boundary surface.
-// Added 04/08/2011
-static int makeEdgesForOtherBndPrisms(GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- MVertexRTree &pos)
+// For use in QuadToTriEdgeGenerator: Does the edging of prisms with some but
+// not all vertices on a lateral boundary surface. Added 04/08/2011
+static int makeEdgesForOtherBndPrisms(
+ GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ MVertexRTree &pos)
{
-
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In makeEdgesForOtherBndPrisms(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return 0;
}
GModel *model = gr->model();
- if( !model ){
+ if(!model) {
Msg::Error("In makeEdgesForOtherBndPrisms(), invalid model for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
- Msg::Error("In makeEdgesForOtherBndPrisms(), invalid source face for region "
- "%d.", gr->tag() );
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
+ Msg::Error(
+ "In makeEdgesForOtherBndPrisms(), invalid source face for region "
+ "%d.",
+ gr->tag());
return 0;
}
- if( gr != cat_src_elems.region || reg_source != cat_src_elems.source_face ){
- Msg::Error("In makeEdgesForOtherBndPrisms(), CatergorizedSourceElements structure data "
- " does not correspond to region %d.", reg_source->tag() );
+ if(gr != cat_src_elems.region || reg_source != cat_src_elems.source_face) {
+ Msg::Error("In makeEdgesForOtherBndPrisms(), CatergorizedSourceElements "
+ "structure data "
+ " does not correspond to region %d.",
+ reg_source->tag());
return 0;
}
- std::set<unsigned int >::iterator it;
+ std::set<unsigned int>::iterator it;
// skip the whole thing if this is true...NO reason to divide!!
- if( !lat_tri_diags.size() && !reg_source->quadrangles.size() )
- return 1;
-
+ if(!lat_tri_diags.size() && !reg_source->quadrangles.size()) return 1;
// edge other_bnd triangles loop
// (draw from boundaries up toward interior)
- for( it = cat_src_elems.other_bnd_tri.begin();
- it != cat_src_elems.other_bnd_tri.end(); it++ ){
-
-
- std::set<std::pair<MVertex*,MVertex*> > edges_new, forbidden_new;
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > problems_new;
- std::vector<MVertex*> verts;
+ for(it = cat_src_elems.other_bnd_tri.begin();
+ it != cat_src_elems.other_bnd_tri.end(); it++) {
+ std::set<std::pair<MVertex *, MVertex *> > edges_new, forbidden_new;
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ problems_new;
+ std::vector<MVertex *> verts;
std::vector<bool> vert_bnd;
MElement *elem = reg_source->triangles[(*it)];
int elem_size = elem->getNumVertices();
- vert_bnd.insert( vert_bnd.begin(), cat_src_elems.tri_bool.begin()+(4*(*it)+1),
- cat_src_elems.tri_bool.begin()+(4*(*it)+4) );
+ vert_bnd.insert(vert_bnd.begin(),
+ cat_src_elems.tri_bool.begin() + (4 * (*it) + 1),
+ cat_src_elems.tri_bool.begin() + (4 * (*it) + 4));
int j_start, k_start;
- // if has lat_tri_diags or is a rotation with quads (may have to do the one point bnd quads to
- // get rid of degenerate hexahedra...they are invalid mesh volumes.
- if( lat_tri_diags.size() || ( reg_source->quadrangles.size() && (
- ep->geo.Type == ROTATE || ep->geo.Type == TRANSLATE_ROTATE ) ) ){
+ // if has lat_tri_diags or is a rotation with quads (may have to do the one
+ // point bnd quads to get rid of degenerate hexahedra...they are invalid
+ // mesh volumes.
+ if(lat_tri_diags.size() ||
+ (reg_source->quadrangles.size() &&
+ (ep->geo.Type == ROTATE || ep->geo.Type == TRANSLATE_ROTATE))) {
j_start = 0;
k_start = 0;
}
- else{
- j_start = ep->mesh.NbLayer-1;
- k_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer-1]-1;
+ else {
+ j_start = ep->mesh.NbLayer - 1;
+ k_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1] - 1;
}
// add edges
- for( int j = j_start; j < ep->mesh.NbLayer; j++ ){
+ for(int j = j_start; j < ep->mesh.NbLayer; j++) {
int k_start_tmp, k_stop;
- if( j == j_start )
+ if(j == j_start)
k_start_tmp = k_start;
else
k_start_tmp = 0;
k_stop = ep->mesh.NbElmLayer[j];
- for( int k = k_start_tmp; k < k_stop; k++ ){
+ for(int k = k_start_tmp; k < k_stop; k++) {
std::vector<MVertex *> verts;
getExtrudedVertices(elem, ep, j, k, pos, verts);
- // NOTE: bnd_face might not really be a bnd_face, but the code takes that into account below.
- for( int p = 0; p < elem_size; p++ ){
- if( vert_bnd[p] ){
+ // NOTE: bnd_face might not really be a bnd_face, but the code takes
+ // that into account below.
+ for(int p = 0; p < elem_size; p++) {
+ if(vert_bnd[p]) {
bool degen = false;
- int p2 = (p+1)%elem_size;
- int p3 = (p+elem_size-1)%elem_size;
+ int p2 = (p + 1) % elem_size;
+ int p3 = (p + elem_size - 1) % elem_size;
// test for degeneracy
- if( verts[p] == verts[p+elem_size] )
- degen = true;
- if( !degen && !vert_bnd[p2] ){
- createEdge( verts[p], verts[p2+elem_size], quadToTri_edges );
- createEdge( verts[p], verts[p2+elem_size], edges_new );
+ if(verts[p] == verts[p + elem_size]) degen = true;
+ if(!degen && !vert_bnd[p2]) {
+ createEdge(verts[p], verts[p2 + elem_size], quadToTri_edges);
+ createEdge(verts[p], verts[p2 + elem_size], edges_new);
}
- if( !degen && !vert_bnd[p3] ){
- createEdge( verts[p], verts[p3+elem_size], quadToTri_edges );
- createEdge( verts[p], verts[p3+elem_size], edges_new );
+ if(!degen && !vert_bnd[p3]) {
+ createEdge(verts[p], verts[p3 + elem_size], quadToTri_edges);
+ createEdge(verts[p], verts[p3 + elem_size], edges_new);
}
// make the adjustable diag (if it exists)
- // Note: p might not really be a bnd face, but this takes that into account
- if( edgeExists( verts[p], verts[p2+elem_size], lat_tri_diags ) &&
- !edgeExists( verts[p+elem_size], verts[p2], quadToTri_edges ) )
- createEdge( verts[p], verts[p2+elem_size], quadToTri_edges );
- else if( edgeExists( verts[p+elem_size], verts[p2], lat_tri_diags ) &&
- !edgeExists( verts[p], verts[p2+elem_size], quadToTri_edges ) )
- createEdge( verts[p+elem_size], verts[p2], quadToTri_edges );
+ // Note: p might not really be a bnd face, but this takes that into
+ // account
+ if(edgeExists(verts[p], verts[p2 + elem_size], lat_tri_diags) &&
+ !edgeExists(verts[p + elem_size], verts[p2], quadToTri_edges))
+ createEdge(verts[p], verts[p2 + elem_size], quadToTri_edges);
+ else if(edgeExists(verts[p + elem_size], verts[p2],
+ lat_tri_diags) &&
+ !edgeExists(verts[p], verts[p2 + elem_size],
+ quadToTri_edges))
+ createEdge(verts[p + elem_size], verts[p2], quadToTri_edges);
}
}
}
}
- } // end of boundary triangles loop
+ } // end of boundary triangles loop
return 1;
-
}
-
-// For use in QuadToTriEdgeGenerator: Does the edging of hexahedra with some but not all vertices
-// on a lateral boundary surface.
-// Added 04/08/2011
-static int makeEdgesForOtherBndHexa(GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- MVertexRTree &pos)
+// For use in QuadToTriEdgeGenerator: Does the edging of hexahedra with some
+// but not all vertices on a lateral boundary surface. Added 04/08/2011
+static int makeEdgesForOtherBndHexa(
+ GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ MVertexRTree &pos)
{
-
- // Edge creation for extruded quadrangles with some but not all vertices on a boundary.
- // (draw from boundaries up toward interior)
- // If no lat_tri_diags, just do the top layer.
- // Follow these instructions:
- // For 2 pts on boundary:
- // Below top level, draw top diags only if there are lat_tri_diags touching elemnt or if
- // element is not adjacent to any boundary (only touching it)
+ // Edge creation for extruded quadrangles with some but not all vertices on a
+ // boundary. (draw from boundaries up toward interior) If no lat_tri_diags,
+ // just do the top layer. Follow these instructions: For 2 pts on boundary:
+ // Below top level, draw top diags only if there are lat_tri_diags touching
+ // elemnt or if element is not adjacent to any boundary (only touching it)
// Order of precedence in top edging decisions:
// a. if bottom diag exists, align top diagonal to it.
- // b. if bnd vertices are on diametrically opposite corners, draw top diag NOT on them.
- // c. if lateral surface diagonals touch element, connect to one at some vertex.
- // d. otherwise, don't draw top diagonal.
- // In any case, draw the lateral edges up from bottom boundary vertices toward interior.
- // At top level, top diagonals should already be done in 2D mesh step.
+ // b. if bnd vertices are on diametrically opposite corners, draw top diag
+ // NOT on them. c. if lateral surface diagonals touch element, connect to
+ // one at some vertex. d. otherwise, don't draw top diagonal.
+ // In any case, draw the lateral edges up from bottom boundary vertices
+ // toward interior. At top level, top diagonals should already be done in 2D
+ // mesh step.
// For 3 pts on boundary:
- // Draw the top diag from corner inward. Draw laterals up from bottom boundary vertices.
+ // Draw the top diag from corner inward. Draw laterals up from bottom
+ // boundary vertices.
// For 1 point on boundary:
- // Draw lateral diagonals up from bottom boundary verts, draw top diagonal completely off the boundary.
- // Draw diagonals toward the "pivot vertex", which is the vertex in the top element face
- // diametrically opposite to the top face vertex on the boundary. Actually, this is only
- // done in the first two extrusion layers, if those layers are not in the top layer.
- // In first layer, draw diags to the top vertex diametrically opposite bnd vert, in the second
- // layer, draw them down to the bottom such vertex. Same vertex for both layers. This is
- // done to ensure that a one pt boundary quad in an unstructured surface can be divided without
- // dividing the entire bottom layer. If two pivot vertices share an edge and these rules would conflict,
- // just give precedence to the first pivot vertex encountered in the edging loop (this works, yes).
- // Also, the internal elements touching this pivot vertex should
- // have diagonals drawn to pivot vertex as well (done in different function, with same precedence).
+ // Draw lateral diagonals up from bottom boundary verts, draw top diagonal
+ // completely off the boundary. Draw diagonals toward the "pivot vertex",
+ // which is the vertex in the top element face diametrically opposite to the
+ // top face vertex on the boundary. Actually, this is only done in the first
+ // two extrusion layers, if those layers are not in the top layer. In first
+ // layer, draw diags to the top vertex diametrically opposite bnd vert, in
+ // the second layer, draw them down to the bottom such vertex. Same vertex
+ // for both layers. This is done to ensure that a one pt boundary quad in an
+ // unstructured surface can be divided without dividing the entire bottom
+ // layer. If two pivot vertices share an edge and these rules would conflict,
+ // just give precedence to the first pivot vertex encountered in the edging
+ // loop (this works, yes). Also, the internal elements touching this pivot
+ // vertex should have diagonals drawn to pivot vertex as well (done in
+ // different function, with same precedence).
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In makeEdgesForOtherBndHexa(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return 0;
}
GModel *model = gr->model();
- if( !model ){
+ if(!model) {
Msg::Error("In makeEdgesForOtherBndHexa(), invalid model for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
Msg::Error("In makeEdgesForOtherBndHexa(), invalid source face for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
- if( gr != cat_src_elems.region || reg_source != cat_src_elems.source_face ){
- Msg::Error("In makeEdgesForOtherBndHexa(), CatergorizedSourceElements structure data "
- " does not correspond to region %d.", reg_source->tag() );
+ if(gr != cat_src_elems.region || reg_source != cat_src_elems.source_face) {
+ Msg::Error("In makeEdgesForOtherBndHexa(), CatergorizedSourceElements "
+ "structure data "
+ " does not correspond to region %d.",
+ reg_source->tag());
return 0;
}
std::set<unsigned int>::iterator it;
- for( it = cat_src_elems.other_bnd_quad.begin();
- it != cat_src_elems.other_bnd_quad.end(); it++ ){
-
+ for(it = cat_src_elems.other_bnd_quad.begin();
+ it != cat_src_elems.other_bnd_quad.end(); it++) {
MElement *elem = reg_source->quadrangles[(*it)];
const int elem_size = elem->getNumVertices();
std::vector<bool> vert_bnd;
- vert_bnd.insert( vert_bnd.begin(), cat_src_elems.quad_bool.begin()+(5*(*it)+1),
- cat_src_elems.quad_bool.begin()+(5*(*it)+5) );
+ vert_bnd.insert(vert_bnd.begin(),
+ cat_src_elems.quad_bool.begin() + (5 * (*it) + 1),
+ cat_src_elems.quad_bool.begin() + (5 * (*it) + 5));
// these locally hold each added edge/problem element temporarily
- std::set< std::pair<MVertex *, MVertex *> > edges_new;
- std::set< std::pair<MVertex *, MVertex *> > forbidden_new;
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > problems_new;
+ std::set<std::pair<MVertex *, MVertex *> > edges_new;
+ std::set<std::pair<MVertex *, MVertex *> > forbidden_new;
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ problems_new;
- // Get a count of bnd verts. If one point, that index will be in one_point_ind.
- // For 3 bnd vert quads record the empty spot in 'skip.'
+ // Get a count of bnd verts. If one point, that index will be in
+ // one_point_ind. For 3 bnd vert quads record the empty spot in 'skip.'
int bnd_count = 0, skip = 0, one_point_ind = 0;
- for( int s = 0; s < elem_size; s++ ){
- if( vert_bnd[s] ){
+ for(int s = 0; s < elem_size; s++) {
+ if(vert_bnd[s]) {
bnd_count++;
one_point_ind = s;
}
- else skip = s;
+ else
+ skip = s;
}
int j_start, k_start;
- // if has lat_tri_diags or is a rotation with quads (may have to do the one point bnd quads to
- // get rid of degenerate hexahedra...they are invalid mesh volumes.
- if( lat_tri_diags.size() || ( reg_source->quadrangles.size() && (
- ep->geo.Type == ROTATE || ep->geo.Type == TRANSLATE_ROTATE ) ) ){
+ // if has lat_tri_diags or is a rotation with quads (may have to do the one
+ // point bnd quads to get rid of degenerate hexahedra...they are invalid
+ // mesh volumes.
+ if(lat_tri_diags.size() ||
+ (reg_source->quadrangles.size() &&
+ (ep->geo.Type == ROTATE || ep->geo.Type == TRANSLATE_ROTATE))) {
j_start = 0;
k_start = 0;
}
- else{
- j_start = ep->mesh.NbLayer-1;
- k_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer-1]-1;
+ else {
+ j_start = ep->mesh.NbLayer - 1;
+ k_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1] - 1;
}
// start of top layer
- int j_top_start = ep->mesh.NbLayer-1;
- int k_top_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer-1]-1;
+ int j_top_start = ep->mesh.NbLayer - 1;
+ int k_top_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1] - 1;
// add edges:
// lateral diags in any case
- for( int j = j_start; j < ep->mesh.NbLayer; j++ ){
+ for(int j = j_start; j < ep->mesh.NbLayer; j++) {
int k_start_tmp, k_stop;
- if( j == j_start )
+ if(j == j_start)
k_start_tmp = k_start;
else
k_start_tmp = 0;
k_stop = ep->mesh.NbElmLayer[j];
- for( int k = k_start_tmp; k < k_stop; k++ ){
+ for(int k = k_start_tmp; k < k_stop; k++) {
std::vector<MVertex *> verts;
getExtrudedVertices(elem, ep, j, k, pos, verts);
// int bnd_face = -1;
- // NOTE: bnd_face might not really be a bnd_face, but don't worry--it won't be diagonalized if not
- for( int p = 0; p < elem_size; p++ ){
- int p2 = (p+1)%elem_size;
- int p3 = (p+elem_size-1)%elem_size;
- if( vert_bnd[p] ){
+ // NOTE: bnd_face might not really be a bnd_face, but don't worry--it
+ // won't be diagonalized if not
+ for(int p = 0; p < elem_size; p++) {
+ int p2 = (p + 1) % elem_size;
+ int p3 = (p + elem_size - 1) % elem_size;
+ if(vert_bnd[p]) {
bool degen = false;
// test for degeneracy
- if( verts[p] == verts[p+elem_size] )
- degen = true;
- if( !degen && !vert_bnd[p2] )
- createEdge( verts[p], verts[p2+elem_size], quadToTri_edges );
- if( !degen && !vert_bnd[p3] )
- createEdge( verts[p], verts[p3+elem_size], quadToTri_edges );
+ if(verts[p] == verts[p + elem_size]) degen = true;
+ if(!degen && !vert_bnd[p2])
+ createEdge(verts[p], verts[p2 + elem_size], quadToTri_edges);
+ if(!degen && !vert_bnd[p3])
+ createEdge(verts[p], verts[p3 + elem_size], quadToTri_edges);
// make the adjustable diag
- if( edgeExists( verts[p], verts[p2+elem_size], lat_tri_diags ) &&
- !edgeExists( verts[p+elem_size], verts[p2], quadToTri_edges ) )
- createEdge( verts[p], verts[p2+elem_size], quadToTri_edges );
- else if( edgeExists( verts[p+elem_size], verts[p2], lat_tri_diags ) &&
- !edgeExists( verts[p], verts[p2+elem_size], quadToTri_edges ) )
- createEdge( verts[p+elem_size], verts[p2], quadToTri_edges );
+ if(edgeExists(verts[p], verts[p2 + elem_size], lat_tri_diags) &&
+ !edgeExists(verts[p + elem_size], verts[p2], quadToTri_edges))
+ createEdge(verts[p], verts[p2 + elem_size], quadToTri_edges);
+ else if(edgeExists(verts[p + elem_size], verts[p2],
+ lat_tri_diags) &&
+ !edgeExists(verts[p], verts[p2 + elem_size],
+ quadToTri_edges))
+ createEdge(verts[p + elem_size], verts[p2], quadToTri_edges);
}
// if face not on boundary and in top layer...make an internal lateral
- else if( j == j_top_start && k == k_top_start && !vert_bnd[p2] ){
+ else if(j == j_top_start && k == k_top_start && !vert_bnd[p2]) {
int ind_low, ind2;
- if( verts[p+elem_size] < verts[p2+elem_size] ){
- ind_low = p+elem_size;
+ if(verts[p + elem_size] < verts[p2 + elem_size]) {
+ ind_low = p + elem_size;
ind2 = p2;
}
- else{
- ind_low = p2+elem_size;
+ else {
+ ind_low = p2 + elem_size;
ind2 = p;
}
- createEdge( verts[ind_low], verts[ind2], quadToTri_edges );
+ createEdge(verts[ind_low], verts[ind2], quadToTri_edges);
}
-
}
}
}
-
// Add top diags for 2-bnd point quads, below top layer
- // If there is a lateral diagonal, connect to it. If this is a two boundary point quad
- // that is not adjacent to a boundary (it is possible), draw diagonal completely off boundary.
- // If neither of the above, don't make the top diagonal.
- // IF degenerate, be careful.
- if( bnd_count == 2 ){
- for( int j = j_start; j < ep->mesh.NbLayer; j++ ){
+ // If there is a lateral diagonal, connect to it. If this is a two boundary
+ // point quad that is not adjacent to a boundary (it is possible), draw
+ // diagonal completely off boundary. If neither of the above, don't make the
+ // top diagonal. IF degenerate, be careful.
+ if(bnd_count == 2) {
+ for(int j = j_start; j < ep->mesh.NbLayer; j++) {
int k_start_tmp, k_stop;
- if( j == j_start )
+ if(j == j_start)
k_start_tmp = k_start;
else
k_start_tmp = 0;
k_stop = ep->mesh.NbElmLayer[j];
- if( j == ep->mesh.NbLayer-1 )
- k_stop--; // dont go to top elements
- for( int k = k_start_tmp; k < k_stop; k++ ){
+ if(j == ep->mesh.NbLayer - 1) k_stop--; // dont go to top elements
+ for(int k = k_start_tmp; k < k_stop; k++) {
std::vector<MVertex *> verts;
getExtrudedVertices(elem, ep, j, k, pos, verts);
int p1 = -1, p2 = -1;
- for( int p = 0; p < elem_size; p++ ){
- if( vert_bnd[p] ){
+ for(int p = 0; p < elem_size; p++) {
+ if(vert_bnd[p]) {
p1 = p;
- int p2_tmp = (p+1)%elem_size;
- int p3_tmp = (p+elem_size-1)%elem_size;
- if( vert_bnd[p2_tmp] ){
- p1 = p; p2 = p2_tmp;
+ int p2_tmp = (p + 1) % elem_size;
+ int p3_tmp = (p + elem_size - 1) % elem_size;
+ if(vert_bnd[p2_tmp]) {
+ p1 = p;
+ p2 = p2_tmp;
}
- else if( vert_bnd[p3_tmp] ){
- p1 = p3_tmp; p2 = p;
+ else if(vert_bnd[p3_tmp]) {
+ p1 = p3_tmp;
+ p2 = p;
}
break;
}
}
- if( p2 < 0 && p1 < 0 ){
- Msg::Error("In makeEdgesForOtherBndHexa(), error finding boundary points on "
- "2-boundary point quadrangle.");
+ if(p2 < 0 && p1 < 0) {
+ Msg::Error(
+ "In makeEdgesForOtherBndHexa(), error finding boundary points on "
+ "2-boundary point quadrangle.");
break;
}
- // First, if bottom diagonal exists, align top diagonal to it, OTHERWISE:
+ // First, if bottom diagonal exists, align top diagonal to it,
+ // OTHERWISE:
// if bnd verts oppose each other, draw top diagonal off boundary
- // otherwise, connect to any existing lateral diagonal either totally ON boundary or totally OFF,
- // but ONLY draw top diag if such a lateral exists
- // NOTE: since laterals were added first, any lat_tri_diag here is in quadToTri_edges already
- if( edgeExists( verts[0], verts[2], quadToTri_edges ) )
- createEdge( verts[4], verts[6], quadToTri_edges );
- else if( edgeExists( verts[1], verts[3], quadToTri_edges ) )
- createEdge( verts[5], verts[7], quadToTri_edges );
- else if( p2 < 0 && p1 >= 0 )
- createEdge( verts[(p1+1)%elem_size+elem_size],
- verts[(p1+elem_size-1)%elem_size+elem_size], quadToTri_edges );
- else if( p1 >= 0 && edgeExists( verts[p1], verts[p2+elem_size], quadToTri_edges ) )
- createEdge( verts[p2+elem_size], verts[(p2+2)%elem_size+elem_size], quadToTri_edges );
- else if( p1 >= 0 && edgeExists( verts[p1+elem_size], verts[p2], quadToTri_edges ) )
- createEdge( verts[p1+elem_size], verts[(p1+2)%elem_size+elem_size], quadToTri_edges );
+ // otherwise, connect to any existing lateral diagonal either
+ // totally ON boundary or totally OFF, but ONLY draw top diag if
+ // such a lateral exists
+ // NOTE: since laterals were added first, any lat_tri_diag here is in
+ // quadToTri_edges already
+ if(edgeExists(verts[0], verts[2], quadToTri_edges))
+ createEdge(verts[4], verts[6], quadToTri_edges);
+ else if(edgeExists(verts[1], verts[3], quadToTri_edges))
+ createEdge(verts[5], verts[7], quadToTri_edges);
+ else if(p2 < 0 && p1 >= 0)
+ createEdge(verts[(p1 + 1) % elem_size + elem_size],
+ verts[(p1 + elem_size - 1) % elem_size + elem_size],
+ quadToTri_edges);
+ else if(p1 >= 0 &&
+ edgeExists(verts[p1], verts[p2 + elem_size], quadToTri_edges))
+ createEdge(verts[p2 + elem_size],
+ verts[(p2 + 2) % elem_size + elem_size],
+ quadToTri_edges);
+ else if(p1 >= 0 &&
+ edgeExists(verts[p1 + elem_size], verts[p2], quadToTri_edges))
+ createEdge(verts[p1 + elem_size],
+ verts[(p1 + 2) % elem_size + elem_size],
+ quadToTri_edges);
}
}
}
-
- // top diags on corner quad ( I *think* this always works for non-degen stuff, even for free wall spanning cases )
- else if( bnd_count == 3 && ( j_start < j_top_start || k_start < k_top_start ) ){
+ // top diags on corner quad ( I *think* this always works for non-degen
+ // stuff, even for free wall spanning cases )
+ else if(bnd_count == 3 &&
+ (j_start < j_top_start || k_start < k_top_start)) {
std::vector<MVertex *> verts;
getExtrudedVertices(elem, ep, j_start, k_start, pos, verts);
problems_new.clear();
forbidden_new.clear();
edges_new.clear();
- createEdge( verts[skip+elem_size], verts[(skip+2)%elem_size+elem_size], quadToTri_edges );
- createEdge( verts[skip+elem_size], verts[(skip+2)%elem_size+elem_size], edges_new );
- // copies the diags in edges_new on up the extrusion but NOT on the top surface
- ExtrudeDiags(gr, verts, j_start, k_start, j_top_start, k_top_start,
- elem, ep, edges_new, forbidden_new,
- quadToTri_edges, forbidden_edges, problems_new, problems, pos);
+ createEdge(verts[skip + elem_size],
+ verts[(skip + 2) % elem_size + elem_size], quadToTri_edges);
+ createEdge(verts[skip + elem_size],
+ verts[(skip + 2) % elem_size + elem_size], edges_new);
+ // copies the diags in edges_new on up the extrusion but NOT on the top
+ // surface
+ ExtrudeDiags(gr, verts, j_start, k_start, j_top_start, k_top_start, elem,
+ ep, edges_new, forbidden_new, quadToTri_edges,
+ forbidden_edges, problems_new, problems, pos);
}
// finally, top diagonal and other two laterals for 1 bnd point quad
- else if( bnd_count == 1 && ( j_start < j_top_start || k_start < k_top_start ) ){
- std::vector<MVertex*> verts;
+ else if(bnd_count == 1 &&
+ (j_start < j_top_start || k_start < k_top_start)) {
+ std::vector<MVertex *> verts;
getExtrudedVertices(elem, ep, j_start, k_start, pos, verts);
int p = one_point_ind;
- // to determine if there is a second level above the start but not in top layer
+ // to determine if there is a second level above the start but not in top
+ // layer
int j_next, k_next;
bool divide_next = false;
- std::vector<MVertex*> verts_next;
- if( ep->mesh.NbElmLayer[0] > 1 ){
+ std::vector<MVertex *> verts_next;
+ if(ep->mesh.NbElmLayer[0] > 1) {
j_next = 0;
k_next = 1;
}
- else{
- j_next = std::min(ep->mesh.NbLayer-1, 1);
+ else {
+ j_next = std::min(ep->mesh.NbLayer - 1, 1);
k_next = 0;
}
- if( j_next < j_top_start || k_next < k_top_start ){
+ if(j_next < j_top_start || k_next < k_top_start) {
divide_next = true;
getExtrudedVertices(elem, ep, j_next, k_next, pos, verts_next);
}
@@ -3265,142 +3438,148 @@ static int makeEdgesForOtherBndHexa(GRegion *gr, bool is_addverts, CategorizedSo
forbidden_new.clear();
edges_new.clear();
- // Create the laterals that run up to the "pivot vertex" for this 1 bnd pt quad
- // Other internal elements have diagonals converging on the pivot index.
- // Only create it if there is NO conflicting diagonal in place, though--this CAN happen,
- // but this approach still give no conflicts.
+ // Create the laterals that run up to the "pivot vertex" for this 1 bnd pt
+ // quad Other internal elements have diagonals converging on the pivot
+ // index. Only create it if there is NO conflicting diagonal in place,
+ // though--this CAN happen, but this approach still give no conflicts.
// NOTE THAT THESE ARE NOT PROPAGATED UP THE ENTIRE EXTRUSION.
- int p2 = (p+1)%elem_size;
- int p3 = (p+2)%elem_size;
- int p4 = (p+elem_size-1)%elem_size;
- if( !edgeExists( verts[p2+elem_size], verts[p3], quadToTri_edges ) )
- createEdge( verts[p2], verts[p3+elem_size], quadToTri_edges );
- if( !edgeExists( verts[p4+elem_size], verts[p3], quadToTri_edges ) )
- createEdge( verts[p4], verts[p3+elem_size], quadToTri_edges );
-
- // if there is a second extrusion level not on the top layer, add the 'reverse' of the
- // previous two diagonals
- if( divide_next && !edgeExists( verts_next[p2], verts_next[p3+elem_size], quadToTri_edges ) )
- createEdge( verts_next[p2+elem_size], verts_next[p3], quadToTri_edges );
- if( divide_next && !edgeExists( verts_next[p4], verts_next[p3+elem_size], quadToTri_edges ) )
- createEdge( verts_next[p4+elem_size], verts_next[p3], quadToTri_edges );
-
- // If this quad has degenerate vertex on boundary and the pivot laterals run to the
- // top pivot vertex and there is no pre-existing
- // top diagonal on other two vertices, draw diagonal out to
- // the pivot_vertex. Otherwise, draw it on the other two verts
- if( verts[p] == verts[p+elem_size] &&
- ( edgeExists( verts[p2], verts[p3+elem_size], quadToTri_edges ) ||
- verts[p2] == verts[p2+elem_size] ) &&
- ( edgeExists( verts[p4], verts[p3+elem_size], quadToTri_edges ) ||
- verts[p4] == verts[p4+elem_size] ) &&
- !edgeExists( verts[p2+elem_size], verts[p4+elem_size], quadToTri_edges ) ){
- createEdge( verts[p+elem_size], verts[p3+elem_size], quadToTri_edges );
- createEdge( verts[p+elem_size], verts[p3+elem_size], edges_new );
- }
- else{
- createEdge( verts[p2+elem_size], verts[p4+elem_size], quadToTri_edges );
- createEdge( verts[p2+elem_size], verts[p4+elem_size], edges_new );
- }
- // copies the top diag in edges_new up the extrusion but NOT to the top surface of region.
- ExtrudeDiags( gr, verts, 0, 0, j_top_start, k_top_start,
- elem, ep, edges_new, forbidden_new,
- quadToTri_edges, forbidden_edges, problems_new, problems, pos);
- }
-
- } // end of boundary quadrangles loop
+ int p2 = (p + 1) % elem_size;
+ int p3 = (p + 2) % elem_size;
+ int p4 = (p + elem_size - 1) % elem_size;
+ if(!edgeExists(verts[p2 + elem_size], verts[p3], quadToTri_edges))
+ createEdge(verts[p2], verts[p3 + elem_size], quadToTri_edges);
+ if(!edgeExists(verts[p4 + elem_size], verts[p3], quadToTri_edges))
+ createEdge(verts[p4], verts[p3 + elem_size], quadToTri_edges);
+
+ // if there is a second extrusion level not on the top layer, add the
+ // 'reverse' of the previous two diagonals
+ if(divide_next && !edgeExists(verts_next[p2], verts_next[p3 + elem_size],
+ quadToTri_edges))
+ createEdge(verts_next[p2 + elem_size], verts_next[p3], quadToTri_edges);
+ if(divide_next && !edgeExists(verts_next[p4], verts_next[p3 + elem_size],
+ quadToTri_edges))
+ createEdge(verts_next[p4 + elem_size], verts_next[p3], quadToTri_edges);
+
+ // If this quad has degenerate vertex on boundary and the pivot laterals
+ // run to the top pivot vertex and there is no pre-existing top diagonal
+ // on other two vertices, draw diagonal out to the pivot_vertex.
+ // Otherwise, draw it on the other two verts
+ if(verts[p] == verts[p + elem_size] &&
+ (edgeExists(verts[p2], verts[p3 + elem_size], quadToTri_edges) ||
+ verts[p2] == verts[p2 + elem_size]) &&
+ (edgeExists(verts[p4], verts[p3 + elem_size], quadToTri_edges) ||
+ verts[p4] == verts[p4 + elem_size]) &&
+ !edgeExists(verts[p2 + elem_size], verts[p4 + elem_size],
+ quadToTri_edges)) {
+ createEdge(verts[p + elem_size], verts[p3 + elem_size],
+ quadToTri_edges);
+ createEdge(verts[p + elem_size], verts[p3 + elem_size], edges_new);
+ }
+ else {
+ createEdge(verts[p2 + elem_size], verts[p4 + elem_size],
+ quadToTri_edges);
+ createEdge(verts[p2 + elem_size], verts[p4 + elem_size], edges_new);
+ }
+ // copies the top diag in edges_new up the extrusion but NOT to the top
+ // surface of region.
+ ExtrudeDiags(gr, verts, 0, 0, j_top_start, k_top_start, elem, ep,
+ edges_new, forbidden_new, quadToTri_edges, forbidden_edges,
+ problems_new, problems, pos);
+ }
+
+ } // end of boundary quadrangles loop
return 1;
-
}
-
-// For use in QuadToTriEdgeGenerator: Does the lateral edging of internal elements that touch
-// a pivot vertex of a hexahedral element that has ONE SOURCE vertex on a lateral boundary surface.
-// See inside function for a definition of the "pivot vertex."
-// Added 04/08/2011
-static int makeEdgesForElemsTouchPivotVert(GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::set<std::pair<MVertex*, MVertex*> > &forbidden_edges,
- MVertexRTree &pos)
+// For use in QuadToTriEdgeGenerator: Does the lateral edging of internal
+// elements that touch a pivot vertex of a hexahedral element that has ONE
+// SOURCE vertex on a lateral boundary surface. See inside function for a
+// definition of the "pivot vertex." Added 04/08/2011
+static int makeEdgesForElemsTouchPivotVert(
+ GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::set<std::pair<MVertex *, MVertex *> > &forbidden_edges,
+ MVertexRTree &pos)
{
-
- // Draw diagonals toward the "pivot vertex" of a hexahedron whose source quad has only one
- // vertex on a lateral boundary. Actually, this is only
- // done in the first two extrusion layers, if those layers are not in the top layer. The pivot
- // vertex is the vertex in the top face of the element that is diametrically opposite the top vertex
- // on the lateral boundary of the region.
- // In first layer, draw diags up from bottom to the pivot vertex, in the second
- // layer, draw them down to pivot vertex. Same vertex for both layers. This is
- // done to ensure that a one pt boundary quad in an unstructured surface can be divided without
- // dividing the entire bottom layer.
- // If two pivot vertices share an edge and these rules would conflict,
- // just give precedence to the first pivot vertex encountered in the edging loop (this works, yes).
-
+ // Draw diagonals toward the "pivot vertex" of a hexahedron whose source quad
+ // has only one vertex on a lateral boundary. Actually, this is only done in
+ // the first two extrusion layers, if those layers are not in the top layer.
+ // The pivot vertex is the vertex in the top face of the element that is
+ // diametrically opposite the top vertex on the lateral boundary of the
+ // region. In first layer, draw diags up from bottom to the pivot vertex, in
+ // the second layer, draw them down to pivot vertex. Same vertex for both
+ // layers. This is done to ensure that a one pt boundary quad in an
+ // unstructured surface can be divided without dividing the entire bottom
+ // layer. If two pivot vertices share an edge and these rules would conflict,
+ // just give precedence to the first pivot vertex encountered in the edging
+ // loop (this works, yes).
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In makeEdgesForElemsTouchPivotVert(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return 0;
}
GModel *model = gr->model();
- if( !model ){
+ if(!model) {
Msg::Error("In makeEdgesForElemsTouchPivotVert(), invalid model for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
- Msg::Error("In makeEdgesForForElemsTouchPivotVert(), invalid source face for region "
- "%d.", gr->tag() );
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
+ Msg::Error(
+ "In makeEdgesForForElemsTouchPivotVert(), invalid source face for region "
+ "%d.",
+ gr->tag());
return 0;
}
- if( gr != cat_src_elems.region || reg_source != cat_src_elems.source_face ){
- Msg::Error("In makeEdgesForElemsTouchPivotVert(), CatergorizedSourceElements structure data "
- " does not correspond to region %d.", reg_source->tag() );
+ if(gr != cat_src_elems.region || reg_source != cat_src_elems.source_face) {
+ Msg::Error("In makeEdgesForElemsTouchPivotVert(), "
+ "CatergorizedSourceElements structure data "
+ " does not correspond to region %d.",
+ reg_source->tag());
return 0;
}
// return if there are no lateral surface diagonals and if not a rotation with
// quadrangles.
- if( !lat_tri_diags.size() && ( !reg_source->quadrangles.size() ||
- (ep->geo.Type != ROTATE &&
- ep->geo.Type != TRANSLATE_ROTATE) ) )
+ if(!lat_tri_diags.size() &&
+ (!reg_source->quadrangles.size() ||
+ (ep->geo.Type != ROTATE && ep->geo.Type != TRANSLATE_ROTATE)))
return 1;
// Return if there is only one extrude layer!!!!
- // (everything gets taken care of because all elements in top layer are divided)
- // ( in fact, this will cause problems if performed )
- if( ep->mesh.NbLayer <= 1 && ep->mesh.NbElmLayer[0] <= 1 )
- return 1;
+ // (everything gets taken care of because all elements in top layer are
+ // divided) ( in fact, this will cause problems if performed )
+ if(ep->mesh.NbLayer <= 1 && ep->mesh.NbElmLayer[0] <= 1) return 1;
int j_top_start, k_top_start;
- j_top_start = ep->mesh.NbLayer-1;
- k_top_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer-1]-1;
+ j_top_start = ep->mesh.NbLayer - 1;
+ k_top_start = ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1] - 1;
// s = 0 for triangles; s = 1 for quadrangles
// These diags are all repeated identically up the extrusion.
- for( int s = 0; s < 2; s++ ){
-
-
+ for(int s = 0; s < 2; s++) {
std::set<unsigned int> *set_elems;
std::set<unsigned int>::iterator it;
- if( !s )
+ if(!s)
set_elems = &cat_src_elems.internal_tri_touch_one_bnd_pt_quad;
else
set_elems = &cat_src_elems.internal_quad_touch_one_bnd_pt_quad;
- for( it = set_elems->begin(); it != set_elems->end(); it++ ){
+ for(it = set_elems->begin(); it != set_elems->end(); it++) {
MElement *elem;
- if( !s )
+ if(!s)
elem = reg_source->triangles[(*it)];
else
elem = reg_source->quadrangles[(*it)];
@@ -3410,280 +3589,309 @@ static int makeEdgesForElemsTouchPivotVert(GRegion *gr, bool is_addverts, Catego
// find pivot vertex index
int v_index;
bool v_index_found = false;
- for( int p = 0; p < elem_size; p++ ){
- if( !s && cat_src_elems.tri_bool[4*(*it)+1+p] ){
- v_index = p; v_index_found = true; break;
+ for(int p = 0; p < elem_size; p++) {
+ if(!s && cat_src_elems.tri_bool[4 * (*it) + 1 + p]) {
+ v_index = p;
+ v_index_found = true;
+ break;
}
- else if( s && cat_src_elems.quad_bool[5*(*it)+1+p] ){
- v_index = p; v_index_found = true; break;
+ else if(s && cat_src_elems.quad_bool[5 * (*it) + 1 + p]) {
+ v_index = p;
+ v_index_found = true;
+ break;
}
}
- if( !v_index_found ){
- Msg::Error("In makeEdgesForElemsTouchPivotVert(), could not find the pivot vertex for an element touching "
- "a quad with one vertex on a face edge boundary in region %d. Skipping...", gr->tag() );
+ if(!v_index_found) {
+ Msg::Error("In makeEdgesForElemsTouchPivotVert(), could not find the "
+ "pivot vertex for an element touching "
+ "a quad with one vertex on a face edge boundary in region "
+ "%d. Skipping...",
+ gr->tag());
continue;
}
- std::vector<MVertex*> verts;
+ std::vector<MVertex *> verts;
getExtrudedVertices(elem, ep, 0, 0, pos, verts);
- // determine the j, k for the next layer above 0,0 so that the elements directly above
- // the base elements can divided AND higher layers may be closed off
- // (no need to divide the elements all the way up)
+ // determine the j, k for the next layer above 0,0 so that the elements
+ // directly above the base elements can divided AND higher layers may be
+ // closed off (no need to divide the elements all the way up)
int j_next, k_next;
bool divide_next = false;
- std::vector<MVertex*> verts_next;
- if( ep->mesh.NbElmLayer[0] > 1 ){
+ std::vector<MVertex *> verts_next;
+ if(ep->mesh.NbElmLayer[0] > 1) {
j_next = 0;
k_next = 1;
}
- else{
- j_next = std::min(ep->mesh.NbLayer-1, 1);
+ else {
+ j_next = std::min(ep->mesh.NbLayer - 1, 1);
k_next = 0;
}
- if( j_next < j_top_start || k_next < k_top_start ){
+ if(j_next < j_top_start || k_next < k_top_start) {
divide_next = true;
getExtrudedVertices(elem, ep, j_next, k_next, pos, verts_next);
}
// add the lateral diagonals (skip faces that are already diagonalized)
- // note these are created in two layers, mirrored about the plane separating the layers
- int p2 = (v_index+1)%elem_size;
- int p3 = (v_index+elem_size-1)%elem_size;
- if( !edgeExists( verts[v_index], verts[p2+elem_size], quadToTri_edges ) ){
- createEdge( verts[v_index+elem_size], verts[p2], quadToTri_edges );
- if( divide_next )
- createEdge( verts_next[v_index], verts_next[p2+elem_size], quadToTri_edges );
- }
- if( !edgeExists( verts[v_index], verts[p3+elem_size], quadToTri_edges ) ){
- createEdge( verts[v_index+elem_size], verts[p3], quadToTri_edges );
- if( divide_next )
- createEdge( verts_next[v_index], verts_next[p3+elem_size], quadToTri_edges );
- }
- // make top diagonals for quads -- note: can't just draw to the preferred pivot because
- // it can touch two and the other might have laterals drawn to it already. have to find
- // the one with two lateral diagonals drawn to it.
- if( s==1 && verts[v_index+elem_size] != verts[v_index] &&
- !edgeExists( verts[p2+elem_size], verts[p3+elem_size], quadToTri_edges ) )
- createEdge( verts[v_index+elem_size], verts[(v_index+2)%elem_size+elem_size], quadToTri_edges );
-
- }
- }
-
-
- // Now revisit the boundary quads that touched a one boundary point quad pivot. These MAY have had
- // edges added and now need a top diagonal
+ // note these are created in two layers, mirrored about the plane
+ // separating the layers
+ int p2 = (v_index + 1) % elem_size;
+ int p3 = (v_index + elem_size - 1) % elem_size;
+ if(!edgeExists(verts[v_index], verts[p2 + elem_size], quadToTri_edges)) {
+ createEdge(verts[v_index + elem_size], verts[p2], quadToTri_edges);
+ if(divide_next)
+ createEdge(verts_next[v_index], verts_next[p2 + elem_size],
+ quadToTri_edges);
+ }
+ if(!edgeExists(verts[v_index], verts[p3 + elem_size], quadToTri_edges)) {
+ createEdge(verts[v_index + elem_size], verts[p3], quadToTri_edges);
+ if(divide_next)
+ createEdge(verts_next[v_index], verts_next[p3 + elem_size],
+ quadToTri_edges);
+ }
+ // make top diagonals for quads -- note: can't just draw to the preferred
+ // pivot because it can touch two and the other might have laterals drawn
+ // to it already. have to find the one with two lateral diagonals drawn
+ // to it.
+ if(s == 1 && verts[v_index + elem_size] != verts[v_index] &&
+ !edgeExists(verts[p2 + elem_size], verts[p3 + elem_size],
+ quadToTri_edges))
+ createEdge(verts[v_index + elem_size],
+ verts[(v_index + 2) % elem_size + elem_size],
+ quadToTri_edges);
+ }
+ }
+
+ // Now revisit the boundary quads that touched a one boundary point quad
+ // pivot. These MAY have had edges added and now need a top diagonal
std::set<unsigned int>::iterator it;
- for( it = cat_src_elems.two_bnd_pt_quad_touch_one_bnd_pt_quad.begin();
- it != cat_src_elems.two_bnd_pt_quad_touch_one_bnd_pt_quad.end(); it++ ){
+ for(it = cat_src_elems.two_bnd_pt_quad_touch_one_bnd_pt_quad.begin();
+ it != cat_src_elems.two_bnd_pt_quad_touch_one_bnd_pt_quad.end(); it++) {
MElement *elem = reg_source->quadrangles[(*it)];
int elem_size = elem->getNumVertices();
std::vector<bool> vert_bnd;
- vert_bnd.insert( vert_bnd.begin(), cat_src_elems.quad_bool.begin()+(5*(*it)+1),
- cat_src_elems.quad_bool.begin()+(5*(*it)+5) );
+ vert_bnd.insert(vert_bnd.begin(),
+ cat_src_elems.quad_bool.begin() + (5 * (*it) + 1),
+ cat_src_elems.quad_bool.begin() + (5 * (*it) + 5));
// find num boundary points
int bnd_count = 0;
- for( int s = 0; s < elem_size; s++ ){
- if( vert_bnd[s] )
- bnd_count++;
+ for(int s = 0; s < elem_size; s++) {
+ if(vert_bnd[s]) bnd_count++;
}
- if( bnd_count != 2 )
- continue;
+ if(bnd_count != 2) continue;
- std::vector<MVertex*> verts;
+ std::vector<MVertex *> verts;
getExtrudedVertices(elem, ep, 0, 0, pos, verts);
int p1 = -1, p2 = -1;
- for( int p = 0; p < elem_size; p++ ){
- if( vert_bnd[p] ){
+ for(int p = 0; p < elem_size; p++) {
+ if(vert_bnd[p]) {
p1 = p;
- int p2_tmp = (p+1)%elem_size;
- int p3_tmp = (p+elem_size-1)%elem_size;
- if( vert_bnd[p2_tmp] ){
- p1 = p; p2 = p2_tmp;
+ int p2_tmp = (p + 1) % elem_size;
+ int p3_tmp = (p + elem_size - 1) % elem_size;
+ if(vert_bnd[p2_tmp]) {
+ p1 = p;
+ p2 = p2_tmp;
}
- else if( vert_bnd[p3_tmp] ){
- p1 = p3_tmp; p2 = p;
+ else if(vert_bnd[p3_tmp]) {
+ p1 = p3_tmp;
+ p2 = p;
}
break;
}
}
- if( p2 < 0 && p1 < 0 ){
- Msg::Error("In makeEdgesForElemsTouchPivotVert(), error finding boundary points on "
+ if(p2 < 0 && p1 < 0) {
+ Msg::Error("In makeEdgesForElemsTouchPivotVert(), error finding boundary "
+ "points on "
"2-boundary point quadrangle.");
break;
}
- // find lateral boundary or internal lateral diagonals. If found, add top diagonal
- std::set< std::pair<MVertex*, MVertex*> > edges_new;
- std::set< std::pair<MVertex*, MVertex*> > forbidden_new;
- std::map< MElement*, std::set< std::pair<unsigned int, unsigned int> > > problems, problems_new;
- if( p1 >= 0 && p2 >= 0 &&
- edgeExists( verts[(p1+2)%elem_size], verts[(p1+elem_size-1)%elem_size+elem_size], quadToTri_edges ) &&
- !edgeExists( verts[p1+elem_size], verts[(p1+2)%elem_size+elem_size], quadToTri_edges ) ){
- createEdge( verts[(p1+1)%elem_size+elem_size], verts[(p1+elem_size-1)%elem_size+elem_size], quadToTri_edges );
- createEdge( verts[(p1+1)%elem_size+elem_size], verts[(p1+elem_size-1)%elem_size+elem_size], edges_new );
- }
- else if( p1 >= 0 && p2 >= 0 &&
- edgeExists( verts[(p1+2)%elem_size+elem_size], verts[(p1+elem_size-1)%elem_size], quadToTri_edges ) &&
- !edgeExists( verts[(p1+1)%elem_size+elem_size], verts[(p1+elem_size-1)%elem_size+elem_size], quadToTri_edges ) ){
- createEdge( verts[p1+elem_size], verts[(p1+2)%elem_size+elem_size], quadToTri_edges );
- createEdge( verts[p1+elem_size], verts[(p1+2)%elem_size+elem_size], edges_new );
- }
-
- if( edges_new.size() ){
- ExtrudeDiags( gr, verts, 0, 0, j_top_start, k_top_start,
- elem, ep, edges_new, forbidden_new,
- quadToTri_edges, forbidden_edges, problems_new, problems, pos);
+ // find lateral boundary or internal lateral diagonals. If found, add top
+ // diagonal
+ std::set<std::pair<MVertex *, MVertex *> > edges_new;
+ std::set<std::pair<MVertex *, MVertex *> > forbidden_new;
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ problems, problems_new;
+ if(p1 >= 0 && p2 >= 0 &&
+ edgeExists(verts[(p1 + 2) % elem_size],
+ verts[(p1 + elem_size - 1) % elem_size + elem_size],
+ quadToTri_edges) &&
+ !edgeExists(verts[p1 + elem_size],
+ verts[(p1 + 2) % elem_size + elem_size], quadToTri_edges)) {
+ createEdge(verts[(p1 + 1) % elem_size + elem_size],
+ verts[(p1 + elem_size - 1) % elem_size + elem_size],
+ quadToTri_edges);
+ createEdge(verts[(p1 + 1) % elem_size + elem_size],
+ verts[(p1 + elem_size - 1) % elem_size + elem_size],
+ edges_new);
+ }
+ else if(p1 >= 0 && p2 >= 0 &&
+ edgeExists(verts[(p1 + 2) % elem_size + elem_size],
+ verts[(p1 + elem_size - 1) % elem_size],
+ quadToTri_edges) &&
+ !edgeExists(verts[(p1 + 1) % elem_size + elem_size],
+ verts[(p1 + elem_size - 1) % elem_size + elem_size],
+ quadToTri_edges)) {
+ createEdge(verts[p1 + elem_size], verts[(p1 + 2) % elem_size + elem_size],
+ quadToTri_edges);
+ createEdge(verts[p1 + elem_size], verts[(p1 + 2) % elem_size + elem_size],
+ edges_new);
+ }
+
+ if(edges_new.size()) {
+ ExtrudeDiags(gr, verts, 0, 0, j_top_start, k_top_start, elem, ep,
+ edges_new, forbidden_new, quadToTri_edges, forbidden_edges,
+ problems_new, problems, pos);
}
}
return 1;
-
}
-
-// For use in QuadToTriEdgeGenerator: Does the lateral edging of internal elements in the top extrusion
-// layer by lowest vertex pointer value in TOP FACE.
-// Added 04/08/2011
-static int makeEdgesInternalTopLayer(GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- MVertexRTree &pos)
+// For use in QuadToTriEdgeGenerator: Does the lateral edging of internal
+// elements in the top extrusion layer by lowest vertex pointer value in TOP
+// FACE. Added 04/08/2011
+static int makeEdgesInternalTopLayer(
+ GRegion *gr, bool is_addverts, CategorizedSourceElements &cat_src_elems,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ MVertexRTree &pos)
{
-
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In makeEdgesInternalTopLayer(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return 0;
}
GModel *model = gr->model();
- if( !model ){
+ if(!model) {
Msg::Error("In makeEdgesInternalTopLayer(), invalid model for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
- Msg::Error("In makeEdgesForInternalTopLayer(), invalid source face for region "
- "%d.", gr->tag() );
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
+ Msg::Error(
+ "In makeEdgesForInternalTopLayer(), invalid source face for region "
+ "%d.",
+ gr->tag());
return 0;
}
- if( gr != cat_src_elems.region || reg_source != cat_src_elems.source_face ){
- Msg::Error("In makeEdgesInternalTopLayer(), CatergorizedSourceElements structure data "
- " does not correspond to region %d.", reg_source->tag() );
+ if(gr != cat_src_elems.region || reg_source != cat_src_elems.source_face) {
+ Msg::Error("In makeEdgesInternalTopLayer(), CatergorizedSourceElements "
+ "structure data "
+ " does not correspond to region %d.",
+ reg_source->tag());
return 0;
}
// s = 0 for triangles; s = 1 for quadrangles
- for( int s = 0; s < 2; s++ ){
-
+ for(int s = 0; s < 2; s++) {
// no need to do this if there are no quads!!!
- if( !reg_source->quadrangles.size() )
- break;
+ if(!reg_source->quadrangles.size()) break;
std::set<unsigned int> *set_elems;
std::set<unsigned int>::iterator it;
- if( !s )
+ if(!s)
set_elems = &cat_src_elems.internal_tri;
else
set_elems = &cat_src_elems.internal_quad;
- for( it = set_elems->begin(); it != set_elems->end(); it++ ){
-
+ for(it = set_elems->begin(); it != set_elems->end(); it++) {
MElement *elem;
- if( !s )
+ if(!s)
elem = reg_source->triangles[(*it)];
else
elem = reg_source->quadrangles[(*it)];
int elem_size = elem->getNumVertices();
- std::vector<MVertex*> verts;
- int j = ep->mesh.NbLayer-1;
- int k = ep->mesh.NbElmLayer[ep->mesh.NbLayer-1]-1;
+ std::vector<MVertex *> verts;
+ int j = ep->mesh.NbLayer - 1;
+ int k = ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1] - 1;
getExtrudedVertices(elem, ep, j, k, pos, verts);
// do this by lowest pointer value IN THE TOP SURFACE
- for( int p = 0; p < elem_size; p++ ){
+ for(int p = 0; p < elem_size; p++) {
int ind1, ind2, ind_low, ind_low_2;
- ind1 = p+elem_size;
- ind2 = (p+1)%elem_size+elem_size;
- if( verts[ind1] < verts[ind2] ){
+ ind1 = p + elem_size;
+ ind2 = (p + 1) % elem_size + elem_size;
+ if(verts[ind1] < verts[ind2]) {
ind_low = ind1;
ind_low_2 = ind2 - elem_size;
}
- else{
+ else {
ind_low = ind2;
ind_low_2 = ind1 - elem_size;
}
- if( !edgeExists( verts[ind_low-elem_size], verts[ind_low_2+elem_size], quadToTri_edges) )
- createEdge( verts[ind_low], verts[ind_low_2], quadToTri_edges );
+ if(!edgeExists(verts[ind_low - elem_size], verts[ind_low_2 + elem_size],
+ quadToTri_edges))
+ createEdge(verts[ind_low], verts[ind_low_2], quadToTri_edges);
}
}
}
return 1;
-
}
-
// Generate the set of QuadToTri diagonal edges to subdivide elements,
-// and records problematic elements that need to be subvided with an internal vertex.
-// Added 2010-01-19
-int QuadToTriEdgeGenerator(GRegion *gr, CategorizedSourceElements &cat_src_elems,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*, MVertex*> > &lat_tri_diags,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- MVertexRTree &pos)
+// and records problematic elements that need to be subvided with an internal
+// vertex. Added 2010-01-19
+int QuadToTriEdgeGenerator(
+ GRegion *gr, CategorizedSourceElements &cat_src_elems,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ MVertexRTree &pos)
{
-
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh ){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In QuadToTriEdgeGenerator(), invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return 0;
}
GModel *model = gr->model();
- if( !model ){
+ if(!model) {
Msg::Error("In QuadToTriEdgeGenerator(), invalid model for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
-
// number of extrusion layers
int num_layers = 0;
- for( int p = 0; p < ep->mesh.NbLayer; p++ )
+ for(int p = 0; p < ep->mesh.NbLayer; p++)
num_layers += ep->mesh.NbElmLayer[p];
// is this a valid 'add internal vertex' extrusion?
bool is_addverts = false;
- if( ep->mesh.QuadToTri == QUADTRI_ADDVERTS_1 || ep->mesh.QuadToTri == QUADTRI_ADDVERTS_1_RECOMB )
+ if(ep->mesh.QuadToTri == QUADTRI_ADDVERTS_1 ||
+ ep->mesh.QuadToTri == QUADTRI_ADDVERTS_1_RECOMB)
is_addverts = true;
-
// now find and verify the source and the top of region
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
Msg::Error("In QuadToTriEdgeGenerator(), invalid source face for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
// need for toroidal loop extrusions...top layer treated specially
bool is_toroidal = IsInToroidalQuadToTri(reg_source);
-
std::vector<GFace *> reg_faces = gr->faces();
std::vector<GFace *>::iterator itf = reg_faces.begin();
@@ -3691,33 +3899,32 @@ int QuadToTriEdgeGenerator(GRegion *gr, CategorizedSourceElements &cat_src_elem
GFace *reg_top = NULL;
GFace *root = findRootSourceFaceForFace(reg_source);
bool foundRoot = false;
- for( itf = reg_faces.begin(); itf != reg_faces.end(); itf++ ){
+ for(itf = reg_faces.begin(); itf != reg_faces.end(); itf++) {
ExtrudeParams *face_ep = (*itf)->meshAttributes.extrude;
- if( face_ep && face_ep->geo.Mode == COPIED_ENTITY &&
- reg_source == model->getFaceByTag( std::abs(face_ep->geo.Source) ) ){
+ if(face_ep && face_ep->geo.Mode == COPIED_ENTITY &&
+ reg_source == model->getFaceByTag(std::abs(face_ep->geo.Source))) {
reg_top = (*itf);
}
- if( (*itf) == root )
- foundRoot = true;
- if( reg_top && (foundRoot || !is_toroidal) )
- break;
-
+ if((*itf) == root) foundRoot = true;
+ if(reg_top && (foundRoot || !is_toroidal)) break;
}
- if( is_toroidal && !reg_top && foundRoot && root != reg_source )
- reg_top = root;
- if( !reg_top ){
+ if(is_toroidal && !reg_top && foundRoot && root != reg_source) reg_top = root;
+ if(!reg_top) {
Msg::Error("In QuadToTriEdgeGenerator(), invalid top surface for region "
- "%d.", gr->tag() );
+ "%d.",
+ gr->tag());
return 0;
}
// list of forbidden edges and boundary verts that are in triangles
- std::set<std::pair<MVertex*, MVertex*> > forbidden_edges;
+ std::set<std::pair<MVertex *, MVertex *> > forbidden_edges;
- // insert ALL fixed edges into quadToTri_edges, all forbidden edges on recombined quads
- // into forbidden_edges, and insert into lat_tri_diags ALL lateral diagonal edges.
- QuadToTriGetRegionDiags( gr, quadToTri_edges, forbidden_edges, lat_tri_diags, pos);
+ // insert ALL fixed edges into quadToTri_edges, all forbidden edges on
+ // recombined quads into forbidden_edges, and insert into lat_tri_diags ALL
+ // lateral diagonal edges.
+ QuadToTriGetRegionDiags(gr, quadToTri_edges, forbidden_edges, lat_tri_diags,
+ pos);
/*unsigned int Rnum = gr->tag()-1;
std::vector<MVertex*> verts;
MElement *elem;
@@ -3728,15 +3935,16 @@ int QuadToTriEdgeGenerator(GRegion *gr, CategorizedSourceElements &cat_src_elem
int state = Rnum / std::pow(3,(elem_size-1-p));
Rnum -= state*std::pow(3,(elem_size-1-p));
if( p < elem_size ){
- if( verts[p] == verts[p+elem_size] || verts[(p+1)%elem_size] == verts[(p+1)%elem_size+elem_size] )
- continue;
- if( state == 1 ){
- //createEdge( verts[p], verts[(p+1)%elem_size+elem_size], quadToTri_edges );
- createEdge( verts[p], verts[(p+1)%elem_size+elem_size], lat_tri_diags );
+ if( verts[p] == verts[p+elem_size] || verts[(p+1)%elem_size] ==
+ verts[(p+1)%elem_size+elem_size] ) continue; if( state == 1 ){
+ //createEdge( verts[p], verts[(p+1)%elem_size+elem_size],
+ quadToTri_edges ); createEdge( verts[p], verts[(p+1)%elem_size+elem_size],
+ lat_tri_diags );
}
else if( state == 2 ){
- //createEdge( verts[p+elem_size], verts[(p+1)%elem_size], quadToTri_edges );
- createEdge( verts[p+elem_size], verts[(p+1)%elem_size], lat_tri_diags );
+ //createEdge( verts[p+elem_size], verts[(p+1)%elem_size],
+ quadToTri_edges ); createEdge( verts[p+elem_size], verts[(p+1)%elem_size],
+ lat_tri_diags );
}
else if( state == 0 ){
std::vector<MVertex *> v_face;
@@ -3767,104 +3975,111 @@ int QuadToTriEdgeGenerator(GRegion *gr, CategorizedSourceElements &cat_src_elem
}
}*/
- // if this is an' add internal vertex' extrusion, don't need adjustable lateral edges, so
- // put all lat_tri_diags into quadToTri_edges
- if( is_addverts)
+ // if this is an' add internal vertex' extrusion, don't need adjustable
+ // lateral edges, so put all lat_tri_diags into quadToTri_edges
+ if(is_addverts)
quadToTri_edges.insert(lat_tri_diags.begin(), lat_tri_diags.end());
// If there are no lat_tri_diags and no quads, there is nothing left to do
- if( !lat_tri_diags.size() && !reg_source->quadrangles.size() )
- return 1;
-
-
- // can return now if this is an 'add internal vertex' extrusion...nothing left to do
- if( is_addverts )
- return 1;
-
-
- // BRUTE FORCE diagonalization of elements with all vertices on a lateral boundary of region:
- // This has to be done for all cases with such elements if
- if(!makeEdgesForElemsWithAllVertsOnBnd(gr, is_addverts, cat_src_elems, quadToTri_edges,
- lat_tri_diags, forbidden_edges, problems, pos)){
- Msg::Error("In QuadToTriEdgeGenerator(), failed to make edges for the elements in region %d "
- "with all vertices on a lateral boundary", gr->tag());
+ if(!lat_tri_diags.size() && !reg_source->quadrangles.size()) return 1;
+
+ // can return now if this is an 'add internal vertex' extrusion...nothing left
+ // to do
+ if(is_addverts) return 1;
+
+ // BRUTE FORCE diagonalization of elements with all vertices on a lateral
+ // boundary of region: This has to be done for all cases with such elements if
+ if(!makeEdgesForElemsWithAllVertsOnBnd(gr, is_addverts, cat_src_elems,
+ quadToTri_edges, lat_tri_diags,
+ forbidden_edges, problems, pos)) {
+ Msg::Error("In QuadToTriEdgeGenerator(), failed to make edges for the "
+ "elements in region %d "
+ "with all vertices on a lateral boundary",
+ gr->tag());
return 0;
}
- // now do the "elegant" diagonalization of all the rest of the surface elements....
+ // now do the "elegant" diagonalization of all the rest of the surface
+ // elements....
-
- // Extrude source triangles that are on the source boundary edges and find any diagonals
- if(!makeEdgesForOtherBndPrisms(gr, is_addverts, cat_src_elems, quadToTri_edges,
- lat_tri_diags, forbidden_edges, problems, pos)){
- Msg::Error("In QuadToTriEdgeGenerator(), failed to make edges for the prism extrusions in region %d with "
- "source triangles having some but not all vertices on the boundary", gr->tag());
+ // Extrude source triangles that are on the source boundary edges and find any
+ // diagonals
+ if(!makeEdgesForOtherBndPrisms(gr, is_addverts, cat_src_elems,
+ quadToTri_edges, lat_tri_diags,
+ forbidden_edges, problems, pos)) {
+ Msg::Error(
+ "In QuadToTriEdgeGenerator(), failed to make edges for the prism "
+ "extrusions in region %d with "
+ "source triangles having some but not all vertices on the boundary",
+ gr->tag());
return 0;
}
+ // For a region with a structured all-quad source surface, none of the
+ // previous edging will be executed, so this is the first place a region with
+ // a structured quad source surface starts getting edges.
- // For a region with a structured all-quad source surface, none of the previous edging will be executed,
- // so this is the first place a region with a structured quad source surface starts getting
- // edges.
-
- // The rest of this function is only necessary for a single layer quadToTri method extrusions:
-
+ // The rest of this function is only necessary for a single layer quadToTri
+ // method extrusions:
- // Edge creation for extruded quadrangles with some but not all vertices on a boundary.
+ // Edge creation for extruded quadrangles with some but not all vertices on a
+ // boundary.
if(!makeEdgesForOtherBndHexa(gr, is_addverts, cat_src_elems, quadToTri_edges,
- lat_tri_diags, forbidden_edges, problems, pos)){
- Msg::Error("In QuadToTriEdgeGenerator(), failed to make edges for the hexahedral extrusions in region %d with "
- "source quads having some but not all vertices on the boundary", gr->tag() );
+ lat_tri_diags, forbidden_edges, problems, pos)) {
+ Msg::Error("In QuadToTriEdgeGenerator(), failed to make edges for the "
+ "hexahedral extrusions in region %d with "
+ "source quads having some but not all vertices on the boundary",
+ gr->tag());
return 0;
}
-
- // Find diagonals for elements touching a "pivot vertex" of a hexa element that has
- // a source quad with only one vertex on a lateral boundary (see inside makeEdgesForOtherBndHexa() and
- // makeEdgesForElemsTouchingPivotVert() for details of "pivot vertex".
- if(!makeEdgesForElemsTouchPivotVert(gr, is_addverts, cat_src_elems, quadToTri_edges,
- lat_tri_diags, forbidden_edges, pos)){
+ // Find diagonals for elements touching a "pivot vertex" of a hexa element
+ // that has a source quad with only one vertex on a lateral boundary (see
+ // inside makeEdgesForOtherBndHexa() and makeEdgesForElemsTouchingPivotVert()
+ // for details of "pivot vertex".
+ if(!makeEdgesForElemsTouchPivotVert(gr, is_addverts, cat_src_elems,
+ quadToTri_edges, lat_tri_diags,
+ forbidden_edges, pos)) {
Msg::Error("In QuadToTriEdgeGenerator(), failed to make edges for "
"the elements in region %d touching a \'pivot vertex\' of a "
- "hexa element with source quad having one vertex on a boundary.", gr->tag() );
+ "hexa element with source quad having one vertex on a boundary.",
+ gr->tag());
return 0;
}
// Mesh internal elements in the top layer (just add lateral diagonals for the
// Do this by lowest pointer in top surface
- if(!is_toroidal && !makeEdgesInternalTopLayer(gr, is_addverts, cat_src_elems, quadToTri_edges, pos)){
+ if(!is_toroidal && !makeEdgesInternalTopLayer(gr, is_addverts, cat_src_elems,
+ quadToTri_edges, pos)) {
Msg::Error("In QuadToTriEdgeGenerator(), failed to make internal edges "
- "in top extrusion layer of region %d.", gr->tag());
+ "in top extrusion layer of region %d.",
+ gr->tag());
return 0;
}
return 1;
-
}
-
-// Remesh the lateral 2D faces of QuadToTri regions using edges in quadToTri_edges as constraints
-// Added 2010-01-24
-static bool QuadToTriLateralRemesh(GRegion *gr, std::set<std::pair<MVertex*,MVertex*> > &quadToTri_edges)
+// Remesh the lateral 2D faces of QuadToTri regions using edges in
+// quadToTri_edges as constraints Added 2010-01-24
+static bool QuadToTriLateralRemesh(
+ GRegion *gr, std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges)
{
-
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh )
- return false;
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) return false;
GModel *model = gr->model();
// find source face
- GFace *reg_source = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if( !reg_source ){
+ GFace *reg_source = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!reg_source) {
Msg::Error("In QuadToTriLateralRemesh(), could not find source face "
- "%d for region %d.", std::abs( ep->geo.Source ),
- gr->tag() );
+ "%d for region %d.",
+ std::abs(ep->geo.Source), gr->tag());
return false;
}
-
// Find a source surface, find a COPIED_ENTITY that is the top surface,
// If shared laterals are all static (quad or non subdivide triangles),
// set the allStaticSharedLaterals argument to true.
@@ -3878,49 +4093,47 @@ static bool QuadToTriLateralRemesh(GRegion *gr, std::set<std::pair<MVertex*,MVer
std::vector<GFace *> faces = gr->faces();
std::vector<GFace *>::iterator it = faces.begin();
- for( it = faces.begin(); it != faces.end(); it++ ){
+ for(it = faces.begin(); it != faces.end(); it++) {
ExtrudeParams *face_tmp_ep = (*it)->meshAttributes.extrude;
- if( (*it) == root )
- foundRoot = true;
- if( face_tmp_ep && face_tmp_ep->geo.Mode ==
- COPIED_ENTITY ){
- GFace *top_source_tmp = model->getFaceByTag(
- std::abs( face_tmp_ep->geo.Source ) );
- if( !top_source_tmp ){
+ if((*it) == root) foundRoot = true;
+ if(face_tmp_ep && face_tmp_ep->geo.Mode == COPIED_ENTITY) {
+ GFace *top_source_tmp =
+ model->getFaceByTag(std::abs(face_tmp_ep->geo.Source));
+ if(!top_source_tmp) {
Msg::Error("In QuadToTriLateralRemesh(), could not find source face "
"%d for copied surface %d of region %d.",
- std::abs( face_tmp_ep->geo.Source ),
- (*it)->tag(), gr->tag() );
+ std::abs(face_tmp_ep->geo.Source), (*it)->tag(), gr->tag());
}
- else if( top_source_tmp == reg_source ){
+ else if(top_source_tmp == reg_source) {
foundTop = true;
reg_top = (*it);
}
}
}
- // if didn't find the copied entity, maybe this is toroidal and the top has been replaced
- if( is_toroidal && !foundTop && foundRoot && root != reg_source )
+ // if didn't find the copied entity, maybe this is toroidal and the top has
+ // been replaced
+ if(is_toroidal && !foundTop && foundRoot && root != reg_source)
foundTop = true;
- if( !foundTop )
+ if(!foundTop)
Msg::Warning("In QuadToTriLateralRemesh(), could not find top face "
- "for region %d.", gr->tag() );
+ "for region %d.",
+ gr->tag());
- Msg::Info("Remeshing lateral surfaces for QuadToTri region %d.", gr->tag() );
+ Msg::Info("Remeshing lateral surfaces for QuadToTri region %d.", gr->tag());
// now loop through faces again, remeshing all laterals that need it.
- for( it = faces.begin(); it != faces.end(); it++ ){
- if( (*it) != reg_top && (*it) != reg_source &&
- IsSurfaceALateralForRegion(gr, *it) ){
-
+ for(it = faces.begin(); it != faces.end(); it++) {
+ if((*it) != reg_top && (*it) != reg_source &&
+ IsSurfaceALateralForRegion(gr, *it)) {
// *** JUST REMESH EVERY SURFACE AGAIN TO BE SURE ***
for(unsigned int i = 0; i < (*it)->triangles.size(); i++)
- delete (*it)->triangles[i];
+ delete(*it)->triangles[i];
(*it)->triangles.clear();
for(unsigned int i = 0; i < (*it)->quadrangles.size(); i++)
- delete (*it)->quadrangles[i];
+ delete(*it)->quadrangles[i];
(*it)->quadrangles.clear();
MeshExtrudedSurface((*it), &quadToTri_edges);
}
@@ -3928,54 +4141,56 @@ static bool QuadToTriLateralRemesh(GRegion *gr, std::set<std::pair<MVertex*,MVer
return foundTop;
}
-
// Adds the face- or body-center vertices needed for some QuadToTri elements
-static bool addBodyCenteredVertices(GRegion *to, CategorizedSourceElements &c,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- bool is_addverts, unsigned int lat_tri_diags_size,
- MVertexRTree &pos)
+static bool addBodyCenteredVertices(
+ GRegion *to, CategorizedSourceElements &c,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ bool is_addverts, unsigned int lat_tri_diags_size, MVertexRTree &pos)
{
-
ExtrudeParams *ep = to->meshAttributes.extrude;
- if( !ep || !ep->mesh.ExtrudeMesh || !ep->mesh.QuadToTri )
- return false;
+ if(!ep || !ep->mesh.ExtrudeMesh || !ep->mesh.QuadToTri) return false;
GModel *model = to->model();
- GFace *from = model->getFaceByTag( std::abs(ep->geo.Source) );
- if( !from )
- return false;
+ GFace *from = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!from) return false;
// find number of layers;
unsigned int num_layer = 0;
- for( int p = 0; p < ep->mesh.NbLayer; p++ )
- num_layer += ep->mesh.NbElmLayer[p];
+ for(int p = 0; p < ep->mesh.NbLayer; p++) num_layer += ep->mesh.NbElmLayer[p];
// create reserve capacity for the temp vector of new vertices:
unsigned int cap_add = 0;
- if( !is_addverts ){
- std::map<MElement *, std::set< std::pair<unsigned int, unsigned int> > >::iterator itmap;
- for( itmap = problems.begin(); itmap != problems.end(); itmap++ )
+ if(!is_addverts) {
+ std::map<MElement *,
+ std::set<std::pair<unsigned int, unsigned int> > >::iterator itmap;
+ for(itmap = problems.begin(); itmap != problems.end(); itmap++)
cap_add += itmap->second.size();
}
- else{
- unsigned int NbBndElems = c.four_bnd_pt_quad.size() + c.three_bnd_pt_tri.size() +
- c.other_bnd_quad.size() + c.other_bnd_tri.size();
- unsigned int NbSourceElems = from->triangles.size() + from->quadrangles.size();
- if( findRootSourceFaceForFace(from) == from ) // if extruded back on the source in a ring
+ else {
+ unsigned int NbBndElems = c.four_bnd_pt_quad.size() +
+ c.three_bnd_pt_tri.size() +
+ c.other_bnd_quad.size() + c.other_bnd_tri.size();
+ unsigned int NbSourceElems =
+ from->triangles.size() + from->quadrangles.size();
+ if(findRootSourceFaceForFace(from) ==
+ from) // if extruded back on the source in a ring
cap_add = NbBndElems * num_layer;
else
- cap_add = NbSourceElems + NbBndElems * (num_layer-1);
+ cap_add = NbSourceElems + NbBndElems * (num_layer - 1);
}
- to->mesh_vertices.reserve(to->mesh_vertices.size()+cap_add);
+ to->mesh_vertices.reserve(to->mesh_vertices.size() + cap_add);
// first the !is_addverts case
- if( problems.size() && !is_addverts ){
- std::map<MElement *, std::set< std::pair<unsigned int, unsigned int> > >::iterator itmap;
- for( itmap = problems.begin(); itmap != problems.end(); itmap++ ){
+ if(problems.size() && !is_addverts) {
+ std::map<MElement *,
+ std::set<std::pair<unsigned int, unsigned int> > >::iterator itmap;
+ for(itmap = problems.begin(); itmap != problems.end(); itmap++) {
MElement *elem = itmap->first;
- std::set< std::pair<unsigned int, unsigned int> >::iterator itpairs;
- for( itpairs = itmap->second.begin(); itpairs != itmap->second.end(); itpairs++ ){
+ std::set<std::pair<unsigned int, unsigned int> >::iterator itpairs;
+ for(itpairs = itmap->second.begin(); itpairs != itmap->second.end();
+ itpairs++) {
std::vector<MVertex *> verts;
int j = (*itpairs).first;
int k = (*itpairs).second;
@@ -3985,81 +4200,93 @@ static bool addBodyCenteredVertices(GRegion *to, CategorizedSourceElements &c,
}
}
- if( !is_addverts )
- return 1;
+ if(!is_addverts) return 1;
// The rest of the function works for is_addverts
-
- //Holds the new vertices...put them in to->mesh_vertices only at the end
+ // Holds the new vertices...put them in to->mesh_vertices only at the end
std::vector<MVertex *> v_tmp;
v_tmp.reserve(cap_add);
// triangles and quadrangles
// t =0 triangles, t=1 quadrangles
- std::vector<MVertex*> verts3D;
- for( int t = 0; t < 2; t++ ){
- for( int s = 0; s < 3; s++ ){
+ std::vector<MVertex *> verts3D;
+ for(int t = 0; t < 2; t++) {
+ for(int s = 0; s < 3; s++) {
std::set<unsigned int> *set_elems;
- if( !t ){
- if( !s ) set_elems = &c.three_bnd_pt_tri;
- else if( s==1 ) set_elems = &c.other_bnd_tri;
- else set_elems = &c.internal_tri;
+ if(!t) {
+ if(!s)
+ set_elems = &c.three_bnd_pt_tri;
+ else if(s == 1)
+ set_elems = &c.other_bnd_tri;
+ else
+ set_elems = &c.internal_tri;
}
- else{
- if( !s ) set_elems = &c.four_bnd_pt_quad;
- else if( s==1 ) set_elems = &c.other_bnd_quad;
- else set_elems = &c.internal_quad;
+ else {
+ if(!s)
+ set_elems = &c.four_bnd_pt_quad;
+ else if(s == 1)
+ set_elems = &c.other_bnd_quad;
+ else
+ set_elems = &c.internal_quad;
}
std::set<unsigned int>::iterator itset;
- for( itset = set_elems->begin(); itset != set_elems->end(); itset++ ){
+ for(itset = set_elems->begin(); itset != set_elems->end(); itset++) {
MElement *elem;
- if( !t ) elem = from->triangles[(*itset)];
- else elem = from->quadrangles[(*itset)];
+ if(!t)
+ elem = from->triangles[(*itset)];
+ else
+ elem = from->quadrangles[(*itset)];
int elem_size = elem->getNumVertices();
- // see if this element is on a boundary with lat_tri_diags or a degenerated hexahedron (always divide those)
+ // see if this element is on a boundary with lat_tri_diags or a
+ // degenerated hexahedron (always divide those)
bool found_diags = false;
bool degen_hex = false;
verts3D.resize(0);
- getExtrudedVertices( elem, ep, 0, 0, pos, verts3D);
- for( int p = 0; p < elem_size; p++ ){
+ getExtrudedVertices(elem, ep, 0, 0, pos, verts3D);
+ for(int p = 0; p < elem_size; p++) {
// always look for degen hex
- if( t && verts3D[p] == verts3D[p+elem_size] &&
- verts3D[(p+1)%elem_size] != verts3D[(p+1)%elem_size+elem_size] &&
- verts3D[(p+elem_size-1)%elem_size] != verts3D[(p+elem_size-1)%elem_size+elem_size] ){
+ if(t && verts3D[p] == verts3D[p + elem_size] &&
+ verts3D[(p + 1) % elem_size] !=
+ verts3D[(p + 1) % elem_size + elem_size] &&
+ verts3D[(p + elem_size - 1) % elem_size] !=
+ verts3D[(p + elem_size - 1) % elem_size + elem_size]) {
degen_hex = true;
break;
}
// skip the rest if no lat_tri_diags or if not on lateral boundary
- if( !lat_tri_diags_size || s >= 2 )
- continue;
+ if(!lat_tri_diags_size || s >= 2) continue;
// if a triangle face, skip it
- if( verts3D[p] == verts3D[p+elem_size] ||
- verts3D[(p+1)%elem_size] == verts3D[(p+1)%elem_size+elem_size] )
+ if(verts3D[p] == verts3D[p + elem_size] ||
+ verts3D[(p + 1) % elem_size] ==
+ verts3D[(p + 1) % elem_size + elem_size])
continue;
- else if( edgeExists( verts3D[p], verts3D[(p+1)%elem_size+elem_size], quadToTri_edges ) )
+ else if(edgeExists(verts3D[p],
+ verts3D[(p + 1) % elem_size + elem_size],
+ quadToTri_edges))
found_diags = true;
- else if( edgeExists( verts3D[p+elem_size], verts3D[(p+1)%elem_size], quadToTri_edges ) )
+ else if(edgeExists(verts3D[p + elem_size],
+ verts3D[(p + 1) % elem_size], quadToTri_edges))
found_diags = true;
}
// triangle extrusions don't need body centered verts if NO diags found
// or if not on lateral boundary
- if( !t && ( !found_diags || s==2 ) )
- continue;
+ if(!t && (!found_diags || s == 2)) continue;
int j_start, k_start;
- if( (s < 2 && found_diags) || degen_hex ){
+ if((s < 2 && found_diags) || degen_hex) {
j_start = 0;
k_start = 0;
}
- else{ // only non-bnd quads or columns with no lateral diags and not extruded into degen hexa should execute this
- j_start = ep->mesh.NbLayer-1;
- k_start = ep->mesh.NbElmLayer[j_start]-1;
+ else { // only non-bnd quads or columns with no lateral diags and not
+ // extruded into degen hexa should execute this
+ j_start = ep->mesh.NbLayer - 1;
+ k_start = ep->mesh.NbElmLayer[j_start] - 1;
}
- std::vector<MVertex*> verts;
- for( int j = j_start; j < ep->mesh.NbLayer; j++ ){
+ std::vector<MVertex *> verts;
+ for(int j = j_start; j < ep->mesh.NbLayer; j++) {
int k_stop = ep->mesh.NbElmLayer[j];
- for( int k = k_start; k < k_stop; k++ ){
+ for(int k = k_start; k < k_stop; k++) {
verts.resize(0);
getExtrudedVertices(elem, ep, j, k, pos, verts);
QtMakeCentroidVertex(verts, &v_tmp, to, pos);
@@ -4069,48 +4296,49 @@ static bool addBodyCenteredVertices(GRegion *to, CategorizedSourceElements &c,
}
}
// Don't forget to add v_tmp to to->mesh_vertices!!!
- to->mesh_vertices.reserve( to->mesh_vertices.size() + v_tmp.size() );
- for(unsigned int p = 0; p < v_tmp.size(); p++ )
+ to->mesh_vertices.reserve(to->mesh_vertices.size() + v_tmp.size());
+ for(unsigned int p = 0; p < v_tmp.size(); p++)
to->mesh_vertices.push_back(v_tmp[p]);
return 1;
-
}
-
-
-// Meshes either a prism or a hexahedral set of mesh vertices with an internal vertex
-// created here in the function.
-// Added 2010-03-30
-static void MeshWithInternalVertex(GRegion *to, MElement *source, std::vector<MVertex *> v, std::vector<int> n1,
- std::vector<int> n2, MVertexRTree &pos)
+// Meshes either a prism or a hexahedral set of mesh vertices with an internal
+// vertex created here in the function. Added 2010-03-30
+static void MeshWithInternalVertex(GRegion *to, MElement *source,
+ std::vector<MVertex *> v,
+ std::vector<int> n1, std::vector<int> n2,
+ MVertexRTree &pos)
{
-
int v_size = v.size();
int n_lat_tmp;
- if( v_size == 6 )
+ if(v_size == 6)
n_lat_tmp = 3;
- else if( v_size == 8 )
+ else if(v_size == 8)
n_lat_tmp = 4;
- else{
- Msg::Error("In MeshWithInternalVertex(), number of element vertices does not equal 6 or 8.");
+ else {
+ Msg::Error("In MeshWithInternalVertex(), number of element vertices does "
+ "not equal 6 or 8.");
return;
}
const int n_lat = n_lat_tmp;
- if( (n_lat == 3 && n1.size() != 3) || (n_lat == 4 && n2.size() != 6) ){
- Msg::Error("In MeshWithInternalVertex(), size of diagonal node vectors is not does not equal 3 or 6.");
+ if((n_lat == 3 && n1.size() != 3) || (n_lat == 4 && n2.size() != 6)) {
+ Msg::Error("In MeshWithInternalVertex(), size of diagonal node vectors is "
+ "not does not equal 3 or 6.");
return;
}
// find the internal vertex
std::vector<double> centroid = QtFindVertsCentroid(v);
- // it's too dangerous to use the 'new' command in here even with body-centered vertices.
+ // it's too dangerous to use the 'new' command in here even with body-centered
+ // vertices.
MVertex *tmp = pos.find(centroid[0], centroid[1], centroid[2]);
- if(!tmp){
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) in geometrical entity %d",
+ if(!tmp) {
+ Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) in "
+ "geometrical entity %d",
centroid[0], centroid[1], centroid[2], to->tag());
Msg::Error("MeshWithInternalVertex() failed to find body-centered vertex.");
return;
@@ -4119,86 +4347,91 @@ static void MeshWithInternalVertex(GRegion *to, MElement *source, std::vector<MV
MVertex *v_int = tmp;
// build all pyramids/tetra
- for( int p = 0; p < n_lat; p++ ){
- int p2 = (p+1)%n_lat;
- if( v[p] == v[p+n_lat] && v[p2] == v[p2+n_lat] )
+ for(int p = 0; p < n_lat; p++) {
+ int p2 = (p + 1) % n_lat;
+ if(v[p] == v[p + n_lat] && v[p2] == v[p2 + n_lat])
continue;
- else if( v[p] == v[p+n_lat] || v[p2] == v[p2+n_lat] ){
- MVertex *v_dup = (v[p] == v[p+n_lat]) ? v[p] : v[p2];
+ else if(v[p] == v[p + n_lat] || v[p2] == v[p2 + n_lat]) {
+ MVertex *v_dup = (v[p] == v[p + n_lat]) ? v[p] : v[p2];
MVertex *v_non_dup = (v_dup == v[p]) ? v[p2] : v[p];
- MVertex *v_non_dup2 = (v_non_dup == v[p]) ? v[p+n_lat] : v[p2+n_lat];
- addTetrahedron( v_dup, v_non_dup, v_non_dup2, v_int, to, source );
+ MVertex *v_non_dup2 = (v_non_dup == v[p]) ? v[p + n_lat] : v[p2 + n_lat];
+ addTetrahedron(v_dup, v_non_dup, v_non_dup2, v_int, to, source);
}
- else if( n1[p] == p || n2[p] == p ){
- addTetrahedron( v[p], v[p2], v[p2+n_lat], v_int, to, source );
- addTetrahedron( v[p], v[p2+n_lat], v[p+n_lat], v_int, to, source );
+ else if(n1[p] == p || n2[p] == p) {
+ addTetrahedron(v[p], v[p2], v[p2 + n_lat], v_int, to, source);
+ addTetrahedron(v[p], v[p2 + n_lat], v[p + n_lat], v_int, to, source);
}
- else if( n1[p] == p+n_lat || n2[p] == p+n_lat ){
- addTetrahedron( v[p], v[p2], v[p+n_lat], v_int, to, source );
- addTetrahedron( v[p2], v[p2+n_lat], v[p+n_lat], v_int, to, source );
+ else if(n1[p] == p + n_lat || n2[p] == p + n_lat) {
+ addTetrahedron(v[p], v[p2], v[p + n_lat], v_int, to, source);
+ addTetrahedron(v[p2], v[p2 + n_lat], v[p + n_lat], v_int, to, source);
}
else
- addPyramid( v[p], v[p2], v[p2+n_lat], v[p+n_lat], v_int, to, source );
+ addPyramid(v[p], v[p2], v[p2 + n_lat], v[p + n_lat], v_int, to, source);
}
- if( n_lat == 3){
+ if(n_lat == 3) {
// bottom and top
- addTetrahedron( v[0], v[1], v[2], v_int, to, source);
- addTetrahedron( v[3], v[5], v[4], v_int, to, source);
+ addTetrahedron(v[0], v[1], v[2], v_int, to, source);
+ addTetrahedron(v[3], v[5], v[4], v_int, to, source);
}
- else if( n_lat == 4 ){
- for( int p = 4; p < 6; p++ ){
+ else if(n_lat == 4) {
+ for(int p = 4; p < 6; p++) {
int add = (p == 4) ? 0 : 4;
- if( n1[p] == 0+add || n2[p] == 0+add ){
- addTetrahedron( v[add], v[1+add], v[2+add], v_int, to, source );
- addTetrahedron( v[add], v[2+add], v[3+add], v_int, to, source );
+ if(n1[p] == 0 + add || n2[p] == 0 + add) {
+ addTetrahedron(v[add], v[1 + add], v[2 + add], v_int, to, source);
+ addTetrahedron(v[add], v[2 + add], v[3 + add], v_int, to, source);
}
- else if( n1[p] == 1+add || n2[p] == 1+add ){
- addTetrahedron( v[1+add], v[2+add], v[3+add], v_int, to, source );
- addTetrahedron( v[1+add], v[3+add], v[add], v_int, to, source );
+ else if(n1[p] == 1 + add || n2[p] == 1 + add) {
+ addTetrahedron(v[1 + add], v[2 + add], v[3 + add], v_int, to, source);
+ addTetrahedron(v[1 + add], v[3 + add], v[add], v_int, to, source);
}
else
- addPyramid( v[add], v[1+add], v[2+add], v[3+add], v_int, to, source );
+ addPyramid(v[add], v[1 + add], v[2 + add], v[3 + add], v_int, to,
+ source);
}
}
-
}
-// Construct the elements that subdivide a prism (or degenerated prism) in a QuadToTri interface;
-// Added 2010-01-24
-static inline void QuadToTriPriPyrTet(std::vector<MVertex*> &v, GRegion *to, int j,
- int k, MElement* source,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts, bool diag_search,
- MVertexRTree &pos)
+// Construct the elements that subdivide a prism (or degenerated prism) in a
+// QuadToTri interface; Added 2010-01-24
+static inline void QuadToTriPriPyrTet(
+ std::vector<MVertex *> &v, GRegion *to, int j, int k, MElement *source,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts,
+ bool diag_search, MVertexRTree &pos)
{
int dup[3];
int m = 0;
for(int i = 0; i < 3; i++)
- if(v[i] == v[i + 3])
- dup[m++] = i;
+ if(v[i] == v[i + 3]) dup[m++] = i;
bool is_problem = false;
- if( !is_addverts ){
- std::pair<unsigned int, unsigned int> jk_pair (j,k);
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > >::iterator itprob;
+ if(!is_addverts) {
+ std::pair<unsigned int, unsigned int> jk_pair(j, k);
+ std::map<MElement *,
+ std::set<std::pair<unsigned int, unsigned int> > >::iterator
+ itprob;
itprob = problems.find(source);
- if( itprob != problems.end() ){
- if( (*itprob).second.find(jk_pair) != (*itprob).second.end() )
+ if(itprob != problems.end()) {
+ if((*itprob).second.find(jk_pair) != (*itprob).second.end())
is_problem = true;
}
}
- if( m && is_problem ){
- Msg::Error("In QuadToTriPriPyrTet(), non-prismatic extrusion of triangle in region %d "
- "marked as needing internal vertex to complete. Skipping....", to->tag() );
+ if(m && is_problem) {
+ Msg::Error("In QuadToTriPriPyrTet(), non-prismatic extrusion of triangle "
+ "in region %d "
+ "marked as needing internal vertex to complete. Skipping....",
+ to->tag());
return;
}
// BAD SHAPE
- if( m > 2 || m < 0 ){
+ if(m > 2 || m < 0) {
Msg::Error("In QuadToTriPriPyrTet(), bad number of degenerate corners.");
return;
}
@@ -4208,121 +4441,134 @@ static inline void QuadToTriPriPyrTet(std::vector<MVertex*> &v, GRegion *to, int
bool found_diags = false;
n1.assign(3, -1);
n2.assign(3, -2);
- if( diag_search ){
- for( int p = 0; p < 3; p++ ){
- n1[p] = -p*p-p-1; n2[p] = -p*p-p-2;
- if( v[p] == v[p+3] || v[(p+1)%3] == v[(p+1)%3+3] )
+ if(diag_search) {
+ for(int p = 0; p < 3; p++) {
+ n1[p] = -p * p - p - 1;
+ n2[p] = -p * p - p - 2;
+ if(v[p] == v[p + 3] || v[(p + 1) % 3] == v[(p + 1) % 3 + 3])
continue;
- else if( edgeExists( v[p], v[(p+1)%3+3], quadToTri_edges ) ){
- n1[p] = p; n2[p] = (p+1)%3+3;
+ else if(edgeExists(v[p], v[(p + 1) % 3 + 3], quadToTri_edges)) {
+ n1[p] = p;
+ n2[p] = (p + 1) % 3 + 3;
found_diags = true;
}
- else if( edgeExists( v[p+3], v[(p+1)%3], quadToTri_edges ) ){
- n1[p] = p+3; n2[p] = (p+1)%3;
+ else if(edgeExists(v[p + 3], v[(p + 1) % 3], quadToTri_edges)) {
+ n1[p] = p + 3;
+ n2[p] = (p + 1) % 3;
found_diags = true;
}
}
}
// mesh with added internal body centered vertex
- // is this prism part of a QuadToTri internal vertex extrusion and does it need to be extruded as such?
- if( is_addverts && bnd_elem && found_diags ){
- MeshWithInternalVertex( to, source, v, n1, n2, pos);
+ // is this prism part of a QuadToTri internal vertex extrusion and does it
+ // need to be extruded as such?
+ if(is_addverts && bnd_elem && found_diags) {
+ MeshWithInternalVertex(to, source, v, n1, n2, pos);
return;
}
// The rest are for 'no new vertex' extrusions or degenerate prisms:
-
// tetrahedron
- if( m == 2 && !is_problem ) {
- int dup_face = (dup[0]+1)%3 == dup[1] ? dup[0] : dup[1];
- addTetrahedron(v[dup_face], v[(dup_face+1)%3], v[(dup_face+2)%3], v[(dup_face+2)%3+3], to, source);
+ if(m == 2 && !is_problem) {
+ int dup_face = (dup[0] + 1) % 3 == dup[1] ? dup[0] : dup[1];
+ addTetrahedron(v[dup_face], v[(dup_face + 1) % 3], v[(dup_face + 2) % 3],
+ v[(dup_face + 2) % 3 + 3], to, source);
return;
}
// pyramid
- else if( m == 1 && !is_problem ) {
- int p = (dup[0]+1)%3;
+ else if(m == 1 && !is_problem) {
+ int p = (dup[0] + 1) % 3;
// determine if the pyramid is sliced into two tetrahedra
- if( n1[p] >= 0 ){
+ if(n1[p] >= 0) {
int add = n1[p] < 3 ? 3 : -3;
- addTetrahedron(v[n1[p]], v[n2[p]], v[n1[p]+add], v[dup[0]], to, source);
- addTetrahedron(v[n1[p]], v[n2[p]-add], v[n2[p]], v[dup[0]], to, source);
+ addTetrahedron(v[n1[p]], v[n2[p]], v[n1[p] + add], v[dup[0]], to, source);
+ addTetrahedron(v[n1[p]], v[n2[p] - add], v[n2[p]], v[dup[0]], to, source);
}
else // pyramid
- addPyramid( v[p], v[p+3], v[(p+1)%3+3], v[(p+1)%3], v[dup[0]], to, source);
+ addPyramid(v[p], v[p + 3], v[(p + 1) % 3 + 3], v[(p + 1) % 3], v[dup[0]],
+ to, source);
- return;
+ return;
}
-
// Full prism: Start looking for a diagonal on a lateral.
- else if( m == 0 && !is_problem ){
- if( !found_diags ){
- addPrism( v[0], v[1], v[2], v[3], v[4], v[5], to, source );
+ else if(m == 0 && !is_problem) {
+ if(!found_diags) {
+ addPrism(v[0], v[1], v[2], v[3], v[4], v[5], to, source);
return;
}
- else{
- for( int p = 0; p < 3; p++ ){
- if( n1[p] >= 0 && n2[p] == n1[(p+1)%3] ){
+ else {
+ for(int p = 0; p < 3; p++) {
+ if(n1[p] >= 0 && n2[p] == n1[(p + 1) % 3]) {
int add = n2[p] < 3 ? 3 : -3;
- int tet_top = n2[p]+add;
+ int tet_top = n2[p] + add;
int pyr_top = n2[p];
- int base = (p+2)%3;
- addTetrahedron( v[n1[p]], v[n2[p]], v[n2[(p+1)%3]], v[tet_top], to, source );
- if( n1[(p+2)%3] >= 0 ){
+ int base = (p + 2) % 3;
+ addTetrahedron(v[n1[p]], v[n2[p]], v[n2[(p + 1) % 3]], v[tet_top], to,
+ source);
+ if(n1[(p + 2) % 3] >= 0) {
int add_2 = n1[base] < 3 ? 3 : -3;
- addTetrahedron( v[n1[base]], v[n2[base]], v[n1[base]+add_2], v[pyr_top], to, source );
- addTetrahedron( v[n1[base]], v[n2[base]], v[n2[base]-add_2], v[pyr_top], to, source );
+ addTetrahedron(v[n1[base]], v[n2[base]], v[n1[base] + add_2],
+ v[pyr_top], to, source);
+ addTetrahedron(v[n1[base]], v[n2[base]], v[n2[base] - add_2],
+ v[pyr_top], to, source);
}
else
- addPyramid( v[base], v[base+3], v[(base+1)%3+3], v[(base+1)%3], v[pyr_top], to, source );
+ addPyramid(v[base], v[base + 3], v[(base + 1) % 3 + 3],
+ v[(base + 1) % 3], v[pyr_top], to, source);
return;
}
}
}
}
+ // At this point, if the function has not returned, element must be meshed
+ // with an additional vertex
- // At this point, if the function has not returned, element must be meshed with an additional vertex
-
- if( !is_problem ) {
- Msg::Error("In QuadToTriPriPyrTet(), Extruded prism needs subdivision, but cannot "
- " be divided without internal vertex, but was not previously detected as such. "
- " This is a bug. Please Report.");
+ if(!is_problem) {
+ Msg::Error(
+ "In QuadToTriPriPyrTet(), Extruded prism needs subdivision, but cannot "
+ " be divided without internal vertex, but was not previously detected as "
+ "such. "
+ " This is a bug. Please Report.");
Msg::Error("j: %d, k: %d", j, k);
- QtMakeCentroidVertex( v, &(to->mesh_vertices), to, pos);
- std::pair<unsigned int, unsigned int> jk_pair(j,k);
+ QtMakeCentroidVertex(v, &(to->mesh_vertices), to, pos);
+ std::pair<unsigned int, unsigned int> jk_pair(j, k);
problems_new[source].insert(jk_pair);
is_problem = true;
}
- if( is_problem ){
- MeshWithInternalVertex( to, source, v, n1, n2, pos);
+ if(is_problem) {
+ MeshWithInternalVertex(to, source, v, n1, n2, pos);
return;
}
-
}
-
-// Construct the elements that subdivde a two-point degenerated hexahedron (prism).
-static inline bool createTwoPtDegenHexElems(std::vector<MVertex*> &v, GRegion *to, ExtrudeParams *ep, int j,
- int k, int dup[], MElement* source, std::vector<int> n1, std::vector<int> n2,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts, bool found_diags)
+// Construct the elements that subdivde a two-point degenerated hexahedron
+// (prism).
+static inline bool createTwoPtDegenHexElems(
+ std::vector<MVertex *> &v, GRegion *to, ExtrudeParams *ep, int j, int k,
+ int dup[], MElement *source, std::vector<int> n1, std::vector<int> n2,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts,
+ bool found_diags)
{
- if( !ep )
- return 0;
+ if(!ep) return 0;
// first find out what is the degenerate face
- int degen_face = (dup[0]+1)%4 == dup[1] ? dup[0] : dup[1];
+ int degen_face = (dup[0] + 1) % 4 == dup[1] ? dup[0] : dup[1];
// if no diags found, make a prism and return
- if( !found_diags ){
- addPrism( v[degen_face], v[(degen_face+3)%4], v[(degen_face+3)%4+4],
- v[(degen_face+1)%4], v[(degen_face+2)%4], v[(degen_face+2)%4+4], to, source );
+ if(!found_diags) {
+ addPrism(v[degen_face], v[(degen_face + 3) % 4],
+ v[(degen_face + 3) % 4 + 4], v[(degen_face + 1) % 4],
+ v[(degen_face + 2) % 4], v[(degen_face + 2) % 4 + 4], to, source);
return 1;
}
@@ -4330,331 +4576,395 @@ static inline bool createTwoPtDegenHexElems(std::vector<MVertex*> &v, GRegion *t
int pyr_top = -2;
// if faces 4 and 5 can make a slice
- if( n1[4] >= 0 &&
- ( n1[4]+4 == n1[5] || n2[4]+4 == n1[5] ) ){
- if( n1[4] == degen_face || n2[4] == degen_face ){
+ if(n1[4] >= 0 && (n1[4] + 4 == n1[5] || n2[4] + 4 == n1[5])) {
+ if(n1[4] == degen_face || n2[4] == degen_face) {
pyr_top = degen_face;
- tet_top = (degen_face+1)%4;
+ tet_top = (degen_face + 1) % 4;
}
- else{
- pyr_top = (degen_face+1)%4;
+ else {
+ pyr_top = (degen_face + 1) % 4;
tet_top = degen_face;
}
- addTetrahedron( v[pyr_top], v[(pyr_top+2)%4], v[(pyr_top+2)%4+4], v[tet_top], to, source );
+ addTetrahedron(v[pyr_top], v[(pyr_top + 2) % 4], v[(pyr_top + 2) % 4 + 4],
+ v[tet_top], to, source);
- int base = (degen_face+2)%4;
- if( n1[base] >= 0 ){
+ int base = (degen_face + 2) % 4;
+ if(n1[base] >= 0) {
int add = n1[base] > 3 ? -4 : 4;
- addTetrahedron( v[n1[base]], v[n2[base]], v[n1[base]+add], v[pyr_top], to, source );
- addTetrahedron( v[n1[base]], v[n2[base]-add], v[n2[base]], v[pyr_top], to, source );
+ addTetrahedron(v[n1[base]], v[n2[base]], v[n1[base] + add], v[pyr_top],
+ to, source);
+ addTetrahedron(v[n1[base]], v[n2[base] - add], v[n2[base]], v[pyr_top],
+ to, source);
}
else
- addPyramid( v[base], v[base+4], v[(base+1)%4+4], v[(base+1)%4], v[pyr_top], to, source );
+ addPyramid(v[base], v[base + 4], v[(base + 1) % 4 + 4], v[(base + 1) % 4],
+ v[pyr_top], to, source);
return 1;
}
// if faces 4 and (degen_face+2)%4 make a slice
- if( tet_top < 0 && n1[4] >= 0 &&
- ( n1[4] == n1[(degen_face+2)%4] || n2[4] == n1[(degen_face+2)%4] ||
- n1[4] == n2[(degen_face+2)%4] || n2[4] == n2[(degen_face+2)%4] ) ){
- pyr_top = n1[(degen_face+2)%4] < 4 ? n1[(degen_face+2)%4] : n2[(degen_face+2)%4];
- tet_top = pyr_top==(degen_face+2)%4 ? (degen_face+3)%4 : (degen_face+2)%4;
+ if(tet_top < 0 && n1[4] >= 0 &&
+ (n1[4] == n1[(degen_face + 2) % 4] || n2[4] == n1[(degen_face + 2) % 4] ||
+ n1[4] == n2[(degen_face + 2) % 4] || n2[4] == n2[(degen_face + 2) % 4])) {
+ pyr_top = n1[(degen_face + 2) % 4] < 4 ? n1[(degen_face + 2) % 4] :
+ n2[(degen_face + 2) % 4];
+ tet_top = pyr_top == (degen_face + 2) % 4 ? (degen_face + 3) % 4 :
+ (degen_face + 2) % 4;
- addTetrahedron( v[pyr_top], v[tet_top+4], v[(pyr_top+2)%4], v[tet_top], to, source );
+ addTetrahedron(v[pyr_top], v[tet_top + 4], v[(pyr_top + 2) % 4], v[tet_top],
+ to, source);
int base = 5;
- if( n1[base] >= 0 ){
- addTetrahedron( v[n1[base]], v[n2[base]], v[(n1[base]-4+1)%4+4], v[pyr_top], to, source );
- addTetrahedron( v[n1[base]], v[n2[base]], v[(n1[base]-4+3)%4+4], v[pyr_top], to, source );
+ if(n1[base] >= 0) {
+ addTetrahedron(v[n1[base]], v[n2[base]], v[(n1[base] - 4 + 1) % 4 + 4],
+ v[pyr_top], to, source);
+ addTetrahedron(v[n1[base]], v[n2[base]], v[(n1[base] - 4 + 3) % 4 + 4],
+ v[pyr_top], to, source);
}
else
- addPyramid( v[4], v[5], v[6], v[7], v[pyr_top], to, source );
+ addPyramid(v[4], v[5], v[6], v[7], v[pyr_top], to, source);
return 1;
-
}
// if faces 5 and (degen_face+2)%4 make a slice
- if( tet_top < 0 && n1[5] >= 0 &&
- ( n1[5] == n1[(degen_face+2)%4] || n2[5] == n1[(degen_face+2)%4] ||
- n1[5] == n2[(degen_face+2)%4] || n2[5] == n2[(degen_face+2)%4] ) ){
- pyr_top = n1[(degen_face+2)%4] < 4 ? n2[(degen_face+2)%4] : n1[(degen_face+2)%4];
- tet_top = pyr_top==(degen_face+2)%4+4 ? (degen_face+3)%4+4 : (degen_face+2)%4+4;
+ if(tet_top < 0 && n1[5] >= 0 &&
+ (n1[5] == n1[(degen_face + 2) % 4] || n2[5] == n1[(degen_face + 2) % 4] ||
+ n1[5] == n2[(degen_face + 2) % 4] || n2[5] == n2[(degen_face + 2) % 4])) {
+ pyr_top = n1[(degen_face + 2) % 4] < 4 ? n2[(degen_face + 2) % 4] :
+ n1[(degen_face + 2) % 4];
+ tet_top = pyr_top == (degen_face + 2) % 4 + 4 ? (degen_face + 3) % 4 + 4 :
+ (degen_face + 2) % 4 + 4;
- addTetrahedron( v[pyr_top], v[(pyr_top-4+2)%4+4], v[tet_top-4], v[tet_top], to, source );
+ addTetrahedron(v[pyr_top], v[(pyr_top - 4 + 2) % 4 + 4], v[tet_top - 4],
+ v[tet_top], to, source);
int base = 4;
- if( n1[base] >= 0 ){
- addTetrahedron( v[n1[base]], v[n2[base]], v[(n1[base]+1)%4], v[pyr_top], to, source );
- addTetrahedron( v[n1[base]], v[n2[base]], v[(n1[base]+3)%4], v[pyr_top], to, source );
+ if(n1[base] >= 0) {
+ addTetrahedron(v[n1[base]], v[n2[base]], v[(n1[base] + 1) % 4],
+ v[pyr_top], to, source);
+ addTetrahedron(v[n1[base]], v[n2[base]], v[(n1[base] + 3) % 4],
+ v[pyr_top], to, source);
}
else
- addPyramid( v[0], v[1], v[2], v[3], v[pyr_top], to, source );
+ addPyramid(v[0], v[1], v[2], v[3], v[pyr_top], to, source);
return 1;
}
return 0;
-
}
-
-// Construct the elements that subdivide a one-point degenerated hexahedron extrusion
-static inline bool createOnePtDegenHexElems(std::vector<MVertex*> &v, GRegion *to, ExtrudeParams *ep, int j,
- int k, int dup[], MElement* source, std::vector<int> n1, std::vector<int> n2,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts, bool found_diags)
+// Construct the elements that subdivide a one-point degenerated hexahedron
+// extrusion
+static inline bool createOnePtDegenHexElems(
+ std::vector<MVertex *> &v, GRegion *to, ExtrudeParams *ep, int j, int k,
+ int dup[], MElement *source, std::vector<int> n1, std::vector<int> n2,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts,
+ bool found_diags)
{
-
- if( !ep )
- return 0;
+ if(!ep) return 0;
// if no diags, then just make the degenerate hexahedron and be done
- if( !found_diags ){
- addHexahedron( v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], to, source );
+ if(!found_diags) {
+ addHexahedron(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], to, source);
Msg::Error("Degenerated hexahedron in extrusion of volume %d", to->tag());
return 1;
}
// test for top and bottom diagonals parallel and incident on degen vertex
- else if( ( n1[4] == dup[0] || n2[4] == dup[0] ) &&
- ( n1[5] == dup[0]+4 || n2[5] == dup[0]+4 ) ){
+ else if((n1[4] == dup[0] || n2[4] == dup[0]) &&
+ (n1[5] == dup[0] + 4 || n2[5] == dup[0] + 4)) {
// first pyramid / tet set
- if( n1[(dup[0]+1)%4] >= 0 ){
- if( n1[(dup[0]+1)%4] == (dup[0]+1)%4 ){
- addTetrahedron( v[(dup[0]+1)%4], v[(dup[0]+1)%4+4], v[(dup[0]+2)%4+4], v[dup[0]], to, source );
- addTetrahedron( v[(dup[0]+1)%4], v[(dup[0]+2)%4+4], v[(dup[0]+2)%4], v[dup[0]], to, source );
- }
- else if( n1[(dup[0]+1)%4] == (dup[0]+1)%4+4 ){
- addTetrahedron( v[(dup[0]+1)%4+4], v[(dup[0]+2)%4], v[(dup[0]+1)%4], v[dup[0]], to, source );
- addTetrahedron( v[(dup[0]+1)%4+4], v[(dup[0]+2)%4+4], v[(dup[0]+2)%4], v[dup[0]], to, source );
+ if(n1[(dup[0] + 1) % 4] >= 0) {
+ if(n1[(dup[0] + 1) % 4] == (dup[0] + 1) % 4) {
+ addTetrahedron(v[(dup[0] + 1) % 4], v[(dup[0] + 1) % 4 + 4],
+ v[(dup[0] + 2) % 4 + 4], v[dup[0]], to, source);
+ addTetrahedron(v[(dup[0] + 1) % 4], v[(dup[0] + 2) % 4 + 4],
+ v[(dup[0] + 2) % 4], v[dup[0]], to, source);
+ }
+ else if(n1[(dup[0] + 1) % 4] == (dup[0] + 1) % 4 + 4) {
+ addTetrahedron(v[(dup[0] + 1) % 4 + 4], v[(dup[0] + 2) % 4],
+ v[(dup[0] + 1) % 4], v[dup[0]], to, source);
+ addTetrahedron(v[(dup[0] + 1) % 4 + 4], v[(dup[0] + 2) % 4 + 4],
+ v[(dup[0] + 2) % 4], v[dup[0]], to, source);
}
else
- Msg::Error("1: In QuadToTriHexPri(), badly subdivided degenerate hexahedron. Mesh for region %d has errors.",
- to->tag() );
+ Msg::Error("1: In QuadToTriHexPri(), badly subdivided degenerate "
+ "hexahedron. Mesh for region %d has errors.",
+ to->tag());
}
else
- addPyramid( v[(dup[0]+1)%4], v[(dup[0]+1)%4+4], v[(dup[0]+2)%4+4], v[(dup[0]+2)%4], v[dup[0]], to, source );
+ addPyramid(v[(dup[0] + 1) % 4], v[(dup[0] + 1) % 4 + 4],
+ v[(dup[0] + 2) % 4 + 4], v[(dup[0] + 2) % 4], v[dup[0]], to,
+ source);
// second pyramid / tet set
- if( n1[(dup[0]+2)%4] >= 0 ){
- if( n1[(dup[0]+2)%4] == (dup[0]+2)%4 ){
- addTetrahedron( v[(dup[0]+2)%4], v[(dup[0]+2)%4+4], v[(dup[0]+3)%4+4], v[dup[0]], to, source );
- addTetrahedron( v[(dup[0]+2)%4], v[(dup[0]+3)%4+4], v[(dup[0]+3)%4], v[dup[0]], to, source );
- }
- else if( n1[(dup[0]+2)%4] == (dup[0]+2)%4+4 ){
- addTetrahedron( v[(dup[0]+2)%4+4], v[(dup[0]+3)%4], v[(dup[0]+2)%4], v[dup[0]], to, source );
- addTetrahedron( v[(dup[0]+2)%4+4], v[(dup[0]+3)%4+4], v[(dup[0]+3)%4], v[dup[0]], to, source );
+ if(n1[(dup[0] + 2) % 4] >= 0) {
+ if(n1[(dup[0] + 2) % 4] == (dup[0] + 2) % 4) {
+ addTetrahedron(v[(dup[0] + 2) % 4], v[(dup[0] + 2) % 4 + 4],
+ v[(dup[0] + 3) % 4 + 4], v[dup[0]], to, source);
+ addTetrahedron(v[(dup[0] + 2) % 4], v[(dup[0] + 3) % 4 + 4],
+ v[(dup[0] + 3) % 4], v[dup[0]], to, source);
+ }
+ else if(n1[(dup[0] + 2) % 4] == (dup[0] + 2) % 4 + 4) {
+ addTetrahedron(v[(dup[0] + 2) % 4 + 4], v[(dup[0] + 3) % 4],
+ v[(dup[0] + 2) % 4], v[dup[0]], to, source);
+ addTetrahedron(v[(dup[0] + 2) % 4 + 4], v[(dup[0] + 3) % 4 + 4],
+ v[(dup[0] + 3) % 4], v[dup[0]], to, source);
}
else
- Msg::Error("2: In QuadToTriHexPri(), badly subdivided degenerate hexahedron. Mesh for region %d has errors.",
- to->tag() );
+ Msg::Error("2: In QuadToTriHexPri(), badly subdivided degenerate "
+ "hexahedron. Mesh for region %d has errors.",
+ to->tag());
}
else
- addPyramid( v[(dup[0]+2)%4], v[(dup[0]+2)%4+4], v[(dup[0]+3)%4+4], v[(dup[0]+3)%4], v[dup[0]], to, source );
+ addPyramid(v[(dup[0] + 2) % 4], v[(dup[0] + 2) % 4 + 4],
+ v[(dup[0] + 3) % 4 + 4], v[(dup[0] + 3) % 4], v[dup[0]], to,
+ source);
return 1;
}
// test for top and bottom diagonals parallel and NOT on degen vertex
- else if( ( n1[4] == (dup[0]+1)%4 || n2[4] == (dup[0]+1)%4 ) &&
- ( n1[5] == (dup[0]+1)%4+4 || n2[5] == (dup[0]+1)%4+4 ) ){
- // See if the prism section has to be divided and if it requires the inner surface to be cut
+ else if((n1[4] == (dup[0] + 1) % 4 || n2[4] == (dup[0] + 1) % 4) &&
+ (n1[5] == (dup[0] + 1) % 4 + 4 || n2[5] == (dup[0] + 1) % 4 + 4)) {
+ // See if the prism section has to be divided and if it requires the inner
+ // surface to be cut
int tet_top = -1;
int n_inner[2];
n_inner[0] = -1;
n_inner[1] = -2;
- if( n1[(dup[0]+1)%4] >= 0 && n1[(dup[0]+2)%4] != n2[(dup[0]+1)%4] ){
- tet_top = n1[(dup[0]+1)%4];
- n_inner[0] = n1[(dup[0]+1)%4];
+ if(n1[(dup[0] + 1) % 4] >= 0 &&
+ n1[(dup[0] + 2) % 4] != n2[(dup[0] + 1) % 4]) {
+ tet_top = n1[(dup[0] + 1) % 4];
+ n_inner[0] = n1[(dup[0] + 1) % 4];
int add = n_inner[0] > 3 ? 0 : 4;
- n_inner[1] = (dup[0]+3)%4+add;
+ n_inner[1] = (dup[0] + 3) % 4 + add;
}
- else if( n1[(dup[0]+2)%4] >= 0 && n1[(dup[0]+2)%4] != n2[(dup[0]+1)%4] ){
- tet_top = n2[(dup[0]+2)%4];
- n_inner[1] = n2[(dup[0]+2)%4];
+ else if(n1[(dup[0] + 2) % 4] >= 0 &&
+ n1[(dup[0] + 2) % 4] != n2[(dup[0] + 1) % 4]) {
+ tet_top = n2[(dup[0] + 2) % 4];
+ n_inner[1] = n2[(dup[0] + 2) % 4];
int add = n_inner[1] > 3 ? 0 : 4;
- n_inner[0] = (dup[0]+1)%4+add;
+ n_inner[0] = (dup[0] + 1) % 4 + add;
}
- else if( n1[(dup[0]+1)%4] >= 0 )
- tet_top = n2[(dup[0]+1)%4];
+ else if(n1[(dup[0] + 1) % 4] >= 0)
+ tet_top = n2[(dup[0] + 1) % 4];
- if( tet_top >= 0 ){
+ if(tet_top >= 0) {
int add = tet_top > 3 ? 0 : 4;
- addTetrahedron( v[(dup[0]+1)%4+add], v[(dup[0]+2)%4+add], v[(dup[0]+3)%4+add], v[tet_top], to, source );
- if( n_inner[0] < 0 )
- addPyramid( v[(dup[0]+1)%4], v[(dup[0]+1)%4+4], v[(dup[0]+3)%4+4], v[(dup[0]+3)%4], v[tet_top], to, source );
- else{
- int base = tet_top-4+add == (dup[0]+1)%4 ? (dup[0]+2)%4 : (dup[0]+1)%4;
- if( n1[base] < 0 )
- addPyramid( v[base], v[base+4], v[(base+1)%4+4], v[(base+1)%4], v[tet_top], to, source );
- else{
+ addTetrahedron(v[(dup[0] + 1) % 4 + add], v[(dup[0] + 2) % 4 + add],
+ v[(dup[0] + 3) % 4 + add], v[tet_top], to, source);
+ if(n_inner[0] < 0)
+ addPyramid(v[(dup[0] + 1) % 4], v[(dup[0] + 1) % 4 + 4],
+ v[(dup[0] + 3) % 4 + 4], v[(dup[0] + 3) % 4], v[tet_top], to,
+ source);
+ else {
+ int base = tet_top - 4 + add == (dup[0] + 1) % 4 ? (dup[0] + 2) % 4 :
+ (dup[0] + 1) % 4;
+ if(n1[base] < 0)
+ addPyramid(v[base], v[base + 4], v[(base + 1) % 4 + 4],
+ v[(base + 1) % 4], v[tet_top], to, source);
+ else {
int add_2 = n1[base] > 3 ? -4 : 4;
- addTetrahedron( v[n1[base]], v[n1[base]+add_2], v[n2[base]], v[tet_top], to, source );
- addTetrahedron( v[n1[base]], v[n2[base]], v[n2[base]-add_2], v[tet_top], to, source );
+ addTetrahedron(v[n1[base]], v[n1[base] + add_2], v[n2[base]],
+ v[tet_top], to, source);
+ addTetrahedron(v[n1[base]], v[n2[base]], v[n2[base] - add_2],
+ v[tet_top], to, source);
}
}
}
else
- addPrism( v[(dup[0]+1)%4], v[(dup[0]+2)%4], v[(dup[0]+3)%4], v[(dup[0]+1)%4+4], v[(dup[0]+2)%4+4],
- v[(dup[0]+3)%4+4], to, source );
+ addPrism(v[(dup[0] + 1) % 4], v[(dup[0] + 2) % 4], v[(dup[0] + 3) % 4],
+ v[(dup[0] + 1) % 4 + 4], v[(dup[0] + 2) % 4 + 4],
+ v[(dup[0] + 3) % 4 + 4], to, source);
// add the pyramid or tets that include the degen vertex
- if( n_inner[0] < 0 )
- addPyramid( v[(dup[0]+1)%4], v[(dup[0]+1)%4+4], v[(dup[0]+3)%4+4], v[(dup[0]+3)%4], v[dup[0]], to, source );
- else{
+ if(n_inner[0] < 0)
+ addPyramid(v[(dup[0] + 1) % 4], v[(dup[0] + 1) % 4 + 4],
+ v[(dup[0] + 3) % 4 + 4], v[(dup[0] + 3) % 4], v[dup[0]], to,
+ source);
+ else {
int add = n_inner[0] > 3 ? -4 : 4;
- addTetrahedron( v[n_inner[0]], v[n_inner[0]+add], v[n_inner[1]], v[dup[0]], to, source );
- addTetrahedron( v[n_inner[0]], v[n_inner[1]], v[n_inner[1]-add], v[dup[0]], to, source );
+ addTetrahedron(v[n_inner[0]], v[n_inner[0] + add], v[n_inner[1]],
+ v[dup[0]], to, source);
+ addTetrahedron(v[n_inner[0]], v[n_inner[1]], v[n_inner[1] - add],
+ v[dup[0]], to, source);
}
return 1;
}
// see if there is a way to divide non-parallel top and bottom verts
- else if( n1[(dup[0]+1)%4] >= 0 || n1[(dup[0]+2)%4] >= 0 ){
+ else if(n1[(dup[0] + 1) % 4] >= 0 || n1[(dup[0] + 2) % 4] >= 0) {
// parameters for a pyramid (that may or may not be divided into tets)
int base = -1, top = -2;
// if corner opposite degen corner has two diagonals meeting on it:
- if( n2[(dup[0]+1)%4] >= 0 && n1[(dup[0]+2)%4] == n2[(dup[0]+1)%4] ){
- if( n1[4] == n1[(dup[0]+2)%4] || n2[4] == n1[(dup[0]+2)%4] ){
- top = n1[(dup[0]+2)%4];
+ if(n2[(dup[0] + 1) % 4] >= 0 &&
+ n1[(dup[0] + 2) % 4] == n2[(dup[0] + 1) % 4]) {
+ if(n1[4] == n1[(dup[0] + 2) % 4] || n2[4] == n1[(dup[0] + 2) % 4]) {
+ top = n1[(dup[0] + 2) % 4];
base = 5;
}
- else if( n1[5] == n1[(dup[0]+2)%4] || n2[5] == n1[(dup[0]+2)%4] ){
- top = n1[(dup[0]+2)%4];
+ else if(n1[5] == n1[(dup[0] + 2) % 4] || n2[5] == n1[(dup[0] + 2) % 4]) {
+ top = n1[(dup[0] + 2) % 4];
base = 4;
}
}
- // if a side corner not opposite the degenerate vertex has two diagonals meeting
- if( base < 0 && n2[(dup[0]+2)%4] >= 0 ){
- if( n2[(dup[0]+2)%4] == (dup[0]+3)%4+4 &&
- ( n1[5] == (dup[0]+3)%4+4 || n2[5] == (dup[0]+3)%4+4 ) ){
- top = (dup[0]+3)%4+4;
+ // if a side corner not opposite the degenerate vertex has two diagonals
+ // meeting
+ if(base < 0 && n2[(dup[0] + 2) % 4] >= 0) {
+ if(n2[(dup[0] + 2) % 4] == (dup[0] + 3) % 4 + 4 &&
+ (n1[5] == (dup[0] + 3) % 4 + 4 || n2[5] == (dup[0] + 3) % 4 + 4)) {
+ top = (dup[0] + 3) % 4 + 4;
base = 4;
}
- else if( n2[(dup[0]+2)%4] == (dup[0]+3)%4 &&
- ( n1[4] == (dup[0]+3)%4 || n2[4] == (dup[0]+3)%4 ) ){
- top = (dup[0]+3)%4;
+ else if(n2[(dup[0] + 2) % 4] == (dup[0] + 3) % 4 &&
+ (n1[4] == (dup[0] + 3) % 4 || n2[4] == (dup[0] + 3) % 4)) {
+ top = (dup[0] + 3) % 4;
base = 5;
}
}
- if( base < 0 && n1[(dup[0]+1)%4] >= 0 ){
- if( n1[(dup[0]+1)%4] == (dup[0]+1)%4+4 &&
- ( n1[5] == (dup[0]+1)%4+4 || n2[5] == (dup[0]+1)%4+4 ) ){
- top = (dup[0]+1)%4+4;
+ if(base < 0 && n1[(dup[0] + 1) % 4] >= 0) {
+ if(n1[(dup[0] + 1) % 4] == (dup[0] + 1) % 4 + 4 &&
+ (n1[5] == (dup[0] + 1) % 4 + 4 || n2[5] == (dup[0] + 1) % 4 + 4)) {
+ top = (dup[0] + 1) % 4 + 4;
base = 4;
}
- else if( n1[(dup[0]+1)%4] == (dup[0]+1)%4 &&
- ( n1[4] == (dup[0]+1)%4 || n2[4] == (dup[0]+1)%4 ) ){
- top = (dup[0]+1)%4;
+ else if(n1[(dup[0] + 1) % 4] == (dup[0] + 1) % 4 &&
+ (n1[4] == (dup[0] + 1) % 4 || n2[4] == (dup[0] + 1) % 4)) {
+ top = (dup[0] + 1) % 4;
base = 5;
}
}
// if 4-corner lateral faces have diagonals that don't meet...
- if( base < 0 && n1[(dup[0]+1)%4] >= 0 && n1[(dup[0]+2)%4] >= 0 &&
- n1[(dup[0]+2)%4] != n2[(dup[0]+1)%4] ){
- top = n1[(dup[0]+1)%4];
+ if(base < 0 && n1[(dup[0] + 1) % 4] >= 0 && n1[(dup[0] + 2) % 4] >= 0 &&
+ n1[(dup[0] + 2) % 4] != n2[(dup[0] + 1) % 4]) {
+ top = n1[(dup[0] + 1) % 4];
base = (top < 4) ? 5 : 4;
}
// if there is a valid top and base, make the element
- if( base >= 0 && top >= 0 ){
+ if(base >= 0 && top >= 0) {
// if pyramid top is NOT opposite degen vertex
- if( top == n1[(dup[0]+1)%4] || top == n2[(dup[0]+2)%4] ){
+ if(top == n1[(dup[0] + 1) % 4] || top == n2[(dup[0] + 2) % 4]) {
int add = base == 4 ? 0 : 4;
- if( n1[base] < 0 ){
- addPyramid( v[0+add], v[1+add], v[2+add], v[3+add], v[top], to, source );
+ if(n1[base] < 0) {
+ addPyramid(v[0 + add], v[1 + add], v[2 + add], v[3 + add], v[top], to,
+ source);
}
- else{
- addTetrahedron( v[n1[base]], v[(n1[base]-add+1)%4+add],
- v[n2[base]], v[top], to, source );
- addTetrahedron( v[n1[base]], v[n2[base]],
- v[(n1[base]-add+3)%4+add], v[top], to, source );
+ else {
+ addTetrahedron(v[n1[base]], v[(n1[base] - add + 1) % 4 + add],
+ v[n2[base]], v[top], to, source);
+ addTetrahedron(v[n1[base]], v[n2[base]],
+ v[(n1[base] - add + 3) % 4 + add], v[top], to, source);
}
int base2 = -1;
- if( base==4 && ( n1[5] == top || n2[5] == top ) ){
- base2 = top==(dup[0]+1)%4+4 ? (dup[0]+2)%4 : (dup[0]+1)%4;
+ if(base == 4 && (n1[5] == top || n2[5] == top)) {
+ base2 =
+ top == (dup[0] + 1) % 4 + 4 ? (dup[0] + 2) % 4 : (dup[0] + 1) % 4;
}
- else if( base==5 && ( n1[4] == top || n2[4] == top ) ){
- base2 = top==(dup[0]+1)%4 ? (dup[0]+2)%4 : (dup[0]+1)%4;
+ else if(base == 5 && (n1[4] == top || n2[4] == top)) {
+ base2 = top == (dup[0] + 1) % 4 ? (dup[0] + 2) % 4 : (dup[0] + 1) % 4;
}
else
- base2 = base==5 ? 4 : 5;
-
- if( base2 != 4 && base2 != 5 ){
- addTetrahedron( v[top], v[(top-4+add+2)%4], v[(top-4+add+2)%4+4], v[dup[0]], to, source );
- if( n1[base2] >= 0 ){
- int add_base2 = n1[base2]<4 ? 4 : -4;
- addTetrahedron( v[n1[base2]], v[n1[base2]+add_base2], v[n2[base2]], v[top], to, source );
- addTetrahedron( v[n1[base2]], v[n2[base2]], v[n2[base2]-add_base2], v[top], to, source );
+ base2 = base == 5 ? 4 : 5;
+
+ if(base2 != 4 && base2 != 5) {
+ addTetrahedron(v[top], v[(top - 4 + add + 2) % 4],
+ v[(top - 4 + add + 2) % 4 + 4], v[dup[0]], to, source);
+ if(n1[base2] >= 0) {
+ int add_base2 = n1[base2] < 4 ? 4 : -4;
+ addTetrahedron(v[n1[base2]], v[n1[base2] + add_base2], v[n2[base2]],
+ v[top], to, source);
+ addTetrahedron(v[n1[base2]], v[n2[base2]], v[n2[base2] - add_base2],
+ v[top], to, source);
}
else
- addPyramid( v[base2], v[(base2+4)], v[(base2+1)%4+4], v[(base2+1)%4], v[top], to, source );
+ addPyramid(v[base2], v[(base2 + 4)], v[(base2 + 1) % 4 + 4],
+ v[(base2 + 1) % 4], v[top], to, source);
}
- else{
- int top2 = (top-4+add+2)%4+add;
- if( n1[base2] >= 0 ){
- addTetrahedron( v[n1[base2]], v[(n1[base2]-4+add+1)%4+4-add], v[n2[base2]], v[top2], to, source );
- addTetrahedron( v[n1[base2]], v[(n1[base2]-4+add+3)%4+4-add], v[n2[base2]], v[top2], to, source );
+ else {
+ int top2 = (top - 4 + add + 2) % 4 + add;
+ if(n1[base2] >= 0) {
+ addTetrahedron(v[n1[base2]],
+ v[(n1[base2] - 4 + add + 1) % 4 + 4 - add],
+ v[n2[base2]], v[top2], to, source);
+ addTetrahedron(v[n1[base2]],
+ v[(n1[base2] - 4 + add + 3) % 4 + 4 - add],
+ v[n2[base2]], v[top2], to, source);
}
else
- addPyramid( v[0+4-add], v[1+4-add], v[2+4-add], v[3+4-add], v[top2], to, source );
+ addPyramid(v[0 + 4 - add], v[1 + 4 - add], v[2 + 4 - add],
+ v[3 + 4 - add], v[top2], to, source);
- int tet_base = top2-add==(dup[0]+1)%4 ? (dup[0]+1)%4 : (dup[0]+2)%4;
- if( tet_base == (dup[0]+1)%4 ){
+ int tet_base = top2 - add == (dup[0] + 1) % 4 ? (dup[0] + 1) % 4 :
+ (dup[0] + 2) % 4;
+ if(tet_base == (dup[0] + 1) % 4) {
int add_tet_base = n2[tet_base] > 3 ? -4 : 4;
- addTetrahedron( v[n1[tet_base]], v[n2[tet_base]], v[n2[tet_base]+add_tet_base], v[top], to, source );
+ addTetrahedron(v[n1[tet_base]], v[n2[tet_base]],
+ v[n2[tet_base] + add_tet_base], v[top], to, source);
}
- else{
+ else {
int add_tet_base = n1[tet_base] > 3 ? -4 : 4;
- addTetrahedron( v[n1[tet_base]], v[n2[tet_base]], v[n1[tet_base]+add_tet_base], v[top], to, source );
+ addTetrahedron(v[n1[tet_base]], v[n2[tet_base]],
+ v[n1[tet_base] + add_tet_base], v[top], to, source);
}
}
return 1;
}
// if pyramid top is opposite degenerate vertex
- else if( top == (dup[0]+2)%4 || top == (dup[0]+2)%4+4 ){
+ else if(top == (dup[0] + 2) % 4 || top == (dup[0] + 2) % 4 + 4) {
int add = base == 4 ? 0 : 4;
- if( n1[base] >= 0 ){
- addTetrahedron( v[n1[base]], v[(n1[base]-add+1)%4+add], v[n2[base]], v[top], to, source );
- addTetrahedron( v[n1[base]], v[(n1[base]-add+3)%4+add], v[n2[base]], v[top], to, source );
+ if(n1[base] >= 0) {
+ addTetrahedron(v[n1[base]], v[(n1[base] - add + 1) % 4 + add],
+ v[n2[base]], v[top], to, source);
+ addTetrahedron(v[n1[base]], v[(n1[base] - add + 3) % 4 + add],
+ v[n2[base]], v[top], to, source);
}
else
- addPyramid( v[0+add], v[1+add], v[2+add], v[3+add], v[top], to, source );
+ addPyramid(v[0 + add], v[1 + add], v[2 + add], v[3 + add], v[top], to,
+ source);
- addTetrahedron( v[dup[0]], v[(dup[0]+1)%4], v[(dup[0]+1)%4+4], v[top], to, source );
- addTetrahedron( v[dup[0]], v[(dup[0]+3)%4], v[(dup[0]+3)%4+4], v[top], to, source );
+ addTetrahedron(v[dup[0]], v[(dup[0] + 1) % 4], v[(dup[0] + 1) % 4 + 4],
+ v[top], to, source);
+ addTetrahedron(v[dup[0]], v[(dup[0] + 3) % 4], v[(dup[0] + 3) % 4 + 4],
+ v[top], to, source);
return 1;
}
else
- Msg::Error("3: In createOnePtDegenHexElems(), badly subdivided degenerate hexahedron. Mesh for region %d has errors.",
- to->tag() );
+ Msg::Error("3: In createOnePtDegenHexElems(), badly subdivided "
+ "degenerate hexahedron. Mesh for region %d has errors.",
+ to->tag());
}
-
}
return 0;
-
}
-
// Construct the elements that subdivide a full hexahedron extrusion.
-static inline bool createFullHexElems(std::vector<MVertex*> &v, GRegion *to, ExtrudeParams *ep, int j,
- int k, int dup[], MElement* source, std::vector<int> n1, std::vector<int> n2,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts, bool found_diags)
+static inline bool createFullHexElems(
+ std::vector<MVertex *> &v, GRegion *to, ExtrudeParams *ep, int j, int k,
+ int dup[], MElement *source, std::vector<int> n1, std::vector<int> n2,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts,
+ bool found_diags)
{
- if( !ep )
- return 0 ;
+ if(!ep) return 0;
// First: does this hexa have ANY dividing diagonals? If no, return
- if( !found_diags ){
- addHexahedron( v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], to, source );
- return 1;
+ if(!found_diags) {
+ addHexahedron(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], to, source);
+ return 1;
}
// First test: Try to identify a corner with three diagonals converging on it
@@ -4668,25 +4978,22 @@ static inline bool createFullHexElems(std::vector<MVertex*> &v, GRegion *to, Ext
b1_diag[p] = -1-p; b2_diag[p] = -2-p; b3_diag[p] = -3-p;
}*/
-
// find a 3-diag corner
- for( int s = 0; s < 2; s++ ){
+ for(int s = 0; s < 2; s++) {
int p = !s ? 4 : 5;
- if( n1[p] >= 0 ){
+ if(n1[p] >= 0) {
int add = !s ? 0 : 4;
- int p1 = n1[p]-add, p2 = (n1[p]-add+3)%4;
- if( n1[p1] >=0 && n1[p2] >= 0 &&
- ( n1[p] == n1[p1] || n1[p] == n2[p1] ) &&
- ( n1[p] == n1[p2] || n1[p] == n2[p2] ) ){
+ int p1 = n1[p] - add, p2 = (n1[p] - add + 3) % 4;
+ if(n1[p1] >= 0 && n1[p2] >= 0 && (n1[p] == n1[p1] || n1[p] == n2[p1]) &&
+ (n1[p] == n1[p2] || n1[p] == n2[p2])) {
pyramid_top = n1[p];
base_face_1 = !s ? 5 : 4;
break;
}
- p1 = n2[p]-add;
- p2 = (n2[p]-add+3)%4;
- if( n1[p1] >=0 && n1[p2] >= 0 &&
- ( n2[p] == n1[p1] || n2[p] == n2[p1] ) &&
- ( n2[p] == n1[p2] || n2[p] == n2[p2] ) ){
+ p1 = n2[p] - add;
+ p2 = (n2[p] - add + 3) % 4;
+ if(n1[p1] >= 0 && n1[p2] >= 0 && (n2[p] == n1[p1] || n2[p] == n2[p1]) &&
+ (n2[p] == n1[p2] || n2[p] == n2[p2])) {
pyramid_top = n2[p];
base_face_1 = !s ? 5 : 4;
break;
@@ -4694,43 +5001,55 @@ static inline bool createFullHexElems(std::vector<MVertex*> &v, GRegion *to, Ext
}
}
- // If pyramid top (3-diag corner) is found, then check for diagonal division of bases:
+ // If pyramid top (3-diag corner) is found, then check for diagonal division
+ // of bases:
- if( pyramid_top >= 0 ){
+ if(pyramid_top >= 0) {
// ( base of first pyramid always the hexa's top or bottom )
int add = pyramid_top < 4 ? 0 : 4;
- int base_face_2 = (pyramid_top-add+1)%4;
- int base_face_3 = (pyramid_top-add+2)%4;
+ int base_face_2 = (pyramid_top - add + 1) % 4;
+ int base_face_3 = (pyramid_top - add + 2) % 4;
// Now construct shapes.
- for( int p = 0; p < 3; p++ ){
+ for(int p = 0; p < 3; p++) {
int b[4], bn1, bn2;
- if( !p ){
- int add = base_face_1==4 ? 0 : 4;
- b[0] = 0+add; b[1] = 1+add; b[2] = 2+add; b[3] = 3+add;
- bn1 = n1[base_face_1]; bn2 = n2[base_face_1];
- }
- else if( p==1 ){
- b[0] = base_face_2; b[1] = b[0]+4;
- b[2] = (b[0]+1)%4+4; b[3] = (b[0]+1)%4;
- bn1 = n1[base_face_2]; bn2 = n2[base_face_3];
- }
- else{
- b[0] = base_face_3; b[1] = b[0]+4;
- b[2] = (b[0]+1)%4+4; b[3] = (b[0]+1)%4;
- bn1 = n1[base_face_3]; bn2 = n2[base_face_3];
- }
-
- if( bn1 < 0 )
- addPyramid( v[b[0]], v[b[1]], v[b[2]], v[b[3]], v[pyramid_top], to, source );
- else{
- if( bn1 == b[0] || bn2 == b[0] ){
- addTetrahedron( v[b[0]], v[b[1]], v[b[2]], v[pyramid_top], to, source );
- addTetrahedron( v[b[0]], v[b[2]], v[b[3]], v[pyramid_top], to, source );
+ if(!p) {
+ int add = base_face_1 == 4 ? 0 : 4;
+ b[0] = 0 + add;
+ b[1] = 1 + add;
+ b[2] = 2 + add;
+ b[3] = 3 + add;
+ bn1 = n1[base_face_1];
+ bn2 = n2[base_face_1];
+ }
+ else if(p == 1) {
+ b[0] = base_face_2;
+ b[1] = b[0] + 4;
+ b[2] = (b[0] + 1) % 4 + 4;
+ b[3] = (b[0] + 1) % 4;
+ bn1 = n1[base_face_2];
+ bn2 = n2[base_face_3];
+ }
+ else {
+ b[0] = base_face_3;
+ b[1] = b[0] + 4;
+ b[2] = (b[0] + 1) % 4 + 4;
+ b[3] = (b[0] + 1) % 4;
+ bn1 = n1[base_face_3];
+ bn2 = n2[base_face_3];
+ }
+
+ if(bn1 < 0)
+ addPyramid(v[b[0]], v[b[1]], v[b[2]], v[b[3]], v[pyramid_top], to,
+ source);
+ else {
+ if(bn1 == b[0] || bn2 == b[0]) {
+ addTetrahedron(v[b[0]], v[b[1]], v[b[2]], v[pyramid_top], to, source);
+ addTetrahedron(v[b[0]], v[b[2]], v[b[3]], v[pyramid_top], to, source);
}
- else{
- addTetrahedron( v[b[0]], v[b[1]], v[b[3]], v[pyramid_top], to, source );
- addTetrahedron( v[b[1]], v[b[2]], v[b[3]], v[pyramid_top], to, source );
+ else {
+ addTetrahedron(v[b[0]], v[b[1]], v[b[3]], v[pyramid_top], to, source);
+ addTetrahedron(v[b[1]], v[b[2]], v[b[3]], v[pyramid_top], to, source);
}
}
}
@@ -4738,115 +5057,130 @@ static inline bool createFullHexElems(std::vector<MVertex*> &v, GRegion *to, Ext
return 1;
}
-
// Second full hexa division possibility (two prisms, possibly subdivided):
// YES, THIS IS HORRIBLE!!!!
- // Diagram of prism-centric coordinates:
- /* ___________ p5
- |\ /|\
- | \ / | \
- | \ / | \
- | \/______|___\
- | / | | /|p2
- p3 |/___|___p4_| / |
- \ | /\ | prism 1,
- \ | / \ | external face 2 (side)
- \ | / \ |
- \|/_________\|
- p0 p1
- prism 1,
- external face 1 (bottom)
-
- NOTE: for Prism 2, the prism coords MIRROR the coords for
- prism 1 about the internal shared face.
- */
-
+ // Diagram of prism-centric coordinates:
+ /* ___________ p5
+ |\ /|\
+ | \ / | \
+ | \ / | \
+ | \/______|___\
+ | / | | /|p2
+ p3 |/___|___p4_| / |
+ \ | /\ | prism 1,
+ \ | / \ | external face 2 (side)
+ \ | / \ |
+ \|/_________\|
+ p0 p1
+ prism 1,
+ external face 1 (bottom)
+
+ NOTE: for Prism 2, the prism coords MIRROR the coords for
+ prism 1 about the internal shared face.
+ */
// prism_v holds prism-centric indices of vertices--new coords!!!
int prism_v[2][6], prism_face[2][2];
// t_prism arrays for tet verts...p_prism arrays for pyramid verts (if any)
int t_prism[2][3][4], p_prism[2][5];
- for( int s = 0; s < 2; s++ ){
- for( int t = 0; t < 5; t++ )
- p_prism[s][t] = -2*s-2;
- for( int t = 0; t < 3; t++ ){
- for( int w = 0; w < 4; w++ )
- t_prism[s][t][w] = -2*s*t*w-2;
+ for(int s = 0; s < 2; s++) {
+ for(int t = 0; t < 5; t++) p_prism[s][t] = -2 * s - 2;
+ for(int t = 0; t < 3; t++) {
+ for(int w = 0; w < 4; w++) t_prism[s][t][w] = -2 * s * t * w - 2;
}
}
int prism_slice_valid = false; // set to true when found a valid slicing
// find valid prism slicing
- for( int p_ind = 0; p_ind < 3; p_ind++ ){
+ for(int p_ind = 0; p_ind < 3; p_ind++) {
int p = p_ind;
- if( p_ind == 2 ) p = 4; // move to the top-to-bottom slicing
+ if(p_ind == 2) p = 4; // move to the top-to-bottom slicing
prism_slice_valid = false;
// n_div1, n_div2 are indices of the vertice in the first diagonal
int n_div1 = -1, n_div2 = -2;
- if( p < 4 ){
- if( ( n1[p] == p || n2[p] == p ) &&
- ( n1[(p+2)%4] == (p+2)%4+4 || n2[(p+2)%4] == (p+2)%4+4 ) ){
- n_div1 = p; n_div2 = (p+1)%4+4;
+ if(p < 4) {
+ if((n1[p] == p || n2[p] == p) && (n1[(p + 2) % 4] == (p + 2) % 4 + 4 ||
+ n2[(p + 2) % 4] == (p + 2) % 4 + 4)) {
+ n_div1 = p;
+ n_div2 = (p + 1) % 4 + 4;
}
- if( ( n1[p] == p+4 || n2[p] == p+4 ) &&
- ( n1[(p+2)%4] == (p+2)%4 || n2[(p+2)%4] == (p+2)%4 ) ){
- n_div1 = p+4; n_div2 = (p+1)%4;
+ if((n1[p] == p + 4 || n2[p] == p + 4) &&
+ (n1[(p + 2) % 4] == (p + 2) % 4 || n2[(p + 2) % 4] == (p + 2) % 4)) {
+ n_div1 = p + 4;
+ n_div2 = (p + 1) % 4;
}
}
- else{
- if( ( n1[4] == 0 || n2[4] == 0 ) &&
- ( n1[5] == 4 || n2[5] == 4 ) ){
- n_div1 = 0; n_div2 = 2;
+ else {
+ if((n1[4] == 0 || n2[4] == 0) && (n1[5] == 4 || n2[5] == 4)) {
+ n_div1 = 0;
+ n_div2 = 2;
}
- if( ( n1[4] == 1 || n2[4] == 1 ) &&
- ( n1[5] == 5 || n2[5] == 5 ) ){
- n_div1 = 1; n_div2 = 3;
+ if((n1[4] == 1 || n2[4] == 1) && (n1[5] == 5 || n2[5] == 5)) {
+ n_div1 = 1;
+ n_div2 = 3;
}
}
- if( n_div1 < 0 )
- continue;
+ if(n_div1 < 0) continue;
- // There are two prisms. Find the vertices of any external and internal prism
+ // There are two prisms. Find the vertices of any external and internal
+ // prism
// face diagonals.
int ext_diag[2][2][2], intern_diag[2];
- for( int s = 0; s < 2; s++ ){
- intern_diag[s] = -5-s*s-s;
- for( int t = 0; t < 2; t++ ){
- ext_diag[s][t][0] = -1-t*t-t; ext_diag[s][t][1] = -2-t*t-t;
+ for(int s = 0; s < 2; s++) {
+ intern_diag[s] = -5 - s * s - s;
+ for(int t = 0; t < 2; t++) {
+ ext_diag[s][t][0] = -1 - t * t - t;
+ ext_diag[s][t][1] = -2 - t * t - t;
}
}
- // Create arrays of verts of both prisms in prism-centric coords (see ascii diagram above)
- // to keep sanity.
- // p0 always refereces a vertex position on a slicing diagonal (see ascii diagram above again.
+ // Create arrays of verts of both prisms in prism-centric coords (see ascii
+ // diagram above) to keep sanity. p0 always refereces a vertex position on a
+ // slicing diagonal (see ascii diagram above again.
int p0;
- if( (n_div1 > 3 && n_div2 < 4) || (n_div1 < 4 && n_div2 > 3) ){
- p0 = n_div1 < 4 ? p : (p+2)%4;
- prism_v[0][0] = p0; prism_v[0][1] = (p0+1)%4; prism_v[0][2] = (p0+1)%4+4;
- prism_v[0][3] = (p0+3)%4; prism_v[0][4] = (p0+2)%4; prism_v[0][5] = (p0+2)%4+4;
- prism_v[1][0] = p0; prism_v[1][1] = p0+4; prism_v[1][2] = (p0+1)%4+4;
- prism_v[1][3] = (p0+3)%4; prism_v[1][4] = (p0+3)%4+4; prism_v[1][5] = (p0+2)%4+4;
+ if((n_div1 > 3 && n_div2 < 4) || (n_div1 < 4 && n_div2 > 3)) {
+ p0 = n_div1 < 4 ? p : (p + 2) % 4;
+ prism_v[0][0] = p0;
+ prism_v[0][1] = (p0 + 1) % 4;
+ prism_v[0][2] = (p0 + 1) % 4 + 4;
+ prism_v[0][3] = (p0 + 3) % 4;
+ prism_v[0][4] = (p0 + 2) % 4;
+ prism_v[0][5] = (p0 + 2) % 4 + 4;
+ prism_v[1][0] = p0;
+ prism_v[1][1] = p0 + 4;
+ prism_v[1][2] = (p0 + 1) % 4 + 4;
+ prism_v[1][3] = (p0 + 3) % 4;
+ prism_v[1][4] = (p0 + 3) % 4 + 4;
+ prism_v[1][5] = (p0 + 2) % 4 + 4;
prism_face[0][0] = 4;
- prism_face[0][1] = (p0+1)%4;
- prism_face[1][0] = (p0+3)%4;
+ prism_face[0][1] = (p0 + 1) % 4;
+ prism_face[1][0] = (p0 + 3) % 4;
prism_face[1][1] = 5;
}
- else{
+ else {
p0 = n_div1;
- prism_v[0][0] = p0; prism_v[0][1] = (p0+1)%4; prism_v[0][2] = (p0+2)%4;
- prism_v[0][3] = p0+4; prism_v[0][4] = (p0+1)%4+4; prism_v[0][5] = (p0+2)%4+4;
- prism_v[1][0] = p0; prism_v[1][1] = (p0+3)%4; prism_v[1][2] = (p0+2)%4;
- prism_v[1][3] = p0+4; prism_v[1][4] = (p0+3)%4+4; prism_v[1][5] = (p0+2)%4+4;
+ prism_v[0][0] = p0;
+ prism_v[0][1] = (p0 + 1) % 4;
+ prism_v[0][2] = (p0 + 2) % 4;
+ prism_v[0][3] = p0 + 4;
+ prism_v[0][4] = (p0 + 1) % 4 + 4;
+ prism_v[0][5] = (p0 + 2) % 4 + 4;
+ prism_v[1][0] = p0;
+ prism_v[1][1] = (p0 + 3) % 4;
+ prism_v[1][2] = (p0 + 2) % 4;
+ prism_v[1][3] = p0 + 4;
+ prism_v[1][4] = (p0 + 3) % 4 + 4;
+ prism_v[1][5] = (p0 + 2) % 4 + 4;
prism_face[0][0] = p0;
- prism_face[0][1] = (p0+1)%4;
- prism_face[1][0] = (p0+3)%4;
- prism_face[1][1] = (p0+2)%4;
+ prism_face[0][1] = (p0 + 1) % 4;
+ prism_face[1][0] = (p0 + 3) % 4;
+ prism_face[1][1] = (p0 + 2) % 4;
}
// 3 ways this prism slice can work:
@@ -4855,63 +5189,69 @@ static inline bool createFullHexElems(std::vector<MVertex*> &v, GRegion *to, Ext
// 3. No more diagonals, just two prisms
// get external diagonals for first and second prism
- for( int s = 0; s < 2; s++ ){
- if( n1[prism_face[s][0]] == prism_v[s][1] ||
- n2[prism_face[s][0]] == prism_v[s][1] ){
- ext_diag[s][0][0] = 1; ext_diag[s][0][1] = 3;
+ for(int s = 0; s < 2; s++) {
+ if(n1[prism_face[s][0]] == prism_v[s][1] ||
+ n2[prism_face[s][0]] == prism_v[s][1]) {
+ ext_diag[s][0][0] = 1;
+ ext_diag[s][0][1] = 3;
}
- else if( n1[prism_face[s][0]] == prism_v[s][4] ||
- n2[prism_face[s][0]] == prism_v[s][4] ){
- ext_diag[s][0][0] = 4; ext_diag[s][0][1] = 0;
+ else if(n1[prism_face[s][0]] == prism_v[s][4] ||
+ n2[prism_face[s][0]] == prism_v[s][4]) {
+ ext_diag[s][0][0] = 4;
+ ext_diag[s][0][1] = 0;
}
- if( n1[prism_face[s][1]] == prism_v[s][1] ||
- n2[prism_face[s][1]] == prism_v[s][1] ){
- ext_diag[s][1][0] = 1; ext_diag[s][1][1] = 5;
+ if(n1[prism_face[s][1]] == prism_v[s][1] ||
+ n2[prism_face[s][1]] == prism_v[s][1]) {
+ ext_diag[s][1][0] = 1;
+ ext_diag[s][1][1] = 5;
}
- else if( n1[prism_face[s][1]] == prism_v[s][4] ||
- n2[prism_face[s][1]] == prism_v[s][4] ){
- ext_diag[s][1][0] = 4; ext_diag[s][1][1] = 2;
+ else if(n1[prism_face[s][1]] == prism_v[s][4] ||
+ n2[prism_face[s][1]] == prism_v[s][4]) {
+ ext_diag[s][1][0] = 4;
+ ext_diag[s][1][1] = 2;
}
}
// if first prism needs the internal diagonal
- if( ext_diag[0][0][0] >= 0 && ext_diag[0][1][0] != ext_diag[0][0][0] ){
+ if(ext_diag[0][0][0] >= 0 && ext_diag[0][1][0] != ext_diag[0][0][0]) {
intern_diag[0] = ext_diag[0][0][1];
- if( ext_diag[0][0][1] == 0 )
+ if(ext_diag[0][0][1] == 0)
intern_diag[1] = 5;
else
intern_diag[1] = 2;
}
- else if( ext_diag[0][1][0] >= 0 && ext_diag[0][0][0] != ext_diag[0][1][0] ){
+ else if(ext_diag[0][1][0] >= 0 && ext_diag[0][0][0] != ext_diag[0][1][0]) {
intern_diag[0] = ext_diag[0][1][1];
- if( ext_diag[0][1][1] == 2 )
+ if(ext_diag[0][1][1] == 2)
intern_diag[1] = 3;
else
intern_diag[1] = 0;
}
- // if 2nd prism needs the internal diagonal to work, check to see if the internal
- // diagonal exists and, if so, if it is consistent. If it doesn't exist, make it
- if( ( ext_diag[1][0][0] != ext_diag[1][1][0] || (ext_diag[1][0][0] < 0 &&
- ext_diag[1][1][0] < 0) ) &&
- intern_diag[0] >= 0 && intern_diag[0] != ext_diag[1][0][1] &&
- intern_diag[0] != ext_diag[1][1][1] && intern_diag[1] != ext_diag[1][0][1] &&
- intern_diag[1] != ext_diag[1][1][1] ) {
+ // if 2nd prism needs the internal diagonal to work, check to see if the
+ // internal diagonal exists and, if so, if it is consistent. If it doesn't
+ // exist, make it
+ if((ext_diag[1][0][0] != ext_diag[1][1][0] ||
+ (ext_diag[1][0][0] < 0 && ext_diag[1][1][0] < 0)) &&
+ intern_diag[0] >= 0 && intern_diag[0] != ext_diag[1][0][1] &&
+ intern_diag[0] != ext_diag[1][1][1] &&
+ intern_diag[1] != ext_diag[1][0][1] &&
+ intern_diag[1] != ext_diag[1][1][1]) {
continue;
}
// add internal diagonal if needed
- else if( intern_diag[0] < 0 && ext_diag[1][0][0] >= 0 &&
- ext_diag[1][1][0] != ext_diag[1][0][0] ){
+ else if(intern_diag[0] < 0 && ext_diag[1][0][0] >= 0 &&
+ ext_diag[1][1][0] != ext_diag[1][0][0]) {
intern_diag[0] = ext_diag[1][0][1];
- if( ext_diag[1][0][1] == 0 )
+ if(ext_diag[1][0][1] == 0)
intern_diag[1] = 5;
else
intern_diag[1] = 2;
}
- else if( intern_diag[0] < 0 && ext_diag[1][1][0] >= 0 &&
- ext_diag[1][0][0] != ext_diag[1][1][0] ){
+ else if(intern_diag[0] < 0 && ext_diag[1][1][0] >= 0 &&
+ ext_diag[1][0][0] != ext_diag[1][1][0]) {
intern_diag[0] = ext_diag[1][1][1];
- if( ext_diag[1][1][1] == 2 )
+ if(ext_diag[1][1][1] == 2)
intern_diag[1] = 3;
else
intern_diag[1] = 0;
@@ -4919,9 +5259,9 @@ static inline bool createFullHexElems(std::vector<MVertex*> &v, GRegion *to, Ext
// this check sees if the internal shared prism face is diagonalized, but
// one prism has no other diags
- if( intern_diag[0] >= 0 &&
- ( (ext_diag[0][0][0] < 0 && ext_diag[0][1][0] < 0) ||
- (ext_diag[1][0][0] < 0 && ext_diag[1][1][0] < 0) ) ){
+ if(intern_diag[0] >= 0 &&
+ ((ext_diag[0][0][0] < 0 && ext_diag[0][1][0] < 0) ||
+ (ext_diag[1][0][0] < 0 && ext_diag[1][1][0] < 0))) {
continue;
}
@@ -4929,170 +5269,197 @@ static inline bool createFullHexElems(std::vector<MVertex*> &v, GRegion *to, Ext
prism_slice_valid = true;
// make arrays of vertices for making the polyhedra
- if( prism_slice_valid ){
- for( int s = 0; s < 2; s++ ){
- if( ext_diag[s][0][0] < 0 && ext_diag[s][1][0] < 0 )
+ if(prism_slice_valid) {
+ for(int s = 0; s < 2; s++) {
+ if(ext_diag[s][0][0] < 0 && ext_diag[s][1][0] < 0)
continue;
- else if( ext_diag[s][0][0] >= 0 && ext_diag[s][0][0] == ext_diag[s][1][0] ){
+ else if(ext_diag[s][0][0] >= 0 &&
+ ext_diag[s][0][0] == ext_diag[s][1][0]) {
int add = (ext_diag[s][0][0] < 3) ? 3 : -3;
- t_prism[s][0][0] = ext_diag[s][0][0]; t_prism[s][0][1] = ext_diag[s][0][1];
- t_prism[s][0][2] = ext_diag[s][1][1]; t_prism[s][0][3] = ext_diag[s][0][0]+add;
- if( intern_diag[0] < 0 ){
- p_prism[s][0] = 0; p_prism[s][1] = 2;
- p_prism[s][2] = 5; p_prism[s][3] = 3;
+ t_prism[s][0][0] = ext_diag[s][0][0];
+ t_prism[s][0][1] = ext_diag[s][0][1];
+ t_prism[s][0][2] = ext_diag[s][1][1];
+ t_prism[s][0][3] = ext_diag[s][0][0] + add;
+ if(intern_diag[0] < 0) {
+ p_prism[s][0] = 0;
+ p_prism[s][1] = 2;
+ p_prism[s][2] = 5;
+ p_prism[s][3] = 3;
p_prism[s][4] = ext_diag[s][0][0];
}
- else{
+ else {
int v_tmp1 = (intern_diag[0] == 0 || intern_diag[1] == 0) ? 2 : 0;
int v_tmp2 = (intern_diag[0] == 0 || intern_diag[1] == 0) ? 3 : 5;
- t_prism[s][1][0] = intern_diag[0]; t_prism[s][1][1] = intern_diag[1];
- t_prism[s][1][2] = v_tmp1; t_prism[s][1][3] = ext_diag[s][0][0];
- t_prism[s][2][0] = intern_diag[0]; t_prism[s][2][1] = intern_diag[1];
- t_prism[s][2][2] = v_tmp2; t_prism[s][2][3] = ext_diag[s][0][0];
+ t_prism[s][1][0] = intern_diag[0];
+ t_prism[s][1][1] = intern_diag[1];
+ t_prism[s][1][2] = v_tmp1;
+ t_prism[s][1][3] = ext_diag[s][0][0];
+ t_prism[s][2][0] = intern_diag[0];
+ t_prism[s][2][1] = intern_diag[1];
+ t_prism[s][2][2] = v_tmp2;
+ t_prism[s][2][3] = ext_diag[s][0][0];
}
}
- else if( intern_diag[0] >= 0 ){
- int p_tet_start = (ext_diag[s][0][0] >= 0) ? ext_diag[s][0][0] : ext_diag[s][1][0];
- int p_pyr_top = (p_tet_start == ext_diag[s][0][0])
- ? ext_diag[s][0][1] : ext_diag[s][1][1];
+ else if(intern_diag[0] >= 0) {
+ int p_tet_start =
+ (ext_diag[s][0][0] >= 0) ? ext_diag[s][0][0] : ext_diag[s][1][0];
+ int p_pyr_top = (p_tet_start == ext_diag[s][0][0]) ?
+ ext_diag[s][0][1] :
+ ext_diag[s][1][1];
int p_tet_top;
- if( p_tet_start == ext_diag[s][0][0] )
+ if(p_tet_start == ext_diag[s][0][0])
p_tet_top = (ext_diag[s][0][1] == 3) ? 0 : 3;
else
p_tet_top = (ext_diag[s][1][1] == 5) ? 2 : 5;
- t_prism[s][0][0] = p_tet_start; t_prism[s][0][1] = intern_diag[0];
- t_prism[s][0][2] = intern_diag[1]; t_prism[s][0][3] = p_tet_top;
-
- if( p_tet_start == ext_diag[s][0][0] ){
- if( ext_diag[s][1][0] < 0 ){
- p_prism[s][0] = 1; p_prism[s][1] = 2;
- p_prism[s][2] = 5; p_prism[s][3] = 4;
+ t_prism[s][0][0] = p_tet_start;
+ t_prism[s][0][1] = intern_diag[0];
+ t_prism[s][0][2] = intern_diag[1];
+ t_prism[s][0][3] = p_tet_top;
+
+ if(p_tet_start == ext_diag[s][0][0]) {
+ if(ext_diag[s][1][0] < 0) {
+ p_prism[s][0] = 1;
+ p_prism[s][1] = 2;
+ p_prism[s][2] = 5;
+ p_prism[s][3] = 4;
p_prism[s][4] = p_pyr_top;
}
- else{
- t_prism[s][1][0] = ext_diag[s][1][0]; t_prism[s][1][1] = ext_diag[s][1][1];
- t_prism[s][1][2] = (ext_diag[s][1][0]==4) ? 1 : 4;
+ else {
+ t_prism[s][1][0] = ext_diag[s][1][0];
+ t_prism[s][1][1] = ext_diag[s][1][1];
+ t_prism[s][1][2] = (ext_diag[s][1][0] == 4) ? 1 : 4;
t_prism[s][1][3] = p_pyr_top;
- t_prism[s][2][0] = ext_diag[s][1][0]; t_prism[s][2][1] = ext_diag[s][1][1];
- t_prism[s][2][2] = (ext_diag[s][1][0]==4) ? 5 : 2;
+ t_prism[s][2][0] = ext_diag[s][1][0];
+ t_prism[s][2][1] = ext_diag[s][1][1];
+ t_prism[s][2][2] = (ext_diag[s][1][0] == 4) ? 5 : 2;
t_prism[s][2][3] = p_pyr_top;
}
}
- else{
- if( ext_diag[s][0][0] < 0 ){
- p_prism[s][0] = 0; p_prism[s][1] = 1;
- p_prism[s][2] = 4; p_prism[s][3] = 3;
+ else {
+ if(ext_diag[s][0][0] < 0) {
+ p_prism[s][0] = 0;
+ p_prism[s][1] = 1;
+ p_prism[s][2] = 4;
+ p_prism[s][3] = 3;
p_prism[s][4] = p_pyr_top;
}
- else{
- t_prism[s][1][0] = ext_diag[s][0][0]; t_prism[s][1][1] = ext_diag[s][0][1];
- t_prism[s][1][2] = (ext_diag[s][0][0]==4) ? 3 : 4;
+ else {
+ t_prism[s][1][0] = ext_diag[s][0][0];
+ t_prism[s][1][1] = ext_diag[s][0][1];
+ t_prism[s][1][2] = (ext_diag[s][0][0] == 4) ? 3 : 4;
t_prism[s][1][3] = p_pyr_top;
- t_prism[s][2][0] = ext_diag[s][0][0]; t_prism[s][2][1] = ext_diag[s][0][1];
- t_prism[s][2][2] = (ext_diag[s][0][0]==4) ? 1 : 0;
+ t_prism[s][2][0] = ext_diag[s][0][0];
+ t_prism[s][2][1] = ext_diag[s][0][1];
+ t_prism[s][2][2] = (ext_diag[s][0][0] == 4) ? 1 : 0;
t_prism[s][2][3] = p_pyr_top;
}
}
}
// translate arrays to 'real' vertex coordinates
- for( int t = 0; t < 3; t++ ){
- for( int w = 0; w < 4; w++ )
- t_prism[s][t][w] = (t_prism[s][t][w] >= 0)
- ? prism_v[s][t_prism[s][t][w]] : t_prism[s][t][w];
+ for(int t = 0; t < 3; t++) {
+ for(int w = 0; w < 4; w++)
+ t_prism[s][t][w] = (t_prism[s][t][w] >= 0) ?
+ prism_v[s][t_prism[s][t][w]] :
+ t_prism[s][t][w];
}
- for( int t = 0; t < 5; t++ )
- p_prism[s][t] = (p_prism[s][t] >= 0)
- ? prism_v[s][p_prism[s][t]] : p_prism[s][t];
+ for(int t = 0; t < 5; t++)
+ p_prism[s][t] =
+ (p_prism[s][t] >= 0) ? prism_v[s][p_prism[s][t]] : p_prism[s][t];
}
// Now construct shapes for prism slice through configuration
- for( int s = 0; s < 2; s++ ){
- if( t_prism[s][0][0] < 0 && p_prism[s][0] < 0 ){
- addPrism( v[prism_v[s][0]], v[prism_v[s][1]], v[prism_v[s][2]], v[prism_v[s][3]],
- v[prism_v[s][4]], v[prism_v[s][5]], to, source);
+ for(int s = 0; s < 2; s++) {
+ if(t_prism[s][0][0] < 0 && p_prism[s][0] < 0) {
+ addPrism(v[prism_v[s][0]], v[prism_v[s][1]], v[prism_v[s][2]],
+ v[prism_v[s][3]], v[prism_v[s][4]], v[prism_v[s][5]], to,
+ source);
}
- else{
- for( int t = 0; t < 3; t++ ){
- if( t_prism[s][t][0] >= 0 )
- addTetrahedron( v[t_prism[s][t][0]], v[t_prism[s][t][1]], v[t_prism[s][t][2]],
- v[t_prism[s][t][3]], to, source );
+ else {
+ for(int t = 0; t < 3; t++) {
+ if(t_prism[s][t][0] >= 0)
+ addTetrahedron(v[t_prism[s][t][0]], v[t_prism[s][t][1]],
+ v[t_prism[s][t][2]], v[t_prism[s][t][3]], to,
+ source);
}
- if( p_prism[s][0] >= 0 )
- addPyramid( v[p_prism[s][0]], v[p_prism[s][1]], v[p_prism[s][2]], v[p_prism[s][3]],
- v[p_prism[s][4]], to, source );
+ if(p_prism[s][0] >= 0)
+ addPyramid(v[p_prism[s][0]], v[p_prism[s][1]], v[p_prism[s][2]],
+ v[p_prism[s][3]], v[p_prism[s][4]], to, source);
}
}
// return now
return 1;
- } // end of "if prism_slice_valid" statement
- } // end of p_ind loop over opposite pairs of diagonals
-
- return 0; // if exhaust possibilities, default to this
+ } // end of "if prism_slice_valid" statement
+ } // end of p_ind loop over opposite pairs of diagonals
+ return 0; // if exhaust possibilities, default to this
}
-
-// Overall function that creates the elements that subdivide any whole element extruded from a quadrangle.
-static inline void QuadToTriHexPri(std::vector<MVertex*> &v, GRegion *to, int j,
- int k, MElement* source,
- std::set<std::pair<MVertex*, MVertex*> > &quadToTri_edges,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems,
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > > &problems_new,
- unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts, bool diag_search,
- MVertexRTree &pos)
+// Overall function that creates the elements that subdivide any whole element
+// extruded from a quadrangle.
+static inline void QuadToTriHexPri(
+ std::vector<MVertex *> &v, GRegion *to, int j, int k, MElement *source,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems_new,
+ unsigned int lat_tri_diags_size, bool bnd_elem, bool is_addverts,
+ bool diag_search, MVertexRTree &pos)
{
-
int dup[4];
int m = 0;
for(int i = 0; i < 4; i++)
- if(v[i] == v[i + 4])
- dup[m++] = i;
+ if(v[i] == v[i + 4]) dup[m++] = i;
bool is_problem = false;
// is element marked as needing internal vertex?
- if( !is_addverts ){
- std::pair<unsigned int, unsigned int> jk_pair (j,k);
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > >::iterator itprob;
+ if(!is_addverts) {
+ std::pair<unsigned int, unsigned int> jk_pair(j, k);
+ std::map<MElement *,
+ std::set<std::pair<unsigned int, unsigned int> > >::iterator
+ itprob;
itprob = problems.find(source);
- if( itprob != problems.end() ){
- if( (*itprob).second.find(jk_pair) != (*itprob).second.end() )
+ if(itprob != problems.end()) {
+ if((*itprob).second.find(jk_pair) != (*itprob).second.end())
is_problem = true;
}
}
ExtrudeParams *ep = to->meshAttributes.extrude;
-
// variables to hold of each faces's diagonal vertex nodes
bool found_diags = false;
std::vector<int> n1, n2;
n1.assign(6, -3);
n2.assign(6, -4);
- if( diag_search ){
- for( int p = 0; p < 6; p++ ){
- n1[p] = -p*p-p-1; n2[p] = -p*p-p-2; //unique negative numbers
- if( p < 4 ){
- if( edgeExists( v[p], v[(p+1)%4+4], quadToTri_edges ) ){
- n1[p] = p; n2[p] = (p+1)%4+4;
+ if(diag_search) {
+ for(int p = 0; p < 6; p++) {
+ n1[p] = -p * p - p - 1;
+ n2[p] = -p * p - p - 2; // unique negative numbers
+ if(p < 4) {
+ if(edgeExists(v[p], v[(p + 1) % 4 + 4], quadToTri_edges)) {
+ n1[p] = p;
+ n2[p] = (p + 1) % 4 + 4;
found_diags = true;
}
- else if( edgeExists( v[(p+1)%4], v[p+4], quadToTri_edges ) ){
- n1[p] = (p+4); n2[p] = (p+1)%4;
+ else if(edgeExists(v[(p + 1) % 4], v[p + 4], quadToTri_edges)) {
+ n1[p] = (p + 4);
+ n2[p] = (p + 1) % 4;
found_diags = true;
}
}
- else{
+ else {
int add = (p == 4) ? 0 : 4;
- if( edgeExists( v[0+add], v[2+add], quadToTri_edges ) ){
+ if(edgeExists(v[0 + add], v[2 + add], quadToTri_edges)) {
n1[p] = 0 + add;
n2[p] = 2 + add;
found_diags = true;
}
- else if( edgeExists( v[1+add], v[3+add], quadToTri_edges ) ){
+ else if(edgeExists(v[1 + add], v[3 + add], quadToTri_edges)) {
n1[p] = 1 + add;
n2[p] = 3 + add;
found_diags = true;
@@ -5101,214 +5468,223 @@ static inline void QuadToTriHexPri(std::vector<MVertex*> &v, GRegion *to, int j,
}
}
-
// BAD SHAPE
- if( m > 2 || m < 0 ){
+ if(m > 2 || m < 0) {
Msg::Error("In QuadToTriHexPri(), bad number of degenerate corners.");
return;
}
-
// Divide by new internal vertex extrusion method?
- if( is_addverts && ( found_diags || m==1 ) ){
- MeshWithInternalVertex( to, source, v, n1, n2, pos);
+ if(is_addverts && (found_diags || m == 1)) {
+ MeshWithInternalVertex(to, source, v, n1, n2, pos);
return;
}
-
// The of the possibilites are for a 'no new vertex' extrusion
// PRISM
- else if(m == 2 && !is_problem){
- if(createTwoPtDegenHexElems(v, to, ep, j, k, dup, source, n1, n2, quadToTri_edges, problems,
- problems_new, lat_tri_diags_size, bnd_elem, is_addverts, found_diags))
+ else if(m == 2 && !is_problem) {
+ if(createTwoPtDegenHexElems(
+ v, to, ep, j, k, dup, source, n1, n2, quadToTri_edges, problems,
+ problems_new, lat_tri_diags_size, bnd_elem, is_addverts, found_diags))
return;
}
// DEGENERATE HEXAHEDRON
- else if(m == 1 && !is_problem){
- if(createOnePtDegenHexElems(v, to, ep, j, k, dup, source, n1, n2, quadToTri_edges, problems,
- problems_new, lat_tri_diags_size, bnd_elem, is_addverts, found_diags))
+ else if(m == 1 && !is_problem) {
+ if(createOnePtDegenHexElems(
+ v, to, ep, j, k, dup, source, n1, n2, quadToTri_edges, problems,
+ problems_new, lat_tri_diags_size, bnd_elem, is_addverts, found_diags))
return;
}
-
// FULL HEXAHEDRON
- else if(!is_problem){
- if(createFullHexElems(v, to, ep, j, k, dup, source, n1, n2, quadToTri_edges, problems,
- problems_new, lat_tri_diags_size, bnd_elem, is_addverts, found_diags))
+ else if(!is_problem) {
+ if(createFullHexElems(v, to, ep, j, k, dup, source, n1, n2, quadToTri_edges,
+ problems, problems_new, lat_tri_diags_size, bnd_elem,
+ is_addverts, found_diags))
return;
}
// now take care of unexpected failure to divide without internal vertex
if(!is_problem) {
- Msg::Error("In QuadToTriHexPri(), Extruded hexahedron needs subdivision, but cannot "
- " be divided without internal vertex, and was not previously detected as such. "
- " This is a bug. Please Report.");
+ Msg::Error(
+ "In QuadToTriHexPri(), Extruded hexahedron needs subdivision, but cannot "
+ " be divided without internal vertex, and was not previously detected as "
+ "such. "
+ " This is a bug. Please Report.");
Msg::Error("j: %d, k: %d", j, k);
QtMakeCentroidVertex(v, &(to->mesh_vertices), to, pos);
- std::pair<unsigned int, unsigned int> jk_pair(j,k);
+ std::pair<unsigned int, unsigned int> jk_pair(j, k);
problems_new[source].insert(jk_pair);
is_problem = true;
}
// Mesh with internal vertex
- if(is_problem){
+ if(is_problem) {
MeshWithInternalVertex(to, source, v, n1, n2, pos);
return;
}
-
}
// reserves approximately the right amount of memory for quadToTri extrusions
// in the element vectors in the region 'to'
-// *** STILL EXPERIMENTAL -- It *kind* of works to limit memory footprint of vectors.
+// *** STILL EXPERIMENTAL -- It *kind* of works to limit memory footprint of
+// vectors.
/*
-static void reserveQuadToTriCapacityForRegion( GRegion *to, GFace *from, bool is_addverts, unsigned int num_layers,
- unsigned int lat_tri_diags_size, CategorizedSourceElements *c,
- std::map<MElement*, std::set<std::pair<unsigned int,
- unsigned int> > > *problems )
+static void reserveQuadToTriCapacityForRegion( GRegion *to, GFace *from, bool
+is_addverts, unsigned int num_layers, unsigned int lat_tri_diags_size,
+CategorizedSourceElements *c, std::map<MElement*, std::set<std::pair<unsigned
+int, unsigned int> > > *problems )
{
ExtrudeParams *ep = to->meshAttributes.extrude;
if( !ep )
return;
- std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> > >::iterator itprob;
- unsigned int num_prob_tri = 0, num_prob_quad = 0;
- for( itprob = problems->begin(); itprob != problems->end(); itprob++ ){
- if( itprob->first->getType() == TYPE_TRI )
- num_prob_tri += itprob->second.size();
+ std::map<MElement*, std::set<std::pair<unsigned int, unsigned int> >
+>::iterator itprob; unsigned int num_prob_tri = 0, num_prob_quad = 0; for(
+itprob = problems->begin(); itprob != problems->end(); itprob++ ){ if(
+itprob->first->getType() == TYPE_TRI ) num_prob_tri += itprob->second.size();
else
num_prob_quad += itprob->second.size();
}
- // unsigned int num_bnd_tri = c->three_bnd_pt_tri.size() + c->other_bnd_tri.size();
- // unsigned int num_bnd_quad = c->four_bnd_pt_quad.size() + c->other_bnd_quad.size();
+ // unsigned int num_bnd_tri = c->three_bnd_pt_tri.size() +
+c->other_bnd_tri.size();
+ // unsigned int num_bnd_quad = c->four_bnd_pt_quad.size() +
+c->other_bnd_quad.size();
// unsigned int num_int_tri = c->internal_tri.size();
// unsigned int num_int_quad = c->internal_quad.size();
unsigned int num_tri = from->triangles.size();
unsigned int num_quad = from->quadrangles.size();
// in case !ep->Recombine is ever allowed...
if( !ep->mesh.Recombine )
- to->tetrahedra.reserve( num_layers*(3*num_tri + 6*num_quad + 8*num_prob_tri + 12*num_prob_quad) );
- else if( !is_addverts ){
- //to->tetrahedra.reserve( (6*num_quad + 3*num_tri +2*lat_tri_diags_size + 8*num_prob_tri + 12*num_prob_quad) );
- to->prisms.reserve( num_tri*num_layers );
+ to->tetrahedra.reserve( num_layers*(3*num_tri + 6*num_quad + 8*num_prob_tri
++ 12*num_prob_quad) ); else if( !is_addverts ){
+ //to->tetrahedra.reserve( (6*num_quad + 3*num_tri +2*lat_tri_diags_size +
+8*num_prob_tri + 12*num_prob_quad) ); to->prisms.reserve( num_tri*num_layers );
to->hexahedra.reserve( num_quad*(num_layers-1) );
}
else{
- unsigned int extra_verts = to->mesh_vertices.size() - from->mesh_vertices.size()*(num_layers-1);
- to->hexahedra.reserve( num_quad*(num_layers-1) );
- to->prisms.reserve( num_tri*num_layers );
- to->pyramids.reserve( num_prob_quad + num_prob_tri + extra_verts*4 + num_quad );
- to->tetrahedra.reserve( num_prob_quad + num_prob_tri + extra_verts );
+ unsigned int extra_verts = to->mesh_vertices.size() -
+from->mesh_vertices.size()*(num_layers-1); to->hexahedra.reserve(
+num_quad*(num_layers-1) ); to->prisms.reserve( num_tri*num_layers );
+ to->pyramids.reserve( num_prob_quad + num_prob_tri + extra_verts*4 +
+num_quad ); to->tetrahedra.reserve( num_prob_quad + num_prob_tri + extra_verts
+);
}
}
*/
-// displays for the user a list of the body centered vertices created for problem elements.
-static void listBodyCenteredVertices(GRegion *to, bool is_addverts,
- std::map<MElement *, std::set<std::pair<unsigned int,unsigned int> > > *problems,
- std::map<MElement *, std::set<std::pair<unsigned int,unsigned int> > > *problems_new,
- MVertexRTree *pos)
+// displays for the user a list of the body centered vertices created for
+// problem elements.
+static void listBodyCenteredVertices(
+ GRegion *to, bool is_addverts,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ *problems,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ *problems_new,
+ MVertexRTree *pos)
{
-
ExtrudeParams *ep = to->meshAttributes.extrude;
- if( !ep )
- return;
-
- if( problems->size() || problems_new->size() ){
+ if(!ep) return;
- std::map<MElement *, std::set<std::pair<unsigned int,unsigned int> > >::iterator it_begin;
- std::map<MElement *, std::set<std::pair<unsigned int,unsigned int> > >::iterator it_end;
- std::map<MElement *, std::set<std::pair<unsigned int,unsigned int> > >::iterator itmap;
+ if(problems->size() || problems_new->size()) {
+ std::map<MElement *,
+ std::set<std::pair<unsigned int, unsigned int> > >::iterator
+ it_begin;
+ std::map<MElement *,
+ std::set<std::pair<unsigned int, unsigned int> > >::iterator
+ it_end;
+ std::map<MElement *,
+ std::set<std::pair<unsigned int, unsigned int> > >::iterator itmap;
+ // insert all of problems_new into problems
+ for(itmap = problems_new->begin(); itmap != problems_new->end(); itmap++)
+ (*problems)[itmap->first].insert(itmap->second.begin(),
+ itmap->second.end());
- //insert all of problems_new into problems
- for( itmap = problems_new->begin(); itmap!= problems_new->end(); itmap++ )
- (*problems)[itmap->first].insert( itmap->second.begin(), itmap->second.end() );
-
- if( is_addverts ){
+ if(is_addverts) {
it_begin = problems_new->begin();
it_end = problems_new->end();
}
- else{
+ else {
it_begin = problems->begin();
it_end = problems->end();
}
unsigned int int_verts_count = 0;
- for( itmap = it_begin; itmap != it_end; itmap++ ){
- if( itmap->second.size() )
- int_verts_count += itmap->second.size();
+ for(itmap = it_begin; itmap != it_end; itmap++) {
+ if(itmap->second.size()) int_verts_count += itmap->second.size();
}
- if( int_verts_count ){
- if( int_verts_count == 1 )
+ if(int_verts_count) {
+ if(int_verts_count == 1)
Msg::Warning("QuadToTri meshed %d element in region %d "
- "with a body-centered internal vertex.",
- int_verts_count, to->tag() );
+ "with a body-centered internal vertex.",
+ int_verts_count, to->tag());
else
Msg::Warning("QuadToTri meshed %d elements in region %d "
- "with body-centered internal vertices.",
- int_verts_count, to->tag() );
- Msg::Warning("( Mesh *should* still conformal, but the user should be aware of these internal vertices. )" );
+ "with body-centered internal vertices.",
+ int_verts_count, to->tag());
+ Msg::Warning("( Mesh *should* still conformal, but the user should be "
+ "aware of these internal vertices. )");
unsigned int int_verts_count2 = 0;
- for( itmap = it_begin; itmap != it_end; itmap++ ){
- if( itmap->second.size() ){
+ for(itmap = it_begin; itmap != it_end; itmap++) {
+ if(itmap->second.size()) {
std::set<std::pair<unsigned int, unsigned int> >::iterator itset;
- for( itset = itmap->second.begin(); itset != itmap->second.end(); itset++ ){
+ for(itset = itmap->second.begin(); itset != itmap->second.end();
+ itset++) {
std::vector<MVertex *> verts;
getExtrudedVertices(itmap->first, ep, (*itset).first,
(*itset).second, (*pos), verts);
// find centroid
std::vector<double> centroid = QtFindVertsCentroid(verts);
int_verts_count2++;
- Msg::Warning("Internal Vertex %d at (x,y,z) = (%g, %g, %g).", int_verts_count2,
- centroid[0], centroid[1], centroid[2] );
+ Msg::Warning("Internal Vertex %d at (x,y,z) = (%g, %g, %g).",
+ int_verts_count2, centroid[0], centroid[1],
+ centroid[2]);
}
}
}
}
}
-
}
-
// Function that makes all the elements in a QuadToTri region, both
-// the divided elements and the whole elements, using already-created subdivision edges.
-bool QuadToTriCreateElements(GRegion *to, CategorizedSourceElements &cat_src_elems,
- std::set<std::pair<MVertex*,MVertex*> > &quadToTri_edges,
- std::set<std::pair<MVertex*,MVertex*> > &lat_tri_diags,
- std::map<MElement*, std::set<std::pair<unsigned int,unsigned int> > > &problems,
- MVertexRTree &pos)
+// the divided elements and the whole elements, using already-created
+// subdivision edges.
+bool QuadToTriCreateElements(
+ GRegion *to, CategorizedSourceElements &cat_src_elems,
+ std::set<std::pair<MVertex *, MVertex *> > &quadToTri_edges,
+ std::set<std::pair<MVertex *, MVertex *> > &lat_tri_diags,
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ &problems,
+ MVertexRTree &pos)
{
-
ExtrudeParams *ep = to->meshAttributes.extrude;
- if( !ep || !ep->mesh.ExtrudeMesh || !ep->mesh.QuadToTri )
- return false;
+ if(!ep || !ep->mesh.ExtrudeMesh || !ep->mesh.QuadToTri) return false;
GModel *model = to->model();
- GFace *from = model->getFaceByTag( std::abs(ep->geo.Source) );
- if( !from )
- return false;
-
+ GFace *from = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!from) return false;
// set lat_tri_diags_size
unsigned int lat_tri_diags_size = lat_tri_diags.size();
// number of element layers
unsigned int num_layers = 0;
- for( int j = 0; j < ep->mesh.NbLayer; j++ )
+ for(int j = 0; j < ep->mesh.NbLayer; j++)
num_layers += ep->mesh.NbElmLayer[j];
// Is this a valid 'add internal vertex' extrusion?
bool is_addverts = false;
- if( ep->mesh.QuadToTri == QUADTRI_ADDVERTS_1 || ep->mesh.QuadToTri == QUADTRI_ADDVERTS_1_RECOMB )
+ if(ep->mesh.QuadToTri == QUADTRI_ADDVERTS_1 ||
+ ep->mesh.QuadToTri == QUADTRI_ADDVERTS_1_RECOMB)
is_addverts = true;
// Find where top divided layer starts
@@ -5340,21 +5716,25 @@ bool QuadToTriCreateElements(GRegion *to, CategorizedSourceElements &cat_src_el
k_second_from_bottom = 0;
}*/
-
- // a container for new problem elements (if such new problems are found, there's a bug)
- std::map<MElement*, std::set<std::pair<unsigned int,unsigned int> > > problems_new;
-
+ // a container for new problem elements (if such new problems are found,
+ // there's a bug)
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ problems_new;
// Make the extra vertices needed for Some QuadToTri elements
- if(!addBodyCenteredVertices(to, cat_src_elems, quadToTri_edges, problems, is_addverts,
- lat_tri_diags_size, pos)){
- Msg::Error("QuadToTriCreateElements() could not add face or body vertices for QuadToTri region %d.", to->tag() );
+ if(!addBodyCenteredVertices(to, cat_src_elems, quadToTri_edges, problems,
+ is_addverts, lat_tri_diags_size, pos)) {
+ Msg::Error("QuadToTriCreateElements() could not add face or body vertices "
+ "for QuadToTri region %d.",
+ to->tag());
return false;
}
- // reserve enough capacity for all possible elements, try to find combination of simplicity and memory efficiency.
+ // reserve enough capacity for all possible elements, try to find combination
+ // of simplicity and memory efficiency.
// *** EXPERIMENTAL ***
- //reserveQuadToTriCapacityForRegion( to, from, is_addverts, num_layers, lat_tri_diags_size, &cat_src_elems, &problems );
+ // reserveQuadToTriCapacityForRegion( to, from, is_addverts, num_layers,
+ // lat_tri_diags_size, &cat_src_elems, &problems );
// create elements:
@@ -5362,16 +5742,19 @@ bool QuadToTriCreateElements(GRegion *to, CategorizedSourceElements &cat_src_el
elem_vec.reserve(num_layers);
*/
// triangles
- for( int s = 0; s < 3; s++ ){
- std::vector<MVertex*> verts;
+ for(int s = 0; s < 3; s++) {
+ std::vector<MVertex *> verts;
verts.reserve(3);
bool bnd_elem = s < 2 ? true : false;
std::set<unsigned int> *set_elems;
std::set<unsigned int>::iterator itset;
- if( !s ) set_elems = &cat_src_elems.three_bnd_pt_tri;
- else if( s==1 ) set_elems = &cat_src_elems.other_bnd_tri;
- else set_elems = &cat_src_elems.internal_tri;
- for( itset = set_elems->begin(); itset != set_elems->end(); itset++ ){
+ if(!s)
+ set_elems = &cat_src_elems.three_bnd_pt_tri;
+ else if(s == 1)
+ set_elems = &cat_src_elems.other_bnd_tri;
+ else
+ set_elems = &cat_src_elems.internal_tri;
+ for(itset = set_elems->begin(); itset != set_elems->end(); itset++) {
/* // *** SPEED IMPROVEMENT ***
unsigned int hex, pyr, pri, tet;
hex = to->hexahedra.size();
@@ -5386,38 +5769,44 @@ bool QuadToTriCreateElements(GRegion *to, CategorizedSourceElements &cat_src_el
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
// keeps old allocation
verts.resize(0);
- if(getExtrudedVertices(elem, ep, j, k, pos, verts) == 6){
- QuadToTriPriPyrTet(verts, to, j, k, elem, quadToTri_edges,
- problems, problems_new, lat_tri_diags_size,
- bnd_elem, is_addverts, 1, pos);
+ if(getExtrudedVertices(elem, ep, j, k, pos, verts) == 6) {
+ QuadToTriPriPyrTet(verts, to, j, k, elem, quadToTri_edges, problems,
+ problems_new, lat_tri_diags_size, bnd_elem,
+ is_addverts, 1, pos);
}
}
}
/*// *** SPEED IMPROVEMENT ***
- elem_vec.insert(elem_vec.end(), to->hexahedra.begin()+hex, to->hexahedra.end() );
- elem_vec.insert(elem_vec.end(), to->tetrahedra.begin()+tet, to->tetrahedra.end() );
- elem_vec.insert(elem_vec.end(), to->prisms.begin()+pri, to->prisms.end() );
- elem_vec.insert(elem_vec.end(), to->pyramids.begin()+pyr, to->pyramids.end() );
+ elem_vec.insert(elem_vec.end(), to->hexahedra.begin()+hex,
+ to->hexahedra.end() ); elem_vec.insert(elem_vec.end(),
+ to->tetrahedra.begin()+tet, to->tetrahedra.end() );
+ elem_vec.insert(elem_vec.end(), to->prisms.begin()+pri, to->prisms.end()
+ ); elem_vec.insert(elem_vec.end(), to->pyramids.begin()+pyr,
+ to->pyramids.end() );
*/
}
}
- if(from->quadrangles.size() && !ep->mesh.Recombine){
- Msg::Error("In QuadToTriCreateElements(), cannot extrude quadrangles without Recombine");
+ if(from->quadrangles.size() && !ep->mesh.Recombine) {
+ Msg::Error("In QuadToTriCreateElements(), cannot extrude quadrangles "
+ "without Recombine");
return false;
}
- else{
- std::vector<MVertex*> verts;
+ else {
+ std::vector<MVertex *> verts;
verts.reserve(4);
- for( int s = 0; s < 3; s++ ){
+ for(int s = 0; s < 3; s++) {
bool bnd_elem = s < 2 ? true : false;
std::set<unsigned int> *set_elems;
std::set<unsigned int>::iterator itset;
- if( !s ) set_elems = &cat_src_elems.four_bnd_pt_quad;
- else if( s==1 ) set_elems = &cat_src_elems.other_bnd_quad;
- else set_elems = &cat_src_elems.internal_quad;
+ if(!s)
+ set_elems = &cat_src_elems.four_bnd_pt_quad;
+ else if(s == 1)
+ set_elems = &cat_src_elems.other_bnd_quad;
+ else
+ set_elems = &cat_src_elems.internal_quad;
- for( itset = set_elems->begin(); itset != set_elems->end(); itset++ ){
+ for(itset = set_elems->begin(); itset != set_elems->end(); itset++) {
/*// *** SPEED IMPROVEMENT ***
unsigned int hex, pyr, pri, tet;
hex = to->hexahedra.size();
@@ -5433,18 +5822,20 @@ bool QuadToTriCreateElements(GRegion *to, CategorizedSourceElements &cat_src_el
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
// keeps old allocation
verts.resize(0);
- if(getExtrudedVertices(elem, ep, j, k, pos, verts) == 8){
- QuadToTriHexPri(verts, to, j, k, elem, quadToTri_edges,
- problems, problems_new, lat_tri_diags_size,
- bnd_elem, is_addverts, 1, pos);
+ if(getExtrudedVertices(elem, ep, j, k, pos, verts) == 8) {
+ QuadToTriHexPri(verts, to, j, k, elem, quadToTri_edges, problems,
+ problems_new, lat_tri_diags_size, bnd_elem,
+ is_addverts, 1, pos);
}
}
}
/*// *** SPEED IMPROVEMENT ***
- elem_vec.insert(elem_vec.end(), to->hexahedra.begin()+hex, to->hexahedra.end() );
- elem_vec.insert(elem_vec.end(), to->tetrahedra.begin()+tet, to->tetrahedra.end() );
- elem_vec.insert(elem_vec.end(), to->prisms.begin()+pri, to->prisms.end() );
- elem_vec.insert(elem_vec.end(), to->pyramids.begin()+pyr, to->pyramids.end() );
+ elem_vec.insert(elem_vec.end(), to->hexahedra.begin()+hex,
+ to->hexahedra.end() ); elem_vec.insert(elem_vec.end(),
+ to->tetrahedra.begin()+tet, to->tetrahedra.end() );
+ elem_vec.insert(elem_vec.end(), to->prisms.begin()+pri, to->prisms.end()
+ ); elem_vec.insert(elem_vec.end(), to->pyramids.begin()+pyr,
+ to->pyramids.end() );
*/
}
}
@@ -5455,7 +5846,7 @@ bool QuadToTriCreateElements(GRegion *to, CategorizedSourceElements &cat_src_el
// Now revert any elements that have positive volume.
// Does this even need to be done?
- // *** KEEP THIS COMMENTED OUT UNLESS IT IS NEEDED ***
+ // *** KEEP THIS COMMENTED OUT UNLESS IT IS NEEDED ***
/*for( int i = 0; i < to->tetrahedra.size(); i++ ){
if( to->tetrahedra[i]->getVolumeSign() > 0 )
to->tetrahedra[i]->reverse();
@@ -5471,7 +5862,8 @@ bool QuadToTriCreateElements(GRegion *to, CategorizedSourceElements &cat_src_el
}
*/
- // ***THE FOLLOWING COMMENTED OUT LINES ARE FOR DEBUGGING PURPOSES ONLY AND WON'T WORK WITHOUT
+ // ***THE FOLLOWING COMMENTED OUT LINES ARE FOR DEBUGGING PURPOSES ONLY AND
+ // WON'T WORK WITHOUT
// A SPECIAL INCLUDE FILE. THESE ARE USELESS WITHOUT THE DEBUG INCLUDE. ***
/*GModel::riter rit;
if( std::abs(to->tag() ) == 4 ){
@@ -5482,76 +5874,85 @@ bool QuadToTriCreateElements(GRegion *to, CategorizedSourceElements &cat_src_el
for( rit = model->firstRegion(); rit != model->lastRegion(); rit++ ){
unsigned int num_nonconformal = TestRegionConformality( (*rit) );
// if( num_nonconformal )
- Msg::Error( "Region %3d Noncomformal faces = %d.", (*rit)->tag(), num_nonconformal );
+ Msg::Error( "Region %3d Noncomformal faces = %d.", (*rit)->tag(),
+ num_nonconformal );
}
}*/
return true;
-
}
-
// Mesh QuadToTri region from extrudeMesh() in meshGRegionExtruded.cpp
// Added 04/08/2011:
int meshQuadToTriRegion(GRegion *gr, MVertexRTree &pos)
{
// Perform some checks to see if this is a valid QuadToTri region.
- // If so, a decision has to be made: if this surface is NOT laterally adjacent to
- // any subdivided extrusion, then it may be meshed here without worrying
+ // If so, a decision has to be made: if this surface is NOT laterally adjacent
+ // to any subdivided extrusion, then it may be meshed here without worrying
// about a global subdivide operation.
- // If the region has a lateral shared with a subdivide region, then it should be part
- // of the subdivide operation later...so just let the default
- // methods here create the vertices and quit.
- // Otherwise, engage in the meshing here.
+ // If the region has a lateral shared with a subdivide region, then it should
+ // be part of the subdivide operation later...so just let the default methods
+ // here create the vertices and quit. Otherwise, engage in the meshing here.
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.ExtrudeMesh || !ep->mesh.QuadToTri || !ep->mesh.Recombine )
+ if(!ep || !ep->mesh.ExtrudeMesh || !ep->mesh.QuadToTri || !ep->mesh.Recombine)
return 0;
// QuadToTri validity check:
bool validQuadToTriReg = false;
- // if any laterals are shared with a subdivided region or an region that otherwise
- // should not have it's lateral diags changed, IsValidQuadToTriRegion will set following to 'false.'
- bool allNonGlobalSharedLaterals = true; // IsValidQuadToTriRegion will set this properly regardless of initial value
+ // if any laterals are shared with a subdivided region or an region that
+ // otherwise should not have it's lateral diags changed,
+ // IsValidQuadToTriRegion will set following to 'false.'
+ bool allNonGlobalSharedLaterals = true; // IsValidQuadToTriRegion will set
+ // this properly regardless of initial
+ // value
validQuadToTriReg = IsValidQuadToTriRegion(gr, &allNonGlobalSharedLaterals);
- if( !validQuadToTriReg && ep->mesh.QuadToTri )
- Msg::Error("Mesh of QuadToTri region %d likely has errors.", gr->tag() );
-
+ if(!validQuadToTriReg && ep->mesh.QuadToTri)
+ Msg::Error("Mesh of QuadToTri region %d likely has errors.", gr->tag());
- if( !allNonGlobalSharedLaterals ){
- Msg::Info("Delaying mesh of QuadToTri Region %d until after global subdivide operation....", gr->tag() );
+ if(!allNonGlobalSharedLaterals) {
+ Msg::Info("Delaying mesh of QuadToTri Region %d until after global "
+ "subdivide operation....",
+ gr->tag());
return 0;
}
// mesh quadToTri even if validQuadToTri is false. Try it anyway!
- if( allNonGlobalSharedLaterals ){
- std::set<std::pair<MVertex*, MVertex*> > quadToTri_edges;
- std::set<std::pair<MVertex*, MVertex*> > lat_tri_diags;
- std::map<MElement*, std::set<std::pair<unsigned int,unsigned int> > > problems;
+ if(allNonGlobalSharedLaterals) {
+ std::set<std::pair<MVertex *, MVertex *> > quadToTri_edges;
+ std::set<std::pair<MVertex *, MVertex *> > lat_tri_diags;
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ problems;
// first thing is first
// data structure for boundary status-categorized source elements,
// (member data containers defined in .h file)
- CategorizedSourceElements cat_src_elems( gr );
- if( !cat_src_elems.valid ){
- Msg::Error("In meshQuadToTriRegion(), failed to classify QuadToTri region %d's source face elements "
- "according to boundary status.", gr->tag() );
+ CategorizedSourceElements cat_src_elems(gr);
+ if(!cat_src_elems.valid) {
+ Msg::Error("In meshQuadToTriRegion(), failed to classify QuadToTri "
+ "region %d's source face elements "
+ "according to boundary status.",
+ gr->tag());
return 0;
}
if(!QuadToTriEdgeGenerator(gr, cat_src_elems, quadToTri_edges,
- lat_tri_diags, problems, pos)){
- Msg::Error("In meshQuadToTriRegion(), failed to create edges for QuadToTri "
- "region %d.", gr->tag() );
+ lat_tri_diags, problems, pos)) {
+ Msg::Error(
+ "In meshQuadToTriRegion(), failed to create edges for QuadToTri "
+ "region %d.",
+ gr->tag());
return 0;
}
if(!QuadToTriCreateElements(gr, cat_src_elems, quadToTri_edges,
- lat_tri_diags, problems, pos)){
- Msg::Error("In meshQuadToTriRegion, failed to create elements for QuadToTri "
- "region %d.", gr->tag() );
+ lat_tri_diags, problems, pos)) {
+ Msg::Error(
+ "In meshQuadToTriRegion, failed to create elements for QuadToTri "
+ "region %d.",
+ gr->tag());
return 0;
}
@@ -5561,91 +5962,96 @@ int meshQuadToTriRegion(GRegion *gr, MVertexRTree &pos)
}
return 0;
-
}
-
-// The function that is called from meshGRegionExtruded.cpp to mesh QuadToTri regions
-// that are adjacent to subdivided regions, after the global Subdivide command is called.
-// Added 04/08/11.
-int meshQuadToTriRegionAfterGlobalSubdivide(GRegion *gr, std::set<std::pair<MVertex*, MVertex*> > *edges,
- MVertexRTree &pos)
+// The function that is called from meshGRegionExtruded.cpp to mesh QuadToTri
+// regions that are adjacent to subdivided regions, after the global Subdivide
+// command is called. Added 04/08/11.
+int meshQuadToTriRegionAfterGlobalSubdivide(
+ GRegion *gr, std::set<std::pair<MVertex *, MVertex *> > *edges,
+ MVertexRTree &pos)
{
-
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if( !ep || !ep->mesh.ExtrudeMesh || !ep->mesh.QuadToTri || !ep->mesh.Recombine )
+ if(!ep || !ep->mesh.ExtrudeMesh || !ep->mesh.QuadToTri || !ep->mesh.Recombine)
return 0;
// QuadToTri validity check:
bool validQuadToTriReg = false;
// if any laterals are shared with a subdivided region or any region that
- // should not have its lateral diags swapped, IsValidQuadToTriRegion() will set following to 'false.'
- bool allNonGlobalSharedLaterals = true; // IsValidQuadToTriRegion will set this properly regardless of initial value
+ // should not have its lateral diags swapped, IsValidQuadToTriRegion() will
+ // set following to 'false.'
+ bool allNonGlobalSharedLaterals = true; // IsValidQuadToTriRegion will set
+ // this properly regardless of initial
+ // value
validQuadToTriReg = IsValidQuadToTriRegion(gr, &allNonGlobalSharedLaterals);
- if( !validQuadToTriReg && ep->mesh.QuadToTri )
- Msg::Error("Mesh of QuadToTri region %d likely has errors.", gr->tag() );
+ if(!validQuadToTriReg && ep->mesh.QuadToTri)
+ Msg::Error("Mesh of QuadToTri region %d likely has errors.", gr->tag());
- // If all lateral edges were non-global, skip. (Region should already be meshed properly).
- if( allNonGlobalSharedLaterals )
- return 0;
+ // If all lateral edges were non-global, skip. (Region should already be
+ // meshed properly).
+ if(allNonGlobalSharedLaterals) return 0;
- Msg::Info("Meshing Region %d (extruded).", gr->tag() );
+ Msg::Info("Meshing Region %d (extruded).", gr->tag());
- GFace *gr_src_face = gr->model()->getFaceByTag( std::abs(ep->geo.Source) );
- if( !gr_src_face ){
- Msg::Error("In meshQuadToTriRegionAfterGlobalSubdivide(), no source face for QuadToTri region %d.", gr->tag());
+ GFace *gr_src_face = gr->model()->getFaceByTag(std::abs(ep->geo.Source));
+ if(!gr_src_face) {
+ Msg::Error("In meshQuadToTriRegionAfterGlobalSubdivide(), no source face "
+ "for QuadToTri region %d.",
+ gr->tag());
return 0;
}
for(unsigned int i = 0; i < gr->hexahedra.size(); i++)
delete gr->hexahedra[i];
gr->hexahedra.clear();
- for(unsigned int i = 0; i < gr->prisms.size(); i++)
- delete gr->prisms[i];
+ for(unsigned int i = 0; i < gr->prisms.size(); i++) delete gr->prisms[i];
gr->prisms.clear();
- for(unsigned int i = 0; i < gr->pyramids.size(); i++)
- delete gr->pyramids[i];
+ for(unsigned int i = 0; i < gr->pyramids.size(); i++) delete gr->pyramids[i];
gr->pyramids.clear();
for(unsigned int i = 0; i < gr->tetrahedra.size(); i++)
delete gr->tetrahedra[i];
gr->tetrahedra.clear();
- std::set<std::pair<MVertex*, MVertex*> > quadToTri_edges;
- std::set<std::pair<MVertex*, MVertex*> > lat_tri_diags;
- std::map<MElement*, std::set<std::pair<unsigned int,unsigned int> > > problems;
+ std::set<std::pair<MVertex *, MVertex *> > quadToTri_edges;
+ std::set<std::pair<MVertex *, MVertex *> > lat_tri_diags;
+ std::map<MElement *, std::set<std::pair<unsigned int, unsigned int> > >
+ problems;
// add edges to quadToTri_edges
- quadToTri_edges.insert( edges->begin(), edges->end() );
+ quadToTri_edges.insert(edges->begin(), edges->end());
// categorize source face elements
- CategorizedSourceElements cat_src_elems( gr );
+ CategorizedSourceElements cat_src_elems(gr);
- if( !cat_src_elems.valid ){
+ if(!cat_src_elems.valid) {
Msg::Error("In meshQuadToTriRegionAfterGlobalSubdivide(), "
"Failed to classify QuadToTri region %d's source face elements "
- "according to boundary status.", gr->tag() );
+ "according to boundary status.",
+ gr->tag());
return 0;
}
// Mesh quadToTri
- if(!QuadToTriEdgeGenerator(gr, cat_src_elems, quadToTri_edges,
- lat_tri_diags, problems, pos)){
- Msg::Error("In meshQuadToTriRegionAfterGlobalSubdivide(), edge generation failed for QuadToTri "
- "region %d.", gr->tag() );
+ if(!QuadToTriEdgeGenerator(gr, cat_src_elems, quadToTri_edges, lat_tri_diags,
+ problems, pos)) {
+ Msg::Error("In meshQuadToTriRegionAfterGlobalSubdivide(), edge generation "
+ "failed for QuadToTri "
+ "region %d.",
+ gr->tag());
return 0;
}
- if(!QuadToTriCreateElements(gr, cat_src_elems, quadToTri_edges,
- lat_tri_diags, problems, pos)){
- Msg::Error("In meshQuadToTriRegionAfterGlobalSubdivide(), element creation failed for QuadToTri "
- "region %d.", gr->tag());
+ if(!QuadToTriCreateElements(gr, cat_src_elems, quadToTri_edges, lat_tri_diags,
+ problems, pos)) {
+ Msg::Error("In meshQuadToTriRegionAfterGlobalSubdivide(), element creation "
+ "failed for QuadToTri "
+ "region %d.",
+ gr->tag());
return 0;
}
QuadToTriLateralRemesh(gr, quadToTri_edges);
return 1;
-
-
}
diff --git a/Mesh/QuadTriExtruded3D.h b/Mesh/QuadTriExtruded3D.h
index df3eb24518633070f689dfd732ed343244153581..4f4c5e71a2d0879d0004feeabcf4452acb01603d 100644
--- a/Mesh/QuadTriExtruded3D.h
+++ b/Mesh/QuadTriExtruded3D.h
@@ -33,7 +33,7 @@ PARTICULAR PURPOSE. See the GNU General Public License for more details.
********************************************************************************/
-#if !defined( _QTEXTR3D_H_ )
+#if !defined(_QTEXTR3D_H_)
#define _QTEXTR3D_H_
#include "GEntity.h"
@@ -71,8 +71,8 @@ int meshQuadToTriRegion(GRegion *gr, MVertexRTree &pos);
// The function that is called from meshGRegionExtruded.cpp to mesh QuadToTri
// regions that are adjacent to subdivided regions, after the global Subdivide
// command is called. Added 04/08/11.
-int meshQuadToTriRegionAfterGlobalSubdivide(GRegion *gr,
- std::set<std::pair<MVertex*, MVertex*> > *edges,
- MVertexRTree &pos);
+int meshQuadToTriRegionAfterGlobalSubdivide(
+ GRegion *gr, std::set<std::pair<MVertex *, MVertex *> > *edges,
+ MVertexRTree &pos);
#endif
diff --git a/Mesh/QuadTriTransfinite3D.cpp b/Mesh/QuadTriTransfinite3D.cpp
index 88c91ae7a664741abbdb38f62abc008b2cfd78f4..e75048667f6ed5083e20d8bed2882a004fcfbd5b 100644
--- a/Mesh/QuadTriTransfinite3D.cpp
+++ b/Mesh/QuadTriTransfinite3D.cpp
@@ -4,20 +4,23 @@ QuadTriTransfinite3D.cpp
The code in this file was written by Dr. Trevor S. Strickler.
email: <trevor.strickler@gmail.com>
-This file is part of the QuadTri contribution to Gmsh. QuadTri allows the conformal interface
-of quadrangle faces to triangle faces using pyramids and other mesh elements.
+This file is part of the QuadTri contribution to Gmsh. QuadTri allows the
+conformal interface of quadrangle faces to triangle faces using pyramids and
+other mesh elements.
-See READMEQUADTRI.txt for more information. The license information is in LICENSE.txt.
+See READMEQUADTRI.txt for more information. The license information is in
+LICENSE.txt.
Trevor S. Strickler hereby transfers copyright of QuadTri files to
Christophe Geuzaine and J.-F. Remacle with the understanding that
his contribution shall be cited appropriately.
-All reused or original Gmsh code is Copyright (C) 1997-2018 C. Geuzaine, J.-F. Remacle
-Gmsh is available at: www.gmsh.info
+All reused or original Gmsh code is Copyright (C) 1997-2018 C. Geuzaine, J.-F.
+Remacle Gmsh is available at: www.gmsh.info
-For Gmsh license information, see the LICENSE.txt file for license information. Please report all
-Gmsh bugs and problems to the public mailing list <gmsh@onelab.info>.
+For Gmsh license information, see the LICENSE.txt file for license information.
+Please report all Gmsh bugs and problems to the public mailing list
+<gmsh@onelab.info>.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, Version 2,
@@ -36,121 +39,126 @@ GNU General Public License for more details.
// Does the pair of MVertex pointers v1 and v2 exist in the set 'edges'?
static int edgeExists(MVertex *v1, MVertex *v2,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
- std::pair<MVertex*, MVertex*> p(std::min(v1, v2), std::max(v1, v2));
+ std::pair<MVertex *, MVertex *> p(std::min(v1, v2), std::max(v1, v2));
return edges.count(p);
}
-
// Create the pair of MVertex pointers v1 and v2 exist in the set 'edges.'
static void createEdge(MVertex *v1, MVertex *v2,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
- std::pair<MVertex*, MVertex*> p(std::min(v1, v2), std::max(v1, v2));
+ std::pair<MVertex *, MVertex *> p(std::min(v1, v2), std::max(v1, v2));
edges.insert(p);
}
-
-static void addTetrahedron(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
+static void addTetrahedron(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
GRegion *to)
{
- MTetrahedron* newElem = new MTetrahedron(v1, v2, v3, v4);
+ MTetrahedron *newElem = new MTetrahedron(v1, v2, v3, v4);
to->tetrahedra.push_back(newElem);
}
-static void addPyramid(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, GRegion *to)
+static void addPyramid(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, GRegion *to)
{
- MPyramid* newElem = new MPyramid(v1, v2, v3, v4, v5);
+ MPyramid *newElem = new MPyramid(v1, v2, v3, v4, v5);
to->pyramids.push_back(newElem);
}
-static void addPrism(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, MVertex* v6, GRegion *to)
+static void addPrism(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, MVertex *v6, GRegion *to)
{
- MPrism* newElem = new MPrism(v1, v2, v3, v4, v5, v6);
+ MPrism *newElem = new MPrism(v1, v2, v3, v4, v5, v6);
to->prisms.push_back(newElem);
}
-static void addHexahedron(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, MVertex* v6, MVertex* v7, MVertex* v8,
+static void addHexahedron(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, MVertex *v6, MVertex *v7, MVertex *v8,
GRegion *to)
{
- MHexahedron* newElem = new MHexahedron(v1, v2, v3, v4, v5, v6, v7, v8);
+ MHexahedron *newElem = new MHexahedron(v1, v2, v3, v4, v5, v6, v7, v8);
to->hexahedra.push_back(newElem);
}
-
-// Function to get all the diagonals from external surfaces of a given Transfinite region tr
-// and place them in boundary_diags.
-int getTransfiniteBoundaryDiags( GRegion *gr, std::set< std::pair<MVertex*,
- MVertex*> > *boundary_diags )
+// Function to get all the diagonals from external surfaces of a given
+// Transfinite region tr and place them in boundary_diags.
+int getTransfiniteBoundaryDiags(
+ GRegion *gr, std::set<std::pair<MVertex *, MVertex *> > *boundary_diags)
{
// Get list of faces
- std::vector<GFace*> faces = gr->faces();
+ std::vector<GFace *> faces = gr->faces();
// Perform some tests of the Transfinite volume
// Is the region Transfinite?
- if( gr->meshAttributes.method != MESH_TRANSFINITE ){
- Msg::Error( "In getTransfiniteBoundaryDiags(), region %d was not detected "
- "to be a transfinite volume", gr->tag() );
+ if(gr->meshAttributes.method != MESH_TRANSFINITE) {
+ Msg::Error("In getTransfiniteBoundaryDiags(), region %d was not detected "
+ "to be a transfinite volume",
+ gr->tag());
return 0;
}
// Found right number of faces?
- if( faces.size() != 5 && faces.size() != 6 ){
- Msg::Error( "In getTransfiniteBoundaryDiags(), number of faces does not equal "
- "5 or 6 for region %d.", gr->tag() );
+ if(faces.size() != 5 && faces.size() != 6) {
+ Msg::Error(
+ "In getTransfiniteBoundaryDiags(), number of faces does not equal "
+ "5 or 6 for region %d.",
+ gr->tag());
return 0;
}
// Are all the faces Transfinite?
- std::vector<GFace*>::iterator itf;
- for( itf = faces.begin(); itf != faces.end(); itf++ ){
- if( (*itf)->meshAttributes.method != MESH_TRANSFINITE ){
- Msg::Error( "In getTransfiniteBoundaryDiags(), surface %d was not detected "
- "to be transfinite", (*itf)->tag() );
+ std::vector<GFace *>::iterator itf;
+ for(itf = faces.begin(); itf != faces.end(); itf++) {
+ if((*itf)->meshAttributes.method != MESH_TRANSFINITE) {
+ Msg::Error(
+ "In getTransfiniteBoundaryDiags(), surface %d was not detected "
+ "to be transfinite",
+ (*itf)->tag());
return 0;
}
- if( !(*itf)->transfinite_vertices.size() ){
- Msg::Error( "In getTransfiniteBoundaryDiags(), no transfinite vertices found for "
- "surface %d.", (*itf)->tag() );
+ if(!(*itf)->transfinite_vertices.size()) {
+ Msg::Error(
+ "In getTransfiniteBoundaryDiags(), no transfinite vertices found for "
+ "surface %d.",
+ (*itf)->tag());
return 0;
}
}
-
- // Now loop through all surfaces checking for unrecombined faces. On 3-sided surfaces, skip the
- // first layer of triangles because they ALWAYS exist even for recombined faces.
- for( itf = faces.begin(); itf != faces.end(); itf++ ){
- if( (*itf)->quadrangles.size() )
- continue;
- // For this face, loop through all sets of 4 vertices that could form a quadrangle
- // if not subdivided. Find which of the 4 vertices are on the diagonal that subdivides
- // the four vertices.
- std::vector<GEdge*> const& edges = (*itf)->edges();
+ // Now loop through all surfaces checking for unrecombined faces. On 3-sided
+ // surfaces, skip the first layer of triangles because they ALWAYS exist even
+ // for recombined faces.
+ for(itf = faces.begin(); itf != faces.end(); itf++) {
+ if((*itf)->quadrangles.size()) continue;
+ // For this face, loop through all sets of 4 vertices that could form a
+ // quadrangle if not subdivided. Find which of the 4 vertices are on the
+ // diagonal that subdivides the four vertices.
+ std::vector<GEdge *> const &edges = (*itf)->edges();
int index_guess = 0;
int i_low = 0;
- if( edges.size() == 3 ){
- if( (*itf)->transfinite_vertices.size() <= 2 )
- continue;
- index_guess += (*itf)->transfinite_vertices[1].size()-1;
+ if(edges.size() == 3) {
+ if((*itf)->transfinite_vertices.size() <= 2) continue;
+ index_guess += (*itf)->transfinite_vertices[1].size() - 1;
i_low = 1;
}
- for(unsigned int i = i_low; i < (*itf)->transfinite_vertices.size()-1; i++ ){
- for(unsigned int j = 0; j < (*itf)->transfinite_vertices[i].size()-1; j++ ){
- std::vector<MVertex*> verts;
+ for(unsigned int i = i_low; i < (*itf)->transfinite_vertices.size() - 1;
+ i++) {
+ for(unsigned int j = 0; j < (*itf)->transfinite_vertices[i].size() - 1;
+ j++) {
+ std::vector<MVertex *> verts;
verts.resize(4);
verts[0] = (*itf)->transfinite_vertices[i][j];
- verts[1] = (*itf)->transfinite_vertices[i+1][j];
- verts[2] = (*itf)->transfinite_vertices[i+1][j+1];
- verts[3] = (*itf)->transfinite_vertices[i][j+1];
- std::pair<int,int> ind_pair = FindDiagonalEdgeIndices( verts, (*itf),
- 0, index_guess );
- createEdge( verts[ind_pair.first], verts[ind_pair.second], (*boundary_diags) );
+ verts[1] = (*itf)->transfinite_vertices[i + 1][j];
+ verts[2] = (*itf)->transfinite_vertices[i + 1][j + 1];
+ verts[3] = (*itf)->transfinite_vertices[i][j + 1];
+ std::pair<int, int> ind_pair =
+ FindDiagonalEdgeIndices(verts, (*itf), 0, index_guess);
+ createEdge(verts[ind_pair.first], verts[ind_pair.second],
+ (*boundary_diags));
index_guess += 2;
}
}
@@ -160,125 +168,128 @@ int getTransfiniteBoundaryDiags( GRegion *gr, std::set< std::pair<MVertex*,
} // End of getTransfiniteBoundaryDiags()
-
-// Meshes either a prism or a hexahedral set of mesh vertices in a Transfinite Region with an internal vertex
-// that is created here in the function.
-void meshTransfElemWithInternalVertex( GRegion *gr, std::vector<MVertex *> v,
- std::set< std::pair<MVertex*, MVertex*> > *boundary_diags )
+// Meshes either a prism or a hexahedral set of mesh vertices in a Transfinite
+// Region with an internal vertex that is created here in the function.
+void meshTransfElemWithInternalVertex(
+ GRegion *gr, std::vector<MVertex *> v,
+ std::set<std::pair<MVertex *, MVertex *> > *boundary_diags)
{
-
int v_size = v.size();
int n_lat_tmp;
- if( v_size == 6 )
+ if(v_size == 6)
n_lat_tmp = 3;
- else if( v_size == 8 )
+ else if(v_size == 8)
n_lat_tmp = 4;
- else{
- Msg::Error("In meshTransfElemWithInternalVertex(), number of element vertices does not equal 6 or 8.");
+ else {
+ Msg::Error("In meshTransfElemWithInternalVertex(), number of element "
+ "vertices does not equal 6 or 8.");
return;
}
const int n_lat = n_lat_tmp;
-
// find vertex node indices for diagonalized faces
std::vector<int> n1, n2;
bool found_diags = false;
int n_size = 0;
- if( n_lat == 3 ){
+ if(n_lat == 3) {
n1.assign(n_lat, -1);
n2.assign(n_lat, -2);
n_size = 3;
}
- else if( n_lat == 4 ){
- n1.assign(n_lat+2, -1);
- n2.assign(n_lat+2, -1);
+ else if(n_lat == 4) {
+ n1.assign(n_lat + 2, -1);
+ n2.assign(n_lat + 2, -1);
n_size = 6;
}
- for( int p = 0; p < n_size; p++ ){
- n1[p] = -p*p-p-1; n2[p] = -p*p-p-2;
- if( p < n_lat || n_lat == 3 ){
- if( v[p] == v[p+n_lat] || v[(p+1)%n_lat] == v[(p+1)%n_lat+n_lat] )
+ for(int p = 0; p < n_size; p++) {
+ n1[p] = -p * p - p - 1;
+ n2[p] = -p * p - p - 2;
+ if(p < n_lat || n_lat == 3) {
+ if(v[p] == v[p + n_lat] ||
+ v[(p + 1) % n_lat] == v[(p + 1) % n_lat + n_lat])
continue;
- else if( edgeExists( v[p], v[(p+1)%n_lat+n_lat], (*boundary_diags) ) ){
- n1[p] = p; n2[p] = (p+1)%n_lat+n_lat;
+ else if(edgeExists(v[p], v[(p + 1) % n_lat + n_lat], (*boundary_diags))) {
+ n1[p] = p;
+ n2[p] = (p + 1) % n_lat + n_lat;
found_diags = true;
}
- else if( edgeExists( v[p+n_lat], v[(p+1)%n_lat], (*boundary_diags) ) ){
- n1[p] = p+n_lat; n2[p] = (p+1)%n_lat;
+ else if(edgeExists(v[p + n_lat], v[(p + 1) % n_lat], (*boundary_diags))) {
+ n1[p] = p + n_lat;
+ n2[p] = (p + 1) % n_lat;
found_diags = true;
}
}
- else{
- int add = ( p == n_lat ) ? 0 : n_lat;
- if( edgeExists( v[add], v[add+2], (*boundary_diags) ) ){
- n1[p] = add; n2[p] = add+2;
+ else {
+ int add = (p == n_lat) ? 0 : n_lat;
+ if(edgeExists(v[add], v[add + 2], (*boundary_diags))) {
+ n1[p] = add;
+ n2[p] = add + 2;
found_diags = true;
}
- else if( edgeExists( v[add+1], v[add+3], (*boundary_diags) ) ){
- n1[p] = add+1; n2[p] = add+3;
+ else if(edgeExists(v[add + 1], v[add + 3], (*boundary_diags))) {
+ n1[p] = add + 1;
+ n2[p] = add + 3;
found_diags = true;
}
}
}
-
-
- if( !found_diags ){
- if( n_lat == 3 )
- addPrism( v[0], v[1], v[2], v[3], v[4], v[5], gr );
- else if( n_lat ==4 )
- addHexahedron( v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], gr );
+ if(!found_diags) {
+ if(n_lat == 3)
+ addPrism(v[0], v[1], v[2], v[3], v[4], v[5], gr);
+ else if(n_lat == 4)
+ addHexahedron(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], gr);
return;
}
// make the internal vertex
std::vector<double> centroid = QtFindVertsCentroid(v);
MVertex *v_int = new MVertex(centroid[0], centroid[1], centroid[2], gr);
- gr->mesh_vertices.push_back( v_int );
+ gr->mesh_vertices.push_back(v_int);
// build all pyramids/tetra
- for( int p = 0; p < n_lat; p++ ){
- int p2 = (p+1)%n_lat;
- if( v[p] == v[p+n_lat] && v[p2] == v[p2+n_lat] )
+ for(int p = 0; p < n_lat; p++) {
+ int p2 = (p + 1) % n_lat;
+ if(v[p] == v[p + n_lat] && v[p2] == v[p2 + n_lat])
continue;
- else if( v[p] == v[p+n_lat] || v[p2] == v[p2+n_lat] ){
- MVertex *v_dup = (v[p] == v[p+n_lat]) ? v[p] : v[p2];
+ else if(v[p] == v[p + n_lat] || v[p2] == v[p2 + n_lat]) {
+ MVertex *v_dup = (v[p] == v[p + n_lat]) ? v[p] : v[p2];
MVertex *v_non_dup = (v_dup == v[p]) ? v[p2] : v[p];
- MVertex *v_non_dup2 = (v_non_dup == v[p]) ? v[p+n_lat] : v[p2+n_lat];
- addTetrahedron( v_dup, v_non_dup, v_non_dup2, v_int, gr);
+ MVertex *v_non_dup2 = (v_non_dup == v[p]) ? v[p + n_lat] : v[p2 + n_lat];
+ addTetrahedron(v_dup, v_non_dup, v_non_dup2, v_int, gr);
}
- else if( n1[p] == p || n2[p] == p ){
- addTetrahedron( v[p], v[p2], v[p2+n_lat], v_int, gr );
- addTetrahedron( v[p], v[p2+n_lat], v[p+n_lat], v_int, gr );
+ else if(n1[p] == p || n2[p] == p) {
+ addTetrahedron(v[p], v[p2], v[p2 + n_lat], v_int, gr);
+ addTetrahedron(v[p], v[p2 + n_lat], v[p + n_lat], v_int, gr);
}
- else if( n1[p] == p+n_lat || n2[p] == p+n_lat ){
- addTetrahedron( v[p], v[p2], v[p+n_lat], v_int, gr );
- addTetrahedron( v[p2], v[p2+n_lat], v[p+n_lat], v_int, gr );
+ else if(n1[p] == p + n_lat || n2[p] == p + n_lat) {
+ addTetrahedron(v[p], v[p2], v[p + n_lat], v_int, gr);
+ addTetrahedron(v[p2], v[p2 + n_lat], v[p + n_lat], v_int, gr);
}
else
- addPyramid( v[p], v[p2], v[p2+n_lat], v[p+n_lat], v_int, gr );
+ addPyramid(v[p], v[p2], v[p2 + n_lat], v[p + n_lat], v_int, gr);
}
- if( n_lat == 3){
+ if(n_lat == 3) {
// bottom and top
- addTetrahedron( v[0], v[1], v[2], v_int, gr );
- addTetrahedron( v[3], v[5], v[4], v_int, gr );
+ addTetrahedron(v[0], v[1], v[2], v_int, gr);
+ addTetrahedron(v[3], v[5], v[4], v_int, gr);
}
- else if( n_lat == 4 ){
- for( int p = 4; p < 6; p++ ){
+ else if(n_lat == 4) {
+ for(int p = 4; p < 6; p++) {
int add = (p == 4) ? 0 : 4;
- if( n1[p] == 0+add || n2[p] == 0+add ){
- addTetrahedron( v[add], v[1+add], v[2+add], v_int, gr );
- addTetrahedron( v[add], v[2+add], v[3+add], v_int, gr );
+ if(n1[p] == 0 + add || n2[p] == 0 + add) {
+ addTetrahedron(v[add], v[1 + add], v[2 + add], v_int, gr);
+ addTetrahedron(v[add], v[2 + add], v[3 + add], v_int, gr);
}
- else if( n1[p] == 1+add || n2[p] == 1+add ){
- addTetrahedron( v[1+add], v[2+add], v[3+add], v_int, gr );
- addTetrahedron( v[1+add], v[3+add], v[add], v_int, gr );
+ else if(n1[p] == 1 + add || n2[p] == 1 + add) {
+ addTetrahedron(v[1 + add], v[2 + add], v[3 + add], v_int, gr);
+ addTetrahedron(v[1 + add], v[3 + add], v[add], v_int, gr);
}
else
- addPyramid( v[add], v[1+add], v[2+add], v[3+add], v_int, gr );
+ addPyramid(v[add], v[1 + add], v[2 + add], v[3 + add], v_int, gr);
}
}
diff --git a/Mesh/QuadTriTransfinite3D.h b/Mesh/QuadTriTransfinite3D.h
index c8836e85dd93270923ec84bf6e694c45bab30cbd..ec1d3a3249bc683eff5818b266bdb740a8b59c38 100644
--- a/Mesh/QuadTriTransfinite3D.h
+++ b/Mesh/QuadTriTransfinite3D.h
@@ -1,28 +1,31 @@
-/**************************************************************************************************
+/**************************************************************************************************
QuadTriTransfinite3D.h
The code in this file was written by Dr. Trevor S. Strickler.
-email: <trevor.strickler@gmail.com>
+email: <trevor.strickler@gmail.com>
-This file is part of the QuadTri contribution to Gmsh. QuadTri allows the conformal interface
-of quadrangle faces to triangle faces using pyramids and other mesh elements.
+This file is part of the QuadTri contribution to Gmsh. QuadTri allows the
+conformal interface of quadrangle faces to triangle faces using pyramids and
+other mesh elements.
-See READMEQUADTRI.txt for more information. The license information is in LICENSE.txt.
+See READMEQUADTRI.txt for more information. The license information is in
+LICENSE.txt.
-Trevor S. Strickler hereby transfers copyright of QuadTri files to
-Christophe Geuzaine and J.-F. Remacle with the understanding that
+Trevor S. Strickler hereby transfers copyright of QuadTri files to
+Christophe Geuzaine and J.-F. Remacle with the understanding that
his contribution shall be cited appropriately.
-All reused or original Gmsh code is Copyright (C) 1997-2018 C. Geuzaine, J.-F. Remacle
-Gmsh is available at: www.geuz.org/gmsh
+All reused or original Gmsh code is Copyright (C) 1997-2018 C. Geuzaine, J.-F.
+Remacle Gmsh is available at: www.geuz.org/gmsh
-For Gmsh license information, see the LICENSE.txt file for license information. Please report all
-Gmsh bugs and problems to the public mailing list <gmsh@onelab.info>.
+For Gmsh license information, see the LICENSE.txt file for license information.
+Please report all Gmsh bugs and problems to the public mailing list
+<gmsh@onelab.info>.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, Version 2,
-as published by the Free Software Foundation, or (at your option)
-any later version, with or without the exception given in the
+as published by the Free Software Foundation, or (at your option)
+any later version, with or without the exception given in the
LICENSE.txt file supplied with this code and with Gmsh.
This program is distributed in the hope that it will be useful,
@@ -32,19 +35,20 @@ GNU General Public License for more details.
****************************************************************************************************/
-#if !defined( _QTTRANS3D_H_ )
+#if !defined(_QTTRANS3D_H_)
#define _QTTRANS3D_H_
#include "QuadTriUtils.h"
-// Function to get all the diagonals from external surfaces of a given Transfinite region tr
-// and place them in boundary_diags.
-int getTransfiniteBoundaryDiags( GRegion *tr, std::set< std::pair<MVertex*,
- MVertex*> > *boundary_diags );
+// Function to get all the diagonals from external surfaces of a given
+// Transfinite region tr and place them in boundary_diags.
+int getTransfiniteBoundaryDiags(
+ GRegion *tr, std::set<std::pair<MVertex *, MVertex *> > *boundary_diags);
-// Meshes either a prism or a hexahedral set of mesh vertices in a Transfinite Region with an internal vertex
-// that is created here in the function.
-void meshTransfElemWithInternalVertex( GRegion *to, std::vector<MVertex *> v,
- std::set< std::pair<MVertex*, MVertex*> > *boundary_diags );
+// Meshes either a prism or a hexahedral set of mesh vertices in a Transfinite
+// Region with an internal vertex that is created here in the function.
+void meshTransfElemWithInternalVertex(
+ GRegion *to, std::vector<MVertex *> v,
+ std::set<std::pair<MVertex *, MVertex *> > *boundary_diags);
#endif
diff --git a/Mesh/QuadTriUtils.cpp b/Mesh/QuadTriUtils.cpp
index dc47772c346bd3997cb968afc7ea1ff50706a381..c254dffb7a191e645f49535ee6be7fa5787acc24 100644
--- a/Mesh/QuadTriUtils.cpp
+++ b/Mesh/QuadTriUtils.cpp
@@ -36,143 +36,145 @@ PARTICULAR PURPOSE. See the GNU General Public License for more details.
#include "QuadTriUtils.h"
// By Geuzaine, Remacle...
-static void addTriangle(MVertex* v1, MVertex* v2, MVertex* v3,
- GFace *to)
+static void addTriangle(MVertex *v1, MVertex *v2, MVertex *v3, GFace *to)
{
- MTriangle* newTri = new MTriangle(v1, v2, v3);
+ MTriangle *newTri = new MTriangle(v1, v2, v3);
to->triangles.push_back(newTri);
}
-// this determines if a face is a non-lateral face in a structured toroidal volume extrusion with at
-// least one QuadToTri region...
+// this determines if a face is a non-lateral face in a structured toroidal
+// volume extrusion with at least one QuadToTri region...
int IsInToroidalQuadToTri(GFace *face)
{
- if(!face)
- return false;
-
- GModel *model = face->model();
-
- bool is_toroidal = false, is_quadtri = false, is_noaddverts = false;
-
- // Find the root face first...then step back through extrusions as far as can find
- // another structured region. If there is a single quadtri region, and this is a torus that
- // extrudes back onto the root source surface, then return true.
- GFace *root_face = 0;
- root_face = findRootSourceFaceForFace(face);
- unsigned int numRegions = 0;
- std::vector<GRegion*> adj_extruded_reg;
-
- //find the two regions adjacent to the root face. If this is a structured torus, then both regions
- // should be structured extrusions and BOTH should have the same root face
- std::set<GRegion *, GEntityLessThan>::iterator itreg;
- for( itreg = model->firstRegion(); itreg != model->lastRegion(); itreg++ ){
- // save time
- if( numRegions >= 2 )
- break;
-
- GRegion *region = (*itreg);
-
- // does face belong to region and if so is it a structured extrusion?
- std::vector<GFace *> region_faces = region->faces();
- if( std::find( region_faces.begin(), region_faces.end(), root_face ) !=
- region_faces.end() && region->meshAttributes.extrude &&
- region->meshAttributes.extrude->mesh.ExtrudeMesh &&
- region->meshAttributes.extrude->geo.Mode == EXTRUDED_ENTITY ){
-
- adj_extruded_reg.push_back(region);
- numRegions++;
- }
- else
- continue;
+ if(!face) return false;
+
+ GModel *model = face->model();
+
+ bool is_toroidal = false, is_quadtri = false, is_noaddverts = false;
+
+ // Find the root face first...then step back through extrusions as far as can
+ // find another structured region. If there is a single quadtri region, and
+ // this is a torus that extrudes back onto the root source surface, then
+ // return true.
+ GFace *root_face = 0;
+ root_face = findRootSourceFaceForFace(face);
+ unsigned int numRegions = 0;
+ std::vector<GRegion *> adj_extruded_reg;
+
+ // find the two regions adjacent to the root face. If this is a structured
+ // torus, then both regions
+ // should be structured extrusions and BOTH should have the same root face
+ std::set<GRegion *, GEntityLessThan>::iterator itreg;
+ for(itreg = model->firstRegion(); itreg != model->lastRegion(); itreg++) {
+ // save time
+ if(numRegions >= 2) break;
+
+ GRegion *region = (*itreg);
+
+ // does face belong to region and if so is it a structured extrusion?
+ std::vector<GFace *> region_faces = region->faces();
+ if(std::find(region_faces.begin(), region_faces.end(), root_face) !=
+ region_faces.end() &&
+ region->meshAttributes.extrude &&
+ region->meshAttributes.extrude->mesh.ExtrudeMesh &&
+ region->meshAttributes.extrude->geo.Mode == EXTRUDED_ENTITY) {
+ adj_extruded_reg.push_back(region);
+ numRegions++;
}
- // if there are two structured extruded regions adjacent to the root face,
- // then find the one that is NOT extruded from the root directly. Then follow this
- // face as far as possible back to the source.
-
- GRegion *last_region = 0;
- GFace *last_reg_source = 0;
- bool found_first = 0, found_last = 0;
- if( numRegions == 2 ){
- for( int ind = 0; ind <= 1; ind++ ){
- ExtrudeParams *adj_ep = adj_extruded_reg[ind]->meshAttributes.extrude;
- GFace *reg_source = 0;
-
- if( adj_ep && adj_ep->mesh.ExtrudeMesh ){
- reg_source = model->getFaceByTag(std::abs( adj_ep->geo.Source ) );
- if( adj_ep->mesh.QuadToTri ){
- is_quadtri = true;
- if( adj_ep->mesh.QuadToTri == QUADTRI_NOVERTS_1 ||
- adj_ep->mesh.QuadToTri == QUADTRI_NOVERTS_1_RECOMB )
- is_noaddverts = true;
- }
- }
- if( reg_source ){
- if( reg_source != root_face ){
- last_region = adj_extruded_reg[ind];
- last_reg_source = reg_source;
- found_last = true;
- }
- else{
- found_first = true;
- }
- }
- else{
- Msg::Error("In IsInToroidalQuadToTri(), could not find source face of region %d",
- adj_extruded_reg[ind]->tag() );
- return 0;
- }
+ else
+ continue;
+ }
+ // if there are two structured extruded regions adjacent to the root face,
+ // then find the one that is NOT extruded from the root directly. Then follow
+ // this face as far as possible back to the source.
+
+ GRegion *last_region = 0;
+ GFace *last_reg_source = 0;
+ bool found_first = 0, found_last = 0;
+ if(numRegions == 2) {
+ for(int ind = 0; ind <= 1; ind++) {
+ ExtrudeParams *adj_ep = adj_extruded_reg[ind]->meshAttributes.extrude;
+ GFace *reg_source = 0;
+
+ if(adj_ep && adj_ep->mesh.ExtrudeMesh) {
+ reg_source = model->getFaceByTag(std::abs(adj_ep->geo.Source));
+ if(adj_ep->mesh.QuadToTri) {
+ is_quadtri = true;
+ if(adj_ep->mesh.QuadToTri == QUADTRI_NOVERTS_1 ||
+ adj_ep->mesh.QuadToTri == QUADTRI_NOVERTS_1_RECOMB)
+ is_noaddverts = true;
+ }
+ }
+ if(reg_source) {
+ if(reg_source != root_face) {
+ last_region = adj_extruded_reg[ind];
+ last_reg_source = reg_source;
+ found_last = true;
+ }
+ else {
+ found_first = true;
+ }
+ }
+ else {
+ Msg::Error(
+ "In IsInToroidalQuadToTri(), could not find source face of region %d",
+ adj_extruded_reg[ind]->tag());
+ return 0;
}
}
+ }
- //walk back around to beginning if possible
- if( last_region && found_first && found_last ){
- GFace *iter_face = last_reg_source;
- GFace *iter_source_face = 0;
- bool done = false;
- unsigned int maxiter = model->getNumFaces() + 2;
- unsigned int counter = 0;
- while( !done && counter <= maxiter ){
- counter++;
- if( iter_face ){
- ExtrudeParams *iter_eps = iter_face->meshAttributes.extrude;
- if( iter_eps && iter_eps->mesh.ExtrudeMesh &&
- iter_eps->geo.Mode == COPIED_ENTITY ){
- if( iter_eps->mesh.QuadToTri )
- is_quadtri = true;
- iter_source_face = model->getFaceByTag(std::abs( iter_eps->geo.Source ));
- if( iter_source_face ){
- if( iter_source_face == root_face ){
- is_toroidal = true;
- done = true;
- }
- else
- iter_face = iter_source_face;
- }
- else{
- Msg::Error("In IsInToroidalQuadToTri(), could not find source face of face %d",
- iter_face->tag() );
- return 0;
- }
- }
- else // if we found a source face not extruded as part of structured source (ie, not copied)
- return 0;
- }
- else{
- Msg::Error("In IsInToroidalQuadToTri(), could not find a face...");
- return 0;
- }
+ // walk back around to beginning if possible
+ if(last_region && found_first && found_last) {
+ GFace *iter_face = last_reg_source;
+ GFace *iter_source_face = 0;
+ bool done = false;
+ unsigned int maxiter = model->getNumFaces() + 2;
+ unsigned int counter = 0;
+ while(!done && counter <= maxiter) {
+ counter++;
+ if(iter_face) {
+ ExtrudeParams *iter_eps = iter_face->meshAttributes.extrude;
+ if(iter_eps && iter_eps->mesh.ExtrudeMesh &&
+ iter_eps->geo.Mode == COPIED_ENTITY) {
+ if(iter_eps->mesh.QuadToTri) is_quadtri = true;
+ iter_source_face =
+ model->getFaceByTag(std::abs(iter_eps->geo.Source));
+ if(iter_source_face) {
+ if(iter_source_face == root_face) {
+ is_toroidal = true;
+ done = true;
+ }
+ else
+ iter_face = iter_source_face;
+ }
+ else {
+ Msg::Error("In IsInToroidalQuadToTri(), could not find source face "
+ "of face %d",
+ iter_face->tag());
+ return 0;
+ }
+ }
+ else // if we found a source face not extruded as part of structured
+ // source (ie, not copied)
+ return 0;
+ }
+ else {
+ Msg::Error("In IsInToroidalQuadToTri(), could not find a face...");
+ return 0;
}
}
+ }
- // now return
- if( is_toroidal && is_quadtri ){
- if( !is_noaddverts )
- return 1;
- else
- return 2;
- }
+ // now return
+ if(is_toroidal && is_quadtri) {
+ if(!is_noaddverts)
+ return 1;
else
- return 0;
+ return 2;
+ }
+ else
+ return 0;
}
// replace boundary quads in a source surface for toroidal quadtri extrusion
@@ -184,13 +186,14 @@ void ReplaceBndQuadsInFace(GFace *face)
face->meshAttributes.method == MESH_TRANSFINITE)
is_struct = true;
GFace *root_face = findRootSourceFaceForFace(face);
- if(root_face == face){
- MVertexRTree pos_src_edge(CTX::instance()->geom.tolerance * CTX::instance()->lc);
+ if(root_face == face) {
+ MVertexRTree pos_src_edge(CTX::instance()->geom.tolerance *
+ CTX::instance()->lc);
QuadToTriInsertFaceEdgeVertices(face, pos_src_edge);
- std::vector<MQuadrangle*> quads2;
- //loop through source quads, if on boundary, delete them
- for(unsigned int i = 0; i < face->quadrangles.size(); i++){
- std::vector<MVertex*> verts;
+ std::vector<MQuadrangle *> quads2;
+ // loop through source quads, if on boundary, delete them
+ for(unsigned int i = 0; i < face->quadrangles.size(); i++) {
+ std::vector<MVertex *> verts;
int num_verts = face->quadrangles[i]->getNumVertices();
bool on_edge = false;
@@ -198,49 +201,48 @@ void ReplaceBndQuadsInFace(GFace *face)
for(int j = 0; j < num_verts; j++)
verts.push_back(face->quadrangles[i]->getVertex(j));
- for(int j = 0; j < num_verts; j++){
- if(pos_src_edge.find(verts[j]->x(), verts[j]->y(), verts[j]->z())){
- on_edge = true;
- break;
- }
+ for(int j = 0; j < num_verts; j++) {
+ if(pos_src_edge.find(verts[j]->x(), verts[j]->y(), verts[j]->z())) {
+ on_edge = true;
+ break;
+ }
}
- if(on_edge){
- delete face->quadrangles[i];
- if(is_struct){
- addTriangle(verts[0],verts[2], verts[3],face);
- addTriangle(verts[0],verts[1], verts[2],face);
- }
- else{
- // draw other diagonals to minimize difference in average edge length
- // with diagonal length, in quadrature
-
- double mag_sq_ave = 0.0;
- for( int p = 0; p < 4; p++ ){
- int d_leg = verts[p]->distance(verts[(p+1)%4]);
- mag_sq_ave += d_leg*d_leg;
- }
- mag_sq_ave /= 4.0;
-
- double d1 = verts[0]->distance(verts[2]);
- double d2 = verts[1]->distance(verts[3]);
-
- if(fabs(d1*d1-mag_sq_ave) <= fabs(d2*d2-mag_sq_ave) ){
- addTriangle(verts[0],verts[1],verts[2],face);
- addTriangle(verts[0],verts[2],verts[3],face);
- }
- else{
- addTriangle(verts[1],verts[2],verts[3],face);
- addTriangle(verts[1],verts[3],verts[0],face);
- }
- }
+ if(on_edge) {
+ delete face->quadrangles[i];
+ if(is_struct) {
+ addTriangle(verts[0], verts[2], verts[3], face);
+ addTriangle(verts[0], verts[1], verts[2], face);
+ }
+ else {
+ // draw other diagonals to minimize difference in average edge length
+ // with diagonal length, in quadrature
+
+ double mag_sq_ave = 0.0;
+ for(int p = 0; p < 4; p++) {
+ int d_leg = verts[p]->distance(verts[(p + 1) % 4]);
+ mag_sq_ave += d_leg * d_leg;
+ }
+ mag_sq_ave /= 4.0;
+
+ double d1 = verts[0]->distance(verts[2]);
+ double d2 = verts[1]->distance(verts[3]);
+
+ if(fabs(d1 * d1 - mag_sq_ave) <= fabs(d2 * d2 - mag_sq_ave)) {
+ addTriangle(verts[0], verts[1], verts[2], face);
+ addTriangle(verts[0], verts[2], verts[3], face);
+ }
+ else {
+ addTriangle(verts[1], verts[2], verts[3], face);
+ addTriangle(verts[1], verts[3], verts[0], face);
+ }
+ }
}
else
- quads2.push_back(face->quadrangles[i]);
+ quads2.push_back(face->quadrangles[i]);
}
face->quadrangles.clear();
face->quadrangles = quads2;
}
-
}
// Insert all vertices on a region's source edge, including corners, into
@@ -248,17 +250,18 @@ void ReplaceBndQuadsInFace(GFace *face)
void QuadToTriInsertSourceEdgeVertices(GRegion *gr, MVertexRTree &pos_src_edge)
{
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if(!ep || !ep->mesh.ExtrudeMesh || ep->geo.Mode != EXTRUDED_ENTITY){
+ if(!ep || !ep->mesh.ExtrudeMesh || ep->geo.Mode != EXTRUDED_ENTITY) {
Msg::Error("In QuadToTriInsertSourceEdgeVertices(), incomplete or no "
- "extrude info for region %d.", gr->tag() );
+ "extrude info for region %d.",
+ gr->tag());
return;
}
GFace *source_face = gr->model()->getFaceByTag(std::abs(ep->geo.Source));
- std::vector<GEdge*> const& edges = source_face->edges();
- std::vector<GEdge*>::const_iterator ite = edges.begin();
- for(ite = edges.begin(); ite != edges.end(); ite++){
+ std::vector<GEdge *> const &edges = source_face->edges();
+ std::vector<GEdge *>::const_iterator ite = edges.begin();
+ for(ite = edges.begin(); ite != edges.end(); ite++) {
pos_src_edge.insert((*ite)->mesh_vertices);
pos_src_edge.insert((*ite)->getBeginVertex()->mesh_vertices);
pos_src_edge.insert((*ite)->getEndVertex()->mesh_vertices);
@@ -269,9 +272,9 @@ void QuadToTriInsertSourceEdgeVertices(GRegion *gr, MVertexRTree &pos_src_edge)
// Added 2010-01-18
void QuadToTriInsertFaceEdgeVertices(GFace *face, MVertexRTree &pos_edges)
{
- std::vector<GEdge*> const& edges = face->edges();
- std::vector<GEdge*>::const_iterator ite = edges.begin();
- while(ite != edges.end()){
+ std::vector<GEdge *> const &edges = face->edges();
+ std::vector<GEdge *>::const_iterator ite = edges.begin();
+ while(ite != edges.end()) {
pos_edges.insert((*ite)->mesh_vertices);
pos_edges.insert((*ite)->getBeginVertex()->mesh_vertices);
pos_edges.insert((*ite)->getEndVertex()->mesh_vertices);
@@ -279,37 +282,40 @@ void QuadToTriInsertFaceEdgeVertices(GFace *face, MVertexRTree &pos_edges)
}
}
-
// Constructor for the CategorizedSourceElements structure. See definition of
// CategorizedSourceElements in QuadTriUtils.h file for details.
CategorizedSourceElements::CategorizedSourceElements(GRegion *gr)
{
- region = (GRegion*)(NULL);
- source_face = (GFace*)(NULL);
+ region = (GRegion *)(NULL);
+ source_face = (GFace *)(NULL);
valid = false;
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh){
+ if(!ep || !ep->mesh.QuadToTri || !ep->mesh.ExtrudeMesh) {
Msg::Error("In CategorizedSourceElements constructor, invalid extrusion "
"in region %d for performing QuadToTri mesh generation.",
- gr->tag() );
+ gr->tag());
return;
}
GModel *model = gr->model();
- if(!model){
- Msg::Error("In CategorizedSourceElements constructor, invalid model for region "
- "%d.", gr->tag() );
+ if(!model) {
+ Msg::Error(
+ "In CategorizedSourceElements constructor, invalid model for region "
+ "%d.",
+ gr->tag());
return;
}
// now find and verify the source face
- GFace *source_tmp = model->getFaceByTag( std::abs( ep->geo.Source ) );
- if(!source_tmp){
- Msg::Error("In CategorizedSourceElements constructor, invalid source face for region "
- "%d.", gr->tag() );
+ GFace *source_tmp = model->getFaceByTag(std::abs(ep->geo.Source));
+ if(!source_tmp) {
+ Msg::Error("In CategorizedSourceElements constructor, invalid source face "
+ "for region "
+ "%d.",
+ gr->tag());
return;
}
@@ -326,23 +332,25 @@ CategorizedSourceElements::CategorizedSourceElements(GRegion *gr)
unsigned int num_quad = source_face->quadrangles.size();
// assign size to bool vectors
- tri_bool.assign(num_tri*4, false);
- quad_bool.assign(num_quad*5, false);
+ tri_bool.assign(num_tri * 4, false);
+ quad_bool.assign(num_quad * 5, false);
// keep temporary set of one boundary point quad pivot indices
- std::set<MVertex*> one_pt_quad_pivots;
+ std::set<MVertex *> one_pt_quad_pivots;
// now classify the source elements in the vectors
- for(int t = 0; t < 2; t++){ // t = 0 loop over triangles, t=1 loop over quads
- int size = !t ? source_face->triangles.size() : source_face->quadrangles.size();
- for(int i = 0; i < size; i++){ // loop over total elements in current vector
- std::vector<MVertex*> elem_verts;
+ for(int t = 0; t < 2; t++) { // t = 0 loop over triangles, t=1 loop over quads
+ int size =
+ !t ? source_face->triangles.size() : source_face->quadrangles.size();
+ for(int i = 0; i < size;
+ i++) { // loop over total elements in current vector
+ std::vector<MVertex *> elem_verts;
MElement *elem;
- if(!t){
+ if(!t) {
elem = source_face->triangles[i];
elem->getVertices(elem_verts);
}
- else{
+ else {
elem = source_face->quadrangles[i];
elem->getVertices(elem_verts);
}
@@ -350,94 +358,101 @@ CategorizedSourceElements::CategorizedSourceElements(GRegion *gr)
int bnd_count = 0;
int bnd_vert = 0;
// get the boundary vert bool values
- for(int k = 0; k < elem_size; k++){
- if(bnd_verts.find(elem_verts[k]->x(), elem_verts[k]->y(), elem_verts[k]->z())){
- if( !t ) tri_bool[4*i+k+1] = true;
- else quad_bool[5*i+k+1] = true;
+ for(int k = 0; k < elem_size; k++) {
+ if(bnd_verts.find(elem_verts[k]->x(), elem_verts[k]->y(),
+ elem_verts[k]->z())) {
+ if(!t)
+ tri_bool[4 * i + k + 1] = true;
+ else
+ quad_bool[5 * i + k + 1] = true;
bnd_vert = k;
bnd_count++;
}
}
- if(bnd_count){
- if(!t) tri_bool[4*i] = true;
- else quad_bool[5*i] = true;
+ if(bnd_count) {
+ if(!t)
+ tri_bool[4 * i] = true;
+ else
+ quad_bool[5 * i] = true;
}
// Place element vector indices into appropriate set
if(!bnd_count)
(!t) ? internal_tri.insert(i) : internal_quad.insert(i);
- else if(bnd_count == 1 || bnd_count == 2 ||
- (bnd_count == 3 && t))
+ else if(bnd_count == 1 || bnd_count == 2 || (bnd_count == 3 && t))
(!t) ? other_bnd_tri.insert(i) : other_bnd_quad.insert(i);
- else if((bnd_count == 3 && !t) || bnd_count == 4){
+ else if((bnd_count == 3 && !t) || bnd_count == 4) {
(!t) ? three_bnd_pt_tri.insert(i) : four_bnd_pt_quad.insert(i);
}
// if a one boundary point quad, record it in one_pt_quads set
- if(t && bnd_count == 1){
- one_pt_quad_pivots.insert(elem_verts[(bnd_vert+2)%4]);
+ if(t && bnd_count == 1) {
+ one_pt_quad_pivots.insert(elem_verts[(bnd_vert + 2) % 4]);
}
}
}
// If there were one_bnd_pt_quads, go through the search for all elements
// touching at pivot index that are either internal or two bnd point quads.
- // This would take awhile if had to do this for every element (n^2). Fortunately,
- // such elements are NOT typical at all.
- if( !one_pt_quad_pivots.size() )
- return;
+ // This would take awhile if had to do this for every element (n^2).
+ // Fortunately, such elements are NOT typical at all.
+ if(!one_pt_quad_pivots.size()) return;
std::set<std::pair<unsigned int, unsigned int> >::iterator it_quad;
std::set<unsigned int>::iterator it_int;
- for( int s = 0; s < 2; s++ ){
- for( int q = 0; q < 2; q++ ){
+ for(int s = 0; s < 2; s++) {
+ for(int q = 0; q < 2; q++) {
std::set<unsigned int> *int_elems;
- if(!s){
- if(!q) int_elems = &internal_tri;
- else continue;
+ if(!s) {
+ if(!q)
+ int_elems = &internal_tri;
+ else
+ continue;
}
else
int_elems = !q ? &internal_quad : &other_bnd_quad;
- for(it_int = (*int_elems).begin(); it_int != (*int_elems).end(); it_int++){
- std::vector<MVertex*> verts;
+ for(it_int = (*int_elems).begin(); it_int != (*int_elems).end();
+ it_int++) {
+ std::vector<MVertex *> verts;
if(!s)
source_face->triangles[(*it_int)]->getVertices(verts);
else
source_face->quadrangles[(*it_int)]->getVertices(verts);
- // for t == s == 1 (other_bnd_quads), only retain those with two boundary verts
- if(s && q){
+ // for t == s == 1 (other_bnd_quads), only retain those with two
+ // boundary verts
+ if(s && q) {
int bnd_count = 0;
- for(unsigned int k = 0; k < verts.size(); k++){
- if(quad_bool[5*(*it_int)+k+1])
- bnd_count++;
+ for(unsigned int k = 0; k < verts.size(); k++) {
+ if(quad_bool[5 * (*it_int) + k + 1]) bnd_count++;
}
- if(bnd_count != 2)
- continue;
+ if(bnd_count != 2) continue;
}
// Don't eliminate the inner for loop with std::find because
- // or reverse the order of the two loops. If an element touches multiple pivots,
- // always want to find the FIRST one in the pivots set so that there is precedence
- // and no conflicts at mesh time. Looping through the element vertices as the outer loop
- // will sometimes choose the wrong pivot.
- std::set<MVertex*>::iterator it_piv;
+ // or reverse the order of the two loops. If an element touches
+ // multiple pivots, always want to find the FIRST one in the pivots set
+ // so that there is precedence and no conflicts at mesh time. Looping
+ // through the element vertices as the outer loop will sometimes choose
+ // the wrong pivot.
+ std::set<MVertex *>::iterator it_piv;
bool found = false;
- for(it_piv = one_pt_quad_pivots.begin(); it_piv != one_pt_quad_pivots.end(); it_piv++){
- for(unsigned int t = 0; t < verts.size(); t++){
+ for(it_piv = one_pt_quad_pivots.begin();
+ it_piv != one_pt_quad_pivots.end(); it_piv++) {
+ for(unsigned int t = 0; t < verts.size(); t++) {
if((*it_piv) == verts[t]) {
found = true;
- if(!s){
+ if(!s) {
internal_tri_touch_one_bnd_pt_quad.insert(*it_int);
- tri_bool[4*(*it_int)] = true;
- tri_bool[4*(*it_int)+t+1] = true;
+ tri_bool[4 * (*it_int)] = true;
+ tri_bool[4 * (*it_int) + t + 1] = true;
}
- else{
- if(!q){
+ else {
+ if(!q) {
internal_quad_touch_one_bnd_pt_quad.insert(*it_int);
- quad_bool[5*(*it_int)] = true;
- quad_bool[5*(*it_int)+t+1] = true;
+ quad_bool[5 * (*it_int)] = true;
+ quad_bool[5 * (*it_int) + t + 1] = true;
}
else
two_bnd_pt_quad_touch_one_bnd_pt_quad.insert(*it_int);
@@ -450,43 +465,46 @@ CategorizedSourceElements::CategorizedSourceElements(GRegion *gr)
}
}
}
-
}
// Find centroid of vertices in vector v, return in vector
-std::vector<double> QtFindVertsCentroid(std::vector<MVertex*> v)
+std::vector<double> QtFindVertsCentroid(std::vector<MVertex *> v)
{
std::vector<double> v_return;
const int v_size = v.size();
- if( v_size != 6 && v_size != 8 && v_size != 3 && v_size != 4 ){
- Msg::Error("In QtFindVertsCentroid(), number of vertices is not 3, 4, 6, or 8.");
+ if(v_size != 6 && v_size != 8 && v_size != 3 && v_size != 4) {
+ Msg::Error(
+ "In QtFindVertsCentroid(), number of vertices is not 3, 4, 6, or 8.");
return v_return;
}
// for 3D
int n_lat_tmp = 10;
- if( v_size==6 )
+ if(v_size == 6)
n_lat_tmp = 3;
- else if( v_size==8 )
+ else if(v_size == 8)
n_lat_tmp = 4;
const int n_lat = n_lat_tmp;
double x = 0.0, y = 0.0, z = 0.0;
int v_count = 0;
- for( int p = 0; p < v_size; p++){
+ for(int p = 0; p < v_size; p++) {
// skip degenerate vertices - 3D
- if( ( v_size == 6 || v_size == 8 ) && p > n_lat-1 && v[p] == v[p-n_lat] )
+ if((v_size == 6 || v_size == 8) && p > n_lat - 1 && v[p] == v[p - n_lat])
continue;
// skip degenerate vertices - 2D
- if( ( v_size == 3 || v_size == 4 ) && v[p] == v[(p+v_size-1)%v_size] )
+ if((v_size == 3 || v_size == 4) && v[p] == v[(p + v_size - 1) % v_size])
continue;
v_count++;
- x += v[p]->x(); y += v[p]->y(); z += v[p]->z();
+ x += v[p]->x();
+ y += v[p]->y();
+ z += v[p]->z();
}
- x /= v_count; y /= v_count; z /= v_count;
-
+ x /= v_count;
+ y /= v_count;
+ z /= v_count;
v_return.push_back(x);
v_return.push_back(y);
@@ -495,22 +513,23 @@ std::vector<double> QtFindVertsCentroid(std::vector<MVertex*> v)
return v_return;
}
-// Add a new vertex at the centroid of a vector of vertices (this goes into a region
-// Added 2010-02-06
+// Add a new vertex at the centroid of a vector of vertices (this goes into a
+// region Added 2010-02-06
MVertex *QtMakeCentroidVertex(const std::vector<MVertex *> &v,
std::vector<MVertex *> *target, GEntity *entity,
MVertexRTree &pos)
{
int v_size = v.size();
- if( v_size != 6 && v_size != 8 && v_size != 3 && v_size != 4){
- Msg::Error("In makeCentroidVertex(), number of vertices does not equal 3, 4, 6, or 8.");
- return (MVertex*)(NULL);
+ if(v_size != 6 && v_size != 8 && v_size != 3 && v_size != 4) {
+ Msg::Error("In makeCentroidVertex(), number of vertices does not equal 3, "
+ "4, 6, or 8.");
+ return (MVertex *)(NULL);
}
// find the centroid of vertices
std::vector<double> centroid = QtFindVertsCentroid(v);
double x = 0., y = 0., z = 0.;
- if( centroid.size() ){
+ if(centroid.size()) {
x = centroid[0];
y = centroid[1];
z = centroid[2];
@@ -520,7 +539,7 @@ MVertex *QtMakeCentroidVertex(const std::vector<MVertex *> &v,
MVertex *tmp = pos.find(x, y, z);
MVertex *v_int;
// simple check if it exists
- if(!tmp){
+ if(!tmp) {
v_int = new MVertex(x, y, z, entity);
target->push_back(v_int);
pos.insert(v_int);
@@ -533,73 +552,74 @@ MVertex *QtMakeCentroidVertex(const std::vector<MVertex *> &v,
// Finds the index of the lowest valued pointer in a vector of MVertex pointers
// Added 2011-03-10
-int getIndexForLowestVertexPointer(std::vector<MVertex*> v)
+int getIndexForLowestVertexPointer(std::vector<MVertex *> v)
{
int ind_low = 0;
int v_size = v.size();
- for( int i = 1; i < v_size; i++ ){
- if( v[i] < v[ind_low] )
- ind_low = i;
+ for(int i = 1; i < v_size; i++) {
+ if(v[i] < v[ind_low]) ind_low = i;
}
return ind_low;
}
// Given 4 verts on a face, find an existent diagonal, if any.
-// Two possible methods: If the 'index_guess' argument is the index of the correct triangle,
-// finding it is simple. If not, have to do a complete pedantic search.
-// Added 2010-01-26
-std::pair<int, int> FindDiagonalEdgeIndices( std::vector<MVertex*> verts,
- GFace *face, bool lateral,
- unsigned int index_guess)
+// Two possible methods: If the 'index_guess' argument is the index of the
+// correct triangle, finding it is simple. If not, have to do a complete
+// pedantic search. Added 2010-01-26
+std::pair<int, int> FindDiagonalEdgeIndices(std::vector<MVertex *> verts,
+ GFace *face, bool lateral,
+ unsigned int index_guess)
{
- if( verts.size() != 4 ){
+ if(verts.size() != 4) {
Msg::Error("FindDiagonalEdgeIndices(), size of verts array not equal 4.");
- return std::pair<int,int>(0,0);
+ return std::pair<int, int>(0, 0);
}
- if( !lateral ){
- MVertex *tmp = verts[2]; verts[2] = verts[3]; verts[3] = tmp;
+ if(!lateral) {
+ MVertex *tmp = verts[2];
+ verts[2] = verts[3];
+ verts[3] = tmp;
}
int s_max = face->triangles.size();
MElement *elem_tmp = NULL;
bool wrong_guess = false;
- for( int s = 0; s < s_max; s++ ){
- if( s != 0 && !wrong_guess ){
+ for(int s = 0; s < s_max; s++) {
+ if(s != 0 && !wrong_guess) {
wrong_guess = true;
- if( !face->quadrangles.size() )
- Msg::Error("FindDiagonalEdgeIndices() encountered unexpected surface configuration.");
+ if(!face->quadrangles.size())
+ Msg::Error("FindDiagonalEdgeIndices() encountered unexpected surface "
+ "configuration.");
}
- int v_count0 = 0, v_count1 = 0;
- elem_tmp = (MElement*)(face->triangles[(s+index_guess)%s_max]);
+ int v_count0 = 0, v_count1 = 0;
+ elem_tmp = (MElement *)(face->triangles[(s + index_guess) % s_max]);
int num_verts = elem_tmp->getNumVertices();
- for( int g = 0; g < num_verts; g++ ){
- if( elem_tmp->getVertex(g) == verts[0] ||
- elem_tmp->getVertex(g) == verts[3] )
+ for(int g = 0; g < num_verts; g++) {
+ if(elem_tmp->getVertex(g) == verts[0] ||
+ elem_tmp->getVertex(g) == verts[3])
v_count0++;
- else if( elem_tmp->getVertex(g) == verts[1] ||
- elem_tmp->getVertex(g) == verts[2] )
+ else if(elem_tmp->getVertex(g) == verts[1] ||
+ elem_tmp->getVertex(g) == verts[2])
v_count1++;
- if( lateral ){
- if( v_count0 > 1 )
- return std::pair<int,int> ( std::min(0,3), std::max(0,3) );
- else if( v_count1 > 1 )
- return std::pair<int,int> ( std::min(1,2), std::max(1,2) );
+ if(lateral) {
+ if(v_count0 > 1)
+ return std::pair<int, int>(std::min(0, 3), std::max(0, 3));
+ else if(v_count1 > 1)
+ return std::pair<int, int>(std::min(1, 2), std::max(1, 2));
}
- else{
- if( v_count0 > 1 )
- return std::pair<int,int> ( std::min(0,2), std::max(0,2) );
- else if( v_count1 > 1 )
- return std::pair<int,int> ( std::min(1,3), std::max(1,3) );
+ else {
+ if(v_count0 > 1)
+ return std::pair<int, int>(std::min(0, 2), std::max(0, 2));
+ else if(v_count1 > 1)
+ return std::pair<int, int>(std::min(1, 3), std::max(1, 3));
}
}
}
- if( !face->quadrangles.size() )
+ if(!face->quadrangles.size())
Msg::Error("In FindDiagonalEdgeIndices(), could not "
- "find a diagonal on surface %d.",
- face->tag() );
- return std::pair<int,int>(0,0);
-
+ "find a diagonal on surface %d.",
+ face->tag());
+ return std::pair<int, int>(0, 0);
}
// Get number of regions neighboring a face
@@ -607,18 +627,17 @@ int GetNeighborRegionsOfFace(GFace *face, std::vector<GRegion *> &neighbors)
{
GModel *model = face->model();
- if(!model){
+ if(!model) {
Msg::Error("GetNeighborRegionsOfFace(), face %d has no parent model.",
- face->tag() );
+ face->tag());
return 0;
}
// first see if the face has the list of regions
int regions_count = face->numRegions();
- if( regions_count > 0 ){
+ if(regions_count > 0) {
neighbors.push_back(face->getRegion(0));
- if( regions_count > 1 )
- neighbors.push_back(face->getRegion(1));
+ if(regions_count > 1) neighbors.push_back(face->getRegion(1));
return regions_count;
}
else
@@ -626,122 +645,122 @@ int GetNeighborRegionsOfFace(GFace *face, std::vector<GRegion *> &neighbors)
// pedantic search
std::set<GRegion *, GEntityLessThan>::iterator itreg;
- for( itreg = model->firstRegion(); itreg != model->lastRegion(); itreg++ ){
+ for(itreg = model->firstRegion(); itreg != model->lastRegion(); itreg++) {
std::vector<GFace *> reg_faces = (*itreg)->faces();
- if(std::find(reg_faces.begin(), reg_faces.end(), face) != reg_faces.end()){
+ if(std::find(reg_faces.begin(), reg_faces.end(), face) != reg_faces.end()) {
regions_count++;
- face->addRegion( (*itreg) );
- neighbors.push_back( (*itreg) );
- if( regions_count >= 2 ) return regions_count;
+ face->addRegion((*itreg));
+ neighbors.push_back((*itreg));
+ if(regions_count >= 2) return regions_count;
}
}
return regions_count;
-
}
-
// Tests whether a surface is a lateral of a region
// Trevor Strickler 12/09/10
int IsSurfaceALateralForRegion(GRegion *region, GFace *face)
{
- // NOTE: don't necessarily require the face to be extruded! just in the position
+ // NOTE: don't necessarily require the face to be extruded! just in the
+ // position
// of lateral is all we care about here.
ExtrudeParams *ep = face->meshAttributes.extrude;
ExtrudeParams *reg_ep = region->meshAttributes.extrude;
// if there is no REGION extrude information, skip the rest
- if( !reg_ep )
- return 0;
+ if(!reg_ep) return 0;
GModel *model = face->model();
- //GEdge *face_source = NULL;
- //if( ep && ep->geo.Mode == EXTRUDED_ENTITY)
- //face_source = model->getEdgeByTag(std::abs(ep->geo.Source));
+ // GEdge *face_source = NULL;
+ // if( ep && ep->geo.Mode == EXTRUDED_ENTITY)
+ // face_source = model->getEdgeByTag(std::abs(ep->geo.Source));
- GFace *reg_source = model->getFaceByTag( std::abs(reg_ep->geo.Source) );
+ GFace *reg_source = model->getFaceByTag(std::abs(reg_ep->geo.Source));
- if(!reg_source){
- Msg::Error("In IsSurfaceALateralForRegion(), unknown source surface number %d.",
- region->meshAttributes.extrude->geo.Source);
+ if(!reg_source) {
+ Msg::Error(
+ "In IsSurfaceALateralForRegion(), unknown source surface number %d.",
+ region->meshAttributes.extrude->geo.Source);
return 0;
}
// if face is the region's source, return 0
- if( reg_source == face )
- return 0;
+ if(reg_source == face) return 0;
// of course, the face has to belong to the region!
std::vector<GFace *> region_faces = region->faces();
- if(std::find( region_faces.begin(), region_faces.end(), face) == region_faces.end())
+ if(std::find(region_faces.begin(), region_faces.end(), face) ==
+ region_faces.end())
return 0;
- // if this face is a COPIED_ENTITY with source = region source face, this is the top. Exit.
- if( ep && ep->geo.Mode == COPIED_ENTITY &&
- reg_source == model->getFaceByTag(std::abs(ep->geo.Source)))
+ // if this face is a COPIED_ENTITY with source = region source face, this is
+ // the top. Exit.
+ if(ep && ep->geo.Mode == COPIED_ENTITY &&
+ reg_source == model->getFaceByTag(std::abs(ep->geo.Source)))
return 0;
- //
- // Now to prove the face is lateral, it must not be the "top" face. If
- // this face has replaced the region's original lateral through
- // ReplaceDuplicateSurfaces(), then the previous test for "topness" won't
- // have signaled an error. However, this face COULD still be in the top position.
- // So, check that the lateral shares AN edge (not the source edge, necessarily) with the
- // region's source face.
- // THEN, IF they share an edge, extrude all of the source GVertex positions and
- // see if they are found in this face. IF so, then it is a top and not a lateral.
+ //
+ // Now to prove the face is lateral, it must not be the "top" face. If
+ // this face has replaced the region's original lateral through
+ // ReplaceDuplicateSurfaces(), then the previous test for "topness" won't
+ // have signaled an error. However, this face COULD still be in the top
+ // position. So, check that the lateral shares AN edge (not the source edge,
+ // necessarily) with the region's source face. THEN, IF they share an edge,
+ // extrude all of the source GVertex positions and see if they are found in
+ // this face. IF so, then it is a top and not a lateral.
- std::vector<GEdge*> region_source_edges = reg_source->edges();
- std::vector<GEdge*> face_edges = face->edges();
- std::vector<GEdge*>::iterator ite = face_edges.begin();
+ std::vector<GEdge *> region_source_edges = reg_source->edges();
+ std::vector<GEdge *> face_edges = face->edges();
+ std::vector<GEdge *>::iterator ite = face_edges.begin();
bool edge_found = false;
int common_count = 0;
- //GEdge *common_edge = NULL;
- for( ite = region_source_edges.begin(); ite != region_source_edges.end(); ite++){
- if( std::find( face_edges.begin(), face_edges.end(), (*ite) )
- != face_edges.end() ){
+ // GEdge *common_edge = NULL;
+ for(ite = region_source_edges.begin(); ite != region_source_edges.end();
+ ite++) {
+ if(std::find(face_edges.begin(), face_edges.end(), (*ite)) !=
+ face_edges.end()) {
edge_found = true;
- //common_edge = (*ite);
+ // common_edge = (*ite);
common_count++;
- if( common_count > 1 )
- return 0;
+ if(common_count > 1) return 0;
}
}
- if( !edge_found )
+ if(!edge_found)
return 0;
- else if( reg_ep->geo.Type == ROTATE ||
- reg_ep->geo.Type == TRANSLATE_ROTATE ){
+ else if(reg_ep->geo.Type == ROTATE || reg_ep->geo.Type == TRANSLATE_ROTATE) {
// create lists of GVertex object for source face and present face
- std::vector<GVertex*> const& face_v = face->vertices();
- std::vector<GVertex*> const& source_v = reg_source->vertices();
- std::vector<GVertex*>::const_iterator itvs;
+ std::vector<GVertex *> const &face_v = face->vertices();
+ std::vector<GVertex *> const &source_v = reg_source->vertices();
+ std::vector<GVertex *>::const_iterator itvs;
double const tol = 1.00e-12;
- double const eps = std::abs( tol * CTX::instance()->lc );
+ double const eps = std::abs(tol * CTX::instance()->lc);
unsigned int j_top, k_top;
- j_top = reg_ep->mesh.NbLayer-1;
+ j_top = reg_ep->mesh.NbLayer - 1;
k_top = reg_ep->mesh.NbElmLayer[j_top];
bool found_all = true;
- for( itvs = source_v.begin(); itvs != source_v.end(); itvs++ ){
+ for(itvs = source_v.begin(); itvs != source_v.end(); itvs++) {
double x1 = (*itvs)->x(), y1 = (*itvs)->y(), z1 = (*itvs)->z();
- reg_ep->Extrude( j_top, k_top, x1, y1, z1 );
- std::vector<GVertex*>::const_iterator itvf;
+ reg_ep->Extrude(j_top, k_top, x1, y1, z1);
+ std::vector<GVertex *>::const_iterator itvf;
bool found_one = false;
- for( itvf = face_v.begin(); itvf != face_v.end(); itvf++ ){
+ for(itvf = face_v.begin(); itvf != face_v.end(); itvf++) {
double x2 = (*itvf)->x(), y2 = (*itvf)->y(), z2 = (*itvf)->z();
- if( fabs(x2-x1) <= eps && fabs(y2-y1) <= eps && fabs(z2-z1) <= eps ){
+ if(fabs(x2 - x1) <= eps && fabs(y2 - y1) <= eps &&
+ fabs(z2 - z1) <= eps) {
found_one = true;
break;
}
}
- if( !found_one ){
+ if(!found_one) {
found_all = false;
break;
}
}
// if surface is certainly the top
- if( found_all ){
+ if(found_all) {
return 0;
}
}
@@ -750,52 +769,45 @@ int IsSurfaceALateralForRegion(GRegion *region, GFace *face)
}
// Function to determine if a face is a top surface for a region. It returns 1
-// if the face is COPIED_ENTITY with source = region's source and if face belongs to region.
-// Otherwise, return 0 (NOTE: ReplaceDuplicateSurfaces() can remove a top surface
-// and replace it. If that happens, this will return 0. That is INTENDED for THIS function.
-// Added 2010-12-13
+// if the face is COPIED_ENTITY with source = region's source and if face
+// belongs to region. Otherwise, return 0 (NOTE: ReplaceDuplicateSurfaces() can
+// remove a top surface and replace it. If that happens, this will return 0.
+// That is INTENDED for THIS function. Added 2010-12-13
int IsSurfaceATopForRegion(GRegion *region, GFace *face)
{
// first make sure there is extrude info
- if( !region->meshAttributes.extrude || !face->meshAttributes.extrude )
- return 0;
+ if(!region->meshAttributes.extrude || !face->meshAttributes.extrude) return 0;
ExtrudeParams *reg_ep = region->meshAttributes.extrude;
ExtrudeParams *face_ep = face->meshAttributes.extrude;
GModel *model = face->model();
- GFace *reg_source = model->getFaceByTag(
- std::abs(reg_ep->geo.Source));
+ GFace *reg_source = model->getFaceByTag(std::abs(reg_ep->geo.Source));
- if( reg_ep->geo.Mode != EXTRUDED_ENTITY || !reg_source)
- return 0;
+ if(reg_ep->geo.Mode != EXTRUDED_ENTITY || !reg_source) return 0;
- if( face_ep->geo.Mode != COPIED_ENTITY || face == reg_source )
- return 0;
+ if(face_ep->geo.Mode != COPIED_ENTITY || face == reg_source) return 0;
- GFace *face_source = model->getFaceByTag(
- std::abs(face_ep->geo.Source));
+ GFace *face_source = model->getFaceByTag(std::abs(face_ep->geo.Source));
// whether face is a copy of region's source
- if( !reg_source || !face_source || reg_source != face_source )
- return 0;
+ if(!reg_source || !face_source || reg_source != face_source) return 0;
// of course, the face has to belong to the region!
std::vector<GFace *> region_faces = region->faces();
- if( std::find( region_faces.begin(), region_faces.end(), face) ==
- region_faces.end() )
+ if(std::find(region_faces.begin(), region_faces.end(), face) ==
+ region_faces.end())
return 0;
// if make it this far, return 1
return 1;
}
-
-// Find the bottom root source surface of an extruded surface (source of source of source, etc.)
-GFace* findRootSourceFaceForFace(GFace *face)
+// Find the bottom root source surface of an extruded surface (source of source
+// of source, etc.)
+GFace *findRootSourceFaceForFace(GFace *face)
{
-
ExtrudeParams *ep = face->meshAttributes.extrude;
- if( !(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == COPIED_ENTITY ) )
+ if(!(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == COPIED_ENTITY))
return face;
GFace *source_face;
@@ -803,41 +815,41 @@ GFace* findRootSourceFaceForFace(GFace *face)
int max_iter = model->getNumFaces();
int iter_counter = 0;
ExtrudeParams *ep_iter = ep;
- while( iter_counter <= max_iter ){
+ while(iter_counter <= max_iter) {
iter_counter++;
- source_face = model->getFaceByTag( std::abs(ep_iter->geo.Source) );
- if( !source_face ){
- Msg::Error("findRootSourceFaceForFace() could not find valid surface for tag %d.", ep->geo.Source );
- return (GFace*)(NULL);
+ source_face = model->getFaceByTag(std::abs(ep_iter->geo.Source));
+ if(!source_face) {
+ Msg::Error(
+ "findRootSourceFaceForFace() could not find valid surface for tag %d.",
+ ep->geo.Source);
+ return (GFace *)(NULL);
}
ep_iter = source_face->meshAttributes.extrude;
- if( !( ep_iter && ep_iter->mesh.ExtrudeMesh && ep_iter->geo.Mode == COPIED_ENTITY ) )
+ if(!(ep_iter && ep_iter->mesh.ExtrudeMesh &&
+ ep_iter->geo.Mode == COPIED_ENTITY))
return source_face;
}
Msg::Error("findRootSourceFaceForFace() failed to find root source.");
- return (GFace*)(NULL);
-
+ return (GFace *)(NULL);
}
-
// Input is vert_bnd[], which describes some 2D element: vert_bnd[i] is true if
// the ith vertex the element touches a lateral edge boundary of the surface the
// element is in.
// Output is touch_bnd[]: Each element of touch_bnd[] corresponds to an edge of
// the element described by vert_bnd[]. Edge i of touch_bnd[] is formed by
-// vertices i and (i+1)%element_size of the element. The value of touch_bnd[i] is non-zero
-// if that edge touches a boundary edge of the surface that the element is in.
-// Added 2011-03-10
-void fill_touch_bnd( int touch_bnd[], std::vector<bool> vert_bnd, int n_lat )
+// vertices i and (i+1)%element_size of the element. The value of touch_bnd[i]
+// is non-zero if that edge touches a boundary edge of the surface that the
+// element is in. Added 2011-03-10
+void fill_touch_bnd(int touch_bnd[], std::vector<bool> vert_bnd, int n_lat)
{
- for(int i = 0; i < n_lat; i++ )
- touch_bnd[i] = 0;
+ for(int i = 0; i < n_lat; i++) touch_bnd[i] = 0;
- for(int i = 0; i < n_lat; i++ ){
- if( vert_bnd[i] ){
+ for(int i = 0; i < n_lat; i++) {
+ if(vert_bnd[i]) {
touch_bnd[i] = 1;
- touch_bnd[(i+n_lat-1)%n_lat] = 1;
+ touch_bnd[(i + n_lat - 1) % n_lat] = 1;
}
}
}
diff --git a/Mesh/QuadTriUtils.h b/Mesh/QuadTriUtils.h
index 3df8845dca6f42a0e91536e2f0310fccaa2749d7..4ce4ec6c41bbb810d80c1c6d1275c96d86bda01e 100644
--- a/Mesh/QuadTriUtils.h
+++ b/Mesh/QuadTriUtils.h
@@ -4,20 +4,23 @@ QuadTriUtils.h
The code in this file was written by Dr. Trevor S. Strickler.
email: <trevor.strickler@gmail.com>
-This file is part of the QuadTri contribution to Gmsh. QuadTri allows the conformal interface
-of quadrangle faces to triangle faces using pyramids and other mesh elements.
+This file is part of the QuadTri contribution to Gmsh. QuadTri allows the
+conformal interface of quadrangle faces to triangle faces using pyramids and
+other mesh elements.
-See READMEQUADTRI.txt for more information. The license information is in LICENSE.txt.
+See READMEQUADTRI.txt for more information. The license information is in
+LICENSE.txt.
Trevor S. Strickler hereby transfers copyright of QuadTri files to
Christophe Geuzaine and J.-F. Remacle with the understanding that
his contribution shall be cited appropriately.
-All reused or original Gmsh code is Copyright (C) 1997-2018 C. Geuzaine, J.-F. Remacle
-Gmsh is available at: www.geuz.org/gmsh
+All reused or original Gmsh code is Copyright (C) 1997-2018 C. Geuzaine, J.-F.
+Remacle Gmsh is available at: www.geuz.org/gmsh
-For Gmsh license information, see the LICENSE.txt file for license information. Please report all
-Gmsh bugs and problems to the public mailing list <gmsh@onelab.info>.
+For Gmsh license information, see the LICENSE.txt file for license information.
+Please report all Gmsh bugs and problems to the public mailing list
+<gmsh@onelab.info>.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, Version 2,
@@ -59,66 +62,80 @@ GNU General Public License for more details.
#include <map>
#include <cmath>
-
-// CategorizedSourceElements: This is a data structure to hold categorized source element info for extruded regions.
-// In addition to the region and source face pointers, there are sets and a vector that are set by the constructor.
-// All containers except for the bool vectors contain indices to the source face's vectors of mesh elements:
+// CategorizedSourceElements: This is a data structure to hold categorized
+// source element info for extruded regions. In addition to the region and
+// source face pointers, there are sets and a vector that are set by the
+// constructor. All containers except for the bool vectors contain indices to
+// the source face's vectors of mesh elements:
//
-// three_bnd_pt_tri : triangle vector indices for triangles with three vertices on a surface boundary edge
-// four_bnd_pt_quad : quadrangle vector indices for quads with four vertices on a surface boundary edge
-// other_bnd_pt_tri, other_bnd_pt_quad : vector indices of the respective elements that have some
-// but not all vertices on a boundary edge.
-// internal_quad_touch_one_bnd_pt_quad : quad vector indices of quads that share a vertex with a
+// three_bnd_pt_tri : triangle vector indices for triangles with three vertices
+// on a surface boundary edge four_bnd_pt_quad : quadrangle vector indices for
+// quads with four vertices on a surface boundary edge other_bnd_pt_tri,
+// other_bnd_pt_quad : vector indices of the respective elements that have some
+// but not all vertices on a boundary
+// edge.
+// internal_quad_touch_one_bnd_pt_quad : quad vector indices of quads that share
+// a vertex with a
// one boundary point quad.
-// internal_tri_touch_one_bnd_pt_quad : triangle vector indices of triangles that share a vertex with a
+// internal_tri_touch_one_bnd_pt_quad : triangle vector indices of triangles
+// that share a vertex with a
// one boundary point quad.
-// two_pt_bnd_quad_touch_one_bnd_pt_quad : set of indices to quads with two points on a boundary that also touch quads
+// two_pt_bnd_quad_touch_one_bnd_pt_quad : set of indices to quads with two
+// points on a boundary that also touch quads
// with one point on a boundary.
-// internal_tri, internal_quad : The indices for the internal elements that don't touch a boundary...
-// NOTE: These DO include the internal_[tri,quad]_touch_one_bnd_pt_quad elements.
+// internal_tri, internal_quad : The indices for the internal elements that
+// don't touch a boundary...
+// NOTE: These DO include the
+// internal_[tri,quad]_touch_one_bnd_pt_quad
+// elements.
//
// The vectors:
//
-// tri_bool, quad_bool : These vectors hold bits to tell which vertices in which elements are on the boundary, OR
-// in the case of the [*]_touch_one_bnd_pt_quad elements, what vertex is the non-boundary 'pivot' vertex shared
-// with a quad having one point on a boundary (diagonals are drawn to the pivot vertex in the single layer quadToTri
-// method).
-// Format: In tri_bool, there are 4*(number of triangles) elements. Each source triangle of index i has
-// four consecutive bool in tri_bool, beginning at i*4. The first bool is true if the triangle touches an edge
-// boundary (or touches a one boundary point quad). The other bools correspond to triangle vertices, in order
-// of appearance in the triangle's own vertex vector, and are true if the corresponding vertex is on the boundary.
-// Everything about tri_bool applies to quad_bool, but there are 5 bool per quad, accessed starting at i*5.
+// tri_bool, quad_bool : These vectors hold bits to tell which vertices in which
+// elements are on the boundary, OR
+// in the case of the [*]_touch_one_bnd_pt_quad elements, what
+// vertex is the non-boundary 'pivot' vertex shared with a quad
+// having one point on a boundary (diagonals are drawn to the pivot
+// vertex in the single layer quadToTri method). Format: In
+// tri_bool, there are 4*(number of triangles) elements. Each source
+// triangle of index i has four consecutive bool in tri_bool,
+// beginning at i*4. The first bool is true if the triangle touches
+// an edge boundary (or touches a one boundary point quad). The
+// other bools correspond to triangle vertices, in order of
+// appearance in the triangle's own vertex vector, and are true if
+// the corresponding vertex is on the boundary. Everything about
+// tri_bool applies to quad_bool, but there are 5 bool per quad,
+// accessed starting at i*5.
//
-struct CategorizedSourceElements{
- public:
+struct CategorizedSourceElements {
+public:
GRegion *region;
GFace *source_face;
bool valid;
- std::set<unsigned int> three_bnd_pt_tri, four_bnd_pt_quad,
- other_bnd_tri, other_bnd_quad;
+ std::set<unsigned int> three_bnd_pt_tri, four_bnd_pt_quad, other_bnd_tri,
+ other_bnd_quad;
std::set<unsigned int> internal_tri_touch_one_bnd_pt_quad,
- internal_quad_touch_one_bnd_pt_quad,
- two_bnd_pt_quad_touch_one_bnd_pt_quad;
+ internal_quad_touch_one_bnd_pt_quad, two_bnd_pt_quad_touch_one_bnd_pt_quad;
std::set<unsigned int> internal_tri, internal_quad;
std::vector<bool> tri_bool, quad_bool;
// constructor
- CategorizedSourceElements( GRegion *gr );
+ CategorizedSourceElements(GRegion *gr);
};
-// this determines if a face is a non-lateral face in a structured toroidal volume extrusion with at
-// least one QuadToTri region...
+// this determines if a face is a non-lateral face in a structured toroidal
+// volume extrusion with at least one QuadToTri region...
int IsInToroidalQuadToTri(GFace *face);
// replace boundary quads in a source surface for toroidal quadtri extrusion
void ReplaceBndQuadsInFace(GFace *face);
-
// This is a member function for the element map in ExtrudeParams.
// This allows insertion of a whole vector at once.
/*void ExtrudeParams::
-ExtrusionElementMap::addExtrudedElemVector(MElement* source, std::vector<MElement*> *extrudedVector );
+ExtrusionElementMap::addExtrudedElemVector(MElement* source,
+std::vector<MElement*> *extrudedVector );
*/
// Insert all vertices on a region's source edge, including corners,
@@ -132,24 +149,24 @@ void QuadToTriInsertSourceEdgeVertices(GRegion *gr, MVertexRTree &pos_src_edge);
void QuadToTriInsertFaceEdgeVertices(GFace *face, MVertexRTree &pos_edges);
// Find centroid of vertices in vector v, return in vector
-std::vector<double> QtFindVertsCentroid(std::vector<MVertex*> v);
+std::vector<double> QtFindVertsCentroid(std::vector<MVertex *> v);
-// Add a new vertex at the centroid of a vector of vertices (this goes into a region
-// Added 2010-02-06
+// Add a new vertex at the centroid of a vector of vertices (this goes into a
+// region Added 2010-02-06
MVertex *QtMakeCentroidVertex(const std::vector<MVertex *> &v,
std::vector<MVertex *> *target, GEntity *entity,
MVertexRTree &pos);
// Finds the index of the lowest valued pointer in a vector of MVertex pointers
// Added 2011-03-10
-int getIndexForLowestVertexPointer(std::vector<MVertex*> v);
-
+int getIndexForLowestVertexPointer(std::vector<MVertex *> v);
// Given 4 verts on a face, find an existent diagonal, if any.
-// Two possible methods: If the 'index_guess' argument is the index of the correct triangle,
-// finding it is simple. If not, have to do a complete pedantic search.
-// Added 2010-01-26
-std::pair<int, int> FindDiagonalEdgeIndices(std::vector<MVertex*> verts, GFace *face, bool lateral,
+// Two possible methods: If the 'index_guess' argument is the index of the
+// correct triangle, finding it is simple. If not, have to do a complete
+// pedantic search. Added 2010-01-26
+std::pair<int, int> FindDiagonalEdgeIndices(std::vector<MVertex *> verts,
+ GFace *face, bool lateral,
unsigned int index_guess = 0);
// Get number of regions neighboring a face
@@ -159,28 +176,25 @@ int GetNeighborRegionsOfFace(GFace *face, std::vector<GRegion *> &neighbors);
// Added 12/09/10
int IsSurfaceALateralForRegion(GRegion *region, GFace *face);
-
// Function to determine if a face is a top surface for a region. It returns 1
-// if the face is COPIED_ENTITY with source = region's source and if face belongs to region.
-// Otherwise, return 0 (NOTE: ReplaceDuplicateSurfaces() can remove a top surface
-// and replace it. If that happens, this will return 0. That is INTENDED for THIS function.
-// Added 2010-12-13
+// if the face is COPIED_ENTITY with source = region's source and if face
+// belongs to region. Otherwise, return 0 (NOTE: ReplaceDuplicateSurfaces() can
+// remove a top surface and replace it. If that happens, this will return 0.
+// That is INTENDED for THIS function. Added 2010-12-13
int IsSurfaceATopForRegion(GRegion *region, GFace *face);
-
-// Find the bottom root source surface of an extruded surface (source of source of source, etc.)
-GFace* findRootSourceFaceForFace(GFace *face);
-
+// Find the bottom root source surface of an extruded surface (source of source
+// of source, etc.)
+GFace *findRootSourceFaceForFace(GFace *face);
// Input is vert_bnd[], which describes some 2D element: vert_bnd[i] is true if
// the ith vertex the element touches a lateral edge boundary of the surface the
// element is in.
// Output is touch_bnd[]: Each element of touch_bnd[] corresponds to an edge of
// the element described by vert_bnd[]. Edge i of touch_bnd[] is formed by
-// vertices i and (i+1)%element_size of the element. The value of touch_bnd[i] is non-zero
-// if that edge touches a boundary edge of the surface that the element is in.
-// Added 2011-03-10
-void fill_touch_bnd( int touch_bnd[], std::vector<bool> vert_bnd, int n_lat );
-
+// vertices i and (i+1)%element_size of the element. The value of touch_bnd[i]
+// is non-zero if that edge touches a boundary edge of the surface that the
+// element is in. Added 2011-03-10
+void fill_touch_bnd(int touch_bnd[], std::vector<bool> vert_bnd, int n_lat);
#endif
diff --git a/Mesh/ThinLayer.cpp b/Mesh/ThinLayer.cpp
index 3750033242f730dae87904157091aee1fd75cba5..89db87e9f917de5b9a366b568c09125ca8026f16 100644
--- a/Mesh/ThinLayer.cpp
+++ b/Mesh/ThinLayer.cpp
@@ -10,119 +10,85 @@
#include "robustPredicates.h"
#include "GRegion.h"
-std::map<MVertex*,std::vector<MTetrahedron*> > ThinLayer::VertexToTets;
-std::map<MTetrahedron*,MTet4*> ThinLayer::TetToTet4;
-std::map<MVertex*,std::vector<CorrespVertices*> > ThinLayer::VertexToCorresp;
-std::vector<std::vector<CorrespVertices*> > ThinLayer::vecOfThinSheets;
+std::map<MVertex *, std::vector<MTetrahedron *> > ThinLayer::VertexToTets;
+std::map<MTetrahedron *, MTet4 *> ThinLayer::TetToTet4;
+std::map<MVertex *, std::vector<CorrespVertices *> > ThinLayer::VertexToCorresp;
+std::vector<std::vector<CorrespVertices *> > ThinLayer::vecOfThinSheets;
const double ThinLayer::epsilon = 0.00001;
const double ThinLayer::angleMax = 0.9;
const double ThinLayer::distP2PMax = 0.3;
-CorrespVertices::CorrespVertices(){}
-CorrespVertices::~CorrespVertices(){}
-void CorrespVertices::setStartPoint(MVertex* v){
- this->StartPoint = v;
-}
+CorrespVertices::CorrespVertices() {}
+CorrespVertices::~CorrespVertices() {}
+void CorrespVertices::setStartPoint(MVertex *v) { this->StartPoint = v; }
void CorrespVertices::setEndPoint(const SPoint3 &p) { this->EndPoint = p; }
void CorrespVertices::setStartNormal(const SVector3 &v)
{
this->StartNormal = v;
}
void CorrespVertices::setEndNormal(const SVector3 &v) { this->EndNormal = v; }
-void CorrespVertices::setEndTriangle(faceXtet f){
- this->EndTriangle = f;
-}
-void CorrespVertices::setdistP2P(double d){
- this->distP2P = d;
-}
-void CorrespVertices::setangleProd(double a){
- this->angleProd = a;
-}
-void CorrespVertices::setActive(bool b){
- this->Active = b;
-}
-void CorrespVertices::setEndTriangleActive(bool b){
+void CorrespVertices::setEndTriangle(faceXtet f) { this->EndTriangle = f; }
+void CorrespVertices::setdistP2P(double d) { this->distP2P = d; }
+void CorrespVertices::setangleProd(double a) { this->angleProd = a; }
+void CorrespVertices::setActive(bool b) { this->Active = b; }
+void CorrespVertices::setEndTriangleActive(bool b)
+{
this->EndTriangleActive = b;
}
-void CorrespVertices::setIsMaster(bool b){
- this->IsMaster = b;
-}
-void CorrespVertices::setTagMaster(int i){
- this->tagMaster = i;
-}
-MVertex* CorrespVertices::getStartPoint(){
- return StartPoint;
-}
-SPoint3 CorrespVertices::getEndPoint(){
- return EndPoint;
-}
-SVector3 CorrespVertices::getStartNormal(){
- return StartNormal;
-}
-SVector3 CorrespVertices::getEndNormal(){
- return EndNormal;
-}
-faceXtet CorrespVertices::getEndTriangle(){
- return EndTriangle;
-}
-double CorrespVertices::getdistP2P(){
- return distP2P;
-}
-double CorrespVertices::getangleProd(){
- return angleProd;
-}
-bool CorrespVertices::getActive(){
- return Active;
-}
-bool CorrespVertices::getEndTriangleActive(){
- return EndTriangleActive;
-}
-bool CorrespVertices::getIsMaster(){
- return IsMaster;
-}
-int CorrespVertices::getTagMaster(){
- return tagMaster;
-}
+void CorrespVertices::setIsMaster(bool b) { this->IsMaster = b; }
+void CorrespVertices::setTagMaster(int i) { this->tagMaster = i; }
+MVertex *CorrespVertices::getStartPoint() { return StartPoint; }
+SPoint3 CorrespVertices::getEndPoint() { return EndPoint; }
+SVector3 CorrespVertices::getStartNormal() { return StartNormal; }
+SVector3 CorrespVertices::getEndNormal() { return EndNormal; }
+faceXtet CorrespVertices::getEndTriangle() { return EndTriangle; }
+double CorrespVertices::getdistP2P() { return distP2P; }
+double CorrespVertices::getangleProd() { return angleProd; }
+bool CorrespVertices::getActive() { return Active; }
+bool CorrespVertices::getEndTriangleActive() { return EndTriangleActive; }
+bool CorrespVertices::getIsMaster() { return IsMaster; }
+int CorrespVertices::getTagMaster() { return tagMaster; }
-ThinLayer::ThinLayer(){}
+ThinLayer::ThinLayer() {}
-ThinLayer::~ThinLayer(){}
+ThinLayer::~ThinLayer() {}
void ThinLayer::perform()
{
ThinLayer::fillVertexToTets();
ThinLayer::fillTetToTet4();
- std::map<MVertex*,double> AllDist = ThinLayer::computeAllDistToOppSide();
+ std::map<MVertex *, double> AllDist = ThinLayer::computeAllDistToOppSide();
ThinLayer::checkOppositeTriangles();
ThinLayer::fillvecOfThinSheets();
- std::set<MVertex*> constr_vertices;
+ std::set<MVertex *> constr_vertices;
}
void ThinLayer::checkOppositeTriangles()
{
- //all endTriangle will be set to active or not
- for (std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it1 =
- VertexToCorresp.begin();it1 != VertexToCorresp.end();it1++){
- std::vector<CorrespVertices*> vecCorr = (*it1).second;
- for (unsigned int i = 0;i < vecCorr.size();i++){
- CorrespVertices* currentCorr = vecCorr[i];
+ // all endTriangle will be set to active or not
+ for(std::map<MVertex *, std::vector<CorrespVertices *> >::iterator it1 =
+ VertexToCorresp.begin();
+ it1 != VertexToCorresp.end(); it1++) {
+ std::vector<CorrespVertices *> vecCorr = (*it1).second;
+ for(unsigned int i = 0; i < vecCorr.size(); i++) {
+ CorrespVertices *currentCorr = vecCorr[i];
faceXtet currentEndTri = currentCorr->getEndTriangle();
- MVertex* endP0 = currentEndTri.v[0];
- MVertex* endP1 = currentEndTri.v[1];
- MVertex* endP2 = currentEndTri.v[2];
- std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it2 =
+ MVertex *endP0 = currentEndTri.v[0];
+ MVertex *endP1 = currentEndTri.v[1];
+ MVertex *endP2 = currentEndTri.v[2];
+ std::map<MVertex *, std::vector<CorrespVertices *> >::iterator it2 =
VertexToCorresp.find(endP0);
- std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it3 =
+ std::map<MVertex *, std::vector<CorrespVertices *> >::iterator it3 =
VertexToCorresp.find(endP1);
- std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it4 =
+ std::map<MVertex *, std::vector<CorrespVertices *> >::iterator it4 =
VertexToCorresp.find(endP2);
(*it1).second[i]->setEndTriangleActive(false);
- if (it2 != VertexToCorresp.end()){
- if (it3 != VertexToCorresp.end()){
- if (it4 != VertexToCorresp.end()){
- if ((*it2).second[0]->getActive()){
- if ((*it3).second[0]->getActive()){
- if ((*it4).second[0]->getActive()){
+ if(it2 != VertexToCorresp.end()) {
+ if(it3 != VertexToCorresp.end()) {
+ if(it4 != VertexToCorresp.end()) {
+ if((*it2).second[0]->getActive()) {
+ if((*it3).second[0]->getActive()) {
+ if((*it4).second[0]->getActive()) {
(*it1).second[i]->setEndTriangleActive(true);
}
}
@@ -134,60 +100,64 @@ void ThinLayer::checkOppositeTriangles()
}
}
-void ThinLayer::fillvecOfThinSheets(){
- for (std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it1 =
- VertexToCorresp.begin();it1 != VertexToCorresp.end();it1++){
- std::vector<CorrespVertices*> vecCorr = (*it1).second;
- for (unsigned int i = 0;i < vecCorr.size();i++){
- CorrespVertices* currentCorr = vecCorr[i];
- if ((currentCorr->getStartPoint()->onWhat()->dim() == 2) &&
- (currentCorr->getActive()) && (currentCorr->getEndTriangleActive()) &&
- (currentCorr->getTagMaster() == (-2))){
- //Found the first node of a new master sheet
- std::vector<CorrespVertices*> MasterSheet;
+void ThinLayer::fillvecOfThinSheets()
+{
+ for(std::map<MVertex *, std::vector<CorrespVertices *> >::iterator it1 =
+ VertexToCorresp.begin();
+ it1 != VertexToCorresp.end(); it1++) {
+ std::vector<CorrespVertices *> vecCorr = (*it1).second;
+ for(unsigned int i = 0; i < vecCorr.size(); i++) {
+ CorrespVertices *currentCorr = vecCorr[i];
+ if((currentCorr->getStartPoint()->onWhat()->dim() == 2) &&
+ (currentCorr->getActive()) && (currentCorr->getEndTriangleActive()) &&
+ (currentCorr->getTagMaster() == (-2))) {
+ // Found the first node of a new master sheet
+ std::vector<CorrespVertices *> MasterSheet;
MasterSheet.clear();
(*it1).second[i]->setTagMaster(-1);
faceXtet faceEndSlave = (*it1).second[i]->getEndTriangle();
- for (unsigned int j = 0;j < 3;j++){
- std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it2 =
+ for(unsigned int j = 0; j < 3; j++) {
+ std::map<MVertex *, std::vector<CorrespVertices *> >::iterator it2 =
VertexToCorresp.find(faceEndSlave.v[j]);
- if (it2 != VertexToCorresp.end()){
- if (faceEndSlave.v[j]->onWhat()->dim() == 2){
- (*it2).second[0]->setTagMaster
- ((*it1).second[i]->getStartPoint()->onWhat()->tag());
+ if(it2 != VertexToCorresp.end()) {
+ if(faceEndSlave.v[j]->onWhat()->dim() == 2) {
+ (*it2).second[0]->setTagMaster(
+ (*it1).second[i]->getStartPoint()->onWhat()->tag());
}
}
}
MasterSheet.push_back((*it1).second[i]);
- std::set<MVertex*> CurrentSheet;
+ std::set<MVertex *> CurrentSheet;
CurrentSheet.clear();
CurrentSheet.insert((*it1).second[i]->getStartPoint());
- while (CurrentSheet.size() != 0){
- MVertex* VToDo = (*CurrentSheet.begin());
- std::vector<MTetrahedron*> surroundingTet = VertexToTets[VToDo];
- for (unsigned int j = 0;j < surroundingTet.size();j++){
- for (std::size_t k = 0;k < surroundingTet[j]->getNumVertices();k++){
- MVertex* ToInsertTmp = surroundingTet[j]->getVertex(k);
- std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it2 =
- VertexToCorresp.find(ToInsertTmp);
- if (ToInsertTmp->onWhat()->tag() == VToDo->onWhat()->tag()){
- //TODO: OR that onwhat -> dim <, for edges
- if (it2 != VertexToCorresp.end()){
- CorrespVertices* correspToInsert = ((*it2).second)[0];
- if ((correspToInsert->getStartPoint()->onWhat()->dim() == 2) &&
- (correspToInsert->getActive()) &&
- (correspToInsert->getEndTriangleActive()) &&
- (correspToInsert->getTagMaster() == (-2))){
+ while(CurrentSheet.size() != 0) {
+ MVertex *VToDo = (*CurrentSheet.begin());
+ std::vector<MTetrahedron *> surroundingTet = VertexToTets[VToDo];
+ for(unsigned int j = 0; j < surroundingTet.size(); j++) {
+ for(std::size_t k = 0; k < surroundingTet[j]->getNumVertices();
+ k++) {
+ MVertex *ToInsertTmp = surroundingTet[j]->getVertex(k);
+ std::map<MVertex *, std::vector<CorrespVertices *> >::iterator
+ it2 = VertexToCorresp.find(ToInsertTmp);
+ if(ToInsertTmp->onWhat()->tag() == VToDo->onWhat()->tag()) {
+ // TODO: OR that onwhat -> dim <, for edges
+ if(it2 != VertexToCorresp.end()) {
+ CorrespVertices *correspToInsert = ((*it2).second)[0];
+ if((correspToInsert->getStartPoint()->onWhat()->dim() == 2) &&
+ (correspToInsert->getActive()) &&
+ (correspToInsert->getEndTriangleActive()) &&
+ (correspToInsert->getTagMaster() == (-2))) {
MasterSheet.push_back((*it2).second[0]);
(*it2).second[0]->setTagMaster(-1);
faceXtet faceEndSlave2 = (*it2).second[0]->getEndTriangle();
- for (unsigned int j = 0;j < 3;j++){
- std::map<MVertex*,std::vector<CorrespVertices*> >::iterator it3 =
+ for(unsigned int j = 0; j < 3; j++) {
+ std::map<MVertex *,
+ std::vector<CorrespVertices *> >::iterator it3 =
VertexToCorresp.find(faceEndSlave2.v[j]);
- if (it3 != VertexToCorresp.end()){
- if (faceEndSlave2.v[j]->onWhat()->dim() == 2){
- (*it3).second[0]->setTagMaster
- ((*it2).second[i]->getStartPoint()->onWhat()->tag());
+ if(it3 != VertexToCorresp.end()) {
+ if(faceEndSlave2.v[j]->onWhat()->dim() == 2) {
+ (*it3).second[0]->setTagMaster(
+ (*it2).second[i]->getStartPoint()->onWhat()->tag());
}
}
}
@@ -205,25 +175,25 @@ void ThinLayer::fillvecOfThinSheets(){
}
}
-std::map<MVertex*,double> ThinLayer::computeAllDistToOppSide()
+std::map<MVertex *, double> ThinLayer::computeAllDistToOppSide()
{
- std::map<MVertex*,double> AllDistToOppSide;
+ std::map<MVertex *, double> AllDistToOppSide;
GModel *m = GModel::current();
// std::vector<MElement*> crackElements;
- std::set<MVertex*> BoundaryVertices;
+ std::set<MVertex *> BoundaryVertices;
- for (GModel::riter itr= m->firstRegion();itr != m->lastRegion();itr++){
- GRegion* rTmp = (*itr);
- for(unsigned int i = 0; i < rTmp->tetrahedra.size(); i++){
- MTet4* tet4Tmp = TetToTet4[rTmp->tetrahedra[i]];
- for (unsigned int j = 0;j < 4;j++){
- if (tet4Tmp->getNeigh(j) == 0){
- //find the 4th point,and fill the two vector of the boundary triangle
- faceXtet fxtTmp(tet4Tmp,j);
- for (int k = 0;k < 3;k++){
- MVertex* toTest = fxtTmp.v[k];
- if (toTest->onWhat()->dim() == 2){
- if(BoundaryVertices.find(toTest) == BoundaryVertices.end()){
+ for(GModel::riter itr = m->firstRegion(); itr != m->lastRegion(); itr++) {
+ GRegion *rTmp = (*itr);
+ for(unsigned int i = 0; i < rTmp->tetrahedra.size(); i++) {
+ MTet4 *tet4Tmp = TetToTet4[rTmp->tetrahedra[i]];
+ for(unsigned int j = 0; j < 4; j++) {
+ if(tet4Tmp->getNeigh(j) == 0) {
+ // find the 4th point,and fill the two vector of the boundary triangle
+ faceXtet fxtTmp(tet4Tmp, j);
+ for(int k = 0; k < 3; k++) {
+ MVertex *toTest = fxtTmp.v[k];
+ if(toTest->onWhat()->dim() == 2) {
+ if(BoundaryVertices.find(toTest) == BoundaryVertices.end()) {
BoundaryVertices.insert(toTest);
}
}
@@ -233,9 +203,9 @@ std::map<MVertex*,double> ThinLayer::computeAllDistToOppSide()
}
}
}
- for(std::set<MVertex*>::iterator it = BoundaryVertices.begin();
- it != BoundaryVertices.end(); it++){
- MVertex* toCompute = (*it);
+ for(std::set<MVertex *>::iterator it = BoundaryVertices.begin();
+ it != BoundaryVertices.end(); it++) {
+ MVertex *toCompute = (*it);
double resultTmp = computeDistToOppSide(toCompute);
AllDistToOppSide[toCompute] = resultTmp;
}
@@ -243,52 +213,55 @@ std::map<MVertex*,double> ThinLayer::computeAllDistToOppSide()
return AllDistToOppSide;
}
-double ThinLayer::computeDistToOppSide(MVertex* v)
+double ThinLayer::computeDistToOppSide(MVertex *v)
{
double DistToOppSide = 0.;
- //We assume v is on the boundary
- //First we need to get the internal normal
+ // We assume v is on the boundary
+ // First we need to get the internal normal
SVector3 InteriorNormal = ThinLayer::computeInteriorNormal(v);
- //Then we find the first triangle
- MTet4* FirstTet = ThinLayer::getTetFromPoint(v,InteriorNormal);
- MTet4* CurrentTet = FirstTet;
- MTet4* PastTet = FirstTet;
- SPoint3 CurrentPos = SPoint3(v->x(),v->y(),v->z());
+ // Then we find the first triangle
+ MTet4 *FirstTet = ThinLayer::getTetFromPoint(v, InteriorNormal);
+ MTet4 *CurrentTet = FirstTet;
+ MTet4 *PastTet = FirstTet;
+ SPoint3 CurrentPos = SPoint3(v->x(), v->y(), v->z());
SPoint3 LastPos = CurrentPos;
- int* CurrentTri = 0;
+ int *CurrentTri = 0;
CorrespVertices CVTemp;
CVTemp.setStartPoint(v);
CVTemp.setStartNormal(InteriorNormal);
- FindNewPoint((&CurrentPos),CurrentTri,CurrentTet,InteriorNormal);
- faceXtet fxtCV(CurrentTet,(*CurrentTri));
+ FindNewPoint((&CurrentPos), CurrentTri, CurrentTet, InteriorNormal);
+ faceXtet fxtCV(CurrentTet, (*CurrentTri));
// while(CurrentTet->getNeigh((*CurrentTri)) != 0){
- while(CurrentTet != 0){
+ while(CurrentTet != 0) {
PastTet = CurrentTet;
- faceXtet fxtCVtmp(PastTet,(*CurrentTri));
- FindNewPoint((&CurrentPos),CurrentTri,CurrentTet,InteriorNormal);
+ faceXtet fxtCVtmp(PastTet, (*CurrentTri));
+ FindNewPoint((&CurrentPos), CurrentTri, CurrentTet, InteriorNormal);
CurrentTet = CurrentTet->getNeigh((*CurrentTri));
DistToOppSide += CurrentPos.distance(LastPos);
LastPos = CurrentPos;
}
CVTemp.setEndPoint(LastPos);
CVTemp.setEndTriangle(fxtCV);
- SVector3 EndDir1(fxtCV.v[1]->x() - fxtCV.v[0]->x(),fxtCV.v[1]->y() -
- fxtCV.v[0]->y(),fxtCV.v[1]->z() - fxtCV.v[0]->z());
- SVector3 EndDir2(fxtCV.v[2]->x() - fxtCV.v[0]->x(),fxtCV.v[2]->y() -
- fxtCV.v[0]->y(),fxtCV.v[2]->z() - fxtCV.v[0]->z());
+ SVector3 EndDir1(fxtCV.v[1]->x() - fxtCV.v[0]->x(),
+ fxtCV.v[1]->y() - fxtCV.v[0]->y(),
+ fxtCV.v[1]->z() - fxtCV.v[0]->z());
+ SVector3 EndDir2(fxtCV.v[2]->x() - fxtCV.v[0]->x(),
+ fxtCV.v[2]->y() - fxtCV.v[0]->y(),
+ fxtCV.v[2]->z() - fxtCV.v[0]->z());
SVector3 EndNormal(EndDir1.y() * EndDir2.z() - EndDir1.z() * EndDir2.y(),
EndDir1.z() * EndDir2.x() - EndDir1.x() * EndDir2.z(),
EndDir1.x() * EndDir2.y() - EndDir1.y() * EndDir2.x());
EndNormal.normalize();
CVTemp.setEndNormal(EndNormal);
- CVTemp.setangleProd(fabs(CVTemp.getStartNormal().x() * CVTemp.getEndNormal().x() +
- CVTemp.getStartNormal().y() * CVTemp.getEndNormal().y() +
- CVTemp.getStartNormal().z() * CVTemp.getEndNormal().z()));
+ CVTemp.setangleProd(
+ fabs(CVTemp.getStartNormal().x() * CVTemp.getEndNormal().x() +
+ CVTemp.getStartNormal().y() * CVTemp.getEndNormal().y() +
+ CVTemp.getStartNormal().z() * CVTemp.getEndNormal().z()));
CVTemp.setdistP2P(DistToOppSide);
- if ((CVTemp.getangleProd() > angleMax) &&(CVTemp.getdistP2P() < distP2PMax)){
+ if((CVTemp.getangleProd() > angleMax) && (CVTemp.getdistP2P() < distP2PMax)) {
CVTemp.setActive(true);
}
- else{
+ else {
CVTemp.setActive(false);
}
CVTemp.setTagMaster(-2);
@@ -296,90 +269,92 @@ double ThinLayer::computeDistToOppSide(MVertex* v)
return DistToOppSide;
}
-SVector3 ThinLayer::computeInteriorNormal(MVertex* v)
+SVector3 ThinLayer::computeInteriorNormal(MVertex *v)
{
- SPoint3 InteriorNormal(0.0,0.0,0.0);
- std::vector<MTetrahedron*> currentVecTet = VertexToTets[v];
+ SPoint3 InteriorNormal(0.0, 0.0, 0.0);
+ std::vector<MTetrahedron *> currentVecTet = VertexToTets[v];
std::vector<SPoint3> vecInteriorNodes;
std::vector<SPoint3> vecFirstDir;
std::vector<SPoint3> vecSecondDir;
- for (unsigned int i = 0;i < currentVecTet.size();i++){
- MTet4* tet4Tmp = TetToTet4[currentVecTet[i]];
- for (int j = 0;j < 4 ; j++){
- if (tet4Tmp->getNeigh(j) == 0){
- //find the 4th point,and fill the two vector of the boundary triangle
- faceXtet fxtTmp(tet4Tmp,j);
- for (int k = 0;k < 4;k++){
+ for(unsigned int i = 0; i < currentVecTet.size(); i++) {
+ MTet4 *tet4Tmp = TetToTet4[currentVecTet[i]];
+ for(int j = 0; j < 4; j++) {
+ if(tet4Tmp->getNeigh(j) == 0) {
+ // find the 4th point,and fill the two vector of the boundary triangle
+ faceXtet fxtTmp(tet4Tmp, j);
+ for(int k = 0; k < 4; k++) {
bool foundInteriorPoint = true;
- for (int l = 0;l < 3;l++){
- if (tet4Tmp->tet()->getVertex(k) == fxtTmp.v[l]){
+ for(int l = 0; l < 3; l++) {
+ if(tet4Tmp->tet()->getVertex(k) == fxtTmp.v[l]) {
foundInteriorPoint = false;
}
}
- if (foundInteriorPoint){
+ if(foundInteriorPoint) {
SPoint3 pointTmp(tet4Tmp->tet()->getVertex(k)->x(),
tet4Tmp->tet()->getVertex(k)->y(),
tet4Tmp->tet()->getVertex(k)->z());
vecInteriorNodes.push_back(pointTmp);
}
}
- SPoint3 pointTmp1(fxtTmp.v[1]->x() - fxtTmp.v[0]->x(),fxtTmp.v[1]->y() -
- fxtTmp.v[0]->y(),fxtTmp.v[1]->z() - fxtTmp.v[0]->z());
- SPoint3 pointTmp2(fxtTmp.v[2]->x() - fxtTmp.v[0]->x(),fxtTmp.v[2]->y() -
- fxtTmp.v[0]->y(),fxtTmp.v[2]->z() - fxtTmp.v[0]->z());
+ SPoint3 pointTmp1(fxtTmp.v[1]->x() - fxtTmp.v[0]->x(),
+ fxtTmp.v[1]->y() - fxtTmp.v[0]->y(),
+ fxtTmp.v[1]->z() - fxtTmp.v[0]->z());
+ SPoint3 pointTmp2(fxtTmp.v[2]->x() - fxtTmp.v[0]->x(),
+ fxtTmp.v[2]->y() - fxtTmp.v[0]->y(),
+ fxtTmp.v[2]->z() - fxtTmp.v[0]->z());
vecFirstDir.push_back(pointTmp1);
vecSecondDir.push_back(pointTmp2);
}
}
}
- //at this point we have all the info necessary.
- SPoint3 pointInteriorAverage(0.0,0.0,0.0);
- for (unsigned int i = 0;i < vecInteriorNodes.size();i++){
- pointInteriorAverage += SPoint3(vecInteriorNodes[i].x(),
- vecInteriorNodes[i].y(),
- vecInteriorNodes[i].z());
+ // at this point we have all the info necessary.
+ SPoint3 pointInteriorAverage(0.0, 0.0, 0.0);
+ for(unsigned int i = 0; i < vecInteriorNodes.size(); i++) {
+ pointInteriorAverage +=
+ SPoint3(vecInteriorNodes[i].x(), vecInteriorNodes[i].y(),
+ vecInteriorNodes[i].z());
// pointInteriorAverage.x() += vecInteriorNodes[i].x();
// pointInteriorAverage.y() += vecInteriorNodes[i].y();
// pointInteriorAverage.z() += vecInteriorNodes[i].z();
}
- pointInteriorAverage = SPoint3(pointInteriorAverage.x() /
- (double(vecInteriorNodes.size())),
- pointInteriorAverage.y() /
- (double(vecInteriorNodes.size())),
- pointInteriorAverage.z() /
- (double(vecInteriorNodes.size())));
- // pointInteriorAverage.x() = pointInteriorAverage.x() / (double(vecInteriorNodes.size()));
- // pointInteriorAverage.y() = pointInteriorAverage.y() / (double(vecInteriorNodes.size()));
- // pointInteriorAverage.z() = pointInteriorAverage.z() / (double(vecInteriorNodes.size()));
+ pointInteriorAverage =
+ SPoint3(pointInteriorAverage.x() / (double(vecInteriorNodes.size())),
+ pointInteriorAverage.y() / (double(vecInteriorNodes.size())),
+ pointInteriorAverage.z() / (double(vecInteriorNodes.size())));
+ // pointInteriorAverage.x() = pointInteriorAverage.x() /
+ // (double(vecInteriorNodes.size())); pointInteriorAverage.y() =
+ // pointInteriorAverage.y() / (double(vecInteriorNodes.size()));
+ // pointInteriorAverage.z() = pointInteriorAverage.z() /
+ // (double(vecInteriorNodes.size()));
SPoint3 dirInteriorAverage(pointInteriorAverage.x() - v->x(),
pointInteriorAverage.y() - v->y(),
pointInteriorAverage.z() - v->z());
double norme = sqrt(dirInteriorAverage.x() * dirInteriorAverage.x() +
dirInteriorAverage.y() * dirInteriorAverage.y() +
dirInteriorAverage.z() * dirInteriorAverage.z());
- dirInteriorAverage = SPoint3(dirInteriorAverage.x() / norme,
- dirInteriorAverage.y() / norme,
- dirInteriorAverage.z() / norme);
+ dirInteriorAverage =
+ SPoint3(dirInteriorAverage.x() / norme, dirInteriorAverage.y() / norme,
+ dirInteriorAverage.z() / norme);
// dirInteriorAverage.x() = dirInteriorAverage.x() / norme;
// dirInteriorAverage.y() = dirInteriorAverage.y() / norme;
// dirInteriorAverage.z() = dirInteriorAverage.z() / norme;
std::vector<SPoint3> vecOrthogDir;
- for(unsigned int i = 0;i < vecFirstDir.size();i++){
+ for(unsigned int i = 0; i < vecFirstDir.size(); i++) {
SPoint3 pointTmp(vecFirstDir[i].y() * vecSecondDir[i].z() -
- vecFirstDir[i].z() * vecSecondDir[i].y(),
+ vecFirstDir[i].z() * vecSecondDir[i].y(),
vecFirstDir[i].z() * vecSecondDir[i].x() -
- vecFirstDir[i].x() * vecSecondDir[i].z(),
+ vecFirstDir[i].x() * vecSecondDir[i].z(),
vecFirstDir[i].x() * vecSecondDir[i].y() -
- vecFirstDir[i].y() * vecSecondDir[i].x());
+ vecFirstDir[i].y() * vecSecondDir[i].x());
vecOrthogDir.push_back(pointTmp);
}
- for(unsigned int i = 0;i < vecOrthogDir.size();i++){
+ for(unsigned int i = 0; i < vecOrthogDir.size(); i++) {
double prodScalTmp = vecOrthogDir[i].x() * dirInteriorAverage.x() +
- vecOrthogDir[i].y() * dirInteriorAverage.y() +
- vecOrthogDir[i].z() * dirInteriorAverage.z();
- if (prodScalTmp < 0.0){
- vecOrthogDir[i] = SPoint3(- vecOrthogDir[i].x(),- vecOrthogDir[i].y(),
- - vecOrthogDir[i].z());
+ vecOrthogDir[i].y() * dirInteriorAverage.y() +
+ vecOrthogDir[i].z() * dirInteriorAverage.z();
+ if(prodScalTmp < 0.0) {
+ vecOrthogDir[i] = SPoint3(-vecOrthogDir[i].x(), -vecOrthogDir[i].y(),
+ -vecOrthogDir[i].z());
// vecOrthogDir[i].x() = - vecOrthogDir[i].x();
// vecOrthogDir[i].y() = - vecOrthogDir[i].y();
// vecOrthogDir[i].z() = - vecOrthogDir[i].z();
@@ -387,13 +362,14 @@ SVector3 ThinLayer::computeInteriorNormal(MVertex* v)
double normeTmp = sqrt(vecOrthogDir[i].x() * vecOrthogDir[i].x() +
vecOrthogDir[i].y() * vecOrthogDir[i].y() +
vecOrthogDir[i].z() * vecOrthogDir[i].z());
- vecOrthogDir[i] = SPoint3(vecOrthogDir[i].x() / normeTmp,
- vecOrthogDir[i].y() / normeTmp,
- vecOrthogDir[i].z() / normeTmp);
+ vecOrthogDir[i] =
+ SPoint3(vecOrthogDir[i].x() / normeTmp, vecOrthogDir[i].y() / normeTmp,
+ vecOrthogDir[i].z() / normeTmp);
// vecOrthogDir[i].x() = vecOrthogDir[i].x() / normeTmp;
// vecOrthogDir[i].y() = vecOrthogDir[i].y() / normeTmp;
// vecOrthogDir[i].z() = vecOrthogDir[i].z() / normeTmp;
- InteriorNormal += SPoint3(vecOrthogDir[i].x(),vecOrthogDir[i].y(),vecOrthogDir[i].z());
+ InteriorNormal +=
+ SPoint3(vecOrthogDir[i].x(), vecOrthogDir[i].y(), vecOrthogDir[i].z());
// InteriorNormal.x() += vecOrthogDir[i].x();
// InteriorNormal.y() += vecOrthogDir[i].y();
// InteriorNormal.z() += vecOrthogDir[i].z();
@@ -401,9 +377,9 @@ SVector3 ThinLayer::computeInteriorNormal(MVertex* v)
norme = sqrt(InteriorNormal.x() * InteriorNormal.x() +
InteriorNormal.y() * InteriorNormal.y() +
InteriorNormal.z() * InteriorNormal.z());
- InteriorNormal = SPoint3(InteriorNormal.x() / norme,
- InteriorNormal.y() / norme,
- InteriorNormal.z() / norme);
+ InteriorNormal =
+ SPoint3(InteriorNormal.x() / norme, InteriorNormal.y() / norme,
+ InteriorNormal.z() / norme);
// InteriorNormal.x() = InteriorNormal.x() / norme;
// InteriorNormal.y() = InteriorNormal.y() / norme;
// InteriorNormal.z() = InteriorNormal.z() / norme;
@@ -412,20 +388,21 @@ SVector3 ThinLayer::computeInteriorNormal(MVertex* v)
MTet4 *ThinLayer::getTetFromPoint(MVertex *v, const SVector3 &InteriorNormal)
{
- MTet4* TetToGet = 0;
- std::vector<MTetrahedron*> currentVecTet = VertexToTets[v];
- for (unsigned int i = 0;i < currentVecTet.size();i++){
+ MTet4 *TetToGet = 0;
+ std::vector<MTetrahedron *> currentVecTet = VertexToTets[v];
+ for(unsigned int i = 0; i < currentVecTet.size(); i++) {
std::vector<SVector3> vecDir;
- for (int j = 0;j < 4 ; j++){
- if (currentVecTet[i]->getVertex(j) != v){
+ for(int j = 0; j < 4; j++) {
+ if(currentVecTet[i]->getVertex(j) != v) {
SVector3 DirTmp(currentVecTet[i]->getVertex(j)->x() - v->x(),
currentVecTet[i]->getVertex(j)->y() - v->y(),
currentVecTet[i]->getVertex(j)->z() - v->z());
vecDir.push_back(DirTmp);
}
}
- bool IsPositiv = ThinLayer::IsPositivOrientation(vecDir[0],vecDir[1],vecDir[2]);
- if (!IsPositiv){
+ bool IsPositiv =
+ ThinLayer::IsPositivOrientation(vecDir[0], vecDir[1], vecDir[2]);
+ if(!IsPositiv) {
SVector3 DirTmp1 = vecDir[1];
SVector3 DirTmp2 = vecDir[0];
SVector3 DirTmp3 = vecDir[2];
@@ -434,12 +411,15 @@ MTet4 *ThinLayer::getTetFromPoint(MVertex *v, const SVector3 &InteriorNormal)
vecDir.push_back(DirTmp2);
vecDir.push_back(DirTmp3);
}
- bool isPositiv1 = ThinLayer::IsPositivOrientation(vecDir[0],vecDir[1],InteriorNormal);
- bool isPositiv2 = ThinLayer::IsPositivOrientation(vecDir[1],vecDir[2],InteriorNormal);
- bool isPositiv3 = ThinLayer::IsPositivOrientation(vecDir[2],vecDir[0],InteriorNormal);
- if (isPositiv1){
- if (isPositiv2){
- if (isPositiv3){
+ bool isPositiv1 =
+ ThinLayer::IsPositivOrientation(vecDir[0], vecDir[1], InteriorNormal);
+ bool isPositiv2 =
+ ThinLayer::IsPositivOrientation(vecDir[1], vecDir[2], InteriorNormal);
+ bool isPositiv3 =
+ ThinLayer::IsPositivOrientation(vecDir[2], vecDir[0], InteriorNormal);
+ if(isPositiv1) {
+ if(isPositiv2) {
+ if(isPositiv3) {
TetToGet = TetToTet4[currentVecTet[i]];
}
}
@@ -452,10 +432,11 @@ bool ThinLayer::IsPositivOrientation(const SVector3 &a, const SVector3 &b,
const SVector3 &c)
{
bool result = false;
- SPoint3 ProdVec(a.y() * b.z() - a.z() * b.y(),a.z() * b.x() -
- a.x() * b.z(),a.x() * b.y() - a.y() * b.x());
- double ProdScal = ProdVec.x() * c.x() + ProdVec.y() * c.y() + ProdVec.z() * c.z();
- if (ProdScal >= 0.0){
+ SPoint3 ProdVec(a.y() * b.z() - a.z() * b.y(), a.z() * b.x() - a.x() * b.z(),
+ a.x() * b.y() - a.y() * b.x());
+ double ProdScal =
+ ProdVec.x() * c.x() + ProdVec.y() * c.y() + ProdVec.z() * c.z();
+ if(ProdScal >= 0.0) {
result = true;
}
return result;
@@ -469,9 +450,9 @@ void ThinLayer::FindNewPoint(SPoint3 *CurrentPoint, int *CurrentTri,
double betaMax = 0.0;
SPoint3 ResultPoint;
int triToGet = 0;
- for (unsigned int n = 0;n < 4 ; n++){
- //calculer matrice a inverser
- faceXtet fxt(CurrentTet,n);
+ for(unsigned int n = 0; n < 4; n++) {
+ // calculer matrice a inverser
+ faceXtet fxt(CurrentTet, n);
double a = fxt.v[1]->x() - fxt.v[0]->x();
double b = fxt.v[2]->x() - fxt.v[0]->x();
double c = InteriorNormal.x();
@@ -481,8 +462,9 @@ void ThinLayer::FindNewPoint(SPoint3 *CurrentPoint, int *CurrentTri,
double g = fxt.v[1]->z() - fxt.v[0]->z();
double h = fxt.v[2]->z() - fxt.v[0]->z();
double i = InteriorNormal.z();
- //produit matrice inverse par vecteur donne poids
- double detMat = a * e * i + b * f * g + c * d * h - c * e * g - f * h * a - i * b * d;
+ // produit matrice inverse par vecteur donne poids
+ double detMat =
+ a * e * i + b * f * g + c * d * h - c * e * g - f * h * a - i * b * d;
double ai = e * i - f * h;
double bi = c * h - b * i;
double ci = b * f - c * e;
@@ -497,20 +479,22 @@ void ThinLayer::FindNewPoint(SPoint3 *CurrentPoint, int *CurrentTri,
double oppz = (*CurrentPoint).z() - fxt.v[0]->z();
double alpha = ai / detMat * oppx + bi / detMat * oppy + ci / detMat * oppz;
double beta = di / detMat * oppx + ei / detMat * oppy + fi / detMat * oppz;
- // double gamma = gi / detMat * oppx + hi / detMat * oppy + ii / detMat * oppz;
- //Test si poids entre 0 et 1 et si length maximale
- if ((alpha >= (0.0-epsilon)) && (alpha <= (1.0 + epsilon))){
- if ((beta >= (0.0-epsilon)) && (beta <= (1.0 + epsilon))){
- if (((1.0 - alpha - beta) >= (0.0-epsilon)) &&
- ((1.0 - alpha - beta) <= (1.0 + epsilon))){
- SPoint3 PointTmp(fxt.v[0]->x() + alpha * (fxt.v[1]->x() - fxt.v[0]->x()) +
- beta * (fxt.v[2]->x() - fxt.v[0]->x()),fxt.v[0]->y() +
- alpha * (fxt.v[1]->y() - fxt.v[0]->y()) +
- beta * (fxt.v[2]->y() - fxt.v[0]->y()),fxt.v[0]->z() +
- alpha * (fxt.v[1]->z() - fxt.v[0]->z()) +
- beta * (fxt.v[2]->z() - fxt.v[0]->z()));
+ // double gamma = gi / detMat * oppx + hi / detMat * oppy + ii / detMat *
+ // oppz;
+ // Test si poids entre 0 et 1 et si length maximale
+ if((alpha >= (0.0 - epsilon)) && (alpha <= (1.0 + epsilon))) {
+ if((beta >= (0.0 - epsilon)) && (beta <= (1.0 + epsilon))) {
+ if(((1.0 - alpha - beta) >= (0.0 - epsilon)) &&
+ ((1.0 - alpha - beta) <= (1.0 + epsilon))) {
+ SPoint3 PointTmp(
+ fxt.v[0]->x() + alpha * (fxt.v[1]->x() - fxt.v[0]->x()) +
+ beta * (fxt.v[2]->x() - fxt.v[0]->x()),
+ fxt.v[0]->y() + alpha * (fxt.v[1]->y() - fxt.v[0]->y()) +
+ beta * (fxt.v[2]->y() - fxt.v[0]->y()),
+ fxt.v[0]->z() + alpha * (fxt.v[1]->z() - fxt.v[0]->z()) +
+ beta * (fxt.v[2]->z() - fxt.v[0]->z()));
double distanceTmp = PointTmp.distance((*CurrentPoint));
- if (distanceTmp > distanceP2P){
+ if(distanceTmp > distanceP2P) {
distanceP2P = distanceTmp;
ResultPoint = PointTmp;
triToGet = n;
@@ -521,39 +505,39 @@ void ThinLayer::FindNewPoint(SPoint3 *CurrentPoint, int *CurrentTri,
}
}
}
- //test si trop proche d'un point / une arete
- if (((alphaMax < epsilon) && (betaMax < epsilon)) ||
- ((alphaMax < epsilon) && ((1.0 - alphaMax - betaMax) < epsilon)) ||
- (((1.0 - alphaMax - betaMax) < epsilon) && (betaMax < epsilon))){
- //proche d'un point
+ // test si trop proche d'un point / une arete
+ if(((alphaMax < epsilon) && (betaMax < epsilon)) ||
+ ((alphaMax < epsilon) && ((1.0 - alphaMax - betaMax) < epsilon)) ||
+ (((1.0 - alphaMax - betaMax) < epsilon) && (betaMax < epsilon))) {
+ // proche d'un point
double DistMinTmp = 10000000.0;
int indexMinTmp = 0;
- for (unsigned int i = 0;i < 4;i++){
+ for(unsigned int i = 0; i < 4; i++) {
double distanceTmp =
sqrt((CurrentTet->tet()->getVertex(i)->x() - ResultPoint.x()) *
- (CurrentTet->tet()->getVertex(i)->x() - ResultPoint.x()) +
+ (CurrentTet->tet()->getVertex(i)->x() - ResultPoint.x()) +
(CurrentTet->tet()->getVertex(i)->y() - ResultPoint.y()) *
- (CurrentTet->tet()->getVertex(i)->y() - ResultPoint.y()) +
+ (CurrentTet->tet()->getVertex(i)->y() - ResultPoint.y()) +
(CurrentTet->tet()->getVertex(i)->z() - ResultPoint.z()) *
- (CurrentTet->tet()->getVertex(i)->z() - ResultPoint.z()));
- if (distanceTmp < DistMinTmp){
+ (CurrentTet->tet()->getVertex(i)->z() - ResultPoint.z()));
+ if(distanceTmp < DistMinTmp) {
DistMinTmp = distanceTmp;
indexMinTmp = i;
}
}
- MTet4* NewTet = ThinLayer::getTetFromPoint
- (CurrentTet->tet()->getVertex(indexMinTmp),InteriorNormal);
+ MTet4 *NewTet = ThinLayer::getTetFromPoint(
+ CurrentTet->tet()->getVertex(indexMinTmp), InteriorNormal);
SPoint3 PointTmp(CurrentTet->tet()->getVertex(indexMinTmp)->x(),
CurrentTet->tet()->getVertex(indexMinTmp)->y(),
CurrentTet->tet()->getVertex(indexMinTmp)->z());
(*CurrentPoint) = PointTmp;
CurrentTet = NewTet;
}
- else if ((alphaMax < epsilon) || (betaMax < epsilon) ||
- ((1.0 - alphaMax - betaMax) < epsilon)){
- //trop proche d'une arete
+ else if((alphaMax < epsilon) || (betaMax < epsilon) ||
+ ((1.0 - alphaMax - betaMax) < epsilon)) {
+ // trop proche d'une arete
}
- else{
+ else {
(*CurrentPoint) = ResultPoint;
(*CurrentTri) = triToGet;
CurrentTet = CurrentTet->getNeigh(triToGet);
@@ -563,41 +547,42 @@ void ThinLayer::FindNewPoint(SPoint3 *CurrentPoint, int *CurrentTri,
void ThinLayer::fillVertexToTets()
{
GModel *m = GModel::current();
- for (GModel::riter itr= m->firstRegion();itr != m->lastRegion();itr++){
- GRegion* rTmp = (*itr);
- for (unsigned int i = 0; i < rTmp->tetrahedra.size();i++){
- MTetrahedron* elem = rTmp->tetrahedra[i];
- for (unsigned int j = 0; j < 4;j++){
- std::vector<MTetrahedron*> emptyTetVec;
+ for(GModel::riter itr = m->firstRegion(); itr != m->lastRegion(); itr++) {
+ GRegion *rTmp = (*itr);
+ for(unsigned int i = 0; i < rTmp->tetrahedra.size(); i++) {
+ MTetrahedron *elem = rTmp->tetrahedra[i];
+ for(unsigned int j = 0; j < 4; j++) {
+ std::vector<MTetrahedron *> emptyTetVec;
emptyTetVec.clear();
VertexToTets[elem->getVertex(j)] = emptyTetVec;
- std::vector<CorrespVertices*> emptyCVVec;
+ std::vector<CorrespVertices *> emptyCVVec;
emptyCVVec.clear();
VertexToCorresp[elem->getVertex(j)] = emptyCVVec;
}
}
}
- for (GModel::riter itr= m->firstRegion();itr != m->lastRegion();itr++){
- GRegion* rTmp = (*itr);
- for (unsigned int i = 0; i < rTmp->tetrahedra.size();i++){
- MTetrahedron* elem = rTmp->tetrahedra[i];
- for (unsigned int j = 0; j < 4;j++){
+ for(GModel::riter itr = m->firstRegion(); itr != m->lastRegion(); itr++) {
+ GRegion *rTmp = (*itr);
+ for(unsigned int i = 0; i < rTmp->tetrahedra.size(); i++) {
+ MTetrahedron *elem = rTmp->tetrahedra[i];
+ for(unsigned int j = 0; j < 4; j++) {
VertexToTets[elem->getVertex(j)].push_back(elem);
}
}
}
}
-void ThinLayer::fillTetToTet4(){
+void ThinLayer::fillTetToTet4()
+{
GModel *m = GModel::current();
- std::vector<MTet4*> vecAllTet4;
+ std::vector<MTet4 *> vecAllTet4;
vecAllTet4.clear();
- for (GModel::riter itr= m->firstRegion();itr != m->lastRegion();itr++){
- GRegion* rTmp = (*itr);
- for (unsigned int i = 0; i < rTmp->tetrahedra.size();i++){
- MTetrahedron* elem = rTmp->tetrahedra[i];
- MTet4 tet4tmp = MTet4(elem,0.0);
- MTet4* currentTet4 = &tet4tmp;
+ for(GModel::riter itr = m->firstRegion(); itr != m->lastRegion(); itr++) {
+ GRegion *rTmp = (*itr);
+ for(unsigned int i = 0; i < rTmp->tetrahedra.size(); i++) {
+ MTetrahedron *elem = rTmp->tetrahedra[i];
+ MTet4 tet4tmp = MTet4(elem, 0.0);
+ MTet4 *currentTet4 = &tet4tmp;
TetToTet4[elem] = currentTet4;
vecAllTet4.clear();
}
diff --git a/Mesh/ThinLayer.h b/Mesh/ThinLayer.h
index 48a48e9939e74d5b5146d8b6d4cb885fb25e7c8f..78ac116689ccc13775a947b9bb2b87613e723ff8 100644
--- a/Mesh/ThinLayer.h
+++ b/Mesh/ThinLayer.h
@@ -12,13 +12,13 @@
#include "MTriangle.h"
#include "meshGRegionDelaunayInsertion.h"
-static int faces[4][3] = {{0,1,2}, {0,2,3}, {0,3,1}, {1,3,2}};
+static int faces[4][3] = {{0, 1, 2}, {0, 2, 3}, {0, 3, 1}, {1, 3, 2}};
-struct faceXtet{
- MVertex *v[3],*unsorted[3];
+struct faceXtet {
+ MVertex *v[3], *unsorted[3];
MTet4 *t1;
int i1;
- faceXtet(MTet4 *_t=0, int iFac=0) : t1(_t), i1(iFac)
+ faceXtet(MTet4 *_t = 0, int iFac = 0) : t1(_t), i1(iFac)
{
MVertex *v0 = t1->tet()->getVertex(faces[iFac][0]);
MVertex *v1 = t1->tet()->getVertex(faces[iFac][1]);
@@ -28,46 +28,46 @@ struct faceXtet{
unsorted[1] = v1;
unsorted[2] = v2;
- v[0] = std::min(std::min(v0,v1),v2);
- v[2] = std::max(std::max(v0,v1),v2);
- v[1] = (v0 != v[0] && v0 != v[2]) ? v0 : (v1 != v[0] && v1 != v[2]) ? v1 : v2;
+ v[0] = std::min(std::min(v0, v1), v2);
+ v[2] = std::max(std::max(v0, v1), v2);
+ v[1] =
+ (v0 != v[0] && v0 != v[2]) ? v0 : (v1 != v[0] && v1 != v[2]) ? v1 : v2;
//
// std::sort(v, v + 3);
}
- inline MVertex * getVertex (int i) const { return unsorted[i];}
+ inline MVertex *getVertex(int i) const { return unsorted[i]; }
- inline bool operator < (const faceXtet & other) const
+ inline bool operator<(const faceXtet &other) const
{
- if (v[0] < other.v[0]) return true;
- if (v[0] > other.v[0]) return false;
- if (v[1] < other.v[1]) return true;
- if (v[1] > other.v[1]) return false;
- if (v[2] < other.v[2]) return true;
+ if(v[0] < other.v[0]) return true;
+ if(v[0] > other.v[0]) return false;
+ if(v[1] < other.v[1]) return true;
+ if(v[1] > other.v[1]) return false;
+ if(v[2] < other.v[2]) return true;
return false;
}
- inline bool operator == (const faceXtet & other) const
+ inline bool operator==(const faceXtet &other) const
{
- return (v[0] == other.v[0] &&
- v[1] == other.v[1] &&
- v[2] == other.v[2] );
+ return (v[0] == other.v[0] && v[1] == other.v[1] && v[2] == other.v[2]);
}
- bool visible (MVertex *v){
- MVertex* v0 = t1->tet()->getVertex(faces[i1][0]);
- MVertex* v1 = t1->tet()->getVertex(faces[i1][1]);
- MVertex* v2 = t1->tet()->getVertex(faces[i1][2]);
- double a[3] = {v0->x(),v0->y(),v0->z()};
- double b[3] = {v1->x(),v1->y(),v1->z()};
- double c[3] = {v2->x(),v2->y(),v2->z()};
- double d[3] = {v->x(),v->y(),v->z()};
- double o = robustPredicates :: orient3d(a,b,c,d);
+ bool visible(MVertex *v)
+ {
+ MVertex *v0 = t1->tet()->getVertex(faces[i1][0]);
+ MVertex *v1 = t1->tet()->getVertex(faces[i1][1]);
+ MVertex *v2 = t1->tet()->getVertex(faces[i1][2]);
+ double a[3] = {v0->x(), v0->y(), v0->z()};
+ double b[3] = {v1->x(), v1->y(), v1->z()};
+ double c[3] = {v2->x(), v2->y(), v2->z()};
+ double d[3] = {v->x(), v->y(), v->z()};
+ double o = robustPredicates ::orient3d(a, b, c, d);
return o < 0;
}
};
-class CorrespVertices{
+class CorrespVertices {
private:
- MVertex* StartPoint;
+ MVertex *StartPoint;
SPoint3 EndPoint;
SVector3 StartNormal;
SVector3 EndNormal;
@@ -78,10 +78,11 @@ private:
bool EndTriangleActive;
bool IsMaster;
int tagMaster;
+
public:
CorrespVertices();
~CorrespVertices();
- void setStartPoint(MVertex* v);
+ void setStartPoint(MVertex *v);
void setEndPoint(const SPoint3 &p);
void setStartNormal(const SVector3 &v);
void setEndNormal(const SVector3 &v);
@@ -92,7 +93,7 @@ public:
void setEndTriangleActive(bool b);
void setIsMaster(bool b);
void setTagMaster(int i);
- MVertex* getStartPoint();
+ MVertex *getStartPoint();
SPoint3 getEndPoint();
SVector3 getStartNormal();
SVector3 getEndNormal();
@@ -105,7 +106,7 @@ public:
int getTagMaster();
};
-class ThinLayer{
+class ThinLayer {
private:
public:
ThinLayer();
@@ -113,18 +114,18 @@ public:
static void perform();
static void checkOppositeTriangles();
static void fillvecOfThinSheets();
- static std::map<MVertex*,double> computeAllDistToOppSide();
- static double computeDistToOppSide(MVertex* v);
- static SVector3 computeInteriorNormal(MVertex* v);
+ static std::map<MVertex *, double> computeAllDistToOppSide();
+ static double computeDistToOppSide(MVertex *v);
+ static SVector3 computeInteriorNormal(MVertex *v);
static MTet4 *getTetFromPoint(MVertex *v, const SVector3 &InteriorNormal);
static bool IsPositivOrientation(const SVector3 &a, const SVector3 &b,
const SVector3 &c);
static void FindNewPoint(SPoint3 *CurrentPoint, int *CurrentTri,
MTet4 *CurrentTet, const SVector3 &InteriorNormal);
- static std::map<MVertex*,std::vector<MTetrahedron*> > VertexToTets;
- static std::map<MTetrahedron*,MTet4*> TetToTet4;
- static std::map<MVertex*,std::vector<CorrespVertices*> > VertexToCorresp;
- static std::vector<std::vector<CorrespVertices*> > vecOfThinSheets;
+ static std::map<MVertex *, std::vector<MTetrahedron *> > VertexToTets;
+ static std::map<MTetrahedron *, MTet4 *> TetToTet4;
+ static std::map<MVertex *, std::vector<CorrespVertices *> > VertexToCorresp;
+ static std::vector<std::vector<CorrespVertices *> > vecOfThinSheets;
static const double epsilon;
static const double angleMax;
static const double distP2PMax;
diff --git a/Mesh/Voronoi3D.cpp b/Mesh/Voronoi3D.cpp
index 5eec7aba884e94433260b9c318b03b908b282734..917a2ed118f95adc8c108197d819c2251a0d0770 100644
--- a/Mesh/Voronoi3D.cpp
+++ b/Mesh/Voronoi3D.cpp
@@ -22,63 +22,70 @@ using namespace voro;
/*********class clip*********/
-clip::clip(){}
+clip::clip() {}
-clip::~clip(){}
+clip::~clip() {}
-void clip::execute(){
- GRegion* gr;
- GModel* model = GModel::current();
+void clip::execute()
+{
+ GRegion *gr;
+ GModel *model = GModel::current();
GModel::riter it;
- for(it=model->firstRegion();it!=model->lastRegion();it++)
- {
+ for(it = model->firstRegion(); it != model->lastRegion(); it++) {
gr = *it;
- if(gr->getNumMeshElements()>0){
- execute(gr);
- }
+ if(gr->getNumMeshElements() > 0) {
+ execute(gr);
+ }
}
}
-void clip::execute(GRegion* gr){
-
- std::set<MVertex*> vertices;
- std::set<MVertex*>::iterator it;
+void clip::execute(GRegion *gr)
+{
+ std::set<MVertex *> vertices;
+ std::set<MVertex *>::iterator it;
- for(std::size_t i=0;i<gr->getNumMeshElements();i++){
- MElement* element = gr->getMeshElement(i);
- for(std::size_t j=0;j<element->getNumVertices();j++){
- MVertex* vertex = element->getVertex(j);
- vertices.insert(vertex);
- }
+ for(std::size_t i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *element = gr->getMeshElement(i);
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
+ MVertex *vertex = element->getVertex(j);
+ vertices.insert(vertex);
+ }
}
std::vector<SPoint3> vertices2;
vertices2.reserve(vertices.size());
- for(it=vertices.begin();it!=vertices.end();it++){
- vertices2.push_back(SPoint3((*it)->x(),(*it)->y(),(*it)->z()));
+ for(it = vertices.begin(); it != vertices.end(); it++) {
+ vertices2.push_back(SPoint3((*it)->x(), (*it)->y(), (*it)->z()));
}
std::vector<VoronoiElement> clipped;
- execute(vertices2,clipped);
+ execute(vertices2, clipped);
printf("%d\n", (int)clipped.size());
std::ofstream file("MicrostructurePolycrystal3D.pos");
file << "View \"test\" {\n";
- for(std::size_t i=0;i<clipped.size();i++){
- print_segment(clipped[i].get_v1().get_point(),clipped[i].get_v2().get_point(),file);
- print_segment(clipped[i].get_v1().get_point(),clipped[i].get_v3().get_point(),file);
- print_segment(clipped[i].get_v1().get_point(),clipped[i].get_v4().get_point(),file);
- print_segment(clipped[i].get_v2().get_point(),clipped[i].get_v3().get_point(),file);
- print_segment(clipped[i].get_v3().get_point(),clipped[i].get_v4().get_point(),file);
- print_segment(clipped[i].get_v4().get_point(),clipped[i].get_v2().get_point(),file);
+ for(std::size_t i = 0; i < clipped.size(); i++) {
+ print_segment(clipped[i].get_v1().get_point(),
+ clipped[i].get_v2().get_point(), file);
+ print_segment(clipped[i].get_v1().get_point(),
+ clipped[i].get_v3().get_point(), file);
+ print_segment(clipped[i].get_v1().get_point(),
+ clipped[i].get_v4().get_point(), file);
+ print_segment(clipped[i].get_v2().get_point(),
+ clipped[i].get_v3().get_point(), file);
+ print_segment(clipped[i].get_v3().get_point(),
+ clipped[i].get_v4().get_point(), file);
+ print_segment(clipped[i].get_v4().get_point(),
+ clipped[i].get_v2().get_point(), file);
}
file << "};\n";
}
-void clip::execute(std::vector<SPoint3>& vertices,std::vector<VoronoiElement>& clipped)
+void clip::execute(std::vector<SPoint3> &vertices,
+ std::vector<VoronoiElement> &clipped)
{
#if defined(HAVE_VOROPP)
unsigned int i;
@@ -91,24 +98,24 @@ void clip::execute(std::vector<SPoint3>& vertices,std::vector<VoronoiElement>& c
int index3;
int count;
int pid;
- double x,y,z;
- double x1,y1,z1;
- double x2,y2,z2;
- double x3,y3,z3;
+ double x, y, z;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double x3, y3, z3;
double delta;
- double min_x,max_x;
- double min_y,max_y;
- double min_z,max_z;
- //double volume1;
+ double min_x, max_x;
+ double min_y, max_y;
+ double min_z, max_z;
+ // double volume1;
double volume2;
- //double l1,l2,l3,l4,l5;
- voronoicell_neighbor* pointer;
+ // double l1,l2,l3,l4,l5;
+ voronoicell_neighbor *pointer;
voronoicell_neighbor cell;
- VoronoiVertex v1,v2,v3,v4;
+ VoronoiVertex v1, v2, v3, v4;
VoronoiElement e;
std::vector<int> faces;
std::vector<double> voronoi_vertices;
- std::vector<voronoicell_neighbor*> pointers;
+ std::vector<voronoicell_neighbor *> pointers;
std::vector<SPoint3> generators;
std::vector<int> IDs;
std::vector<int> IDs2;
@@ -121,191 +128,230 @@ void clip::execute(std::vector<SPoint3>& vertices,std::vector<VoronoiElement>& c
max_y = -1000000000.0;
min_z = 1000000000.0;
max_z = -1000000000.0;
- for(i=0;i<vertices.size();i++){
- min_x = min(vertices[i].x(),min_x);
- max_x = max(vertices[i].x(),max_x);
- min_y = min(vertices[i].y(),min_y);
- max_y = max(vertices[i].y(),max_y);
- min_z = min(vertices[i].z(),min_z);
- max_z = max(vertices[i].z(),max_z);
+ for(i = 0; i < vertices.size(); i++) {
+ min_x = min(vertices[i].x(), min_x);
+ max_x = max(vertices[i].x(), max_x);
+ min_y = min(vertices[i].y(), min_y);
+ max_y = max(vertices[i].y(), max_y);
+ min_z = min(vertices[i].z(), min_z);
+ max_z = max(vertices[i].z(), max_z);
}
- delta = 0.2*(max_x - min_x);
- container cont(min_x-delta,max_x+delta,min_y-delta,max_y+delta,min_z-delta,max_z+delta,6,6,6,false,false,false,vertices.size());
- //volume1 = (max_x-min_x+2.0*delta)*(max_y-min_y+2.0*delta)*(max_z-min_z+2.0*delta);
+ delta = 0.2 * (max_x - min_x);
+ container cont(min_x - delta, max_x + delta, min_y - delta, max_y + delta,
+ min_z - delta, max_z + delta, 6, 6, 6, false, false, false,
+ vertices.size());
+ // volume1 =
+ // (max_x-min_x+2.0*delta)*(max_y-min_y+2.0*delta)*(max_z-min_z+2.0*delta);
- for(i=0;i<vertices.size();i++){
- cont.put(i,vertices[i].x(),vertices[i].y(),vertices[i].z());
+ for(i = 0; i < vertices.size(); i++) {
+ cont.put(i, vertices[i].x(), vertices[i].y(), vertices[i].z());
}
count = 0;
IDs.resize(vertices.size());
c_loop_all loop(cont);
loop.start();
- do{
- cont.compute_cell(cell,loop);
- loop.pos(x,y,z);
- pointer = new voronoicell_neighbor();
- *pointer = cell;
- pointers.push_back(pointer);
- generators.push_back(SPoint3(x,y,z));
- pid = loop.pid();
- IDs[pid] = count;
- IDs2.push_back(pid);
- count++;
- }while(loop.inc());
+ do {
+ cont.compute_cell(cell, loop);
+ loop.pos(x, y, z);
+ pointer = new voronoicell_neighbor();
+ *pointer = cell;
+ pointers.push_back(pointer);
+ generators.push_back(SPoint3(x, y, z));
+ pid = loop.pid();
+ IDs[pid] = count;
+ IDs2.push_back(pid);
+ count++;
+ } while(loop.inc());
bisectors.resize(pointers.size());
- for(i=0;i<pointers.size();i++){
+ for(i = 0; i < pointers.size(); i++) {
faces.clear();
- voronoi_vertices.clear();
- pointers[i]->face_vertices(faces);
- pointers[i]->neighbors(neighbors);
- pointers[i]->vertices(generators[i].x(),generators[i].y(),generators[i].z(),voronoi_vertices);
- bisectors[i].resize(voronoi_vertices.size()/3);
- for(j=0;j<bisectors[i].size();j++){
- bisectors[i][j].push_back(IDs2[i]);
- }
- count = 0;
- end = 0;
- while(end<faces.size()){
- start = end + 1;
- end = start + faces[end];
- for(j=start;j<end;j++){
- index = faces[j];
- bisectors[i][index].push_back(neighbors[count]);
- }
- count++;
- }
+ voronoi_vertices.clear();
+ pointers[i]->face_vertices(faces);
+ pointers[i]->neighbors(neighbors);
+ pointers[i]->vertices(generators[i].x(), generators[i].y(),
+ generators[i].z(), voronoi_vertices);
+ bisectors[i].resize(voronoi_vertices.size() / 3);
+ for(j = 0; j < bisectors[i].size(); j++) {
+ bisectors[i][j].push_back(IDs2[i]);
+ }
+ count = 0;
+ end = 0;
+ while(end < faces.size()) {
+ start = end + 1;
+ end = start + faces[end];
+ for(j = start; j < end; j++) {
+ index = faces[j];
+ bisectors[i][index].push_back(neighbors[count]);
+ }
+ count++;
+ }
}
- for(i=0;i<bisectors.size();i++){
- for(j=0;j<bisectors[i].size();j++){
- //printf("%d %d %d %d %d %d\n",i,IDs2[i],bisectors[i][j][0],bisectors[i][j][1],bisectors[i][j][2],bisectors[i][j][3]);
- }
+ for(i = 0; i < bisectors.size(); i++) {
+ for(j = 0; j < bisectors[i].size(); j++) {
+ // printf("%d %d %d %d %d
+ // %d\n",i,IDs2[i],bisectors[i][j][0],bisectors[i][j][1],bisectors[i][j][2],bisectors[i][j][3]);
+ }
}
- for(i=0;i<pointers.size();i++){
- faces.clear();
- voronoi_vertices.clear();
- pointers[i]->face_vertices(faces);
- pointers[i]->vertices(generators[i].x(),generators[i].y(),generators[i].z(),voronoi_vertices);
- end = 0;
- while(end<faces.size()){
- start = end + 1;
- end = start + faces[end];
- for(j=start+1;j<end-1;j++){
- index1 = faces[start];
- index2 = faces[j];
- index3 = faces[j+1];
- x1 = voronoi_vertices[3*index1];
- y1 = voronoi_vertices[3*index1+1];
- z1 = voronoi_vertices[3*index1+2];
- x2 = voronoi_vertices[3*index2];
- y2 = voronoi_vertices[3*index2+1];
- z2 = voronoi_vertices[3*index2+2];
- x3 = voronoi_vertices[3*index3];
- y3 = voronoi_vertices[3*index3+1];
- z3 = voronoi_vertices[3*index3+2];
- v1 = VoronoiVertex();
- v2 = VoronoiVertex();
- v3 = VoronoiVertex();
- v4 = VoronoiVertex();
- v1.set_point(SPoint3(generators[i].x(),generators[i].y(),generators[i].z()));
- v1.set_category(4);
- v1.set_index1(IDs2[i]);
- v2.set_point(SPoint3(x1,y1,z1));
- v2.set_category(category(bisectors[i][index1][0],bisectors[i][index1][1],bisectors[i][index1][2],bisectors[i][index1][3]));
- v2.set_index1(bisectors[i][index1][0]);
- v2.set_index2(bisectors[i][index1][1]);
- v2.set_index3(bisectors[i][index1][2]);
- v2.set_index4(bisectors[i][index1][3]);
- v3.set_point(SPoint3(x2,y2,z2));
- v3.set_category(category(bisectors[i][index2][0],bisectors[i][index2][1],bisectors[i][index2][2],bisectors[i][index2][3]));
- v3.set_index1(bisectors[i][index2][0]);
- v3.set_index2(bisectors[i][index2][1]);
- v3.set_index3(bisectors[i][index2][2]);
- v3.set_index4(bisectors[i][index2][3]);
- v4.set_point(SPoint3(x3,y3,z3));
- v4.set_category(category(bisectors[i][index3][0],bisectors[i][index3][1],bisectors[i][index3][2],bisectors[i][index3][3]));
- v4.set_index1(bisectors[i][index3][0]);
- v4.set_index2(bisectors[i][index3][1]);
- v4.set_index3(bisectors[i][index3][2]);
- v4.set_index4(bisectors[i][index3][3]);
- e = VoronoiElement();
- e.set_v1(v1);
- e.set_v2(v2);
- e.set_v3(v3);
- e.set_v4(v4);
- clipped.push_back(e);
- }
- }
+ for(i = 0; i < pointers.size(); i++) {
+ faces.clear();
+ voronoi_vertices.clear();
+ pointers[i]->face_vertices(faces);
+ pointers[i]->vertices(generators[i].x(), generators[i].y(),
+ generators[i].z(), voronoi_vertices);
+ end = 0;
+ while(end < faces.size()) {
+ start = end + 1;
+ end = start + faces[end];
+ for(j = start + 1; j < end - 1; j++) {
+ index1 = faces[start];
+ index2 = faces[j];
+ index3 = faces[j + 1];
+ x1 = voronoi_vertices[3 * index1];
+ y1 = voronoi_vertices[3 * index1 + 1];
+ z1 = voronoi_vertices[3 * index1 + 2];
+ x2 = voronoi_vertices[3 * index2];
+ y2 = voronoi_vertices[3 * index2 + 1];
+ z2 = voronoi_vertices[3 * index2 + 2];
+ x3 = voronoi_vertices[3 * index3];
+ y3 = voronoi_vertices[3 * index3 + 1];
+ z3 = voronoi_vertices[3 * index3 + 2];
+ v1 = VoronoiVertex();
+ v2 = VoronoiVertex();
+ v3 = VoronoiVertex();
+ v4 = VoronoiVertex();
+ v1.set_point(
+ SPoint3(generators[i].x(), generators[i].y(), generators[i].z()));
+ v1.set_category(4);
+ v1.set_index1(IDs2[i]);
+ v2.set_point(SPoint3(x1, y1, z1));
+ v2.set_category(
+ category(bisectors[i][index1][0], bisectors[i][index1][1],
+ bisectors[i][index1][2], bisectors[i][index1][3]));
+ v2.set_index1(bisectors[i][index1][0]);
+ v2.set_index2(bisectors[i][index1][1]);
+ v2.set_index3(bisectors[i][index1][2]);
+ v2.set_index4(bisectors[i][index1][3]);
+ v3.set_point(SPoint3(x2, y2, z2));
+ v3.set_category(
+ category(bisectors[i][index2][0], bisectors[i][index2][1],
+ bisectors[i][index2][2], bisectors[i][index2][3]));
+ v3.set_index1(bisectors[i][index2][0]);
+ v3.set_index2(bisectors[i][index2][1]);
+ v3.set_index3(bisectors[i][index2][2]);
+ v3.set_index4(bisectors[i][index2][3]);
+ v4.set_point(SPoint3(x3, y3, z3));
+ v4.set_category(
+ category(bisectors[i][index3][0], bisectors[i][index3][1],
+ bisectors[i][index3][2], bisectors[i][index3][3]));
+ v4.set_index1(bisectors[i][index3][0]);
+ v4.set_index2(bisectors[i][index3][1]);
+ v4.set_index3(bisectors[i][index3][2]);
+ v4.set_index4(bisectors[i][index3][3]);
+ e = VoronoiElement();
+ e.set_v1(v1);
+ e.set_v2(v2);
+ e.set_v3(v3);
+ e.set_v4(v4);
+ clipped.push_back(e);
+ }
+ }
}
volume2 = 0.0;
- for(i=0;i<clipped.size();i++){
+ for(i = 0; i < clipped.size(); i++) {
/*if(clipped[i].get_v2().get_category()==1){
- l1 = (clipped[i].get_v2().get_point()).distance(clipped[i].get_v1().get_point());
- l2 = (clipped[i].get_v2().get_point()).distance(generators[IDs[clipped[i].get_v2().get_index1()]]);
- l3 = (clipped[i].get_v2().get_point()).distance(generators[IDs[clipped[i].get_v2().get_index2()]]);
- l4 = (clipped[i].get_v2().get_point()).distance(generators[IDs[clipped[i].get_v2().get_index3()]]);
- l5 = (clipped[i].get_v2().get_point()).distance(generators[IDs[clipped[i].get_v2().get_index4()]]);
- //printf("%f %f %f %f %f %f %f %f %f\n",l1,l2,l3,l4,l5,l1-l2,l1-l3,l1-l4,l1-l5);
- }
- if(clipped[i].get_v3().get_category()==1){
- l1 = (clipped[i].get_v3().get_point()).distance(clipped[i].get_v1().get_point());
- l2 = (clipped[i].get_v3().get_point()).distance(generators[IDs[clipped[i].get_v3().get_index1()]]);
- l3 = (clipped[i].get_v3().get_point()).distance(generators[IDs[clipped[i].get_v3().get_index2()]]);
- l4 = (clipped[i].get_v3().get_point()).distance(generators[IDs[clipped[i].get_v3().get_index3()]]);
- l5 = (clipped[i].get_v3().get_point()).distance(generators[IDs[clipped[i].get_v3().get_index4()]]);
- //printf("%f %f %f %f %f %f %f %f %f\n",l1,l2,l3,l4,l5,l1-l2,l1-l3,l1-l4,l1-l5);
- }
- if(clipped[i].get_v4().get_category()==1){
- l1 = (clipped[i].get_v4().get_point()).distance(clipped[i].get_v1().get_point());
- l2 = (clipped[i].get_v4().get_point()).distance(generators[IDs[clipped[i].get_v4().get_index1()]]);
- l3 = (clipped[i].get_v4().get_point()).distance(generators[IDs[clipped[i].get_v4().get_index2()]]);
- l4 = (clipped[i].get_v4().get_point()).distance(generators[IDs[clipped[i].get_v4().get_index3()]]);
- l5 = (clipped[i].get_v4().get_point()).distance(generators[IDs[clipped[i].get_v4().get_index4()]]);
- //printf("%f %f %f %f %f %f %f %f %f\n",l1,l2,l3,l4,l5,l1-l2,l1-l3,l1-l4,l1-l5);
- }*/
- clipped[i].compute_jacobian();
- volume2 = volume2 + fabs(clipped[i].get_jacobian())/6.0;
+ l1 =
+ (clipped[i].get_v2().get_point()).distance(clipped[i].get_v1().get_point());
+ l2 =
+ (clipped[i].get_v2().get_point()).distance(generators[IDs[clipped[i].get_v2().get_index1()]]);
+ l3 =
+ (clipped[i].get_v2().get_point()).distance(generators[IDs[clipped[i].get_v2().get_index2()]]);
+ l4 =
+ (clipped[i].get_v2().get_point()).distance(generators[IDs[clipped[i].get_v2().get_index3()]]);
+ l5 =
+ (clipped[i].get_v2().get_point()).distance(generators[IDs[clipped[i].get_v2().get_index4()]]);
+ //printf("%f %f %f %f %f %f %f %f
+ %f\n",l1,l2,l3,l4,l5,l1-l2,l1-l3,l1-l4,l1-l5);
+ }
+ if(clipped[i].get_v3().get_category()==1){
+ l1 =
+ (clipped[i].get_v3().get_point()).distance(clipped[i].get_v1().get_point());
+ l2 =
+ (clipped[i].get_v3().get_point()).distance(generators[IDs[clipped[i].get_v3().get_index1()]]);
+ l3 =
+ (clipped[i].get_v3().get_point()).distance(generators[IDs[clipped[i].get_v3().get_index2()]]);
+ l4 =
+ (clipped[i].get_v3().get_point()).distance(generators[IDs[clipped[i].get_v3().get_index3()]]);
+ l5 =
+ (clipped[i].get_v3().get_point()).distance(generators[IDs[clipped[i].get_v3().get_index4()]]);
+ //printf("%f %f %f %f %f %f %f %f
+ %f\n",l1,l2,l3,l4,l5,l1-l2,l1-l3,l1-l4,l1-l5);
+ }
+ if(clipped[i].get_v4().get_category()==1){
+ l1 =
+ (clipped[i].get_v4().get_point()).distance(clipped[i].get_v1().get_point());
+ l2 =
+ (clipped[i].get_v4().get_point()).distance(generators[IDs[clipped[i].get_v4().get_index1()]]);
+ l3 =
+ (clipped[i].get_v4().get_point()).distance(generators[IDs[clipped[i].get_v4().get_index2()]]);
+ l4 =
+ (clipped[i].get_v4().get_point()).distance(generators[IDs[clipped[i].get_v4().get_index3()]]);
+ l5 =
+ (clipped[i].get_v4().get_point()).distance(generators[IDs[clipped[i].get_v4().get_index4()]]);
+ //printf("%f %f %f %f %f %f %f %f
+ %f\n",l1,l2,l3,l4,l5,l1-l2,l1-l3,l1-l4,l1-l5);
+ }*/
+ clipped[i].compute_jacobian();
+ volume2 = volume2 + fabs(clipped[i].get_jacobian()) / 6.0;
}
- //printf("%f %f\n",volume1,volume2);
+ // printf("%f %f\n",volume1,volume2);
- for(i=0;i<pointers.size();i++) delete pointers[i];
+ for(i = 0; i < pointers.size(); i++) delete pointers[i];
#endif
}
-double clip::min(double a,double b){
- if(a<b) return a;
- else return b;
+double clip::min(double a, double b)
+{
+ if(a < b)
+ return a;
+ else
+ return b;
}
-double clip::max(double a,double b){
- if(a>b) return a;
- else return b;
+double clip::max(double a, double b)
+{
+ if(a > b)
+ return a;
+ else
+ return b;
}
-int clip::category(int a,int b,int c,int d)
+int clip::category(int a, int b, int c, int d)
{
int count;
count = 0;
- if(a<0) count++;
- if(b<0) count++;
- if(c<0) count++;
- if(d<0) count++;
- if(count==0) return 1;
- else if(count==1) return 2;
- else if(count==2) return 3;
- else return 4;
+ if(a < 0) count++;
+ if(b < 0) count++;
+ if(c < 0) count++;
+ if(d < 0) count++;
+ if(count == 0)
+ return 1;
+ else if(count == 1)
+ return 2;
+ else if(count == 2)
+ return 3;
+ else
+ return 4;
}
void clip::print_segment(const SPoint3 &p1, const SPoint3 &p2,
std::ofstream &file)
{
- file << "SL ("
- << p1.x() << ", " << p1.y() << ", " << p1.z() << ", "
- << p2.x() << ", " << p2.y() << ", " << p2.z()
- << "){10, 20};\n";
+ file << "SL (" << p1.x() << ", " << p1.y() << ", " << p1.z() << ", " << p2.x()
+ << ", " << p2.y() << ", " << p2.z() << "){10, 20};\n";
}
diff --git a/Mesh/Voronoi3D.h b/Mesh/Voronoi3D.h
index a5c30adc56d5975fb111d3a83b90dcc5f60b8391..fe82536064101717e7a66a7b5e5079d599ff33ef 100644
--- a/Mesh/Voronoi3D.h
+++ b/Mesh/Voronoi3D.h
@@ -10,15 +10,15 @@
class VoronoiElement;
-class clip{
- public:
+class clip {
+public:
clip();
~clip();
void execute();
- void execute(GRegion*);
- void execute(std::vector<SPoint3>&,std::vector<VoronoiElement>&);
- double min(double,double);
- double max(double,double);
- int category(int,int,int,int);
+ void execute(GRegion *);
+ void execute(std::vector<SPoint3> &, std::vector<VoronoiElement> &);
+ double min(double, double);
+ double max(double, double);
+ int category(int, int, int, int);
void print_segment(const SPoint3 &, const SPoint3 &, std::ofstream &);
};
diff --git a/Mesh/cross3D.h b/Mesh/cross3D.h
index a0be4708b3207bf9bb401bcf74444a246af40f98..4a2b5182b8e4c827aad11f9459755d2aa4f28438 100644
--- a/Mesh/cross3D.h
+++ b/Mesh/cross3D.h
@@ -12,7 +12,6 @@
#include <ostream>
using std::ostream;
-
/* Defined in SVector3.h */
/* double angle(const SVector3 v, const SVector3 w) { */
/* /\* returns the angle (in radian) between the vectors v and w */
@@ -24,119 +23,145 @@ using std::ostream;
/* return val; */
/* } */
-class Qtn{
+class Qtn {
public:
double v[4];
- Qtn(){};
+ Qtn(){};
~Qtn(){};
Qtn(const SVector3 &axis, const double theta = M_PI)
{
double temp = sin(0.5 * theta);
- v[0] = axis[0] * temp;
- v[1] = axis[1] * temp;
- v[2] = axis[2] * temp;
+ v[0] = axis[0] * temp;
+ v[1] = axis[1] * temp;
+ v[2] = axis[2] * temp;
v[3] = cos(0.5 * theta);
}
- double re() const{ return v[3]; }
- SVector3 im() const{ return SVector3(v[0], v[1], v[2]); }
- Qtn conj() { v[0] *= -1.; v[1] *= -1.; v[2] *= -1.; return *this; }
- Qtn opp() { v[0] *= -1.; v[1] *= -1.; v[2] *= -1.; v[3] *= -1.; return *this; }
- double operator [](const unsigned int i) const { return v[i]; }
+ double re() const { return v[3]; }
+ SVector3 im() const { return SVector3(v[0], v[1], v[2]); }
+ Qtn conj()
+ {
+ v[0] *= -1.;
+ v[1] *= -1.;
+ v[2] *= -1.;
+ return *this;
+ }
+ Qtn opp()
+ {
+ v[0] *= -1.;
+ v[1] *= -1.;
+ v[2] *= -1.;
+ v[3] *= -1.;
+ return *this;
+ }
+ double operator[](const unsigned int i) const { return v[i]; }
void storeProduct(const Qtn &x, const Qtn &y);
- Qtn operator *(const Qtn &x) const;
+ Qtn operator*(const Qtn &x) const;
SVector3 eulerAxisFromQtn(const Qtn &x);
double eulerAngleFromQtn(const Qtn &x);
};
-double re(const Qtn &x){ return x.re(); }
-SVector3 im(const Qtn &x){ return x.im(); }
-Qtn conj(const Qtn &x) { Qtn y(x); return y.conj(); }
+double re(const Qtn &x) { return x.re(); }
+SVector3 im(const Qtn &x) { return x.im(); }
+Qtn conj(const Qtn &x)
+{
+ Qtn y(x);
+ return y.conj();
+}
-void Qtn::storeProduct(const Qtn &x, const Qtn &y) {
+void Qtn::storeProduct(const Qtn &x, const Qtn &y)
+{
double a0 = x[0], a1 = x[1], a2 = x[2], a3 = x[3];
double b0 = y[0], b1 = y[1], b2 = y[2], b3 = y[3];
- v[0] = a0*b3 + a1*b2 - a2*b1 + a3*b0;
- v[1] =-a0*b2 + a1*b3 + a2*b0 + a3*b1;
- v[2] = a0*b1 - a1*b0 + a2*b3 + a3*b2;
- v[3] =-a0*b0 - a1*b1 - a2*b2 + a3*b3;
+ v[0] = a0 * b3 + a1 * b2 - a2 * b1 + a3 * b0;
+ v[1] = -a0 * b2 + a1 * b3 + a2 * b0 + a3 * b1;
+ v[2] = a0 * b1 - a1 * b0 + a2 * b3 + a3 * b2;
+ v[3] = -a0 * b0 - a1 * b1 - a2 * b2 + a3 * b3;
}
-Qtn Qtn::operator *(const Qtn &y) const {
+Qtn Qtn::operator*(const Qtn &y) const
+{
Qtn x;
x.storeProduct(*this, y);
return x;
}
-SVector3 eulerAxisFromQtn(const Qtn &x){
- double temp = sqrt(1. - x[3]*x[3]);
- if(temp< 1e-10)
- return SVector3(1,0,0);
+SVector3 eulerAxisFromQtn(const Qtn &x)
+{
+ double temp = sqrt(1. - x[3] * x[3]);
+ if(temp < 1e-10)
+ return SVector3(1, 0, 0);
else
- return SVector3(x[0]/temp, x[1]/temp, x[2]/temp);
-}
-
-double eulerAngleFromQtn(const Qtn &x){
- return 2.*acos(x[3]);
+ return SVector3(x[0] / temp, x[1] / temp, x[2] / temp);
}
+double eulerAngleFromQtn(const Qtn &x) { return 2. * acos(x[3]); }
+
#define TOL 1e-12
-ostream& operator<< (ostream &os, const Qtn &x) {
- os << "[ " << ((fabs(x[0])<TOL)?0:x[0])
- << ", " << ((fabs(x[1])<TOL)?0:x[1])
- << ", " << ((fabs(x[2])<TOL)?0:x[2])
- << "; " << ((fabs(x[3])<TOL)?0:x[3]) << " ]";
+ostream &operator<<(ostream &os, const Qtn &x)
+{
+ os << "[ " << ((fabs(x[0]) < TOL) ? 0 : x[0]) << ", "
+ << ((fabs(x[1]) < TOL) ? 0 : x[1]) << ", "
+ << ((fabs(x[2]) < TOL) ? 0 : x[2]) << "; "
+ << ((fabs(x[3]) < TOL) ? 0 : x[3]) << " ]";
return os;
}
-ostream& operator<< (ostream &os, const SVector3 &v) {
- os << "( " << ((fabs(v.x())<TOL)?0:v.x())
- << ", " << ((fabs(v.y())<TOL)?0:v.y())
- << ", " << ((fabs(v.z())<TOL)?0:v.z()) << " )";
+ostream &operator<<(ostream &os, const SVector3 &v)
+{
+ os << "( " << ((fabs(v.x()) < TOL) ? 0 : v.x()) << ", "
+ << ((fabs(v.y()) < TOL) ? 0 : v.y()) << ", "
+ << ((fabs(v.z()) < TOL) ? 0 : v.z()) << " )";
return os;
}
-class cross3D{
+class cross3D {
private:
SVector3 frst, scnd;
+
public:
- cross3D() {
- frst = SVector3(1,0,0);
- scnd = SVector3(0,1,0);
+ cross3D()
+ {
+ frst = SVector3(1, 0, 0);
+ scnd = SVector3(0, 1, 0);
}
- cross3D(const SVector3 &a, const SVector3 &b){
+ cross3D(const SVector3 &a, const SVector3 &b)
+ {
frst = a.unit();
scnd = crossprod(crossprod(frst, b), frst).unit();
}
- cross3D(const SVector3 &a) {
- //if only a is given, b is an arbitrary vector not parallel to a
- SVector3 b, Ex(1,0,0), Ey(0,1,0);
+ cross3D(const SVector3 &a)
+ {
+ // if only a is given, b is an arbitrary vector not parallel to a
+ SVector3 b, Ex(1, 0, 0), Ey(0, 1, 0);
frst = a.unit();
- b = (crossprod(a,Ex).norm() < 1e-2) ? Ey : Ex;
+ b = (crossprod(a, Ex).norm() < 1e-2) ? Ey : Ex;
scnd = crossprod(crossprod(frst, b), frst).unit();
}
- cross3D(const STensor3 &x){
+ cross3D(const STensor3 &x)
+ {
STensor3 m = x;
SVector3 a(m.get_m11(), m.get_m21(), m.get_m31());
SVector3 b(m.get_m12(), m.get_m22(), m.get_m32());
frst = a.unit();
- scnd = crossprod(crossprod(a, b),a).unit();
+ scnd = crossprod(crossprod(a, b), a).unit();
}
~cross3D() {}
SVector3 getFrst() const { return frst; }
SVector3 getScnd() const { return scnd; }
SVector3 getThrd() const { return crossprod(frst, scnd); }
cross3D get(const int k) const;
- bool test() const{
- if( (fabs(dot(frst,scnd)) > 1e-8) ||
- (fabs(frst.norm() - 1.) > 1e-8) ||
- (fabs(scnd.norm() - 1.) > 1e-8) ) {
+ bool test() const
+ {
+ if((fabs(dot(frst, scnd)) > 1e-8) || (fabs(frst.norm() - 1.) > 1e-8) ||
+ (fabs(scnd.norm() - 1.) > 1e-8)) {
std::cout << "Illegal cross" << std::endl;
exit(1);
return false;
}
return true;
}
- cross3D rotate(const Qtn &R){
- frst = im(R*frst*conj(R));
- scnd = im(R*scnd*conj(R));
+ cross3D rotate(const Qtn &R)
+ {
+ frst = im(R * frst * conj(R));
+ scnd = im(R * scnd * conj(R));
return *this;
}
Qtn correspQuat();
@@ -145,117 +170,193 @@ public:
Qtn rotationToOnSurf(const cross3D &y) const;
};
-ostream& operator<< (ostream &os, const cross3D &x) {
- os << x.getFrst() << " /\\ " << x.getScnd() ;
+ostream &operator<<(ostream &os, const cross3D &x)
+{
+ os << x.getFrst() << " /\\ " << x.getScnd();
return os;
}
-cross3D cross3D::get(int k) const{
+cross3D cross3D::get(int k) const
+{
SVector3 a, b;
- switch(k){
- case 0: a = getFrst() ; b = getScnd() ; break;
- case 1: a = getFrst() ; b = -1 * getScnd() ; break;
- case 2: a = getFrst() ; b = getThrd() ; break;
- case 3: a = getFrst() ; b = -1 * getThrd() ; break;
- case 4: a = -1 * getFrst() ; b = getScnd() ; break;
- case 5: a = -1 * getFrst() ; b = -1 * getScnd() ; break;
- case 6: a = -1 * getFrst() ; b = getThrd() ; break;
- case 7: a = -1 * getFrst() ; b = -1 * getThrd() ; break;
-
- case 8: a = getScnd() ; b = getThrd() ; break;
- case 9: a = getScnd() ; b = -1 * getThrd() ; break;
- case 10: a = getScnd() ; b = getFrst() ; break;
- case 11: a = getScnd() ; b = -1 * getFrst() ; break;
- case 12: a = -1 * getScnd() ; b = getThrd() ; break;
- case 13: a = -1 * getScnd() ; b = -1 * getThrd() ; break;
- case 14: a = -1 * getScnd() ; b = getFrst() ; break;
- case 15: a = -1 * getScnd() ; b = -1 * getFrst() ; break;
-
- case 16: a = getThrd() ; b = getFrst() ; break;
- case 17: a = getThrd() ; b = -1 * getFrst() ; break;
- case 18: a = getThrd() ; b = getScnd() ; break;
- case 19: a = getThrd() ; b = -1 * getScnd() ; break;
- case 20: a = -1 * getThrd() ; b = getFrst() ; break;
- case 21: a = -1 * getThrd() ; b = -1 * getFrst() ; break;
- case 22: a = -1 * getThrd() ; b = getScnd() ; break;
- case 23: a = -1 * getThrd() ; b = -1 * getScnd() ; break;
- default:
- std::cout << "Argument out of range" << std::endl;
- exit(1);
+ switch(k) {
+ case 0:
+ a = getFrst();
+ b = getScnd();
+ break;
+ case 1:
+ a = getFrst();
+ b = -1 * getScnd();
+ break;
+ case 2:
+ a = getFrst();
+ b = getThrd();
+ break;
+ case 3:
+ a = getFrst();
+ b = -1 * getThrd();
+ break;
+ case 4:
+ a = -1 * getFrst();
+ b = getScnd();
+ break;
+ case 5:
+ a = -1 * getFrst();
+ b = -1 * getScnd();
+ break;
+ case 6:
+ a = -1 * getFrst();
+ b = getThrd();
+ break;
+ case 7:
+ a = -1 * getFrst();
+ b = -1 * getThrd();
+ break;
+
+ case 8:
+ a = getScnd();
+ b = getThrd();
+ break;
+ case 9:
+ a = getScnd();
+ b = -1 * getThrd();
+ break;
+ case 10:
+ a = getScnd();
+ b = getFrst();
+ break;
+ case 11:
+ a = getScnd();
+ b = -1 * getFrst();
+ break;
+ case 12:
+ a = -1 * getScnd();
+ b = getThrd();
+ break;
+ case 13:
+ a = -1 * getScnd();
+ b = -1 * getThrd();
+ break;
+ case 14:
+ a = -1 * getScnd();
+ b = getFrst();
+ break;
+ case 15:
+ a = -1 * getScnd();
+ b = -1 * getFrst();
+ break;
+
+ case 16:
+ a = getThrd();
+ b = getFrst();
+ break;
+ case 17:
+ a = getThrd();
+ b = -1 * getFrst();
+ break;
+ case 18:
+ a = getThrd();
+ b = getScnd();
+ break;
+ case 19:
+ a = getThrd();
+ b = -1 * getScnd();
+ break;
+ case 20:
+ a = -1 * getThrd();
+ b = getFrst();
+ break;
+ case 21:
+ a = -1 * getThrd();
+ b = -1 * getFrst();
+ break;
+ case 22:
+ a = -1 * getThrd();
+ b = getScnd();
+ break;
+ case 23:
+ a = -1 * getThrd();
+ b = -1 * getScnd();
+ break;
+ default: std::cout << "Argument out of range" << std::endl; exit(1);
}
- return cross3D(a,b);
+ return cross3D(a, b);
}
-Qtn cross3D::correspQuat(){
- /*
- returns the quaternion representing the rotation from the canonical basis to this
- */
- SVector3 frst = SVector3(1,0,0);
- SVector3 scnd = SVector3(0,1,0);
- cross3D xx = cross3D(frst,scnd);
- cross3D yy = *this;
- Qtn R = xx.rotationDirectTo(yy);
- return R;
-
+Qtn cross3D::correspQuat()
+{
+ /*
+ returns the quaternion representing the rotation from the canonical basis
+ to this
+ */
+ SVector3 frst = SVector3(1, 0, 0);
+ SVector3 scnd = SVector3(0, 1, 0);
+ cross3D xx = cross3D(frst, scnd);
+ cross3D yy = *this;
+ Qtn R = xx.rotationDirectTo(yy);
+ return R;
}
-Qtn cross3D::rotationDirectTo(const cross3D &y) const{
- double dmin, th1, th2;
- SVector3 axis;
- Qtn Rxy1, Rxy2;
+Qtn cross3D::rotationDirectTo(const cross3D &y) const
+{
+ double dmin, th1, th2;
+ SVector3 axis;
+ Qtn Rxy1, Rxy2;
- cross3D xx = *this;
- cross3D yy = y;
+ cross3D xx = *this;
+ cross3D yy = y;
- //ind1 = 0; jmin=0; dmin = angle(xx.get(kmin).frst, vect[jmin]);
- dmin = angle(xx.frst, yy.frst);
+ // ind1 = 0; jmin=0; dmin = angle(xx.get(kmin).frst, vect[jmin]);
+ dmin = angle(xx.frst, yy.frst);
- th1 = dmin;
+ th1 = dmin;
- if(th1 > 1e-8)
- axis = crossprod(xx.frst, yy.frst).unit();
- else {
- axis = SVector3(1,0,0);
- th1 = 0.;
- }
+ if(th1 > 1e-8)
+ axis = crossprod(xx.frst, yy.frst).unit();
+ else {
+ axis = SVector3(1, 0, 0);
+ th1 = 0.;
+ }
- Rxy1 = Qtn(axis, th1);
- xx.rotate(Rxy1);
+ Rxy1 = Qtn(axis, th1);
+ xx.rotate(Rxy1);
- dmin = angle(xx.scnd, yy.scnd);
- // xx.scnd and yy.scnd now form the smallest angle among the 4^2 possible.
+ dmin = angle(xx.scnd, yy.scnd);
+ // xx.scnd and yy.scnd now form the smallest angle among the 4^2 possible.
- th2 = dmin;
+ th2 = dmin;
- if(th2 > 1e-8)
- axis = crossprod(xx.scnd, yy.scnd).unit();
- else {
- axis = SVector3(1,0,0);
- th2 = 0.;
- }
+ if(th2 > 1e-8)
+ axis = crossprod(xx.scnd, yy.scnd).unit();
+ else {
+ axis = SVector3(1, 0, 0);
+ th2 = 0.;
+ }
- Rxy2 = Qtn(axis, th2);
- Qtn R = Rxy2*Rxy1;
+ Rxy2 = Qtn(axis, th2);
+ Qtn R = Rxy2 * Rxy1;
- // test
- double theta = eulerAngleFromQtn(R);
- if(theta > 1.07 /*0.988*/){ //
- std::cout << "Ouch! th1 = " << th1 << " th2 = " << th2 << std::endl;
- std::cout << "x = " << *this << std::endl;
- std::cout << "y = " << y << std::endl;
- std::cout << "R = " << R << std::endl;
- std::cout << "u = " << eulerAngleFromQtn(R) << std::endl;
- std::cout << "axis = " << eulerAxisFromQtn(R) << std::endl;
- }
+ // test
+ double theta = eulerAngleFromQtn(R);
+ if(theta > 1.07 /*0.988*/) { //
+ std::cout << "Ouch! th1 = " << th1 << " th2 = " << th2 << std::endl;
+ std::cout << "x = " << *this << std::endl;
+ std::cout << "y = " << y << std::endl;
+ std::cout << "R = " << R << std::endl;
+ std::cout << "u = " << eulerAngleFromQtn(R) << std::endl;
+ std::cout << "axis = " << eulerAxisFromQtn(R) << std::endl;
+ }
- return R;
+ return R;
}
-Qtn cross3D::rotationTo(const cross3D &y) const{
- /* x.rotationTo(y) returns a quaternion R representing the rotation
+Qtn cross3D::rotationTo(const cross3D &y) const
+{
+ /* x.rotationTo(y) returns a quaternion R representing the rotation
such that y = R x, x = conj(R) y
eulerAngleFromQtn(R) = distance(x, y)
- if onFace is true, only the rotation around y.frst (which is the normal) is returned
+ if onFace is true, only the rotation around y.frst (which is the normal) is
+ returned
*/
double d, dmin, jmin, kmin, th1, th2;
SVector3 axis;
@@ -264,14 +365,15 @@ Qtn cross3D::rotationTo(const cross3D &y) const{
cross3D xx = *this;
cross3D yy = y;
- //ind1 = 0; jmin=0; dmin = angle(xx.get(kmin).frst, vect[jmin]);
- dmin = M_PI; jmin = kmin = 0;
- for(int j=0 ; j<24; j=j+4){
- for(int k=0 ; k<12; k=k+4){
+ // ind1 = 0; jmin=0; dmin = angle(xx.get(kmin).frst, vect[jmin]);
+ dmin = M_PI;
+ jmin = kmin = 0;
+ for(int j = 0; j < 24; j = j + 4) {
+ for(int k = 0; k < 12; k = k + 4) {
if((d = angle(xx.get(j).frst, yy.get(k).frst)) < dmin) {
- kmin = k;
- jmin = j;
- dmin = d;
+ kmin = k;
+ jmin = j;
+ dmin = d;
}
}
}
@@ -280,14 +382,14 @@ Qtn cross3D::rotationTo(const cross3D &y) const{
// xx.frst and yy.frst now form the smallest angle among the 6^2 possible.
th1 = dmin;
- if(th1 > 1.00001*acos(1./sqrt(3.))){
- std::cout << "This should not happen: th1 = " << th1 << std::endl;
+ if(th1 > 1.00001 * acos(1. / sqrt(3.))) {
+ std::cout << "This should not happen: th1 = " << th1 << std::endl;
exit(1);
}
if(th1 > 1e-8)
axis = crossprod(xx.frst, yy.frst).unit();
else {
- axis = SVector3(1,0,0);
+ axis = SVector3(1, 0, 0);
th1 = 0.;
}
@@ -295,7 +397,7 @@ Qtn cross3D::rotationTo(const cross3D &y) const{
xx.rotate(Rxy1);
dmin = M_PI;
- for(int j=0 ; j<4; j++){
+ for(int j = 0; j < 4; j++) {
if((d = angle(xx.get(j).scnd, yy.scnd)) < dmin) {
jmin = j;
dmin = d;
@@ -305,23 +407,23 @@ Qtn cross3D::rotationTo(const cross3D &y) const{
// xx.scnd and yy.scnd now form the smallest angle among the 4^2 possible.
th2 = dmin;
- if(th2 > M_PI/4.){
- std::cout << "This should not happen: th2 = " << th2 << std::endl;
+ if(th2 > M_PI / 4.) {
+ std::cout << "This should not happen: th2 = " << th2 << std::endl;
exit(1);
}
if(th2 > 1e-8)
axis = crossprod(xx.scnd, yy.scnd).unit();
else {
- axis = SVector3(1,0,0);
+ axis = SVector3(1, 0, 0);
th2 = 0.;
}
Rxy2 = Qtn(axis, th2);
- Qtn R = Rxy2*Rxy1;
+ Qtn R = Rxy2 * Rxy1;
// test
double theta = eulerAngleFromQtn(R);
- if(theta > 1.07 /*0.988*/){ //
+ if(theta > 1.07 /*0.988*/) { //
std::cout << "Ouch! th1 = " << th1 << " th2 = " << th2 << std::endl;
std::cout << "x = " << *this << std::endl;
std::cout << "y = " << y << std::endl;
@@ -333,14 +435,15 @@ Qtn cross3D::rotationTo(const cross3D &y) const{
return R;
}
-Qtn cross3D::rotationToOnSurf(const cross3D &y) const{
- /* this->frst and y.frst are assumed to be the normal to the face
+Qtn cross3D::rotationToOnSurf(const cross3D &y) const
+{
+ /* this->frst and y.frst are assumed to be the normal to the face
R1 is the rotation such that R1(this->frst) = y.frst.
R2 is then the rotation such that R2 o R1(this->scnd) = y.scnd
*/
double d, dmin, jmin, th1, th2;
SVector3 axis;
-
+
cross3D xx = *this;
cross3D yy = y;
@@ -348,20 +451,21 @@ Qtn cross3D::rotationToOnSurf(const cross3D &y) const{
if(th1 > 1e-8)
axis = crossprod(xx.frst, yy.frst).unit();
else {
- axis = SVector3(1,0,0);
+ axis = SVector3(1, 0, 0);
th1 = 0.;
}
Qtn R1 = Qtn(axis, th1);
xx.rotate(R1);
double temp = fabs(angle(xx.getFrst(), yy.getFrst()));
- if( (temp > 1e-8) && (temp < M_PI - 1e-8)){
- std::cout << "This should not happen: not aligned= " << temp << std::endl;
+ if((temp > 1e-8) && (temp < M_PI - 1e-8)) {
+ std::cout << "This should not happen: not aligned= " << temp << std::endl;
exit(1);
}
-
- dmin = M_PI; jmin = 0;
- for(int j=0 ; j<4; j++){
+
+ dmin = M_PI;
+ jmin = 0;
+ for(int j = 0; j < 4; j++) {
if((d = angle(xx.get(j).scnd, yy.scnd)) < dmin) {
jmin = j;
dmin = d;
@@ -371,14 +475,14 @@ Qtn cross3D::rotationToOnSurf(const cross3D &y) const{
// xx.scnd and yy.scnd now form the smallest angle among the 4^2 possible.
th2 = dmin;
- if(th2 > M_PI/4.){
- std::cout << "This should not happen: th2 = " << th2 << std::endl;
+ if(th2 > M_PI / 4.) {
+ std::cout << "This should not happen: th2 = " << th2 << std::endl;
exit(1);
}
if(th2 > 1e-8)
axis = crossprod(xx.scnd, yy.scnd).unit();
else {
- axis = SVector3(1,0,0);
+ axis = SVector3(1, 0, 0);
th2 = 0.;
}
@@ -389,100 +493,109 @@ Qtn cross3D::rotationToOnSurf(const cross3D &y) const{
STensor3 convert(const cross3D &x)
{
STensor3 m;
- SVector3 v;
- v = x.getFrst() ; m.set_m11(v[0]); m.set_m21(v[1]); m.set_m31(v[2]);
- v = x.getScnd() ; m.set_m12(v[0]); m.set_m22(v[1]); m.set_m32(v[2]);
- v = x.getThrd() ; m.set_m13(v[0]); m.set_m23(v[1]); m.set_m33(v[2]);
+ SVector3 v;
+ v = x.getFrst();
+ m.set_m11(v[0]);
+ m.set_m21(v[1]);
+ m.set_m31(v[2]);
+ v = x.getScnd();
+ m.set_m12(v[0]);
+ m.set_m22(v[1]);
+ m.set_m32(v[2]);
+ v = x.getThrd();
+ m.set_m13(v[0]);
+ m.set_m23(v[1]);
+ m.set_m33(v[2]);
return m;
}
-double computeSetSmoothness(std::vector<cross3D > S){
- /* this->frst and y.frst are assumed to be the normal to the face
- R1 is the rotation such that R1(this->frst) = y.frst.
- R2 is then the rotation such that R2 o R1(this->scnd) = y.scnd
- */
- double result = 1.0;
- double qmean[4];
- qmean[0] = 0.0;
- qmean[1] = 0.0;
- qmean[2] = 0.0;
- qmean[3] = 0.0;
- std::vector<cross3D>::iterator it1 = S.begin();
- cross3D cInit = (*it1);
- Qtn qInit = cInit.correspQuat();
- for (it1 = S.begin();it1 != S.end();it1++){
- //pour chaque element du set
- cross3D cTmp = (*it1);
- Qtn qTmp = cTmp.correspQuat();
- double prodVecMin = 0.0;
- for (unsigned int i = 1;i < 24;i++){
- //on trouve la cross appropriee
- Qtn qTmpi = cTmp.get(i).correspQuat();
- double prodVeci = 0.0;
- for (unsigned int j = 0;j < 4;j++){
- prodVeci += qInit.v[j] * qTmpi.v[j];
- }
- if (prodVeci >= 0.0){
- if (prodVeci > prodVecMin){
- prodVecMin = prodVeci;
- qTmp = qTmpi;
- }
- }
- else{
- prodVeci = - prodVeci;
- qTmpi = qTmpi.opp();
- if (prodVeci > prodVecMin){
- prodVecMin = prodVeci;
- qTmp = qTmpi;
- }
- }
- }
- //on a trouve le quat approprie
- for (unsigned int j = 0;j < 4;j++){
- qmean[j] += qTmp[j];
- }
- }
- double normQt = sqrt(qmean[0] * qmean[0] + qmean[1] * qmean[1] + qmean[2] * qmean[2] + qmean[3] * qmean[3]);
- if (normQt != 0.0){
- for (unsigned int j = 0;j < 4;j++){
- qmean[j] = qmean[j] / normQt;
- }
- }
- for (it1 = S.begin();it1 != S.end();it1++){
- //pour chaque element du set
- cross3D cTmp = (*it1);
- Qtn qTmp = cTmp.correspQuat();
- double prodVecMin = 0.0;
- for (unsigned int i = 0;i < 24;i++){
- //on trouve la cross appropriee
- Qtn qTmpi = cTmp.get(i).correspQuat();
- double prodVeci = 0.0;
- for (unsigned int j = 0;j < 4;j++){
- prodVeci += qmean[j] * qTmpi.v[j];
- }
- if (prodVeci >= 0.0){
- if (prodVeci > prodVecMin){
- prodVecMin = prodVeci;
- qTmp = qTmpi;
- }
- }
- else{
- prodVeci = - prodVeci;
- qTmpi = qTmpi.opp();
- if (prodVeci > prodVecMin){
- prodVecMin = prodVeci;
- qTmp = qTmpi;
- }
- }
- }
- //on a trouve le quat approprie
- if (prodVecMin < result){
- result = prodVecMin;
- }
- }
- return result;
+double computeSetSmoothness(std::vector<cross3D> S)
+{
+ /* this->frst and y.frst are assumed to be the normal to the face
+ R1 is the rotation such that R1(this->frst) = y.frst.
+ R2 is then the rotation such that R2 o R1(this->scnd) = y.scnd
+ */
+ double result = 1.0;
+ double qmean[4];
+ qmean[0] = 0.0;
+ qmean[1] = 0.0;
+ qmean[2] = 0.0;
+ qmean[3] = 0.0;
+ std::vector<cross3D>::iterator it1 = S.begin();
+ cross3D cInit = (*it1);
+ Qtn qInit = cInit.correspQuat();
+ for(it1 = S.begin(); it1 != S.end(); it1++) {
+ // pour chaque element du set
+ cross3D cTmp = (*it1);
+ Qtn qTmp = cTmp.correspQuat();
+ double prodVecMin = 0.0;
+ for(unsigned int i = 1; i < 24; i++) {
+ // on trouve la cross appropriee
+ Qtn qTmpi = cTmp.get(i).correspQuat();
+ double prodVeci = 0.0;
+ for(unsigned int j = 0; j < 4; j++) {
+ prodVeci += qInit.v[j] * qTmpi.v[j];
+ }
+ if(prodVeci >= 0.0) {
+ if(prodVeci > prodVecMin) {
+ prodVecMin = prodVeci;
+ qTmp = qTmpi;
+ }
+ }
+ else {
+ prodVeci = -prodVeci;
+ qTmpi = qTmpi.opp();
+ if(prodVeci > prodVecMin) {
+ prodVecMin = prodVeci;
+ qTmp = qTmpi;
+ }
+ }
+ }
+ // on a trouve le quat approprie
+ for(unsigned int j = 0; j < 4; j++) {
+ qmean[j] += qTmp[j];
+ }
+ }
+ double normQt = sqrt(qmean[0] * qmean[0] + qmean[1] * qmean[1] +
+ qmean[2] * qmean[2] + qmean[3] * qmean[3]);
+ if(normQt != 0.0) {
+ for(unsigned int j = 0; j < 4; j++) {
+ qmean[j] = qmean[j] / normQt;
+ }
+ }
+ for(it1 = S.begin(); it1 != S.end(); it1++) {
+ // pour chaque element du set
+ cross3D cTmp = (*it1);
+ Qtn qTmp = cTmp.correspQuat();
+ double prodVecMin = 0.0;
+ for(unsigned int i = 0; i < 24; i++) {
+ // on trouve la cross appropriee
+ Qtn qTmpi = cTmp.get(i).correspQuat();
+ double prodVeci = 0.0;
+ for(unsigned int j = 0; j < 4; j++) {
+ prodVeci += qmean[j] * qTmpi.v[j];
+ }
+ if(prodVeci >= 0.0) {
+ if(prodVeci > prodVecMin) {
+ prodVecMin = prodVeci;
+ qTmp = qTmpi;
+ }
+ }
+ else {
+ prodVeci = -prodVeci;
+ qTmpi = qTmpi.opp();
+ if(prodVeci > prodVecMin) {
+ prodVecMin = prodVeci;
+ qTmp = qTmpi;
+ }
+ }
+ }
+ // on a trouve le quat approprie
+ if(prodVecMin < result) {
+ result = prodVecMin;
+ }
+ }
+ return result;
}
-
-
#endif
diff --git a/Mesh/delaunay3d.cpp b/Mesh/delaunay3d.cpp
index 24c81942219eea9d5830484423b3a780040ed86e..021ecc743783fd3f6234be6f32e044e2b55b3c8b 100644
--- a/Mesh/delaunay3d.cpp
+++ b/Mesh/delaunay3d.cpp
@@ -56,9 +56,7 @@ struct HilbertSortB {
double BoundingBoxXmin, double BoundingBoxXmax,
double BoundingBoxYmin, double BoundingBoxYmax,
double BoundingBoxZmin, double BoundingBoxZmax, int depth);
- HilbertSortB(int m = 0, int l = 2)
- : maxDepth(m)
- , Limit(l)
+ HilbertSortB(int m = 0, int l = 2) : maxDepth(m), Limit(l)
{
ComputeGrayCode(3);
}
@@ -106,7 +104,9 @@ void HilbertSortB::ComputeGrayCode(int n)
mask = (n == 2) ? 3 : 7;
// Generate the Gray code sequence.
- for(i = 0; i < N; i++) { gc[i] = i ^ (i >> 1); }
+ for(i = 0; i < N; i++) {
+ gc[i] = i ^ (i >> 1);
+ }
for(e = 0; e < N; e++) {
for(d = 0; d < n; d++) {
@@ -131,7 +131,9 @@ void HilbertSortB::ComputeGrayCode(int n)
for(i = 1; i < N; i++) {
v = ~i; // Count the 0s.
v = (v ^ (v - 1)) >> 1; // Set v's trailing 0s to 1s and zero rest
- for(c = 0; v; c++) { v >>= 1; }
+ for(c = 0; v; c++) {
+ v >>= 1;
+ }
tsb1mod3[i] = c % n;
}
}
@@ -151,7 +153,9 @@ int HilbertSortB::Split(Vert **vertices, int arraysize, int GrayCode0,
axis = (GrayCode0 ^ GrayCode1) >> 1;
// Calulate the split position along the axis.
- if(axis == 0) { split = 0.5 * (BoundingBoxXmin + BoundingBoxXmax); }
+ if(axis == 0) {
+ split = 0.5 * (BoundingBoxXmin + BoundingBoxXmax);
+ }
else if(axis == 1) {
split = 0.5 * (BoundingBoxYmin + BoundingBoxYmax);
}
@@ -261,7 +265,9 @@ void HilbertSortB::Sort(Vert **vertices, int arraysize, int e, int d,
// Recursively sort the points in sub-boxes.
for(w = 0; w < 8; w++) {
if((p[w + 1] - p[w]) > Limit) {
- if(w == 0) { e_w = 0; }
+ if(w == 0) {
+ e_w = 0;
+ }
else {
k = 2 * ((w - 1) / 2);
e_w = k ^ (k >> 1);
@@ -269,7 +275,9 @@ void HilbertSortB::Sort(Vert **vertices, int arraysize, int e, int d,
k = e_w;
e_w = ((k << (d + 1)) & mask) | ((k >> (n - d - 1)) & mask);
ei = e ^ e_w;
- if(w == 0) { d_w = 0; }
+ if(w == 0) {
+ d_w = 0;
+ }
else {
d_w = ((w % 2) == 0) ? tsb1mod3[w - 1] : tsb1mod3[w];
}
@@ -314,7 +322,9 @@ void computeAdjacencies(Tet *t, int iFace, connContainer &faceToTet)
{
conn c(t->getFace(iFace), iFace, t);
connContainer::iterator it = std::find(faceToTet.begin(), faceToTet.end(), c);
- if(it == faceToTet.end()) { faceToTet.push_back(c); }
+ if(it == faceToTet.end()) {
+ faceToTet.push_back(c);
+ }
else {
t->T[iFace] = it->t;
it->t->T[it->i] = t;
@@ -598,7 +608,9 @@ static bool edgeSwap(Tet *tet, int iLocalEdge, tetContainer &T, int myThread)
connContainer ctnr;
for(unsigned int i = 0; i < outside.size(); i++) {
- for(int j = 0; j < 4; j++) { computeAdjacencies(outside[i], j, ctnr); }
+ for(int j = 0; j < 4; j++) {
+ computeAdjacencies(outside[i], j, ctnr);
+ }
}
return true;
@@ -634,7 +646,9 @@ static bool relocateVertex(Vert *v, std::vector<Tet *> &cavity)
volumeNew += volume;
}
- if(fabs(volumeNew - volumeOld) < 1.e-14 * volumeOld) { return true; }
+ if(fabs(volumeNew - volumeOld) < 1.e-14 * volumeOld) {
+ return true;
+ }
v->x() = oldX, v->y() = oldY, v->z() = oldZ;
return false;
}
@@ -643,7 +657,9 @@ static bool relocateVertex(Vert *v, std::stack<Tet *> &_work,
std::vector<Tet *> &cavity)
{
cavity.clear();
- if(buildVertexCavity(v, cavity, _work)) { return relocateVertex(v, cavity); }
+ if(buildVertexCavity(v, cavity, _work)) {
+ return relocateVertex(v, cavity);
+ }
return false;
}
@@ -713,7 +729,9 @@ static void starShapeness(Vert *v, connContainer &bndK,
const double val = robustPredicates::orient3d(
(double *)bndK[i].f.V[0], (double *)bndK[i].f.V[1],
(double *)bndK[i].f.V[2], (double *)v);
- if(val <= 0.0) { _negatives.push_back(i); }
+ if(val <= 0.0) {
+ _negatives.push_back(i);
+ }
}
}
@@ -725,7 +743,9 @@ static Tet *tetContainsV(Vert *v, cavityContainer &cavity)
Face f = cavity[i]->getFace(j);
const double val = robustPredicates::orient3d(
(double *)f.V[0], (double *)f.V[1], (double *)f.V[2], (double *)v);
- if(val >= 0) { count++; }
+ if(val >= 0) {
+ count++;
+ }
}
if(count == 4) return cavity[i];
}
@@ -742,7 +762,9 @@ static void buildDelaunayBall(cavityContainer &cavity, connContainer &faceToTet)
conn c(t->getFace(iFace), iFace, neigh);
connContainer::iterator it =
std::find(faceToTet.begin(), faceToTet.end(), c);
- if(it == faceToTet.end()) { faceToTet.push_back(c); }
+ if(it == faceToTet.end()) {
+ faceToTet.push_back(c);
+ }
else {
faceToTet.erase(it);
}
@@ -783,7 +805,9 @@ static Tet *tetInsideCavityWithFAce(Face &f, cavityContainer &cavity)
for(unsigned int i = 0; i < cavity.size(); i++) {
Tet *t = cavity[i];
for(unsigned int iFace = 0; iFace < 4; iFace++) {
- if(t->getFace(iFace) == f) { return t; }
+ if(t->getFace(iFace) == f) {
+ return t;
+ }
}
}
return NULL;
@@ -818,7 +842,9 @@ static bool fixDelaunayCavity(Vert *v, cavityContainer &cavity,
if(toRemove) {
std::vector<Tet *>::iterator it =
std::find(cavity.begin(), cavity.end(), toRemove);
- if(it != cavity.end()) { cavity.erase(it); }
+ if(it != cavity.end()) {
+ cavity.erase(it);
+ }
else {
Msg::Error("Datastructure Broken in %s line %5d", __FILE__, __LINE__);
break;
@@ -877,7 +903,9 @@ static void delaunayCavity2(Tet *tet, Tet *prevTet, Vert *v,
}
}
- if(stack.empty()) { finished = true; }
+ if(stack.empty()) {
+ finished = true;
+ }
else {
const std::pair<std::pair<Tet *, Tet *>, std::pair<int, int> > &next =
stack.top();
@@ -991,7 +1019,9 @@ void __print(const char *name, int thread, tetContainer &T, Vert *v)
void print(std::vector<Vert *> &V, std::vector<Tet *> &T)
{
std::map<Vert *, int> nums;
- for(unsigned int i = 0; i < V.size(); i++) { nums[V[i]] = i; }
+ for(unsigned int i = 0; i < V.size(); i++) {
+ nums[V[i]] = i;
+ }
for(unsigned int i = 0; i < T.size(); i++) {
printf("%p\n", T[i]);
printf("%d %d %d %d\n", nums[T[i]->V[0]], nums[T[i]->V[1]],
@@ -1158,7 +1188,7 @@ void delaunayTrgl(const unsigned int numThreads,
// Main loop
for(unsigned int iPGlob = 0; iPGlob < maxLocSizeK; iPGlob++) {
- // printf("%d vs %d\n",iPGlob,maxLocSizeK);
+ // printf("%d vs %d\n",iPGlob,maxLocSizeK);
#if defined(_OPENMP)
#pragma omp barrier
#endif
@@ -1211,7 +1241,7 @@ void delaunayTrgl(const unsigned int numThreads,
}
}
- // t3 += Cpu() - t1;
+ // t3 += Cpu() - t1;
#if defined(_OPENMP)
#pragma omp barrier
@@ -1374,7 +1404,9 @@ void delaunayTriangulation(const int numThreads, const int nptsatonce,
std::vector<int> indices;
SortHilbert(S, indices);
- if(!allocator.size(0)) { initialCube(S, box, allocator); }
+ if(!allocator.size(0)) {
+ initialCube(S, box, allocator);
+ }
int nbBlocks = nptsatonce * numThreads;
// int blockSize = (nbBlocks * (N / nbBlocks))/nbBlocks;
diff --git a/Mesh/delaunay3d.h b/Mesh/delaunay3d.h
index f4b673d07db6d4b8e04ed9319aae53262c4f4e15..2e4026d8e3d377821f7dd082f4ba735215c162ba 100644
--- a/Mesh/delaunay3d.h
+++ b/Mesh/delaunay3d.h
@@ -9,9 +9,8 @@
class MVertex;
class MTetrahedron;
-void delaunayTriangulation(const int numThreads,
- const int nptsatonce,
- std::vector<MVertex*> &S,
- std::vector<MTetrahedron*> &T);
+void delaunayTriangulation(const int numThreads, const int nptsatonce,
+ std::vector<MVertex *> &S,
+ std::vector<MTetrahedron *> &T);
#endif
diff --git a/Mesh/delaunay3d_private.h b/Mesh/delaunay3d_private.h
index 801b6f5560bce46000edcb3f3dc19bf5fb9e467b..a49d512db45428ace35823968ec51c71a35337a7 100644
--- a/Mesh/delaunay3d_private.h
+++ b/Mesh/delaunay3d_private.h
@@ -45,9 +45,7 @@ public:
inline double &lc() { return _lc; }
inline operator double *() { return _x; }
Vert(double X = 0, double Y = 0, double Z = 0, double lc = 0, int num = 0)
- : _num(num)
- , _t(NULL)
- , _thread(0)
+ : _num(num), _t(NULL), _thread(0)
{
_x[0] = X;
_x[1] = Y;
@@ -145,9 +143,7 @@ inline double orientationTestFast(Vert *va, Vert *vb, Vert *vc, Vert *vd)
class Edge {
public:
Vert *first, *second;
- Edge(Vert *v1, Vert *v2)
- : first(std::min(v1, v2))
- , second(std::max(v1, v2))
+ Edge(Vert *v1, Vert *v2) : first(std::min(v1, v2)), second(std::max(v1, v2))
{
}
bool operator==(const Edge &e) const
@@ -195,7 +191,9 @@ public:
{
std::vector<Edge> &v = _hash[H(e)];
for(unsigned int i = 0; i < v.size(); i++)
- if(e == v[i]) { return false; }
+ if(e == v[i]) {
+ return false;
+ }
v.push_back(e);
_size++;
return true;
@@ -245,8 +243,7 @@ struct Tet {
CHECKTYPE _bitset[MAX_NUM_THREADS_];
bool _modified;
// static int in_sphere_counter;
- Tet()
- : _modified(true)
+ Tet() : _modified(true)
{
V[0] = V[1] = V[2] = V[3] = NULL;
T[0] = T[1] = T[2] = T[3] = NULL;
@@ -341,18 +338,8 @@ struct conn {
Face f;
int i;
Tet *t;
- conn()
- : f(0, 0, 0)
- , i(0)
- , t(0)
- {
- }
- conn(Face _f, int _i, Tet *_t)
- : f(_f)
- , i(_i)
- , t(_t)
- {
- }
+ conn() : f(0, 0, 0), i(0), t(0) {}
+ conn(Face _f, int _i, Tet *_t) : f(_f), i(_i), t(_t) {}
bool operator==(const conn &c) const { return f == c.f; }
bool operator<(const conn &c) const { return f < c.f; }
};
@@ -374,16 +361,16 @@ public:
return _all[_array] + _offset;
}
- aBunchOfStuff(unsigned int s)
- : _current(0)
- , _nbAlloc(s)
+ aBunchOfStuff(unsigned int s) : _current(0), _nbAlloc(s)
{
_all.push_back(new T[_nbAlloc]);
}
~aBunchOfStuff()
{
- for(unsigned int i = 0; i < _all.size(); i++) { delete[] _all[i]; }
+ for(unsigned int i = 0; i < _all.size(); i++) {
+ delete[] _all[i];
+ }
}
T *newStuff()
diff --git a/Mesh/delaunay_refinement.cpp b/Mesh/delaunay_refinement.cpp
index b3f7246d05cd2b9ee7162bb5ff7ddaab3d571986..bfe9406f858127cd9199f3c487ef6dd7374844ff 100644
--- a/Mesh/delaunay_refinement.cpp
+++ b/Mesh/delaunay_refinement.cpp
@@ -28,28 +28,27 @@
#include "GModel.h"
#include "Field.h"
-#define SQR(X) (X)*(X)
+#define SQR(X) (X) * (X)
const double EXCLUSION_FACTOR = 0.8;
struct IPT {
- double _x1,_x2,_x3,_x4, _x5;
+ double _x1, _x2, _x3, _x4, _x5;
IPT(double x1, double x2, double x3, double x4)
- : _x1(x1), _x2(x2), _x3(x3), _x4(x4),_x5(0.0)
- {
- };
+ : _x1(x1), _x2(x2), _x3(x3), _x4(x4), _x5(0.0){};
};
////int C_COUNT = 0;
-//double _C1, _C2, _C3, _C4;
-static double GMSHSIZE (const SPoint3 &p, Field *f, double lc_nodal) {
+// double _C1, _C2, _C3, _C4;
+static double GMSHSIZE(const SPoint3 &p, Field *f, double lc_nodal)
+{
double f_field = 1.e22;
- if (!CTX::instance()->mesh.lcExtendFromBoundary) lc_nodal = 1.e22;
+ if(!CTX::instance()->mesh.lcExtendFromBoundary) lc_nodal = 1.e22;
// double _a = Cpu();
- if (f)f_field = (*f)(p.x(), p.y(), p.z());
+ if(f) f_field = (*f)(p.x(), p.y(), p.z());
// _C3 += Cpu() - _a;
- double lc = std::min (lc_nodal,f_field);
+ double lc = std::min(lc_nodal, f_field);
lc = std::max(lc, CTX::instance()->mesh.lcMin);
lc = std::min(lc, CTX::instance()->mesh.lcMax);
// C_COUNT++;
@@ -67,28 +66,28 @@ double adaptiveTrapezoidalRule(const SPoint3 &p1, const SPoint3 &p2, double lc1,
double t1 = 0.0;
double t2 = 1.0;
// edge vector
- SPoint3 dp = p2-p1;
+ SPoint3 dp = p2 - p1;
// value of f on both sides
- double f1 = lc1;//GMSHSIZE(p1, bgm, lc1); //f(p1 + dp*t1,data);
- double f2 = lc2;//GMSHSIZE(p2, bgm, lc2); //f(p1 + dp*t2,data);
+ double f1 = lc1; // GMSHSIZE(p1, bgm, lc1); //f(p1 + dp*t1,data);
+ double f2 = lc2; // GMSHSIZE(p2, bgm, lc2); //f(p1 + dp*t2,data);
dl = p1.distance(p2);
// adim_lenght of half the edge should be bigger than EXCLUSION_FACTOR
// +------x--------+
- if (dl / (2*std::min(lc1,lc2)) <= EXCLUSION_FACTOR){
+ if(dl / (2 * std::min(lc1, lc2)) <= EXCLUSION_FACTOR) {
// printf ("edge length %g lc %g %g\n",dl,f1,f2);
return EXCLUSION_FACTOR;
}
// add one subsegment on the stack
- IPT top (t1,t2,f1,f2);
+ IPT top(t1, t2, f1, f2);
_stack.push(top);
// store total value of the integral
double totalValue = 0.0;
- while(!_stack.empty()){
+ while(!_stack.empty()) {
IPT pp = _stack.top();
_stack.pop();
t1 = pp._x1;
@@ -96,27 +95,28 @@ double adaptiveTrapezoidalRule(const SPoint3 &p1, const SPoint3 &p2, double lc1,
f1 = pp._x3;
f2 = pp._x4;
// mid point
- const double t12 = 0.5* (t1+t2);
- const SPoint3 pmid = p1 + dp*t12;
- const double dt = t2-t1;
+ const double t12 = 0.5 * (t1 + t2);
+ const SPoint3 pmid = p1 + dp * t12;
+ const double dt = t2 - t1;
// average should be compared to mid value
// double f12 = 0.5* (f1+f2);
- double f12 = GMSHSIZE(pmid, bgm, lc1 + t12 *(lc2-lc1) ); //f(p1 + dp*t2,data);
+ double f12 =
+ GMSHSIZE(pmid, bgm, lc1 + t12 * (lc2 - lc1)); // f(p1 + dp*t2,data);
const double AA = dt * dl;
const double I1 = AA / f12;
- const double I2 = 2 * AA / (f1+f2);
+ const double I2 = 2 * AA / (f1 + f2);
- if (fabs (I1 - I2) > epsilon) {
- IPT left (t1,t12,f1,f12);
- IPT right (t12,t2,f12,f2);
+ if(fabs(I1 - I2) > epsilon) {
+ IPT left(t1, t12, f1, f12);
+ IPT right(t12, t2, f12, f2);
_stack.push(left);
_stack.push(right);
}
else {
// compute the integral using trapezoidal rule on both sides
- totalValue += 1./((0.5*f12+0.25*(f1+f2)))*dt;
- pp._x5 = totalValue*dl;
- _result.push_back (pp);
+ totalValue += 1. / ((0.5 * f12 + 0.25 * (f1 + f2))) * dt;
+ pp._x5 = totalValue * dl;
+ _result.push_back(pp);
}
}
// take into account the real length of the edge
@@ -125,17 +125,16 @@ double adaptiveTrapezoidalRule(const SPoint3 &p1, const SPoint3 &p2, double lc1,
return totalValue;
}
-
-void saturateEdge(Edge &e, std::vector<Vert*> &S, std::stack<IPT> &temp)
+void saturateEdge(Edge &e, std::vector<Vert *> &S, std::stack<IPT> &temp)
{
- std::vector< IPT > _result;
+ std::vector<IPT> _result;
double dl;
SPoint3 p1 = e.first->point();
SPoint3 p2 = e.second->point();
FieldManager *fields = GModel::current()->getFields();
Field *bgm = NULL;
- if(fields->getBackgroundField() > 0){
+ if(fields->getBackgroundField() > 0) {
bgm = fields->get(fields->getBackgroundField());
}
@@ -143,47 +142,47 @@ void saturateEdge(Edge &e, std::vector<Vert*> &S, std::stack<IPT> &temp)
// printf("%g %g \n",e.first->lc(), e.second->lc());
- const double dN = adaptiveTrapezoidalRule(p1,p2,e.first->lc(), e.second->lc(),
- _result, dl, temp, bgm);
+ const double dN = adaptiveTrapezoidalRule(
+ p1, p2, e.first->lc(), e.second->lc(), _result, dl, temp, bgm);
// _C1 += Cpu() - _a;
// _a = Cpu();
- const int N = (int) (dN+0.1);
- const double interval = dN/N;
+ const int N = (int)(dN + 0.1);
+ const double interval = dN / N;
double L = 0.0;
// printf("edge length %g %d intervals of size %g (%d results)\n",
// dl,N,interval,_result.size());
const unsigned int Nr = _result.size();
double _f = interval;
- for (unsigned int i=0; i< Nr ; i++) {
- const IPT & rr = _result[i];
+ for(unsigned int i = 0; i < Nr; i++) {
+ const IPT &rr = _result[i];
const double t1 = rr._x1;
const double t2 = rr._x2;
const double f1 = rr._x3;
const double f2 = rr._x4;
const double l1 = rr._x3;
const double l2 = rr._x4;
- const double dL = 2.*(t2-t1) * dl / (f1+f2);
+ const double dL = 2. * (t2 - t1) * dl / (f1 + f2);
- const double _f1 = i ? _result[i-1]._x5 : 0.0;
+ const double _f1 = i ? _result[i - 1]._x5 : 0.0;
const double _f2 = rr._x5;
// printf("%g --> %g for %g --> %g\n",L,dL,t1,t2);
- while (1) {
- const double t = t1 + (L+interval-_f1)*(t2-t1) / dL;
- if (t >= t2*.999) {
- break;
+ while(1) {
+ const double t = t1 + (L + interval - _f1) * (t2 - t1) / dL;
+ if(t >= t2 * .999) {
+ break;
}
else {
- // printf("%g ",t);
- SPoint3 p = p1 * (1.-t) + p2*t;
- const double lc = l1 + (_f-_f1)*(l2-l1) / (_f2-_f1);
- const double dx = 0;//lc * 1.e-12 * (double) rand() / RAND_MAX;
- const double dy = 0;//lc * 1.e-12 * (double) rand() / RAND_MAX;
- const double dz = 0;//lc * 1.e-12 * (double) rand() / RAND_MAX;
- S.push_back(new Vert(p.x()+dx,p.y()+dy,p.z()+dz,lc));
- L += interval;
+ // printf("%g ",t);
+ SPoint3 p = p1 * (1. - t) + p2 * t;
+ const double lc = l1 + (_f - _f1) * (l2 - l1) / (_f2 - _f1);
+ const double dx = 0; // lc * 1.e-12 * (double) rand() / RAND_MAX;
+ const double dy = 0; // lc * 1.e-12 * (double) rand() / RAND_MAX;
+ const double dz = 0; // lc * 1.e-12 * (double) rand() / RAND_MAX;
+ S.push_back(new Vert(p.x() + dx, p.y() + dy, p.z() + dz, lc));
+ L += interval;
_f += interval;
}
}
@@ -205,56 +204,54 @@ inline bool distributeEdgeThroughThreads(int nbThreads, int myThread,
return (int)(h % nbThreads) == myThread;
}
-void saturateEdges(edgeContainer &ec,
- tetContainer &T,
- int nbThreads,
- std::vector<Vert*> &S)
+void saturateEdges(edgeContainer &ec, tetContainer &T, int nbThreads,
+ std::vector<Vert *> &S)
{
#ifdef _OPENMP
#pragma omp parallel
#endif
{
- std::vector<Vert*> Sloc;
+ std::vector<Vert *> Sloc;
std::stack<IPT> temp;
#ifdef _OPENMP
- int myThread = omp_get_thread_num();
+ int myThread = omp_get_thread_num();
// nbThreads = omp_get_num_threads();
#else
- int myThread = 0;
+ int myThread = 0;
#endif
- for (int iThread = 0; iThread<nbThreads;iThread++){
+ for(int iThread = 0; iThread < nbThreads; iThread++) {
const int N = T.size(iThread);
- for (int i=0;i<N;i++){
- Tet *t = T(iThread,i);
- if (t->V[0] && t->_modified){
- // t->_modified = false;
- for (int iEdge=0;iEdge<6;iEdge++){
- Edge ed = t->getEdge(iEdge);
- if (distributeEdgeThroughThreads (nbThreads,myThread, ed)){
- bool isNew = ec.addNewEdge(ed);
- if (isNew){
- saturateEdge (ed, Sloc, temp);
- }
- }
- }
- }
+ for(int i = 0; i < N; i++) {
+ Tet *t = T(iThread, i);
+ if(t->V[0] && t->_modified) {
+ // t->_modified = false;
+ for(int iEdge = 0; iEdge < 6; iEdge++) {
+ Edge ed = t->getEdge(iEdge);
+ if(distributeEdgeThroughThreads(nbThreads, myThread, ed)) {
+ bool isNew = ec.addNewEdge(ed);
+ if(isNew) {
+ saturateEdge(ed, Sloc, temp);
+ }
+ }
+ }
+ }
}
}
#ifdef _OPENMP
#pragma omp critical
#endif
- S.insert (S.end(),Sloc.begin(), Sloc.end());
+ S.insert(S.end(), Sloc.begin(), Sloc.end());
#ifdef _OPENMP
#pragma omp barrier
#endif
}
- for (int iThread = 0; iThread<nbThreads;iThread++){
+ for(int iThread = 0; iThread < nbThreads; iThread++) {
const int N = T.size(iThread);
- for (int i=0;i<N;i++){
- Tet *t = T(iThread,i);
- if (t->V[0] && t->_modified){
- t->_modified = false;
+ for(int i = 0; i < N; i++) {
+ Tet *t = T(iThread, i);
+ if(t->V[0] && t->_modified) {
+ t->_modified = false;
}
}
}
@@ -264,23 +261,20 @@ void saturateEdges(edgeContainer &ec,
// F I L T E R I N G
-
class volumePointWithExclusionRegion {
-public :
+public:
Vert *_v;
- volumePointWithExclusionRegion (Vert *v) : _v(v) {}
+ volumePointWithExclusionRegion(Vert *v) : _v(v) {}
- inline bool inExclusionZone (volumePointWithExclusionRegion *p) const
+ inline bool inExclusionZone(volumePointWithExclusionRegion *p) const
{
- const double K = EXCLUSION_FACTOR*p->_v->lc();
- const double d =
- SQR(p->_v->x() - _v->x())+
- SQR(p->_v->y() - _v->y())+
- SQR(p->_v->z() - _v->z());
+ const double K = EXCLUSION_FACTOR * p->_v->lc();
+ const double d = SQR(p->_v->x() - _v->x()) + SQR(p->_v->y() - _v->y()) +
+ SQR(p->_v->z() - _v->z());
// printf(" %g %g\n",p-//>_v->lc(),d);
return d < SQR(K);
}
- void minmax (double _min[3], double _max[3]) const
+ void minmax(double _min[3], double _max[3]) const
{
_min[0] = _v->x() - _v->lc();
_min[1] = _v->y() - _v->lc();
@@ -294,15 +288,16 @@ public :
struct my_wrapper_3D {
bool _tooclose;
volumePointWithExclusionRegion *_p;
- my_wrapper_3D (volumePointWithExclusionRegion *sp) :
- _tooclose (false), _p(sp) {}
+ my_wrapper_3D(volumePointWithExclusionRegion *sp) : _tooclose(false), _p(sp)
+ {
+ }
};
-bool rtree_callback(volumePointWithExclusionRegion *neighbour,void* point)
+bool rtree_callback(volumePointWithExclusionRegion *neighbour, void *point)
{
- my_wrapper_3D *w = static_cast<my_wrapper_3D*>(point);
+ my_wrapper_3D *w = static_cast<my_wrapper_3D *>(point);
- if (neighbour->inExclusionZone(w->_p)){
+ if(neighbour->inExclusionZone(w->_p)) {
w->_tooclose = true;
return false;
}
@@ -310,32 +305,35 @@ bool rtree_callback(volumePointWithExclusionRegion *neighbour,void* point)
}
class vertexFilter {
- RTree<volumePointWithExclusionRegion*,double,3,double> _rtree;
+ RTree<volumePointWithExclusionRegion *, double, 3, double> _rtree;
+
public:
- void insert (Vert * v) {
- volumePointWithExclusionRegion *sp = new volumePointWithExclusionRegion (v);
- double _min[3],_max[3];
- sp->minmax(_min,_max);
- _rtree.Insert (_min,_max,sp);
+ void insert(Vert *v)
+ {
+ volumePointWithExclusionRegion *sp = new volumePointWithExclusionRegion(v);
+ double _min[3], _max[3];
+ sp->minmax(_min, _max);
+ _rtree.Insert(_min, _max, sp);
}
- bool inExclusionZone (volumePointWithExclusionRegion *p)
+ bool inExclusionZone(volumePointWithExclusionRegion *p)
{
- my_wrapper_3D w (p);
- double _min[3] = {p->_v->x()-1.e-8, p->_v->y()-1.e-8, p->_v->z()-1.e-8};
- // double _max[3] = {p->_v->x()+1.e-8, p->_v->y()+1.e-8, p->_v->z()+1.e-8};
- _rtree.Search(_min,_min,rtree_callback,&w);
+ my_wrapper_3D w(p);
+ double _min[3] = {p->_v->x() - 1.e-8, p->_v->y() - 1.e-8,
+ p->_v->z() - 1.e-8};
+ // double _max[3] = {p->_v->x()+1.e-8, p->_v->y()+1.e-8,
+ // p->_v->z()+1.e-8};
+ _rtree.Search(_min, _min, rtree_callback, &w);
return w._tooclose;
}
};
-void filterVertices(const int numThreads,
- vertexFilter &_filter,
- std::vector<Vert*> &add)
+void filterVertices(const int numThreads, vertexFilter &_filter,
+ std::vector<Vert *> &add)
{
std::vector<int> indices;
SortHilbert(add, indices);
- std::vector<Vert*> _add=add;
+ std::vector<Vert *> _add = add;
// std::vector<Vert*> _add;
// Vert *current = add[0];
@@ -355,11 +353,11 @@ void filterVertices(const int numThreads,
// printf("after %d\n",_add.size());
add.clear();
- for (unsigned int i=0;i<_add.size();i++){
- SPoint3 p (_add[i]->x(),_add[i]->y(),_add[i]->z());
- volumePointWithExclusionRegion v (_add[i]);
- if (! _filter. inExclusionZone (&v)){
- _filter.insert( _add[i]);
+ for(unsigned int i = 0; i < _add.size(); i++) {
+ SPoint3 p(_add[i]->x(), _add[i]->y(), _add[i]->z());
+ volumePointWithExclusionRegion v(_add[i]);
+ if(!_filter.inExclusionZone(&v)) {
+ _filter.insert(_add[i]);
add.push_back(_add[i]);
}
else
@@ -374,25 +372,25 @@ static void _print (const char *name, std::vector<Vert*> &T)
fprintf(f,"View \"\"{\n");
for (unsigned int i=0;i<T.size();i++){
fprintf(f,"SP(%g,%g,%g){%d};\n",
- T[i]->x(),T[i]->y(),T[i]->z(),i);
+ T[i]->x(),T[i]->y(),T[i]->z(),i);
}
fprintf(f,"};\n");
fclose(f);
}
*/
-typedef std::set<conn> connSet;
+typedef std::set<conn> connSet;
-void computeAdjacencies (Tet *t, int iFace, connSet &faceToTet)
+void computeAdjacencies(Tet *t, int iFace, connSet &faceToTet)
{
- conn c (t->getFace(iFace), iFace, t);
+ conn c(t->getFace(iFace), iFace, t);
connSet::iterator it = faceToTet.find(c);
- if (it == faceToTet.end()){
+ if(it == faceToTet.end()) {
faceToTet.insert(c);
}
- else{
+ else {
t->T[iFace] = it->t;
- it->t->T[it->i] =t;
+ it->t->T[it->i] = t;
// faceToTet.erase(it);
}
}
@@ -403,120 +401,135 @@ bool edgeSwaps(tetContainer &T, int myThread)
return false;
}
-void updateSize (MVertex *v, std::map<MVertex*, double> &s, double d){
- d = std::max(d, CTX::instance()->mesh.lcMin);
- d = std::min(d, CTX::instance()->mesh.lcMax);
- std::map<MVertex*, double>::iterator it = s.find(v);
- if (it == s.end())s[v]=d;
- else it->second = std::min(it->second, d);
+void updateSize(MVertex *v, std::map<MVertex *, double> &s, double d)
+{
+ d = std::max(d, CTX::instance()->mesh.lcMin);
+ d = std::min(d, CTX::instance()->mesh.lcMax);
+ std::map<MVertex *, double>::iterator it = s.find(v);
+ if(it == s.end())
+ s[v] = d;
+ else
+ it->second = std::min(it->second, d);
}
-void createEmbeddedEdges (GRegion *gr,
- edgeContainer &embedded,
- std::vector<Vert *> &_vertices){
- std::vector<GEdge*> const& e = gr->embeddedEdges();
- for (std::vector<GEdge*>::const_iterator it = e.begin() ; it != e.end(); ++it){
- for (unsigned int i = 0; i < (*it)->lines.size(); i++){
+void createEmbeddedEdges(GRegion *gr, edgeContainer &embedded,
+ std::vector<Vert *> &_vertices)
+{
+ std::vector<GEdge *> const &e = gr->embeddedEdges();
+ for(std::vector<GEdge *>::const_iterator it = e.begin(); it != e.end();
+ ++it) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); i++) {
Vert *v0 = _vertices[(*it)->lines[i]->getVertex(0)->getIndex()];
Vert *v1 = _vertices[(*it)->lines[i]->getVertex(1)->getIndex()];
- Edge e (v0,v1);
+ Edge e(v0, v1);
embedded.addNewEdge(e);
}
}
}
-
-void disconnectEmbeddedFaces (GRegion *gr, connSet &faceToTet, std::vector<Vert *> &_vertices){
- std::vector<GFace*> const& f = gr->embeddedFaces();
- for (std::vector<GFace*>::const_iterator it = f.begin() ; it != f.end(); ++it){
- for (unsigned int i = 0; i < (*it)->triangles.size(); i++){
+void disconnectEmbeddedFaces(GRegion *gr, connSet &faceToTet,
+ std::vector<Vert *> &_vertices)
+{
+ std::vector<GFace *> const &f = gr->embeddedFaces();
+ for(std::vector<GFace *>::const_iterator it = f.begin(); it != f.end();
+ ++it) {
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
bool ok1 = false;
bool ok2 = false;
Vert *v0 = _vertices[(*it)->triangles[i]->getVertex(0)->getIndex()];
Vert *v1 = _vertices[(*it)->triangles[i]->getVertex(1)->getIndex()];
Vert *v2 = _vertices[(*it)->triangles[i]->getVertex(2)->getIndex()];
- Face f (v0,v1,v2);
- conn c(f,0,NULL);
+ Face f(v0, v1, v2);
+ conn c(f, 0, NULL);
connSet::iterator itf = faceToTet.find(c);
- if (itf != faceToTet.end()){
- Tet *t1 = itf->t;
- Tet *t2 = itf->t->T[itf->i];
- // if (!(f == t1->getFace(itf->i)))printf("aie\n");
- for (int k=0;k<4;k++){
- if (t1 && t1->T[k] == t2){t1->T[k]=NULL;ok1=true;}
- if (t2 && t2->T[k] == t1){t2->T[k]=NULL;ok2=true;}
- }
- if (!ok1 || !ok2)printf("oops %d %d %p %p\n",ok1,ok2,t1,t2);
+ if(itf != faceToTet.end()) {
+ Tet *t1 = itf->t;
+ Tet *t2 = itf->t->T[itf->i];
+ // if (!(f == t1->getFace(itf->i)))printf("aie\n");
+ for(int k = 0; k < 4; k++) {
+ if(t1 && t1->T[k] == t2) {
+ t1->T[k] = NULL;
+ ok1 = true;
+ }
+ if(t2 && t2->T[k] == t1) {
+ t2->T[k] = NULL;
+ ok2 = true;
+ }
+ }
+ if(!ok1 || !ok2) printf("oops %d %d %p %p\n", ok1, ok2, t1, t2);
}
- else printf("oops2\n");
+ else
+ printf("oops2\n");
}
}
}
-void computeMeshSizes (GRegion *gr, std::map<MVertex*, double> &s){
- std::vector<GEdge*> const& e = gr->embeddedEdges();
- for (std::vector<GEdge*>::const_iterator it = e.begin() ; it != e.end(); ++it){
- for (unsigned int i = 0; i < (*it)->lines.size(); i++){
- double const d = distance((*it)->lines[i]->getVertex(0), (*it)->lines[i]->getVertex(1));
- updateSize ((*it)->lines[i]->getVertex(0), s, d);
- updateSize ((*it)->lines[i]->getVertex(1), s, d);
+void computeMeshSizes(GRegion *gr, std::map<MVertex *, double> &s)
+{
+ std::vector<GEdge *> const &e = gr->embeddedEdges();
+ for(std::vector<GEdge *>::const_iterator it = e.begin(); it != e.end();
+ ++it) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); i++) {
+ double const d =
+ distance((*it)->lines[i]->getVertex(0), (*it)->lines[i]->getVertex(1));
+ updateSize((*it)->lines[i]->getVertex(0), s, d);
+ updateSize((*it)->lines[i]->getVertex(1), s, d);
}
}
- std::vector<GFace*> const& f1 = gr->faces();
- std::vector<GFace*> const& f2 = gr->embeddedFaces();
-
- std::vector<GFace*> f(f1.begin(), f1.end());
- f.insert(f.end(),f2.begin(), f2.end());
- for (std::vector<GFace*>::const_iterator it = f.begin() ; it != f.end(); ++it){
- for (unsigned int i = 0; i < (*it)->triangles.size(); i++){
- for (unsigned int j = 0; j < 3; j++){
- double d = distance((*it)->triangles[i]->getVertex(j), (*it)->triangles[i]->getVertex((j+1)%3));
- updateSize ((*it)->triangles[i]->getVertex(j), s, d);
- updateSize ((*it)->triangles[i]->getVertex((j+1)%3), s, d);
+ std::vector<GFace *> const &f1 = gr->faces();
+ std::vector<GFace *> const &f2 = gr->embeddedFaces();
+
+ std::vector<GFace *> f(f1.begin(), f1.end());
+ f.insert(f.end(), f2.begin(), f2.end());
+ for(std::vector<GFace *>::const_iterator it = f.begin(); it != f.end();
+ ++it) {
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
+ for(unsigned int j = 0; j < 3; j++) {
+ double d = distance((*it)->triangles[i]->getVertex(j),
+ (*it)->triangles[i]->getVertex((j + 1) % 3));
+ updateSize((*it)->triangles[i]->getVertex(j), s, d);
+ updateSize((*it)->triangles[i]->getVertex((j + 1) % 3), s, d);
}
}
}
// there may be steiner points
- for (unsigned int i=0;i<gr->tetrahedra.size();i++){
- for (unsigned int j = 0; j < 4; j++){
+ for(unsigned int i = 0; i < gr->tetrahedra.size(); i++) {
+ for(unsigned int j = 0; j < 4; j++) {
MVertex *v = gr->tetrahedra[i]->getVertex(j);
- if (s.find(v) == s.end()){
- s[v] = 1.0;
+ if(s.find(v) == s.end()) {
+ s[v] = 1.0;
}
}
}
}
-
-void parallelDelaunay (int NT, std::vector<Vert*> &S,
- tetContainer &allocator,
- int iter,
- bool explicitFiltering,
- std::vector<int> &indices,
- edgeContainer *embeddedEdges){
+void parallelDelaunay(int NT, std::vector<Vert *> &S, tetContainer &allocator,
+ int iter, bool explicitFiltering,
+ std::vector<int> &indices, edgeContainer *embeddedEdges)
+{
// Msg::Info ("Parallel Delaunay with %d threads",NT);
int N = S.size();
NT = std::min(NT, MAX_NUM_THREADS_);
- std::vector<Vert*> assignTo0[1];
- std::vector<std::vector<Vert*> > assignTo (NT);
+ std::vector<Vert *> assignTo0[1];
+ std::vector<std::vector<Vert *> > assignTo(NT);
- for (unsigned int i = 1; i < indices.size(); i++){
- int start = indices[i-1];
+ for(unsigned int i = 1; i < indices.size(); i++) {
+ int start = indices[i - 1];
int end = indices[i];
- int sizePerBlock = (NT*((end-start) / NT))/NT;
+ int sizePerBlock = (NT * ((end - start) / NT)) / NT;
int currentBlock = 0;
int localCounter = 0;
// printf("sizePerBlock[%d] = %d (%d,%d)\n",i,sizePerBlock, start, end);
- if (i < 2){
- for (int jPt=start;jPt<end;jPt++){
+ if(i < 2) {
+ for(int jPt = start; jPt < end; jPt++) {
assignTo0[0].push_back(S[jPt]);
}
}
else {
- for (int jPt=start;jPt<end;jPt++){
- if (localCounter++ >= sizePerBlock && currentBlock != NT-1){
+ for(int jPt = start; jPt < end; jPt++) {
+ if(localCounter++ >= sizePerBlock && currentBlock != NT - 1) {
localCounter = 0;
currentBlock++;
}
@@ -524,58 +537,59 @@ void parallelDelaunay (int NT, std::vector<Vert*> &S,
}
}
}
- // delaunayTrgl (numThreads,1,add.size(), &add,allocator,embeddedEdges.empty() ? NULL : &embeddedEdges);
- delaunayTrgl(1,1, assignTo0[0].size(),assignTo0,allocator,embeddedEdges);
- delaunayTrgl(NT,1, N,&assignTo[0], allocator,embeddedEdges);
+ // delaunayTrgl (numThreads,1,add.size(),
+ // &add,allocator,embeddedEdges.empty() ? NULL : &embeddedEdges);
+ delaunayTrgl(1, 1, assignTo0[0].size(), assignTo0, allocator, embeddedEdges);
+ delaunayTrgl(NT, 1, N, &assignTo[0], allocator, embeddedEdges);
}
-extern double tetQuality (Tet* t, double *volume);
+extern double tetQuality(Tet *t, double *volume);
-void edgeBasedRefinement(const int numThreads,
- const int nptsatonce,
+void edgeBasedRefinement(const int numThreads, const int nptsatonce,
GRegion *gr)
{
// fill up old Datastructures
- edgeContainer embeddedEdges (10000);
+ edgeContainer embeddedEdges(10000);
- std::map<MVertex*, double> sizes;
- computeMeshSizes (gr, sizes);
+ std::map<MVertex *, double> sizes;
+ computeMeshSizes(gr, sizes);
- tetContainer allocator (numThreads,1000000);
+ tetContainer allocator(numThreads, 1000000);
SBoundingBox3d bb;
std::vector<Vert *> _vertices;
edgeContainer ec;
- std::map<Vert*,MVertex*> _ma;
+ std::map<Vert *, MVertex *> _ma;
{
- std::vector<MTetrahedron*> &T = gr->tetrahedra;
+ std::vector<MTetrahedron *> &T = gr->tetrahedra;
std::set<MVertex *> all;
- for (unsigned int i=0;i<T.size();i++){
- for (unsigned int j=0;j<4;j++){
- all.insert(T[i]->getVertex(j));
+ for(unsigned int i = 0; i < T.size(); i++) {
+ for(unsigned int j = 0; j < 4; j++) {
+ all.insert(T[i]->getVertex(j));
}
}
// FILE *f = fopen ("pts_init.dat","w");
// fprintf(f,"%d\n",all.size());
- // for (std::set<MVertex*>::iterator it = all.begin();it !=all.end(); ++it){
+ // for (std::set<MVertex*>::iterator it = all.begin();it !=all.end();
+ // ++it){
// MVertex *mv = *it;
// fprintf(f,"%12.5E %12.5E %12.5E\n",mv->x(),mv->y(),mv->z());
// }
// fclose(f);
_vertices.resize(all.size());
- int counter=0;
- for (std::set<MVertex*>::iterator it = all.begin();it !=all.end(); ++it){
+ int counter = 0;
+ for(std::set<MVertex *>::iterator it = all.begin(); it != all.end(); ++it) {
MVertex *mv = *it;
mv->setIndex(counter);
double size = CTX::instance()->mesh.lcMax;
- std::map<MVertex*,double>::iterator itv = sizes.find(mv);
- if (itv != sizes.end())size = itv->second;
- Vert *v = new Vert (mv->x(),mv->y(),mv->z(),size, counter);
+ std::map<MVertex *, double>::iterator itv = sizes.find(mv);
+ if(itv != sizes.end()) size = itv->second;
+ Vert *v = new Vert(mv->x(), mv->y(), mv->z(), size, counter);
_vertices[counter] = v;
- bb += SPoint3(v->x(),v->y(),v->z());
+ bb += SPoint3(v->x(), v->y(), v->z());
_ma[v] = mv;
counter++;
}
@@ -583,67 +597,70 @@ void edgeBasedRefinement(const int numThreads,
{
connSet faceToTet;
// FIXME MULTITHREADING
- for (unsigned int i=0;i<T.size();i++){
- MTetrahedron *tt = T[i];
- int i0 = tt->getVertex(0)->getIndex();
- int i1 = tt->getVertex(1)->getIndex();
- int i2 = tt->getVertex(2)->getIndex();
- int i3 = tt->getVertex(3)->getIndex();
- Tet *t = allocator.newTet(0) ;
- t->setVertices(_vertices[i0],_vertices[i1],_vertices[i2],_vertices[i3]);
- computeAdjacencies (t,0,faceToTet);
- computeAdjacencies (t,1,faceToTet);
- computeAdjacencies (t,2,faceToTet);
- computeAdjacencies (t,3,faceToTet);
- delete tt;
+ for(unsigned int i = 0; i < T.size(); i++) {
+ MTetrahedron *tt = T[i];
+ int i0 = tt->getVertex(0)->getIndex();
+ int i1 = tt->getVertex(1)->getIndex();
+ int i2 = tt->getVertex(2)->getIndex();
+ int i3 = tt->getVertex(3)->getIndex();
+ Tet *t = allocator.newTet(0);
+ t->setVertices(_vertices[i0], _vertices[i1], _vertices[i2],
+ _vertices[i3]);
+ computeAdjacencies(t, 0, faceToTet);
+ computeAdjacencies(t, 1, faceToTet);
+ computeAdjacencies(t, 2, faceToTet);
+ computeAdjacencies(t, 3, faceToTet);
+ delete tt;
}
T.clear();
- disconnectEmbeddedFaces (gr, faceToTet, _vertices);
- createEmbeddedEdges (gr, embeddedEdges, _vertices);
+ disconnectEmbeddedFaces(gr, faceToTet, _vertices);
+ createEmbeddedEdges(gr, embeddedEdges, _vertices);
}
}
// do not allow to saturate boundary edges
{
- for (unsigned int i=0;i< allocator.size(0);i++) {
- Tet *tt = allocator (0,i);
- for (int j=0;j<4;j++){
- if (!tt->T[j]){
- Face f = tt->getFace(j);
- for (int k=0;k<3;k++){
- Vert *vi = f.V[k];
- Vert *vj = f.V[(k+1)%3];
- ec.addNewEdge(Edge(vi,vj));
- }
- }
+ for(unsigned int i = 0; i < allocator.size(0); i++) {
+ Tet *tt = allocator(0, i);
+ for(int j = 0; j < 4; j++) {
+ if(!tt->T[j]) {
+ Face f = tt->getFace(j);
+ for(int k = 0; k < 3; k++) {
+ Vert *vi = f.V[k];
+ Vert *vj = f.V[(k + 1) % 3];
+ ec.addNewEdge(Edge(vi, vj));
+ }
+ }
}
}
}
- std::vector<Vert*> add_all;
+ std::vector<Vert *> add_all;
{
// vertexFilter _filter (bb, 20);
vertexFilter _filter;
- for (unsigned int i=0;i<_vertices.size();i++){
- _filter.insert( _vertices[i] );
+ for(unsigned int i = 0; i < _vertices.size(); i++) {
+ _filter.insert(_vertices[i]);
}
int iter = 1;
- Msg::Info("------------------------------------- SATUR FILTR SORTH DELNY TIME TETS");
+ Msg::Info("------------------------------------- SATUR FILTR SORTH DELNY "
+ "TIME TETS");
double __t__ = Cpu();
// Tet::in_sphere_counter = 0;
- while(1){
- std::vector<Vert*> add;
+ while(1) {
+ std::vector<Vert *> add;
double t1 = Cpu();
// PARALLEL DONE
- saturateEdges (ec, allocator, numThreads, add);
+ saturateEdges(ec, allocator, numThreads, add);
// printf("%d points added",add.size());
double t2 = Cpu();
- filterVertices (numThreads, _filter, add);
+ filterVertices(numThreads, _filter, add);
// printf(" %d points remain\n",add.size());
double t3 = Cpu();
- if (add.empty())break;
- // randomize vertices (EXTREMELY IMPORTANT FOR NOT DETERIORATING PERFORMANCE)
+ if(add.empty()) break;
+ // randomize vertices (EXTREMELY IMPORTANT FOR NOT DETERIORATING
+ // PERFORMANCE)
std::random_shuffle(add.begin(), add.end());
// sort them using BRIO
std::vector<int> indices;
@@ -651,116 +668,118 @@ void edgeBasedRefinement(const int numThreads,
// printf("%d indices\n",indices.size());
double t4 = Cpu();
- parallelDelaunay ( numThreads, add, allocator, iter, false, indices,embeddedEdges.empty() ? NULL : &embeddedEdges);
+ parallelDelaunay(numThreads, add, allocator, iter, false, indices,
+ embeddedEdges.empty() ? NULL : &embeddedEdges);
- // delaunayTrgl (2 ,1,add.size(), &add,allocator,embeddedEdges.empty() ? NULL : &embeddedEdges);
+ // delaunayTrgl (2 ,1,add.size(),
+ // &add,allocator,embeddedEdges.empty() ? NULL : &embeddedEdges);
double t5 = Cpu();
- add_all.insert (add_all.end(), add.begin(), add.end());
+ add_all.insert(add_all.end(), add.begin(), add.end());
size_t sss = 0;
- for (int myThread=0; myThread < numThreads; myThread++)sss+= allocator.size(myThread);
-
- Msg::Info("IT %3d %8d points added, timings %5.2f %5.2f %5.2f %5.2f %5.2f %5d",
- iter,add.size(),
- (t2-t1),
- (t3-t2),
- (t4-t3),
- (t5-t4),
- (t5-__t__),
- sss);
+ for(int myThread = 0; myThread < numThreads; myThread++)
+ sss += allocator.size(myThread);
+
+ Msg::Info(
+ "IT %3d %8d points added, timings %5.2f %5.2f %5.2f %5.2f %5.2f %5d",
+ iter, add.size(), (t2 - t1), (t3 - t2), (t4 - t3), (t5 - t4),
+ (t5 - __t__), sss);
iter++;
}
}
- std::vector<Vert*> vv;
- for (int myThread=0; myThread < numThreads; myThread++)
- for (unsigned int i=0;i<allocator.size(myThread);i++)
- for (unsigned int j=0;j<4;j++)
- if (allocator(myThread,i)->V[j])
- allocator(myThread,i)->V[j]->setNum(0);
-
- for (int myThread=0; myThread < numThreads; myThread++)
- for (unsigned int i=0;i<allocator.size(myThread);i++)
- for (unsigned int j=0;j<4;j++)
- if (allocator(myThread,i)->V[j] && allocator(myThread,i)->V[j]->getNum() == 0){
- allocator(myThread,i)->V[j]->setNum(1);
- std::map<Vert*,MVertex*>::iterator it = _ma.find(allocator(myThread,i)->V[j]);
- if (it == _ma.end())vv.push_back(allocator(myThread,i)->V[j]);
- }
+ std::vector<Vert *> vv;
+ for(int myThread = 0; myThread < numThreads; myThread++)
+ for(unsigned int i = 0; i < allocator.size(myThread); i++)
+ for(unsigned int j = 0; j < 4; j++)
+ if(allocator(myThread, i)->V[j])
+ allocator(myThread, i)->V[j]->setNum(0);
+
+ for(int myThread = 0; myThread < numThreads; myThread++)
+ for(unsigned int i = 0; i < allocator.size(myThread); i++)
+ for(unsigned int j = 0; j < 4; j++)
+ if(allocator(myThread, i)->V[j] &&
+ allocator(myThread, i)->V[j]->getNum() == 0) {
+ allocator(myThread, i)->V[j]->setNum(1);
+ std::map<Vert *, MVertex *>::iterator it =
+ _ma.find(allocator(myThread, i)->V[j]);
+ if(it == _ma.end()) vv.push_back(allocator(myThread, i)->V[j]);
+ }
double t6 = Cpu();
Msg::Info("Optimizing");
- edgeSwapPass (numThreads, allocator, embeddedEdges);
- vertexRelocationPass (numThreads,vv);
- edgeSwapPass (numThreads, allocator, embeddedEdges);
- vertexRelocationPass (numThreads,vv);
- edgeSwapPass (numThreads, allocator, embeddedEdges);
- vertexRelocationPass (numThreads,vv);
+ edgeSwapPass(numThreads, allocator, embeddedEdges);
+ vertexRelocationPass(numThreads, vv);
+ edgeSwapPass(numThreads, allocator, embeddedEdges);
+ vertexRelocationPass(numThreads, vv);
+ edgeSwapPass(numThreads, allocator, embeddedEdges);
+ vertexRelocationPass(numThreads, vv);
double t7 = Cpu();
- Msg::Info("Optimization done (%g seconds)",t7-t6);
+ Msg::Info("Optimization done (%g seconds)", t7 - t6);
- int cat [10] = {0,0,0,0,0,0,0,0,0,0};
+ int cat[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
double MIN = 1.0;
- for (int myThread=0; myThread < numThreads; myThread++) {
- for (unsigned int i=0; i< allocator.size(myThread);i++){
- Tet *tt = allocator (myThread,i);
+ for(int myThread = 0; myThread < numThreads; myThread++) {
+ for(unsigned int i = 0; i < allocator.size(myThread); i++) {
+ Tet *tt = allocator(myThread, i);
MVertex *mvs[4];
- if (tt->V[0]){
- double vol;
- double q = tetQuality (tt,&vol);
- cat [(int)(q*10)] ++;
- MIN = std::min(MIN,q);
- for (int j=0;j<4;j++){
- Vert *v = tt->V[j];
- std::map<Vert*,MVertex*>::iterator it = _ma.find(v);
- if (it == _ma.end()){
- MVertex *mv = new MVertex (v->x(),v->y(),v->z(),gr);
- gr->mesh_vertices.push_back(mv);
- _ma[v] = mv;
- mvs[j] = mv;
- }
- else mvs[j] = it->second;
- }
- gr->tetrahedra.push_back(new MTetrahedron(mvs[0],mvs[1],mvs[2],mvs[3]));
+ if(tt->V[0]) {
+ double vol;
+ double q = tetQuality(tt, &vol);
+ cat[(int)(q * 10)]++;
+ MIN = std::min(MIN, q);
+ for(int j = 0; j < 4; j++) {
+ Vert *v = tt->V[j];
+ std::map<Vert *, MVertex *>::iterator it = _ma.find(v);
+ if(it == _ma.end()) {
+ MVertex *mv = new MVertex(v->x(), v->y(), v->z(), gr);
+ gr->mesh_vertices.push_back(mv);
+ _ma[v] = mv;
+ mvs[j] = mv;
+ }
+ else
+ mvs[j] = it->second;
+ }
+ gr->tetrahedra.push_back(
+ new MTetrahedron(mvs[0], mvs[1], mvs[2], mvs[3]));
}
}
}
- Msg::Info ("Min Tet Quality %22.15E",MIN);
- for (int i=0;i<10;i++){
- Msg::Info ("Tet Quality [%4.3f,%4.3f] %8d",0.1*i,0.1*(i+1),cat[i]);
+ Msg::Info("Min Tet Quality %22.15E", MIN);
+ for(int i = 0; i < 10; i++) {
+ Msg::Info("Tet Quality [%4.3f,%4.3f] %8d", 0.1 * i, 0.1 * (i + 1), cat[i]);
}
- if (Msg::GetVerbosity() == 99) {
- std::map<Edge,double> _sizes;
- for (unsigned int i=0; i< allocator.size(0);i++){
- Tet *tt = allocator (0,i);
- if (tt->V[0]){
- for (int j=0;j<6;j++){
- Edge e = tt->getEdge(j);
- std::map<Edge,double>::iterator it = _sizes.find(e);
- if (it == _sizes.end()){
- double l = sqrt ((e.first->x() - e.second->x()) * (e.first->x() - e.second->x()) +
- (e.first->y() - e.second->y()) * (e.first->y() - e.second->y()) +
- (e.first->z() - e.second->z()) * (e.first->z() - e.second->z()));
- _sizes[e]= 2* l / (e.first->lc() + e.second->lc());
- }
- }
+ if(Msg::GetVerbosity() == 99) {
+ std::map<Edge, double> _sizes;
+ for(unsigned int i = 0; i < allocator.size(0); i++) {
+ Tet *tt = allocator(0, i);
+ if(tt->V[0]) {
+ for(int j = 0; j < 6; j++) {
+ Edge e = tt->getEdge(j);
+ std::map<Edge, double>::iterator it = _sizes.find(e);
+ if(it == _sizes.end()) {
+ double l = sqrt(
+ (e.first->x() - e.second->x()) * (e.first->x() - e.second->x()) +
+ (e.first->y() - e.second->y()) * (e.first->y() - e.second->y()) +
+ (e.first->z() - e.second->z()) * (e.first->z() - e.second->z()));
+ _sizes[e] = 2 * l / (e.first->lc() + e.second->lc());
+ }
+ }
}
}
- std::map<Edge,double>::iterator it = _sizes.begin();
+ std::map<Edge, double>::iterator it = _sizes.begin();
double sum = 0;
int nbBad = 0;
- for (; it !=_sizes.end();++it){
+ for(; it != _sizes.end(); ++it) {
double d = it->second;
- double tau = d < 1 ? d - 1 : 1./d - 1;
- if (d > 2.)nbBad++;
+ double tau = d < 1 ? d - 1 : 1. / d - 1;
+ if(d > 2.) nbBad++;
sum += tau;
}
Msg::Info("MESH EFFICIENCY : %22.15E %6d edges among %d are out of range",
- exp (sum / _sizes.size()),nbBad,_sizes.size());
+ exp(sum / _sizes.size()), nbBad, _sizes.size());
}
-
-
}
diff --git a/Mesh/delaunay_refinement.h b/Mesh/delaunay_refinement.h
index 1d222365b3299b63242b1adbc5d796859a530d9c..50b9e87d9f7dd2d7c240910bcf46281760f58403 100644
--- a/Mesh/delaunay_refinement.h
+++ b/Mesh/delaunay_refinement.h
@@ -10,11 +10,8 @@
#include <vector>
class Tet;
class Vert;
-void delaunayRefinement (const int numThreads,
- const int nptsatonce,
- std::vector<Vert*> &S,
- std::vector<Tet*> &T,
- double (*f)(const SPoint3 &p, void *),
- void *data);
+void delaunayRefinement(const int numThreads, const int nptsatonce,
+ std::vector<Vert *> &S, std::vector<Tet *> &T,
+ double (*f)(const SPoint3 &p, void *), void *data);
#endif
diff --git a/Mesh/directions3D.cpp b/Mesh/directions3D.cpp
index 27aff0b031ebf99de354e324c4d21dc58f625daf..5531ae50344becad9858add26a16f6f50620ab5f 100644
--- a/Mesh/directions3D.cpp
+++ b/Mesh/directions3D.cpp
@@ -29,16 +29,16 @@
#include "PViewDataList.h"
#endif
-Frame_field::Frame_field(){}
+Frame_field::Frame_field() {}
-void Frame_field::init_region(GRegion* gr)
+void Frame_field::init_region(GRegion *gr)
{
#if defined(HAVE_ANN)
// Fill in a ANN tree with the boundary cross field of region gr
unsigned int i;
- GFace* gf;
- std::vector<GFace*> faces;
- std::vector<GFace*>::iterator it;
+ GFace *gf;
+ std::vector<GFace *> faces;
+ std::vector<GFace *>::iterator it;
Nearest_point::init_region(gr);
@@ -47,24 +47,24 @@ void Frame_field::init_region(GRegion* gr)
field.clear();
labels.clear();
- for(it=faces.begin();it!=faces.end();it++){
+ for(it = faces.begin(); it != faces.end(); it++) {
gf = *it;
init_face(gf);
}
- ANNpointArray duplicate = annAllocPts(field.size(),3);
+ ANNpointArray duplicate = annAllocPts(field.size(), 3);
- for(i=0;i<field.size();i++){
+ for(i = 0; i < field.size(); i++) {
duplicate[i][0] = field[i].first.x();
duplicate[i][1] = field[i].first.y();
duplicate[i][2] = field[i].first.z();
}
- kd_tree = new ANNkd_tree(duplicate,field.size(),3);
+ kd_tree = new ANNkd_tree(duplicate, field.size(), 3);
#endif
}
-void Frame_field::init_face(GFace* gf)
+void Frame_field::init_face(GFace *gf)
{
// Fills the auxiliary std::map "field" with a pair <SPoint3, STensor3>
// for each vertex of the face gf.
@@ -75,14 +75,14 @@ void Frame_field::init_face(GFace* gf)
SVector3 v3;
STensor3 m(1.0);
- for(i=0;i<gf->storage1.size();i++){
+ for(i = 0; i < gf->storage1.size(); i++) {
point = gf->storage1[i];
v1 = gf->storage2[i];
v2 = gf->storage3[i];
v1.normalize();
v2.normalize();
- v3 = crossprod(v1,v2);
+ v3 = crossprod(v1, v2);
v3.normalize();
m.set_m11(v1.x());
m.set_m21(v1.y());
@@ -93,12 +93,12 @@ void Frame_field::init_face(GFace* gf)
m.set_m13(v3.x());
m.set_m23(v3.y());
m.set_m33(v3.z());
- field.push_back(std::pair<SPoint3,STensor3>(point,m));
+ field.push_back(std::pair<SPoint3, STensor3>(point, m));
labels.push_back(gf->tag());
}
}
-STensor3 Frame_field::search(double x,double y,double z)
+STensor3 Frame_field::search(double x, double y, double z)
{
// Determines the frame/cross at location (x,y,z)
int index1;
@@ -117,7 +117,7 @@ STensor3 Frame_field::search(double x,double y,double z)
ANNidxArray indices;
ANNdistArray distances;
- if(field.size()<=1){
+ if(field.size() <= 1) {
return STensor3(1.0);
}
@@ -130,7 +130,7 @@ STensor3 Frame_field::search(double x,double y,double z)
distances = new ANNdist[2];
double e = 0.0;
- kd_tree->annkSearch(query,2,indices,distances,e);
+ kd_tree->annkSearch(query, 2, indices, distances, e);
index1 = indices[0];
index2 = indices[1];
distance1 = distances[0];
@@ -141,57 +141,57 @@ STensor3 Frame_field::search(double x,double y,double z)
delete[] distances;
#endif
- if(fabs(sqrt(distance2)-sqrt(distance1))<e2){
- if(labels[index2]<labels[index1]){
+ if(fabs(sqrt(distance2) - sqrt(distance1)) < e2) {
+ if(labels[index2] < labels[index1]) {
return field[index2].second;
}
- else{
+ else {
return field[index1].second;
}
}
- else{
+ else {
return field[index1].second;
}
}
-STensor3 Frame_field::combine(double x,double y,double z)
+STensor3 Frame_field::combine(double x, double y, double z)
{
// Determines the frame/cross at location (x,y,z)
// Alternative to Frame_field::search
bool ok;
- double val1,val2,val3;
- SVector3 vec,other;
- SVector3 vec1,vec2,vec3;
- SVector3 final1,final2;
- STensor3 m(1.0),m2(1.0);
+ double val1, val2, val3;
+ SVector3 vec, other;
+ SVector3 vec1, vec2, vec3;
+ SVector3 final1, final2;
+ STensor3 m(1.0), m2(1.0);
- m = search(x,y,z);
+ m = search(x, y, z);
m2 = m;
- ok = Nearest_point::search(x,y,z,vec);
+ ok = Nearest_point::search(x, y, z, vec);
vec.normalize();
- if(ok){
- vec1 = SVector3(m.get_m11(),m.get_m21(),m.get_m31());
- vec2 = SVector3(m.get_m12(),m.get_m22(),m.get_m32());
- vec3 = SVector3(m.get_m13(),m.get_m23(),m.get_m33());
+ if(ok) {
+ vec1 = SVector3(m.get_m11(), m.get_m21(), m.get_m31());
+ vec2 = SVector3(m.get_m12(), m.get_m22(), m.get_m32());
+ vec3 = SVector3(m.get_m13(), m.get_m23(), m.get_m33());
- val1 = fabs(dot(vec,vec1));
- val2 = fabs(dot(vec,vec2));
- val3 = fabs(dot(vec,vec3));
+ val1 = fabs(dot(vec, vec1));
+ val2 = fabs(dot(vec, vec2));
+ val3 = fabs(dot(vec, vec3));
- if(val1<=val2 && val1<=val3){
+ if(val1 <= val2 && val1 <= val3) {
other = vec1;
}
- else if(val2<=val1 && val2<=val3){
+ else if(val2 <= val1 && val2 <= val3) {
other = vec2;
}
- else{
+ else {
other = vec3;
}
- final1 = crossprod(vec,other);
+ final1 = crossprod(vec, other);
final1.normalize();
- final2 = crossprod(vec,final1);
+ final2 = crossprod(vec, final1);
final2.normalize();
m2.set_m11(vec.x());
@@ -211,10 +211,9 @@ STensor3 Frame_field::combine(double x,double y,double z)
void Frame_field::print_segment(const SPoint3 &p1, const SPoint3 &p2,
double val1, double val2, std::ofstream &file)
{
- file << "SL ("
- << p1.x() << ", " << p1.y() << ", " << p1.z() << ", "
- << p2.x() << ", " << p2.y() << ", " << p2.z() << ")"
- << "{" << val1 << "," << val2 << "};\n";
+ file << "SL (" << p1.x() << ", " << p1.y() << ", " << p1.z() << ", " << p2.x()
+ << ", " << p2.y() << ", " << p2.z() << ")"
+ << "{" << val1 << "," << val2 << "};\n";
}
void Frame_field::print_field1()
@@ -226,7 +225,7 @@ void Frame_field::print_field1()
double color1;
double color2;
SPoint3 point;
- SPoint3 p1,p2,p3,p4,p5,p6;
+ SPoint3 p1, p2, p3, p4, p5, p6;
STensor3 m(1.0);
k = 0.05;
@@ -235,41 +234,35 @@ void Frame_field::print_field1()
color1 = 10.0;
color2 = 20.0;
- for(i=0;i<field.size();i++){
+ for(i = 0; i < field.size(); i++) {
point = field[i].first;
m = field[i].second;
- p1 = SPoint3(point.x() + k*m.get_m11(),
- point.y() + k*m.get_m21(),
- point.z() + k*m.get_m31());
- p2 = SPoint3(point.x() - k*m.get_m11(),
- point.y() - k*m.get_m21(),
- point.z() - k*m.get_m31());
- p3 = SPoint3(point.x() + k*m.get_m12(),
- point.y() + k*m.get_m22(),
- point.z() + k*m.get_m32());
- p4 = SPoint3(point.x() - k*m.get_m12(),
- point.y() - k*m.get_m22(),
- point.z() - k*m.get_m32());
- p5 = SPoint3(point.x() + k*m.get_m13(),
- point.y() + k*m.get_m23(),
- point.z() + k*m.get_m33());
- p6 = SPoint3(point.x() - k*m.get_m13(),
- point.y() - k*m.get_m23(),
- point.z() - k*m.get_m33());
-
- print_segment(point,p1,color1,color2,file);
- print_segment(point,p2,color1,color2,file);
- print_segment(point,p3,color1,color2,file);
- print_segment(point,p4,color1,color2,file);
- print_segment(point,p5,color1,color2,file);
- print_segment(point,p6,color1,color2,file);
+ p1 = SPoint3(point.x() + k * m.get_m11(), point.y() + k * m.get_m21(),
+ point.z() + k * m.get_m31());
+ p2 = SPoint3(point.x() - k * m.get_m11(), point.y() - k * m.get_m21(),
+ point.z() - k * m.get_m31());
+ p3 = SPoint3(point.x() + k * m.get_m12(), point.y() + k * m.get_m22(),
+ point.z() + k * m.get_m32());
+ p4 = SPoint3(point.x() - k * m.get_m12(), point.y() - k * m.get_m22(),
+ point.z() - k * m.get_m32());
+ p5 = SPoint3(point.x() + k * m.get_m13(), point.y() + k * m.get_m23(),
+ point.z() + k * m.get_m33());
+ p6 = SPoint3(point.x() - k * m.get_m13(), point.y() - k * m.get_m23(),
+ point.z() - k * m.get_m33());
+
+ print_segment(point, p1, color1, color2, file);
+ print_segment(point, p2, color1, color2, file);
+ print_segment(point, p3, color1, color2, file);
+ print_segment(point, p4, color1, color2, file);
+ print_segment(point, p5, color1, color2, file);
+ print_segment(point, p6, color1, color2, file);
}
file << "};\n";
}
-void Frame_field::print_field2(GRegion* gr)
+void Frame_field::print_field2(GRegion *gr)
{
// Saves a file with the cross fields inside the given GRegion, excluding the
// boundary.
@@ -279,39 +272,33 @@ void Frame_field::print_field2(GRegion* gr)
double const color1 = 10.0;
double const color2 = 20.0;
- for(std::size_t i=0;i<gr->getNumMeshElements();i++){
- MElement* element = gr->getMeshElement(i);
- for(std::size_t j=0;j<element->getNumVertices();j++){
- MVertex* vertex = element->getVertex(j);
- if(vertex->onWhat()->dim()>2){
- SPoint3 point = SPoint3(vertex->x(),vertex->y(),vertex->z());
- STensor3 m = search(vertex->x(),vertex->y(),vertex->z());
-
- SPoint3 p1(point.x() + k*m.get_m11(),
- point.y() + k*m.get_m21(),
- point.z() + k*m.get_m31());
- SPoint3 p2(point.x() - k*m.get_m11(),
- point.y() - k*m.get_m21(),
- point.z() - k*m.get_m31());
- SPoint3 p3(point.x() + k*m.get_m12(),
- point.y() + k*m.get_m22(),
- point.z() + k*m.get_m32());
- SPoint3 p4(point.x() - k*m.get_m12(),
- point.y() - k*m.get_m22(),
- point.z() - k*m.get_m32());
- SPoint3 p5(point.x() + k*m.get_m13(),
- point.y() + k*m.get_m23(),
- point.z() + k*m.get_m33());
- SPoint3 p6(point.x() - k*m.get_m13(),
- point.y() - k*m.get_m23(),
- point.z() - k*m.get_m33());
-
- print_segment(point,p1,color1,color2,file);
- print_segment(point,p2,color1,color2,file);
- print_segment(point,p3,color1,color2,file);
- print_segment(point,p4,color1,color2,file);
- print_segment(point,p5,color1,color2,file);
- print_segment(point,p6,color1,color2,file);
+ for(std::size_t i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *element = gr->getMeshElement(i);
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
+ MVertex *vertex = element->getVertex(j);
+ if(vertex->onWhat()->dim() > 2) {
+ SPoint3 point = SPoint3(vertex->x(), vertex->y(), vertex->z());
+ STensor3 m = search(vertex->x(), vertex->y(), vertex->z());
+
+ SPoint3 p1(point.x() + k * m.get_m11(), point.y() + k * m.get_m21(),
+ point.z() + k * m.get_m31());
+ SPoint3 p2(point.x() - k * m.get_m11(), point.y() - k * m.get_m21(),
+ point.z() - k * m.get_m31());
+ SPoint3 p3(point.x() + k * m.get_m12(), point.y() + k * m.get_m22(),
+ point.z() + k * m.get_m32());
+ SPoint3 p4(point.x() - k * m.get_m12(), point.y() - k * m.get_m22(),
+ point.z() - k * m.get_m32());
+ SPoint3 p5(point.x() + k * m.get_m13(), point.y() + k * m.get_m23(),
+ point.z() + k * m.get_m33());
+ SPoint3 p6(point.x() - k * m.get_m13(), point.y() - k * m.get_m23(),
+ point.z() - k * m.get_m33());
+
+ print_segment(point, p1, color1, color2, file);
+ print_segment(point, p2, color1, color2, file);
+ print_segment(point, p3, color1, color2, file);
+ print_segment(point, p4, color1, color2, file);
+ print_segment(point, p5, color1, color2, file);
+ print_segment(point, p6, color1, color2, file);
}
}
}
@@ -319,10 +306,10 @@ void Frame_field::print_field2(GRegion* gr)
file << "};\n";
}
-GRegion* Frame_field::test()
+GRegion *Frame_field::test()
{
- GRegion* gr;
- GModel* model = GModel::current();
+ GRegion *gr;
+ GModel *model = GModel::current();
gr = *(model->firstRegion());
return gr;
}
@@ -343,55 +330,59 @@ void Frame_field::clear()
#endif
}
-//double max(const double a, const double b) { return (b>a)?b:a;}
-double min(const double a, const double b) { return (b<a)?b:a; }
-double squ(const double a) { return a*a; }
+// double max(const double a, const double b) { return (b>a)?b:a;}
+double min(const double a, const double b) { return (b < a) ? b : a; }
+double squ(const double a) { return a * a; }
-int Frame_field::build_vertex_to_vertices(GEntity* gr, int onWhat, bool initialize)
+int Frame_field::build_vertex_to_vertices(GEntity *gr, int onWhat,
+ bool initialize)
{
// build vertex to vertices data
- std::set<MVertex*> vertices;
+ std::set<MVertex *> vertices;
if(initialize) vertex_to_vertices.clear();
- for(unsigned int i=0; i<gr->getNumMeshElements(); i++){
- MElement* pElem = gr->getMeshElement(i);
+ for(unsigned int i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *pElem = gr->getMeshElement(i);
unsigned int n = pElem->getNumVertices();
- for(unsigned int j=0; j<n; j++){
- MVertex* pVertex = pElem->getVertex(j);
- if(onWhat >0 && pVertex->onWhat()->dim() != onWhat) continue;
-
- std::map<MVertex*,std::set<MVertex*> >::iterator it = vertex_to_vertices.find(pVertex);
- if(it != vertex_to_vertices.end()){
- for(unsigned int k=1; k<n; k++)
- it->second.insert(pElem->getVertex((j+k) % n));
+ for(unsigned int j = 0; j < n; j++) {
+ MVertex *pVertex = pElem->getVertex(j);
+ if(onWhat > 0 && pVertex->onWhat()->dim() != onWhat) continue;
+
+ std::map<MVertex *, std::set<MVertex *> >::iterator it =
+ vertex_to_vertices.find(pVertex);
+ if(it != vertex_to_vertices.end()) {
+ for(unsigned int k = 1; k < n; k++)
+ it->second.insert(pElem->getVertex((j + k) % n));
}
- else{
- vertices.clear();
- for(unsigned int k=1; k<n; k++)
- vertices.insert(pElem->getVertex((j+k) % n));
- vertex_to_vertices.insert(std::pair<MVertex*,std::set<MVertex*> >(pVertex,vertices));
+ else {
+ vertices.clear();
+ for(unsigned int k = 1; k < n; k++)
+ vertices.insert(pElem->getVertex((j + k) % n));
+ vertex_to_vertices.insert(
+ std::pair<MVertex *, std::set<MVertex *> >(pVertex, vertices));
}
-
}
}
return vertex_to_vertices.size();
}
-int Frame_field::build_vertex_to_elements(GEntity* gr, bool initialize)
+int Frame_field::build_vertex_to_elements(GEntity *gr, bool initialize)
{
- std::set<MElement*> elements;
+ std::set<MElement *> elements;
if(initialize) vertex_to_elements.clear();
- for(unsigned int i=0; i<gr->getNumMeshElements(); i++){
- MElement* pElem = gr->getMeshElement(i);
+ for(unsigned int i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *pElem = gr->getMeshElement(i);
unsigned int n = pElem->getNumVertices();
- for(unsigned int j=0; j<n; j++){
- MVertex* pVertex = pElem->getVertex(j);
- std::map<MVertex*,std::set<MElement*> >::iterator it = vertex_to_elements.find(pVertex);
+ for(unsigned int j = 0; j < n; j++) {
+ MVertex *pVertex = pElem->getVertex(j);
+ std::map<MVertex *, std::set<MElement *> >::iterator it =
+ vertex_to_elements.find(pVertex);
if(it != vertex_to_elements.end())
- it->second.insert(pElem);
- else{
- elements.clear();
- elements.insert(pElem);
- vertex_to_elements.insert(std::pair<MVertex*,std::set<MElement*> >(pVertex,elements));
+ it->second.insert(pElem);
+ else {
+ elements.clear();
+ elements.insert(pElem);
+ vertex_to_elements.insert(
+ std::pair<MVertex *, std::set<MElement *> >(pVertex, elements));
}
}
}
@@ -416,21 +407,22 @@ void Frame_field::build_listVertices(GEntity *gr, int dim, bool initialize)
}
}
-int Frame_field::buildAnnData(GEntity* ge, int dim)
+int Frame_field::buildAnnData(GEntity *ge, int dim)
{
- build_listVertices(ge,dim);
+ build_listVertices(ge, dim);
int n = listVertices.size();
#if defined(HAVE_ANN)
- ANNpointArray annTreeData = annAllocPts(n,3);
- for(int i=0; i<n; i++){
- MVertex* pVertex = listVertices[i];
+ ANNpointArray annTreeData = annAllocPts(n, 3);
+ for(int i = 0; i < n; i++) {
+ MVertex *pVertex = listVertices[i];
annTreeData[i][0] = pVertex->x();
annTreeData[i][1] = pVertex->y();
annTreeData[i][2] = pVertex->z();
}
- annTree = new ANNkd_tree(annTreeData,n,3);
+ annTree = new ANNkd_tree(annTreeData, n, 3);
#endif
- std::cout << "ANN data for " << ge->tag() << "(" << dim << ") contains " << n << " vertices" << std::endl;
+ std::cout << "ANN data for " << ge->tag() << "(" << dim << ") contains " << n
+ << " vertices" << std::endl;
return n;
}
@@ -454,7 +446,7 @@ int Frame_field::findAnnIndex(const SPoint3 &p)
query[1] = p.y();
query[2] = p.z();
double e = 0.;
- annTree->annkSearch(query,1,indices,distances,e);
+ annTree->annkSearch(query, 1, indices, distances, e);
annDeallocPt(query);
index = indices[0];
delete[] indices;
@@ -463,55 +455,61 @@ int Frame_field::findAnnIndex(const SPoint3 &p)
return index;
}
-void Frame_field::initFace(GFace* gf)
+void Frame_field::initFace(GFace *gf)
{
// align crosses of "gf" with the normal (average on neighbour elements)
// at all vertices of the GFace gf
build_vertex_to_elements(gf);
- for(std::map<MVertex*, std::set<MElement*> >::const_iterator it
- = vertex_to_elements.begin(); it != vertex_to_elements.end(); it++){
- std::set<MElement*> elements = it->second;
- SVector3 Area = SVector3(0,0,0);
- for(std::set<MElement*>::const_iterator iter=elements.begin();
- iter != elements.end(); iter++){
+ for(std::map<MVertex *, std::set<MElement *> >::const_iterator it =
+ vertex_to_elements.begin();
+ it != vertex_to_elements.end(); it++) {
+ std::set<MElement *> elements = it->second;
+ SVector3 Area = SVector3(0, 0, 0);
+ for(std::set<MElement *>::const_iterator iter = elements.begin();
+ iter != elements.end(); iter++) {
MElement *pElem = *iter;
int n = pElem->getNumVertices();
int i;
- for(i=0; i<n; i++){
- if(pElem->getVertex(i) == it->first) break;
- if(i == n-1) {
- std::cout << "This should not happen" << std:: endl; exit(1);
- }
+ for(i = 0; i < n; i++) {
+ if(pElem->getVertex(i) == it->first) break;
+ if(i == n - 1) {
+ std::cout << "This should not happen" << std::endl;
+ exit(1);
+ }
}
SVector3 V0 = pElem->getVertex(i)->point();
- SVector3 V1 = pElem->getVertex((i+n-1)%n)->point(); // previous vertex
- SVector3 V2 = pElem->getVertex((i+1)%n)->point(); // next vertex
- Area += crossprod(V2-V0,V1-V0);
+ SVector3 V1 =
+ pElem->getVertex((i + n - 1) % n)->point(); // previous vertex
+ SVector3 V2 = pElem->getVertex((i + 1) % n)->point(); // next vertex
+ Area += crossprod(V2 - V0, V1 - V0);
}
Area.normalize(); // average normal over neighbour face elements
STensor3 m = convert(cross3D(Area));
- std::map<MVertex*, STensor3>::iterator iter = crossField.find(it->first);
+ std::map<MVertex *, STensor3>::iterator iter = crossField.find(it->first);
if(iter == crossField.end())
- crossField.insert(std::pair<MVertex*, STensor3>(it->first,m));
+ crossField.insert(std::pair<MVertex *, STensor3>(it->first, m));
else
crossField[it->first] = m;
}
std::cout << "Nodes in face = " << vertex_to_elements.size() << std::endl;
- // compute cumulative cross-data "vertices x elements" for the whole contour of gf
- std::vector<GEdge*> const& edges = gf->edges();
+ // compute cumulative cross-data "vertices x elements" for the whole contour
+ // of gf
+ std::vector<GEdge *> const &edges = gf->edges();
vertex_to_elements.clear();
- for( std::vector<GEdge*>::const_iterator it=edges.begin(); it!=edges.end(); it++){
- build_vertex_to_elements(*it,false);
+ for(std::vector<GEdge *>::const_iterator it = edges.begin();
+ it != edges.end(); it++) {
+ build_vertex_to_elements(*it, false);
}
// align crosses of the contour of "gf" with the tangent to the contour
- for(std::map<MVertex*, std::set<MElement*> >::const_iterator it
- = vertex_to_elements.begin(); it != vertex_to_elements.end(); it++){
- MVertex* pVertex = it->first;
- std::set<MElement*> elements = it->second;
- if(elements.size() != 2){
+ for(std::map<MVertex *, std::set<MElement *> >::const_iterator it =
+ vertex_to_elements.begin();
+ it != vertex_to_elements.end(); it++) {
+ MVertex *pVertex = it->first;
+ std::set<MElement *> elements = it->second;
+ if(elements.size() != 2) {
std::cout << "The face has an open boundary" << std::endl;
exit(1);
}
@@ -520,7 +518,7 @@ void Frame_field::initFace(GFace* gf)
SVector3 tangent = edg1.scaledTangent() + edg2.scaledTangent();
tangent.normalize();
- std::map<MVertex*, STensor3>::iterator iter = crossField.find(pVertex);
+ std::map<MVertex *, STensor3>::iterator iter = crossField.find(pVertex);
if(iter == crossField.end()) {
std::cout << "This should not happen: cross not found 1" << std::endl;
exit(1);
@@ -531,7 +529,7 @@ void Frame_field::initFace(GFace* gf)
}
// fills ANN data with the vertices of the contour (dim=1) of "gf"
- buildAnnData(gf,1);
+ buildAnnData(gf, 1);
std::cout << "Nodes on contour = " << vertex_to_elements.size() << std::endl;
std::cout << "crossField = " << crossField.size() << std::endl;
@@ -543,41 +541,46 @@ void Frame_field::initFace(GFace* gf)
// The natural iterator gf->getMeshVertex(i) seems not to work
// when the option PackingOfParallelogram is on.
build_vertex_to_elements(gf);
- for(std::map<MVertex*, std::set<MElement*> >::const_iterator it
- = vertex_to_elements.begin(); it != vertex_to_elements.end(); it++){
- //for(unsigned int i=0; i<gf->getNumMeshVertices(); i++){
- //MVertex* pVertex0 = gf->getMeshVertex(i);
+ for(std::map<MVertex *, std::set<MElement *> >::const_iterator it =
+ vertex_to_elements.begin();
+ it != vertex_to_elements.end(); it++) {
+ // for(unsigned int i=0; i<gf->getNumMeshVertices(); i++){
+ // MVertex* pVertex0 = gf->getMeshVertex(i);
- MVertex* pVertex0 = it->first;
+ MVertex *pVertex0 = it->first;
if(pVertex0->onWhat()->dim() != 2) continue;
- std::map<MVertex*, STensor3>::iterator iter = crossField.find(pVertex0);
+ std::map<MVertex *, STensor3>::iterator iter = crossField.find(pVertex0);
cross3D y;
- if(iter == crossField.end()){
+ if(iter == crossField.end()) {
std::cout << "This should not happen: cross not found 2" << std::endl;
- std::cout << pVertex0->x() << "," << pVertex0->y() << "," << pVertex0->z() << std::endl;
- //exit(1);
+ std::cout << pVertex0->x() << "," << pVertex0->y() << "," << pVertex0->z()
+ << std::endl;
+ // exit(1);
y = cross3D();
}
else
- y = cross3D((*iter).second); //local cross y.getFirst() is the normal
+ y = cross3D((*iter).second); // local cross y.getFirst() is the normal
// Find the index of the nearest cross on the contour, using annTree
int index = findAnnIndex(pVertex0->point());
- MVertex* pVertex = listVertices[index]; //nearest vertex on contour
+ MVertex *pVertex = listVertices[index]; // nearest vertex on contour
iter = crossField.find(pVertex);
- if(iter == crossField.end()){
+ if(iter == crossField.end()) {
std::cout << "This should not happen: cross not found 3" << std::endl;
exit(1);
}
- cross3D x = cross3D((*iter).second); //nearest cross on contour, x.getFrst() is the normal
+ cross3D x = cross3D(
+ (*iter).second); // nearest cross on contour, x.getFrst() is the normal
- //STensor3 m = convert(cross3D(x.getFrst(),y.getScnd()));
+ // STensor3 m = convert(cross3D(x.getFrst(),y.getScnd()));
SVector3 v1 = y.getFrst();
- STensor3 m = convert( y.rotate(conj(x.rotationToOnSurf(y)))); //rotation around the normal
+ STensor3 m = convert(
+ y.rotate(conj(x.rotationToOnSurf(y)))); // rotation around the normal
SVector3 v2 = y.getFrst();
- if(fabs(angle(v1,v2)) > 1e-8){
- std::cout << "This should not happen: rotation affected the normal" << std::endl;
+ if(fabs(angle(v1, v2)) > 1e-8) {
+ std::cout << "This should not happen: rotation affected the normal"
+ << std::endl;
exit(1);
}
crossField[pVertex0] = m;
@@ -586,62 +589,67 @@ void Frame_field::initFace(GFace* gf)
deleteAnnData();
}
-void Frame_field::initRegion(GRegion* gr, int n)
+void Frame_field::initRegion(GRegion *gr, int n)
{
- std::vector<GFace*> faces = gr->faces();
- for(std::vector<GFace*>::const_iterator iter=faces.begin(); iter!=faces.end(); iter++){
+ std::vector<GFace *> faces = gr->faces();
+ for(std::vector<GFace *>::const_iterator iter = faces.begin();
+ iter != faces.end(); iter++) {
initFace(*iter);
- // smoothing must be done immediately because crosses on the contour vertices
- // are now initialized with the normal to THIS face.
+ // smoothing must be done immediately because crosses on the contour
+ // vertices are now initialized with the normal to THIS face.
smoothFace(*iter, n);
}
// Fills ANN data with the vertices of the surface (dim=2) of "gr"
- buildAnnData(gr,2);
- for(unsigned int i=0; i<gr->getNumMeshVertices(); i++){
- MVertex* pVertex0 = gr->getMeshVertex(i);
+ buildAnnData(gr, 2);
+ for(unsigned int i = 0; i < gr->getNumMeshVertices(); i++) {
+ MVertex *pVertex0 = gr->getMeshVertex(i);
if(pVertex0->onWhat()->dim() != 3) continue;
// Find the index of the nearest cross on the contour, using annTree
int index = findAnnIndex(pVertex0->point());
- MVertex* pVertex = listVertices[index];
+ MVertex *pVertex = listVertices[index];
STensor3 m = crossField[pVertex];
- crossField.insert(std::pair<MVertex*, STensor3>(pVertex0,m));
+ crossField.insert(std::pair<MVertex *, STensor3>(pVertex0, m));
}
deleteAnnData();
- buildAnnData(gr,3);
+ buildAnnData(gr, 3);
}
STensor3 Frame_field::findCross(double x, double y, double z)
{
- int index = Frame_field::findAnnIndex(SPoint3(x,y,z));
- MVertex* pVertex = Frame_field::listVertices[index];
+ int index = Frame_field::findAnnIndex(SPoint3(x, y, z));
+ MVertex *pVertex = Frame_field::listVertices[index];
return crossField[pVertex];
}
-double Frame_field::findBarycenter
- (std::map<MVertex*, std::set<MVertex*> >::const_iterator iter, STensor3 &m0)
+double Frame_field::findBarycenter(
+ std::map<MVertex *, std::set<MVertex *> >::const_iterator iter, STensor3 &m0)
{
double theta, gradient, energy;
STensor3 m;
SVector3 axis;
bool debug = false;
- MVertex* pVertex0 = iter->first;
- std::set<MVertex*> list = iter->second;
+ MVertex *pVertex0 = iter->first;
+ std::set<MVertex *> list = iter->second;
cross3D x(m0);
- if(debug) std::cout << "# " << pVertex0->getNum()
- << " with " << list.size() << " neighbours" << std::endl;
+ if(debug)
+ std::cout << "# " << pVertex0->getNum() << " with " << list.size()
+ << " neighbours" << std::endl;
SVector3 T = SVector3(0.), dT;
double temp = 0.;
energy = 0;
- for (std::set<MVertex*>::const_iterator it=list.begin(); it != list.end(); ++it){
+ for(std::set<MVertex *>::const_iterator it = list.begin(); it != list.end();
+ ++it) {
MVertex *pVertex = *it;
if(pVertex->getNum() == pVertex0->getNum())
std::cout << "This should not happen!" << std::endl;
- std::map<MVertex*, STensor3>::const_iterator itB = crossField.find(pVertex);
- if(itB == crossField.end()){ // not found
- std::cout << "This should not happen: cross not found 4" << std::endl; exit(1);
+ std::map<MVertex *, STensor3>::const_iterator itB =
+ crossField.find(pVertex);
+ if(itB == crossField.end()) { // not found
+ std::cout << "This should not happen: cross not found 4" << std::endl;
+ exit(1);
}
else
m = itB->second;
@@ -650,23 +658,24 @@ double Frame_field::findBarycenter
MEdge edge(pVertex0, pVertex);
theta = eulerAngleFromQtn(Rxy);
- gradient = theta/edge.length();
+ gradient = theta / edge.length();
energy += gradient * gradient;
crossDist[edge] = theta;
- if (fabs(theta) > 1e-10) {
+ if(fabs(theta) > 1e-10) {
axis = eulerAxisFromQtn(Rxy); // undefined if theta==0
- dT = axis * (theta / edge.length() / edge.length()) ;
+ dT = axis * (theta / edge.length() / edge.length());
T += dT;
}
temp += 1. / edge.length() / edge.length();
}
- if(temp) T *= 1.0/temp; // average rotation vector
+ if(temp) T *= 1.0 / temp; // average rotation vector
theta = T.norm();
- if(fabs(theta) > 1e-10){
+ if(fabs(theta) > 1e-10) {
axis = T;
- if(debug) std::cout << "-> " << pVertex0->getNum() << " : " << T << std::endl;
- Qtn R(axis.unit(),theta);
+ if(debug)
+ std::cout << "-> " << pVertex0->getNum() << " : " << T << std::endl;
+ Qtn R(axis.unit(), theta);
x.rotate(R);
m0 = convert(x);
}
@@ -676,19 +685,19 @@ double Frame_field::findBarycenter
void Frame_field::buildSmoothness()
{
GModel *m = GModel::current();
- std::vector<GEntity*> entities;
+ std::vector<GEntity *> entities;
m->getEntities(entities);
- //pour commencer on va creer une map de connectique des Mvertex
- std::map<MVertex*, std::vector<MVertex* > > Neighbours;
- for(unsigned int i = 0; i < entities.size(); i++){
- GEntity* eTmp = entities[i];
- for (unsigned int j = 0; j < eTmp->getNumMeshElements();j++){
- MElement* elem = eTmp->getMeshElement(j);
- for (std::size_t k = 0;k < elem->getNumVertices();k++){
- for (std::size_t l = k;l < elem->getNumVertices();l++){
- if (k != l){
- MVertex* v1 = elem->getVertex(k);
- MVertex* v2 = elem->getVertex(l);
+ // pour commencer on va creer une map de connectique des Mvertex
+ std::map<MVertex *, std::vector<MVertex *> > Neighbours;
+ for(unsigned int i = 0; i < entities.size(); i++) {
+ GEntity *eTmp = entities[i];
+ for(unsigned int j = 0; j < eTmp->getNumMeshElements(); j++) {
+ MElement *elem = eTmp->getMeshElement(j);
+ for(std::size_t k = 0; k < elem->getNumVertices(); k++) {
+ for(std::size_t l = k; l < elem->getNumVertices(); l++) {
+ if(k != l) {
+ MVertex *v1 = elem->getVertex(k);
+ MVertex *v2 = elem->getVertex(l);
Neighbours[v1].push_back(v2);
Neighbours[v2].push_back(v1);
}
@@ -696,55 +705,61 @@ void Frame_field::buildSmoothness()
}
}
}
- for(unsigned int i = 0; i < entities.size(); i++){
- for (unsigned int j = 0;j < entities[i]->mesh_vertices.size();j++){
- //on va traiter chaque noeud
- std::set<MVertex*> V1;
- std::set<MVertex*> V2;
- std::set<MVertex*> V3;
- MVertex* v0 = entities[i]->mesh_vertices[j];
+ for(unsigned int i = 0; i < entities.size(); i++) {
+ for(unsigned int j = 0; j < entities[i]->mesh_vertices.size(); j++) {
+ // on va traiter chaque noeud
+ std::set<MVertex *> V1;
+ std::set<MVertex *> V2;
+ std::set<MVertex *> V3;
+ MVertex *v0 = entities[i]->mesh_vertices[j];
V1.insert(v0);
- std::vector<MVertex* > v0vec = Neighbours[v0];
- for (unsigned int k = 0;k < v0vec.size();k++){
+ std::vector<MVertex *> v0vec = Neighbours[v0];
+ for(unsigned int k = 0; k < v0vec.size(); k++) {
V1.insert(v0vec[k]);
}
- for (std::set<MVertex*>::iterator itSet = V1.begin();itSet != V1.end();itSet++){
- MVertex* vTmp = (*itSet);
+ for(std::set<MVertex *>::iterator itSet = V1.begin(); itSet != V1.end();
+ itSet++) {
+ MVertex *vTmp = (*itSet);
V2.insert(vTmp);
v0vec = Neighbours[vTmp];
- for (unsigned int k = 0;k < v0vec.size();k++){
+ for(unsigned int k = 0; k < v0vec.size(); k++) {
V2.insert(v0vec[k]);
}
}
- for (std::set<MVertex*>::iterator itSet = V2.begin();itSet != V2.end();itSet++){
- MVertex* vTmp = (*itSet);
+ for(std::set<MVertex *>::iterator itSet = V2.begin(); itSet != V2.end();
+ itSet++) {
+ MVertex *vTmp = (*itSet);
V3.insert(vTmp);
v0vec = Neighbours[vTmp];
- for (unsigned int k = 0;k < v0vec.size();k++){
+ for(unsigned int k = 0; k < v0vec.size(); k++) {
V3.insert(v0vec[k]);
}
}
- //we have all three set here, time to compute the smoothnesses for each one
+ // we have all three set here, time to compute the smoothnesses for each
+ // one
std::vector<cross3D> C1;
std::vector<cross3D> C2;
std::vector<cross3D> C3;
double S1 = 0.0;
double S2 = 0.0;
double S3 = 0.0;
- for (std::set<MVertex*>::iterator itSet = V1.begin();itSet != V1.end();itSet++){
- MVertex* vTmp = (*itSet);
+ for(std::set<MVertex *>::iterator itSet = V1.begin(); itSet != V1.end();
+ itSet++) {
+ MVertex *vTmp = (*itSet);
STensor3 tTmp = crossField[vTmp];
cross3D cTmp = cross3D(tTmp);
C1.push_back(cTmp);
}
- for (std::set<MVertex*>::iterator itSet = V2.begin();itSet != V2.end();itSet++){
- MVertex* vTmp = (*itSet);
+ for(std::set<MVertex *>::iterator itSet = V2.begin(); itSet != V2.end();
+ itSet++) {
+ MVertex *vTmp = (*itSet);
STensor3 tTmp = crossField[vTmp];
cross3D cTmp = cross3D(tTmp);
C2.push_back(cTmp);
}
- for (std::set<MVertex*>::iterator itSet = V3.begin();itSet != V3.end();itSet++){
- MVertex* vTmp = (*itSet);
+ for(std::set<MVertex *>::iterator itSet = V3.begin(); itSet != V3.end();
+ itSet++) {
+ MVertex *vTmp = (*itSet);
STensor3 tTmp = crossField[vTmp];
cross3D cTmp = cross3D(tTmp);
C3.push_back(cTmp);
@@ -752,7 +767,7 @@ void Frame_field::buildSmoothness()
S1 = computeSetSmoothness(C1);
S2 = computeSetSmoothness(C2);
S3 = computeSetSmoothness(C3);
- double finalSmoothness = (9.0 * S1 + 3.0 * S2 + S3) / 13.0 ;
+ double finalSmoothness = (9.0 * S1 + 3.0 * S2 + S3) / 13.0;
crossFieldSmoothness[v0] = finalSmoothness;
}
}
@@ -760,10 +775,10 @@ void Frame_field::buildSmoothness()
double Frame_field::smoothFace(GFace *gf, int n)
{
- double energy=0;
+ double energy = 0;
build_vertex_to_vertices(gf, 2);
build_vertex_to_vertices(gf, 0, false);
- for(int i=0; i<n; i++){
+ for(int i = 0; i < n; i++) {
energy = smooth();
std::cout << "energy = " << energy << std::endl;
}
@@ -772,11 +787,11 @@ double Frame_field::smoothFace(GFace *gf, int n)
double Frame_field::smoothRegion(GRegion *gr, int n)
{
- double energy=0;
+ double energy = 0;
build_vertex_to_vertices(gr, 3);
- //build_vertex_to_vertices(gr, 1, false);
- //build_vertex_to_vertices(gr, 0, false);
- for(int i=0; i<n; i++){
+ // build_vertex_to_vertices(gr, 1, false);
+ // build_vertex_to_vertices(gr, 0, false);
+ for(int i = 0; i < n; i++) {
energy = smooth();
std::cout << "energy = " << energy << std::endl;
}
@@ -789,14 +804,15 @@ double Frame_field::smooth()
double enew, eold;
double energy = 0;
- for(std::map<MVertex*, std::set<MVertex*> >::const_iterator iter
- = vertex_to_vertices.begin(); iter != vertex_to_vertices.end(); ++iter){
-
- //MVertex* pVertex0 = iter->first;
+ for(std::map<MVertex *, std::set<MVertex *> >::const_iterator iter =
+ vertex_to_vertices.begin();
+ iter != vertex_to_vertices.end(); ++iter) {
+ // MVertex* pVertex0 = iter->first;
SVector3 T(0, 0, 0);
- std::map<MVertex*, STensor3>::iterator itA = crossField.find(iter->first);
- if(itA == crossField.end()){
- std::cout << "This should not happen" << std::endl; exit(1);
+ std::map<MVertex *, STensor3>::iterator itA = crossField.find(iter->first);
+ if(itA == crossField.end()) {
+ std::cout << "This should not happen" << std::endl;
+ exit(1);
}
else
m0 = itA->second;
@@ -804,11 +820,11 @@ double Frame_field::smooth()
m = m0;
unsigned int NbIter = 0;
enew = findBarycenter(iter, m); // initial energy in cell
- do{
+ do {
eold = enew;
crossField[itA->first] = m;
enew = findBarycenter(iter, m);
- } while ((enew < eold) && (++NbIter < 10));
+ } while((enew < eold) && (++NbIter < 10));
energy += eold;
}
return energy;
@@ -817,95 +833,88 @@ double Frame_field::smooth()
void Frame_field::save(const std::vector<std::pair<SPoint3, STensor3> > &data,
const std::string &filename)
{
- const cross3D origin(SVector3(1,0,0), SVector3(0,1,0));
+ const cross3D origin(SVector3(1, 0, 0), SVector3(0, 1, 0));
SPoint3 p1;
double k = 0.1;
std::ofstream file(filename.c_str());
file << "View \"cross field\" {\n";
- for(unsigned int i=0; i<data.size(); i++){
+ for(unsigned int i = 0; i < data.size(); i++) {
SPoint3 p = data[i].first;
STensor3 m = data[i].second;
- double val1 = eulerAngleFromQtn(cross3D(m).rotationTo(origin)), val2=val1;
- p1 = SPoint3(p.x() + k*m.get_m11(),
- p.y() + k*m.get_m21(),
- p.z() + k*m.get_m31());
- print_segment(p,p1,val1,val2,file);
- p1 = SPoint3(p.x() - k*m.get_m11(),
- p.y() - k*m.get_m21(),
- p.z() - k*m.get_m31());
- print_segment(p,p1,val1,val2,file);
- p1 = SPoint3(p.x() + k*m.get_m12(),
- p.y() + k*m.get_m22(),
- p.z() + k*m.get_m32());
- print_segment(p,p1,val1,val2,file);
- p1 = SPoint3(p.x() - k*m.get_m12(),
- p.y() - k*m.get_m22(),
- p.z() - k*m.get_m32());
- print_segment(p,p1,val1,val2,file);
- p1 = SPoint3(p.x() + k*m.get_m13(),
- p.y() + k*m.get_m23(),
- p.z() + k*m.get_m33());
- print_segment(p,p1,val1,val2,file);
- p1 = SPoint3(p.x() - k*m.get_m13(),
- p.y() - k*m.get_m23(),
- p.z() - k*m.get_m33());
- print_segment(p,p1,val1,val2,file);
+ double val1 = eulerAngleFromQtn(cross3D(m).rotationTo(origin)), val2 = val1;
+ p1 = SPoint3(p.x() + k * m.get_m11(), p.y() + k * m.get_m21(),
+ p.z() + k * m.get_m31());
+ print_segment(p, p1, val1, val2, file);
+ p1 = SPoint3(p.x() - k * m.get_m11(), p.y() - k * m.get_m21(),
+ p.z() - k * m.get_m31());
+ print_segment(p, p1, val1, val2, file);
+ p1 = SPoint3(p.x() + k * m.get_m12(), p.y() + k * m.get_m22(),
+ p.z() + k * m.get_m32());
+ print_segment(p, p1, val1, val2, file);
+ p1 = SPoint3(p.x() - k * m.get_m12(), p.y() - k * m.get_m22(),
+ p.z() - k * m.get_m32());
+ print_segment(p, p1, val1, val2, file);
+ p1 = SPoint3(p.x() + k * m.get_m13(), p.y() + k * m.get_m23(),
+ p.z() + k * m.get_m33());
+ print_segment(p, p1, val1, val2, file);
+ p1 = SPoint3(p.x() - k * m.get_m13(), p.y() - k * m.get_m23(),
+ p.z() - k * m.get_m33());
+ print_segment(p, p1, val1, val2, file);
}
file << "};\n";
file.close();
}
-void Frame_field::recur_connect_vert(FILE *fi, int count,
- MVertex *v,
+void Frame_field::recur_connect_vert(FILE *fi, int count, MVertex *v,
STensor3 &cross,
- std::multimap<MVertex*,MVertex*> &v2v,
- std::set<MVertex*> &touched)
+ std::multimap<MVertex *, MVertex *> &v2v,
+ std::set<MVertex *> &touched)
{
- if (touched.find(v) != touched.end()) return;
+ if(touched.find(v) != touched.end()) return;
touched.insert(v);
count++;
- for (std::multimap <MVertex*,MVertex*>::iterator it = v2v.lower_bound(v);
- it != v2v.upper_bound(v) ; ++it){
-
+ for(std::multimap<MVertex *, MVertex *>::iterator it = v2v.lower_bound(v);
+ it != v2v.upper_bound(v); ++it) {
MVertex *nextV = it->second;
- if (touched.find(nextV) == touched.end()){
-
- //compute dot product (N0,R0,A0) dot (Ni,Ri,Ai)^T
- //where N,R,A are the 3 directions
- std::map<MVertex*, STensor3>::iterator iter = crossField.find(nextV);
+ if(touched.find(nextV) == touched.end()) {
+ // compute dot product (N0,R0,A0) dot (Ni,Ri,Ai)^T
+ // where N,R,A are the 3 directions
+ std::map<MVertex *, STensor3>::iterator iter = crossField.find(nextV);
STensor3 nextCross = iter->second;
STensor3 nextCrossT = nextCross.transpose();
STensor3 prod = cross.operator*=(nextCrossT);
- fullMatrix<double> mat(3,3); prod.getMat(mat);
+ fullMatrix<double> mat(3, 3);
+ prod.getMat(mat);
- //find biggest dot product
+ // find biggest dot product
fullVector<int> Id(3);
Id(0) = Id(1) = Id(2) = 0;
- for (int j = 0; j < 3; j++){
+ for(int j = 0; j < 3; j++) {
double maxVal = 0.0;
- for (int i = 0; i < 3; i++){
- double val = fabs(mat(i,j));
- if( val > maxVal ){
- maxVal = val;
+ for(int i = 0; i < 3; i++) {
+ double val = fabs(mat(i, j));
+ if(val > maxVal) {
+ maxVal = val;
Id(j) = i;
}
}
}
- //check
- if (Id(0) +Id(1)+ Id(2) != 3 || (Id(0) == 1 && Id(1)==1 && Id(2)==1)) {
+ // check
+ if(Id(0) + Id(1) + Id(2) != 3 ||
+ (Id(0) == 1 && Id(1) == 1 && Id(2) == 1)) {
std::cout << "This should not happen: sum should be 0+1+2" << std::endl;
printf("Id =%d %d %d \n", Id(0), Id(1), Id(2));
return;
}
- //create new cross
- fullMatrix<double> newmat(3,3);
- for (int i = 0; i < 3; i++){
- for (int j = 0; j < 3; j++){
- newmat(i,j) = nextCross(Id(i),j) ;
+ // create new cross
+ fullMatrix<double> newmat(3, 3);
+ for(int i = 0; i < 3; i++) {
+ for(int j = 0; j < 3; j++) {
+ newmat(i, j) = nextCross(Id(i), j);
}
}
@@ -913,12 +922,12 @@ void Frame_field::recur_connect_vert(FILE *fi, int count,
newcross.setMat(newmat);
crossField[iter->first] = newcross;
- //print info
+ // print info
printf("************** COUNT = %d \n", count);
- if (Id(0) == 0 && Id(1) == 1 && Id(2) == 2)
+ if(Id(0) == 0 && Id(1) == 1 && Id(2) == 2)
printf("orient OK Id=%d %d %d\n", Id(0), Id(1), Id(2));
- else{
- printf("change orientation Id=%d %d %d \n", Id(0), Id(1), Id(2));
+ else {
+ printf("change orientation Id=%d %d %d \n", Id(0), Id(1), Id(2));
cross.print("cross ");
nextCross.print("nextCross ");
prod.print("product");
@@ -926,12 +935,12 @@ void Frame_field::recur_connect_vert(FILE *fi, int count,
}
if(fi)
- fprintf(fi,"SP(%g,%g,%g) {%g};\n",nextV->x(),nextV->y(),nextV->z(), (double)count);
+ fprintf(fi, "SP(%g,%g,%g) {%g};\n", nextV->x(), nextV->y(), nextV->z(),
+ (double)count);
- //continue recursion
- recur_connect_vert (fi, count, nextV, newcross, v2v,touched);
+ // continue recursion
+ recur_connect_vert(fi, count, nextV, newcross, v2v, touched);
}
-
}
}
@@ -939,151 +948,153 @@ void Frame_field::continuousCrossField(GRegion *gr, GFace *gf)
{
printf("continuous cross field \n");
- //start from a vertex of a face
- std::vector<GFace*> faces = gr->faces();
+ // start from a vertex of a face
+ std::vector<GFace *> faces = gr->faces();
bool foundFace = false;
- for(std::vector<GFace*>::const_iterator iter=faces.begin(); iter!=faces.end(); iter++){
- if (*iter == gf){
+ for(std::vector<GFace *>::const_iterator iter = faces.begin();
+ iter != faces.end(); iter++) {
+ if(*iter == gf) {
foundFace = true;
break;
}
}
- if (!foundFace){
- std::cout << "This should not happen: face does not belong to region" << std::endl;
+ if(!foundFace) {
+ std::cout << "This should not happen: face does not belong to region"
+ << std::endl;
exit(1);
}
- //build connectivity
+ // build connectivity
build_vertex_to_vertices(gr, -1, true);
- std::multimap<MVertex*,MVertex*> v2v;
- for(std::map<MVertex*, std::set<MVertex*> >::const_iterator iter
- = vertex_to_vertices.begin(); iter != vertex_to_vertices.end(); ++iter){
+ std::multimap<MVertex *, MVertex *> v2v;
+ for(std::map<MVertex *, std::set<MVertex *> >::const_iterator iter =
+ vertex_to_vertices.begin();
+ iter != vertex_to_vertices.end(); ++iter) {
MVertex *v = iter->first;
- std::set<MVertex*> mySet = iter->second;
- for (std::set<MVertex*>::iterator it = mySet.begin(); it!=mySet.end(); ++it){
- v2v.insert(std::make_pair(v,*it));
+ std::set<MVertex *> mySet = iter->second;
+ for(std::set<MVertex *>::iterator it = mySet.begin(); it != mySet.end();
+ ++it) {
+ v2v.insert(std::make_pair(v, *it));
}
}
- //recursive loop
+ // recursive loop
MVertex *beginV = gf->getMeshVertex(0);
- std::set<MVertex*> touched;
- std::map<MVertex*, STensor3>::iterator iter = crossField.find(beginV);
+ std::set<MVertex *> touched;
+ std::map<MVertex *, STensor3>::iterator iter = crossField.find(beginV);
STensor3 bCross = iter->second;
- FILE *fi = Fopen ("cross_recur.pos","w");
- if(fi){
- fprintf(fi,"View \"\"{\n");
- fprintf(fi,"SP(%g,%g,%g) {%g};\n",beginV->x(),beginV->y(),beginV->z(), 0.0);
+ FILE *fi = Fopen("cross_recur.pos", "w");
+ if(fi) {
+ fprintf(fi, "View \"\"{\n");
+ fprintf(fi, "SP(%g,%g,%g) {%g};\n", beginV->x(), beginV->y(), beginV->z(),
+ 0.0);
}
int count = 0;
- recur_connect_vert(fi, count, beginV,bCross,v2v,touched);
- if(fi){
- fprintf(fi,"};\n");
- fclose (fi);
+ recur_connect_vert(fi, count, beginV, bCross, v2v, touched);
+ if(fi) {
+ fprintf(fi, "};\n");
+ fclose(fi);
}
- //printf("touched =%d vert =%d \n", touched.size(), vertex_to_vertices.size());
+ // printf("touched =%d vert =%d \n", touched.size(),
+ // vertex_to_vertices.size());
}
-void Frame_field::saveCrossField(const std::string& filename, double scale, bool full)
+void Frame_field::saveCrossField(const std::string &filename, double scale,
+ bool full)
{
- const cross3D origin(SVector3(1,0,0), SVector3(0,1,0));
+ const cross3D origin(SVector3(1, 0, 0), SVector3(0, 1, 0));
SPoint3 p1;
double k = scale;
std::ofstream file(filename.c_str());
file << "View \"cross field\" {\n";
- for(std::map<MVertex*, STensor3>::const_iterator it = crossField.begin();
- it != crossField.end(); it++){
+ for(std::map<MVertex *, STensor3>::const_iterator it = crossField.begin();
+ it != crossField.end(); it++) {
SPoint3 p = it->first->point();
STensor3 m = it->second;
- //double val1 = eulerAngleFromQtn(cross3D(m).rotationTo(origin))*180./M_PI, val2=val1;
- double val1=1.0, val2=1.0;
- p1 = SPoint3(p.x() + k*m.get_m11(),
- p.y() + k*m.get_m21(),
- p.z() + k*m.get_m31());
- print_segment(p,p1,val1,val2,file);
- p1 = SPoint3(p.x() - k*m.get_m11(),
- p.y() - k*m.get_m21(),
- p.z() - k*m.get_m31());
- if(full) print_segment(p,p1,val1,val2,file);
- val1=2.0; val2=2.0;
- p1 = SPoint3(p.x() + k*m.get_m12(),
- p.y() + k*m.get_m22(),
- p.z() + k*m.get_m32());
- print_segment(p,p1,val1,val2,file);
- p1 = SPoint3(p.x() - k*m.get_m12(),
- p.y() - k*m.get_m22(),
- p.z() - k*m.get_m32());
- if(full) print_segment(p,p1,val1,val2,file);
- val1=3.0; val2=3.0;
- p1 = SPoint3(p.x() + k*m.get_m13(),
- p.y() + k*m.get_m23(),
- p.z() + k*m.get_m33());
- if(full) print_segment(p,p1,val1,val2,file);
- p1 = SPoint3(p.x() - k*m.get_m13(),
- p.y() - k*m.get_m23(),
- p.z() - k*m.get_m33());
- if(full) print_segment(p,p1,val1,val2,file);
+ // double val1 = eulerAngleFromQtn(cross3D(m).rotationTo(origin))*180./M_PI,
+ // val2=val1;
+ double val1 = 1.0, val2 = 1.0;
+ p1 = SPoint3(p.x() + k * m.get_m11(), p.y() + k * m.get_m21(),
+ p.z() + k * m.get_m31());
+ print_segment(p, p1, val1, val2, file);
+ p1 = SPoint3(p.x() - k * m.get_m11(), p.y() - k * m.get_m21(),
+ p.z() - k * m.get_m31());
+ if(full) print_segment(p, p1, val1, val2, file);
+ val1 = 2.0;
+ val2 = 2.0;
+ p1 = SPoint3(p.x() + k * m.get_m12(), p.y() + k * m.get_m22(),
+ p.z() + k * m.get_m32());
+ print_segment(p, p1, val1, val2, file);
+ p1 = SPoint3(p.x() - k * m.get_m12(), p.y() - k * m.get_m22(),
+ p.z() - k * m.get_m32());
+ if(full) print_segment(p, p1, val1, val2, file);
+ val1 = 3.0;
+ val2 = 3.0;
+ p1 = SPoint3(p.x() + k * m.get_m13(), p.y() + k * m.get_m23(),
+ p.z() + k * m.get_m33());
+ if(full) print_segment(p, p1, val1, val2, file);
+ p1 = SPoint3(p.x() - k * m.get_m13(), p.y() - k * m.get_m23(),
+ p.z() - k * m.get_m33());
+ if(full) print_segment(p, p1, val1, val2, file);
}
file << "};\n";
file.close();
}
-void Frame_field::save_dist(const std::string& filename)
+void Frame_field::save_dist(const std::string &filename)
{
std::ofstream file(filename.c_str());
file << "View \"Distance\" {\n";
for(std::map<MEdge, double, Less_Edge>::iterator it = crossDist.begin();
- it != crossDist.end(); it++){
- MVertex* pVerta = it->first.getVertex(0);
- MVertex* pVertb = it->first.getVertex(1);
- double value = it->second*180./M_PI;
- if(it->first.length())
- value /= it->first.length();
- file << "SL ("
- << pVerta->x() << ", " << pVerta->y() << ", " << pVerta->z() << ", "
- << pVertb->x() << ", " << pVertb->y() << ", " << pVertb->z() << ")"
- << "{" << value << "," << value << "};\n";
+ it != crossDist.end(); it++) {
+ MVertex *pVerta = it->first.getVertex(0);
+ MVertex *pVertb = it->first.getVertex(1);
+ double value = it->second * 180. / M_PI;
+ if(it->first.length()) value /= it->first.length();
+ file << "SL (" << pVerta->x() << ", " << pVerta->y() << ", " << pVerta->z()
+ << ", " << pVertb->x() << ", " << pVertb->y() << ", " << pVertb->z()
+ << ")"
+ << "{" << value << "," << value << "};\n";
}
file << "};\n";
file.close();
}
-void Frame_field::checkAnnData(GEntity* ge, const std::string& filename)
+void Frame_field::checkAnnData(GEntity *ge, const std::string &filename)
{
#if defined(HAVE_ANN)
std::ofstream file(filename.c_str());
file << "View \"ANN pairing\" {\n";
- for(unsigned int i=0; i<ge->getNumMeshVertices(); i++){
- MVertex* pVerta = ge->getMeshVertex(i);
- MVertex* pVertb = listVertices[findAnnIndex(pVerta->point())];
+ for(unsigned int i = 0; i < ge->getNumMeshVertices(); i++) {
+ MVertex *pVerta = ge->getMeshVertex(i);
+ MVertex *pVertb = listVertices[findAnnIndex(pVerta->point())];
double value = pVerta->distance(pVertb);
- file << "SL ("
- << pVerta->x() << ", " << pVerta->y() << ", " << pVerta->z() << ", "
- << pVertb->x() << ", " << pVertb->y() << ", " << pVertb->z() << ")"
- << "{" << value << "," << value << "};\n";
+ file << "SL (" << pVerta->x() << ", " << pVerta->y() << ", " << pVerta->z()
+ << ", " << pVertb->x() << ", " << pVertb->y() << ", " << pVertb->z()
+ << ")"
+ << "{" << value << "," << value << "};\n";
}
file << "};\n";
file.close();
#endif
}
-void Frame_field::save_energy(GRegion* gr, const std::string& filename)
+void Frame_field::save_energy(GRegion *gr, const std::string &filename)
{
#if defined(HAVE_POST)
- MElement* pElem;
+ MElement *pElem;
const int order = 1;
const int NumNodes = 4;
PViewDataList *data = new PViewDataList();
- for(unsigned int i = 0; i < gr->getNumMeshElements(); i++){
+ for(unsigned int i = 0; i < gr->getNumMeshElements(); i++) {
pElem = gr->getMeshElement(i);
- MTetrahedron* pTet = new MTetrahedron(pElem->getVertex(0),
- pElem->getVertex(1),
- pElem->getVertex(2),
- pElem->getVertex(3));
- //std::vector<double> *out = data->incrementList(1, TYPE_TET, NumNodes);
+ MTetrahedron *pTet =
+ new MTetrahedron(pElem->getVertex(0), pElem->getVertex(1),
+ pElem->getVertex(2), pElem->getVertex(3));
+ // std::vector<double> *out = data->incrementList(1, TYPE_TET, NumNodes);
std::vector<double> *out = data->incrementList(3, TYPE_TET, NumNodes);
for(std::size_t j = 0; j < pTet->getNumVertices(); j++)
out->push_back(pTet->getVertex(j)->x());
@@ -1091,76 +1102,78 @@ void Frame_field::save_energy(GRegion* gr, const std::string& filename)
out->push_back(pTet->getVertex(j)->y());
for(std::size_t j = 0; j < pTet->getNumVertices(); j++)
out->push_back(pTet->getVertex(j)->z());
- for(std::size_t j = 0; j < pTet->getNumVertices(); j++){
+ for(std::size_t j = 0; j < pTet->getNumVertices(); j++) {
double u, v, w;
- pTet->getNode(j,u,v,w);
+ pTet->getNode(j, u, v, w);
double sf[4], gsf[4][3];
pTet->getShapeFunctions(u, v, w, sf, order);
pTet->getGradShapeFunctions(u, v, w, gsf, order);
double jac[3][3], inv[3][3];
pTet->getJacobian(u, v, w, jac);
inv3x3(jac, inv);
- SVector3 sum(0,0,0);
- for(int k = 0; k < pTet->getNumEdges(); k++){
- int nod1 = pTet->edges_tetra(k,0);
- int nod2 = pTet->edges_tetra(k,1);
- double grd1[3], grd2[3];
- matvec(inv, gsf[nod1], grd1);
- matvec(inv, gsf[nod2], grd2);
- SVector3 esf = sf[nod1] * SVector3(grd2) - sf[nod2] * SVector3(grd1);
- std::map<MEdge, double, Less_Edge>::iterator it = crossDist.find(pTet->getEdge(k));
- sum += it->second * esf;
- //sum += (pTet->getVertex(nod2)->z() - pTet->getVertex(nod1)->z()) * esf;
+ SVector3 sum(0, 0, 0);
+ for(int k = 0; k < pTet->getNumEdges(); k++) {
+ int nod1 = pTet->edges_tetra(k, 0);
+ int nod2 = pTet->edges_tetra(k, 1);
+ double grd1[3], grd2[3];
+ matvec(inv, gsf[nod1], grd1);
+ matvec(inv, gsf[nod2], grd2);
+ SVector3 esf = sf[nod1] * SVector3(grd2) - sf[nod2] * SVector3(grd1);
+ std::map<MEdge, double, Less_Edge>::iterator it =
+ crossDist.find(pTet->getEdge(k));
+ sum += it->second * esf;
+ // sum += (pTet->getVertex(nod2)->z() - pTet->getVertex(nod1)->z()) *
+ // esf;
}
out->push_back(sum[0]);
out->push_back(sum[1]);
out->push_back(sum[2]);
- //out->push_back(sum.norm());
+ // out->push_back(sum.norm());
}
delete pTet;
}
data->setName("energy");
- //data->setFileName("energ.pos");
+ // data->setFileName("energ.pos");
data->writePOS(filename + ".pos");
data->writeMSH(filename + ".msh");
data->finalize();
#endif
}
-Size_field::Size_field(){}
+Size_field::Size_field() {}
-void Size_field::init_region(GRegion* gr)
+void Size_field::init_region(GRegion *gr)
{
#if defined(HAVE_ANN)
- GModel* model = GModel::current();
+ GModel *model = GModel::current();
- std::vector<GFace*> faces = gr->faces();
+ std::vector<GFace *> faces = gr->faces();
field.clear();
field.reserve(faces.size());
- std::vector<GFace*>::iterator it;
- for(it=faces.begin();it!=faces.end();it++){
- GFace* gf = *it;
+ std::vector<GFace *>::iterator it;
+ for(it = faces.begin(); it != faces.end(); it++) {
+ GFace *gf = *it;
- for(GRegion::size_type i=0;i<gf->storage1.size();i++){
+ for(GRegion::size_type i = 0; i < gf->storage1.size(); i++) {
SPoint3 point = gf->storage1[i];
double const h = gf->storage4[i];
- field.push_back(std::pair<SPoint3,double>(point,h));
+ field.push_back(std::pair<SPoint3, double>(point, h));
}
}
- ANNpointArray duplicate = annAllocPts(field.size(),3);
+ ANNpointArray duplicate = annAllocPts(field.size(), 3);
- for(GRegion::size_type i=0;i<field.size();i++){
+ for(GRegion::size_type i = 0; i < field.size(); i++) {
duplicate[i][0] = field[i].first.x();
duplicate[i][1] = field[i].first.y();
duplicate[i][2] = field[i].first.z();
}
- kd_tree = new ANNkd_tree(duplicate,field.size(),3);
+ kd_tree = new ANNkd_tree(duplicate, field.size(), 3);
boundary.clear();
@@ -1171,22 +1184,23 @@ void Size_field::init_region(GRegion* gr)
int index = 0;
double e = 0.0;
- for(it=faces.begin();it!=faces.end();it++){
- GFace* gf = *it;
+ for(it = faces.begin(); it != faces.end(); it++) {
+ GFace *gf = *it;
- for(GRegion::size_type i=0;i<gf->getNumMeshElements();i++){
- MElement* element = gf->getMeshElement(i);
- for(std::size_t j=0;j<element->getNumVertices();j++){
- MVertex* vertex = element->getVertex(j);
+ for(GRegion::size_type i = 0; i < gf->getNumMeshElements(); i++) {
+ MElement *element = gf->getMeshElement(i);
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
+ MVertex *vertex = element->getVertex(j);
query[0] = vertex->x();
query[1] = vertex->y();
query[2] = vertex->z();
- kd_tree->annkSearch(query,1,indices,distances,e);
+ kd_tree->annkSearch(query, 1, indices, distances, e);
index = indices[0];
- boundary.insert(std::pair<MVertex*,double>(vertex,field[index].second));
+ boundary.insert(
+ std::pair<MVertex *, double>(vertex, field[index].second));
}
}
}
@@ -1199,7 +1213,7 @@ void Size_field::init_region(GRegion* gr)
#endif
}
-void Size_field::solve(GRegion* gr)
+void Size_field::solve(GRegion *gr)
{
#if defined(HAVE_SOLVER)
@@ -1216,88 +1230,88 @@ void Size_field::solve(GRegion* gr)
int count2;
double val;
double volume;
- std::set<MVertex*> interior;
- std::set<MVertex*>::iterator it;
- std::map<MVertex*,double>::iterator it2;
+ std::set<MVertex *> interior;
+ std::set<MVertex *>::iterator it;
+ std::map<MVertex *, double>::iterator it2;
interior.clear();
dofManager<double> assembler(system);
count = 0;
- for(it2=boundary.begin();it2!=boundary.end();it2++){
- assembler.fixVertex(it2->first,0,1,it2->second);
+ for(it2 = boundary.begin(); it2 != boundary.end(); it2++) {
+ assembler.fixVertex(it2->first, 0, 1, it2->second);
count++;
}
- //printf("\n");
- //printf("number of boundary vertices = %d\n",count);
+ // printf("\n");
+ // printf("number of boundary vertices = %d\n",count);
- for(i=0;i<gr->tetrahedra.size();i++){
+ for(i = 0; i < gr->tetrahedra.size(); i++) {
interior.insert(gr->tetrahedra[i]->getVertex(0));
interior.insert(gr->tetrahedra[i]->getVertex(1));
interior.insert(gr->tetrahedra[i]->getVertex(2));
interior.insert(gr->tetrahedra[i]->getVertex(3));
}
- for(it=interior.begin();it!=interior.end();it++){
+ for(it = interior.begin(); it != interior.end(); it++) {
it2 = boundary.find(*it);
- if(it2==boundary.end()){
- assembler.numberVertex(*it,0,1);
+ if(it2 == boundary.end()) {
+ assembler.numberVertex(*it, 0, 1);
}
}
- for(i=0;i<gr->tetrahedra.size();i++){
+ for(i = 0; i < gr->tetrahedra.size(); i++) {
gr->tetrahedra[i]->setVolumePositive();
}
count2 = 0;
volume = 0.0;
simpleFunction<double> ONE(1.0);
- laplaceTerm term(0,1,&ONE);
- for(i=0;i<gr->tetrahedra.size();i++){
+ laplaceTerm term(0, 1, &ONE);
+ for(i = 0; i < gr->tetrahedra.size(); i++) {
SElement se(gr->tetrahedra[i]);
- term.addToMatrix(assembler,&se);
+ term.addToMatrix(assembler, &se);
count2++;
volume = volume + gr->tetrahedra[i]->getVolume();
}
- //printf("number of tetrahedra = %d\n",count2);
- //printf("volume = %f\n",volume);
+ // printf("number of tetrahedra = %d\n",count2);
+ // printf("volume = %f\n",volume);
- if(assembler.sizeOfR()){
+ if(assembler.sizeOfR()) {
system->systemSolve();
}
- for(it=interior.begin();it!=interior.end();it++){
- assembler.getDofValue(*it,0,1,val);
- boundary.insert(std::pair<MVertex*,double>(*it,val));
+ for(it = interior.begin(); it != interior.end(); it++) {
+ assembler.getDofValue(*it, 0, 1, val);
+ boundary.insert(std::pair<MVertex *, double>(*it, val));
}
delete system;
#endif
}
-double Size_field::search(double x,double y,double z)
+double Size_field::search(double x, double y, double z)
{
- double u,v,w;
+ double u, v, w;
double val;
- MElement* element;
+ MElement *element;
double temp1[3];
double temp2[3];
- std::map<MVertex*,double>::iterator it1;
- std::map<MVertex*,double>::iterator it2;
- std::map<MVertex*,double>::iterator it3;
- std::map<MVertex*,double>::iterator it4;
+ std::map<MVertex *, double>::iterator it1;
+ std::map<MVertex *, double>::iterator it2;
+ std::map<MVertex *, double>::iterator it3;
+ std::map<MVertex *, double>::iterator it4;
val = 1.0;
- element = (MElement*)octree->find(x,y,z,3,true);
+ element = (MElement *)octree->find(x, y, z, 3, true);
- if(element!=NULL){
+ if(element != NULL) {
temp1[0] = x;
temp1[1] = y;
temp1[2] = z;
- element->xyz2uvw(temp1,temp2);
+ element->xyz2uvw(temp1, temp2);
u = temp2[0];
v = temp2[1];
@@ -1308,62 +1322,62 @@ double Size_field::search(double x,double y,double z)
it3 = boundary.find(element->getVertex(2));
it4 = boundary.find(element->getVertex(3));
- if(it1!=boundary.end() && it2!=boundary.end() &&
- it3!=boundary.end() && it4!=boundary.end()){
- val = (it1->second)*(1.0-u-v-w) + (it2->second)*u +
- (it3->second)*v + (it4->second)*w;
+ if(it1 != boundary.end() && it2 != boundary.end() &&
+ it3 != boundary.end() && it4 != boundary.end()) {
+ val = (it1->second) * (1.0 - u - v - w) + (it2->second) * u +
+ (it3->second) * v + (it4->second) * w;
}
}
return val;
}
-void Size_field::print_field(GRegion* gr)
+void Size_field::print_field(GRegion *gr)
{
size_t i;
- double min,max;
- //double x,y,z;
- double x1,y1,z1,h1;
- double x2,y2,z2,h2;
- double x3,y3,z3,h3;
- double x4,y4,z4,h4;
- std::map<MVertex*,double>::iterator it;
- std::map<MVertex*,double>::iterator it1;
- std::map<MVertex*,double>::iterator it2;
- std::map<MVertex*,double>::iterator it3;
- std::map<MVertex*,double>::iterator it4;
+ double min, max;
+ // double x,y,z;
+ double x1, y1, z1, h1;
+ double x2, y2, z2, h2;
+ double x3, y3, z3, h3;
+ double x4, y4, z4, h4;
+ std::map<MVertex *, double>::iterator it;
+ std::map<MVertex *, double>::iterator it1;
+ std::map<MVertex *, double>::iterator it2;
+ std::map<MVertex *, double>::iterator it3;
+ std::map<MVertex *, double>::iterator it4;
min = 1000000000.0;
max = -1000000000.0;
- for(it=boundary.begin();it!=boundary.end();it++){
- //x = (it->first)->x();
- //y = (it->first)->y();
- //z = (it->first)->z();
+ for(it = boundary.begin(); it != boundary.end(); it++) {
+ // x = (it->first)->x();
+ // y = (it->first)->y();
+ // z = (it->first)->z();
- if(it->second>max){
+ if(it->second > max) {
max = it->second;
}
- if(it->second<min){
+ if(it->second < min) {
min = it->second;
}
- //printf("x = %f, y = %f, z = %f, mesh size = %f\n",x,y,z,it->second);
+ // printf("x = %f, y = %f, z = %f, mesh size = %f\n",x,y,z,it->second);
}
- //printf("\n");
+ // printf("\n");
- printf("min mesh size = %f\n",min);
- printf("max mesh size = %f\n",max);
+ printf("min mesh size = %f\n", min);
+ printf("max mesh size = %f\n", max);
- printf("total number of vertices = %zu\n",boundary.size());
+ printf("total number of vertices = %zu\n", boundary.size());
printf("\n");
std::ofstream file("laplace.pos");
file << "View \"test\" {\n";
- for(i=0;i<gr->tetrahedra.size();i++){
+ for(i = 0; i < gr->tetrahedra.size(); i++) {
x1 = gr->tetrahedra[i]->getVertex(0)->x();
y1 = gr->tetrahedra[i]->getVertex(0)->y();
z1 = gr->tetrahedra[i]->getVertex(0)->z();
@@ -1384,30 +1398,27 @@ void Size_field::print_field(GRegion* gr)
z4 = gr->tetrahedra[i]->getVertex(3)->z();
it4 = boundary.find(gr->tetrahedra[i]->getVertex(3));
- if(it1!=boundary.end() && it2!=boundary.end() &&
- it3!=boundary.end() && it4!=boundary.end()){
+ if(it1 != boundary.end() && it2 != boundary.end() &&
+ it3 != boundary.end() && it4 != boundary.end()) {
h1 = it1->second;
h2 = it2->second;
h3 = it3->second;
h4 = it4->second;
- file << "SS ("
- << x1 << ", " << y1 << ", " << z1 << ", "
- << x2 << ", " << y2 << ", " << z2 << ", "
- << x3 << ", " << y3 << ", " << z3 << ", "
- << x4 << ", " << y4 << ", " << z4 << "){"
- << h1 << ", " << h2 << ", " << h3 << ", "
- << h4 << "};\n";
+ file << "SS (" << x1 << ", " << y1 << ", " << z1 << ", " << x2 << ", "
+ << y2 << ", " << z2 << ", " << x3 << ", " << y3 << ", " << z3 << ", "
+ << x4 << ", " << y4 << ", " << z4 << "){" << h1 << ", " << h2 << ", "
+ << h3 << ", " << h4 << "};\n";
}
}
file << "};\n";
}
-GRegion* Size_field::test()
+GRegion *Size_field::test()
{
- GRegion* gr;
- GModel* model = GModel::current();
+ GRegion *gr;
+ GModel *model = GModel::current();
gr = *(model->firstRegion());
@@ -1424,42 +1435,41 @@ void Size_field::clear()
delete kd_tree;
annClose();
#endif
-
}
-Nearest_point::Nearest_point(){}
+Nearest_point::Nearest_point() {}
-void Nearest_point::init_region(GRegion* gr)
+void Nearest_point::init_region(GRegion *gr)
{
#if defined(HAVE_ANN)
unsigned int i;
int j;
int gauss_num;
- double u,v;
- double x,y,z;
- double x1,y1,z1;
- double x2,y2,z2;
- double x3,y3,z3;
- MElement* element;
- GFace* gf;
- std::set<MVertex*> temp;
- std::vector<GFace*>::iterator it;
- std::set<MVertex*>::iterator it2;
+ double u, v;
+ double x, y, z;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double x3, y3, z3;
+ MElement *element;
+ GFace *gf;
+ std::set<MVertex *> temp;
+ std::vector<GFace *>::iterator it;
+ std::set<MVertex *>::iterator it2;
fullMatrix<double> gauss_points;
fullVector<double> gauss_weights;
- gaussIntegration::getTriangle(8,gauss_points,gauss_weights);
+ gaussIntegration::getTriangle(8, gauss_points, gauss_weights);
gauss_num = gauss_points.size1();
- std::vector<GFace*> faces = gr->faces();
+ std::vector<GFace *> faces = gr->faces();
field.clear();
vicinity.clear();
temp.clear();
- for(it=faces.begin();it!=faces.end();it++){
+ for(it = faces.begin(); it != faces.end(); it++) {
gf = *it;
- for(i=0;i<gf->getNumMeshElements();i++){
+ for(i = 0; i < gf->getNumMeshElements(); i++) {
element = gf->getMeshElement(i);
x1 = element->getVertex(0)->x();
@@ -1474,15 +1484,15 @@ void Nearest_point::init_region(GRegion* gr)
y3 = element->getVertex(2)->y();
z3 = element->getVertex(2)->z();
- for(j=0;j<gauss_num;j++){
- u = gauss_points(j,0);
- v = gauss_points(j,1);
+ for(j = 0; j < gauss_num; j++) {
+ u = gauss_points(j, 0);
+ v = gauss_points(j, 1);
- x = T(u,v,x1,x2,x3);
- y = T(u,v,y1,y2,y3);
- z = T(u,v,z1,z2,z3);
+ x = T(u, v, x1, x2, x3);
+ y = T(u, v, y1, y2, y3);
+ z = T(u, v, z1, z2, z3);
- field.push_back(SPoint3(x,y,z));
+ field.push_back(SPoint3(x, y, z));
vicinity.push_back(element);
}
@@ -1492,27 +1502,27 @@ void Nearest_point::init_region(GRegion* gr)
}
}
- for(it2=temp.begin();it2!=temp.end();it2++){
+ for(it2 = temp.begin(); it2 != temp.end(); it2++) {
x = (*it2)->x();
y = (*it2)->y();
z = (*it2)->z();
- //field.push_back(SPoint3(x,y,z));
- //vicinity.push_back(NULL);
+ // field.push_back(SPoint3(x,y,z));
+ // vicinity.push_back(NULL);
}
- ANNpointArray duplicate = annAllocPts(field.size(),3);
+ ANNpointArray duplicate = annAllocPts(field.size(), 3);
- for(i=0;i<field.size();i++){
+ for(i = 0; i < field.size(); i++) {
duplicate[i][0] = field[i].x();
duplicate[i][1] = field[i].y();
duplicate[i][2] = field[i].z();
}
- kd_tree = new ANNkd_tree(duplicate,field.size(),3);
+ kd_tree = new ANNkd_tree(duplicate, field.size(), 3);
#endif
}
-bool Nearest_point::search(double x,double y,double z,SVector3& vec)
+bool Nearest_point::search(double x, double y, double z, SVector3 &vec)
{
int index;
bool val = false;
@@ -1533,29 +1543,30 @@ bool Nearest_point::search(double x,double y,double z,SVector3& vec)
distances = new ANNdist[1];
e = 0.0;
- kd_tree->annkSearch(query,1,indices,distances,e);
+ kd_tree->annkSearch(query, 1, indices, distances, e);
index = indices[0];
annDeallocPt(query);
delete[] indices;
delete[] distances;
- if(vicinity[index]!=NULL){
- found = closest(vicinity[index],SPoint3(x,y,z));
+ if(vicinity[index] != NULL) {
+ found = closest(vicinity[index], SPoint3(x, y, z));
}
- else{
+ else {
found = field[index];
}
e2 = 0.000001;
- if(fabs(found.x()-x)>e2 || fabs(found.y()-y)>e2 || fabs(found.z()-z)>e2){
- vec = SVector3(found.x()-x,found.y()-y,found.z()-z);
+ if(fabs(found.x() - x) > e2 || fabs(found.y() - y) > e2 ||
+ fabs(found.z() - z) > e2) {
+ vec = SVector3(found.x() - x, found.y() - y, found.z() - z);
vec.normalize();
val = 1;
}
- else{
- vec = SVector3(1.0,0.0,0.0);
+ else {
+ vec = SVector3(1.0, 0.0, 0.0);
val = 0;
}
#endif
@@ -1563,9 +1574,10 @@ bool Nearest_point::search(double x,double y,double z,SVector3& vec)
return val;
}
-double Nearest_point::T(double u,double v,double val1,double val2,double val3)
+double Nearest_point::T(double u, double v, double val1, double val2,
+ double val3)
{
- return (1.0-u-v)*val1 + u*val2 + v*val3;
+ return (1.0 - u - v) * val1 + u * val2 + v * val3;
}
// The following method comes from this page :
@@ -1574,110 +1586,112 @@ double Nearest_point::T(double u,double v,double val1,double val2,double val3)
SPoint3 Nearest_point::closest(MElement *element, const SPoint3 &point)
{
- SVector3 edge0 = SVector3(element->getVertex(1)->x()-element->getVertex(0)->x(),
- element->getVertex(1)->y()-element->getVertex(0)->y(),
- element->getVertex(1)->z()-element->getVertex(0)->z());
- SVector3 edge1 = SVector3(element->getVertex(2)->x()-element->getVertex(0)->x(),
- element->getVertex(2)->y()-element->getVertex(0)->y(),
- element->getVertex(2)->z()-element->getVertex(0)->z());
- SVector3 v0 = SVector3(element->getVertex(0)->x()-point.x(),
- element->getVertex(0)->y()-point.y(),
- element->getVertex(0)->z()-point.z());
-
- double a = dot(edge0,edge0);
- double b = dot(edge0,edge1);
- double c = dot(edge1,edge1);
- double d = dot(edge0,v0);
- double e = dot(edge1,v0);
-
- double det = a*c-b*b;
- double s = b*e-c*d;
- double t = b*d-a*e;
-
- if(s+t<det){
- if(s<0.0){
- if(t<0.0){
- if(d<0.0){
- s = clamp(-d/a,0.0,1.0);
+ SVector3 edge0 =
+ SVector3(element->getVertex(1)->x() - element->getVertex(0)->x(),
+ element->getVertex(1)->y() - element->getVertex(0)->y(),
+ element->getVertex(1)->z() - element->getVertex(0)->z());
+ SVector3 edge1 =
+ SVector3(element->getVertex(2)->x() - element->getVertex(0)->x(),
+ element->getVertex(2)->y() - element->getVertex(0)->y(),
+ element->getVertex(2)->z() - element->getVertex(0)->z());
+ SVector3 v0 = SVector3(element->getVertex(0)->x() - point.x(),
+ element->getVertex(0)->y() - point.y(),
+ element->getVertex(0)->z() - point.z());
+
+ double a = dot(edge0, edge0);
+ double b = dot(edge0, edge1);
+ double c = dot(edge1, edge1);
+ double d = dot(edge0, v0);
+ double e = dot(edge1, v0);
+
+ double det = a * c - b * b;
+ double s = b * e - c * d;
+ double t = b * d - a * e;
+
+ if(s + t < det) {
+ if(s < 0.0) {
+ if(t < 0.0) {
+ if(d < 0.0) {
+ s = clamp(-d / a, 0.0, 1.0);
t = 0.0;
}
- else{
+ else {
s = 0.0;
- t = clamp(-e/c,0.0,1.0);
+ t = clamp(-e / c, 0.0, 1.0);
}
}
- else{
+ else {
s = 0.0;
- t = clamp(-e/c,0.0,1.0);
+ t = clamp(-e / c, 0.0, 1.0);
}
}
- else if(t<0.0){
- s = clamp(-d/a,0.0,1.0);
+ else if(t < 0.0) {
+ s = clamp(-d / a, 0.0, 1.0);
t = 0.0;
}
- else{
- double invDet = 1.0/det;
+ else {
+ double invDet = 1.0 / det;
s *= invDet;
t *= invDet;
}
}
- else{
- if(s<0.0){
- double tmp0 = b+d;
- double tmp1 = c+e;
- if(tmp1>tmp0){
- double numer = tmp1-tmp0;
- double denom = a-2.0*b+c;
- s = clamp(numer/denom,0.0,1.0);
- t = 1.0-s;
+ else {
+ if(s < 0.0) {
+ double tmp0 = b + d;
+ double tmp1 = c + e;
+ if(tmp1 > tmp0) {
+ double numer = tmp1 - tmp0;
+ double denom = a - 2.0 * b + c;
+ s = clamp(numer / denom, 0.0, 1.0);
+ t = 1.0 - s;
}
- else{
- t = clamp(-e/c,0.0,1.0);
+ else {
+ t = clamp(-e / c, 0.0, 1.0);
s = 0.0;
}
}
- else if(t<0.0){
- if(a+d>b+e){
- double numer = c+e-b-d;
- double denom = a-2.0*b+c;
- s = clamp(numer/denom,0.0,1.0);
- t = 1.0-s;
+ else if(t < 0.0) {
+ if(a + d > b + e) {
+ double numer = c + e - b - d;
+ double denom = a - 2.0 * b + c;
+ s = clamp(numer / denom, 0.0, 1.0);
+ t = 1.0 - s;
}
- else{
- s = clamp(-e/c,0.0,1.0);
+ else {
+ s = clamp(-e / c, 0.0, 1.0);
t = 0.0;
}
}
- else{
- double numer = c+e-b-d;
- double denom = a-2.0*b+c;
- s = clamp(numer/denom,0.0,1.0);
- t = 1.0-s;
+ else {
+ double numer = c + e - b - d;
+ double denom = a - 2.0 * b + c;
+ s = clamp(numer / denom, 0.0, 1.0);
+ t = 1.0 - s;
}
}
- return SPoint3(element->getVertex(0)->x()+s*edge0.x()+t*edge1.x(),
- element->getVertex(0)->y()+s*edge0.y()+t*edge1.y(),
- element->getVertex(0)->z()+s*edge0.z()+t*edge1.z());
+ return SPoint3(element->getVertex(0)->x() + s * edge0.x() + t * edge1.x(),
+ element->getVertex(0)->y() + s * edge0.y() + t * edge1.y(),
+ element->getVertex(0)->z() + s * edge0.z() + t * edge1.z());
}
-double Nearest_point::clamp(double x,double min,double max)
+double Nearest_point::clamp(double x, double min, double max)
{
double val;
val = x;
- if(val<min){
+ if(val < min) {
val = min;
}
- else if(val>max){
+ else if(val > max) {
val = max;
}
return val;
}
-void Nearest_point::print_field(GRegion* gr)
+void Nearest_point::print_field(GRegion *gr)
{
SVector3 vec;
@@ -1685,17 +1699,18 @@ void Nearest_point::print_field(GRegion* gr)
std::ofstream file("nearest.pos");
file << "View \"test\" {\n";
- for(GRegion::size_type i=0;i<gr->getNumMeshElements();i++){
- MElement* element = gr->getMeshElement(i);
- for(GRegion::size_type j=0;j<element->getNumVertices();j++){
- MVertex* vertex = element->getVertex(j);
+ for(GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *element = gr->getMeshElement(i);
+ for(GRegion::size_type j = 0; j < element->getNumVertices(); j++) {
+ MVertex *vertex = element->getVertex(j);
double x = vertex->x();
double y = vertex->y();
double z = vertex->z();
- bool const val = search(x,y,z,vec);
- if(val){
- print_segment(SPoint3(x+k*vec.x(),y+k*vec.y(),z+k*vec.z()),
- SPoint3(x-k*vec.x(),y-k*vec.y(),z-k*vec.z()),file);
+ bool const val = search(x, y, z, vec);
+ if(val) {
+ print_segment(
+ SPoint3(x + k * vec.x(), y + k * vec.y(), z + k * vec.z()),
+ SPoint3(x - k * vec.x(), y - k * vec.y(), z - k * vec.z()), file);
}
}
}
@@ -1706,16 +1721,15 @@ void Nearest_point::print_field(GRegion* gr)
void Nearest_point::print_segment(const SPoint3 &p1, const SPoint3 &p2,
std::ofstream &file)
{
- file << "SL ("
- << p1.x() << ", " << p1.y() << ", " << p1.z() << ", "
- << p2.x() << ", " << p2.y() << ", " << p2.z() << ")"
- << "{10, 20};\n";
+ file << "SL (" << p1.x() << ", " << p1.y() << ", " << p1.z() << ", " << p2.x()
+ << ", " << p2.y() << ", " << p2.z() << ")"
+ << "{10, 20};\n";
}
-GRegion* Nearest_point::test()
+GRegion *Nearest_point::test()
{
- GRegion* gr;
- GModel* model = GModel::current();
+ GRegion *gr;
+ GModel *model = GModel::current();
gr = *(model->firstRegion());
@@ -1727,36 +1741,36 @@ void Nearest_point::clear()
field.clear();
vicinity.clear();
#if defined(HAVE_ANN)
- delete kd_tree->thePoints();
- delete kd_tree;
+ delete kd_tree->thePoints();
+ delete kd_tree;
annClose();
#endif
}
// static declarations
-std::vector<std::pair<SPoint3,STensor3> > Frame_field::field;
+std::vector<std::pair<SPoint3, STensor3> > Frame_field::field;
std::vector<int> Frame_field::labels;
-std::map<MVertex*, STensor3> Frame_field::crossField;
-std::map<MVertex*, double> Frame_field::crossFieldSmoothness;
+std::map<MVertex *, STensor3> Frame_field::crossField;
+std::map<MVertex *, double> Frame_field::crossFieldSmoothness;
std::map<MEdge, double, Less_Edge> Frame_field::crossDist;
-std::map<MVertex*,std::set<MVertex*> > Frame_field::vertex_to_vertices;
-std::map<MVertex*,std::set<MElement*> > Frame_field::vertex_to_elements;
-std::vector<MVertex*> Frame_field::listVertices;
+std::map<MVertex *, std::set<MVertex *> > Frame_field::vertex_to_vertices;
+std::map<MVertex *, std::set<MElement *> > Frame_field::vertex_to_elements;
+std::vector<MVertex *> Frame_field::listVertices;
#if defined(HAVE_ANN)
-ANNkd_tree* Frame_field::kd_tree;
-ANNkd_tree* Frame_field::annTree;
+ANNkd_tree *Frame_field::kd_tree;
+ANNkd_tree *Frame_field::annTree;
#endif
-std::vector<std::pair<SPoint3,double> > Size_field::field;
-std::map<MVertex*,double> Size_field::boundary;
-MElementOctree* Size_field::octree;
+std::vector<std::pair<SPoint3, double> > Size_field::field;
+std::map<MVertex *, double> Size_field::boundary;
+MElementOctree *Size_field::octree;
#if defined(HAVE_ANN)
-ANNkd_tree* Size_field::kd_tree;
+ANNkd_tree *Size_field::kd_tree;
#endif
std::vector<SPoint3> Nearest_point::field;
-std::vector<MElement*> Nearest_point::vicinity;
+std::vector<MElement *> Nearest_point::vicinity;
#if defined(HAVE_ANN)
-ANNkd_tree* Nearest_point::kd_tree;
+ANNkd_tree *Nearest_point::kd_tree;
#endif
diff --git a/Mesh/directions3D.h b/Mesh/directions3D.h
index fccf57297f56005a0d4a4a55cde7b7268ba47b6d..4405a7ff85033a6a3c6681e5866efa1ba60b832d 100644
--- a/Mesh/directions3D.h
+++ b/Mesh/directions3D.h
@@ -19,95 +19,108 @@ class ANNkd_tree;
#include "STensor3.h"
struct lowerThan {
- bool operator() (const std::pair<int, STensor3>& lhs, const std::pair<int, STensor3>& rhs) const
- {return lhs.first < rhs.first;}
+ bool operator()(const std::pair<int, STensor3> &lhs,
+ const std::pair<int, STensor3> &rhs) const
+ {
+ return lhs.first < rhs.first;
+ }
};
-class Frame_field{
- private:
- static std::vector<std::pair<SPoint3,STensor3> > field;
+class Frame_field {
+private:
+ static std::vector<std::pair<SPoint3, STensor3> > field;
static std::vector<int> labels;
- static std::map<MVertex*, STensor3> crossField;
- static std::map<MVertex*, double> crossFieldSmoothness;
+ static std::map<MVertex *, STensor3> crossField;
+ static std::map<MVertex *, double> crossFieldSmoothness;
static std::map<MEdge, double, Less_Edge> crossDist;
- static std::vector<MVertex*> listVertices;
+ static std::vector<MVertex *> listVertices;
#if defined(HAVE_ANN)
- static ANNkd_tree* kd_tree;
- static ANNkd_tree* annTree;
+ static ANNkd_tree *kd_tree;
+ static ANNkd_tree *annTree;
#endif
Frame_field();
- static std::map<MVertex*, std::set<MVertex*> > vertex_to_vertices;
- static std::map<MVertex*, std::set<MElement*> > vertex_to_elements;
- public:
- static void init_region(GRegion*);
- static void init_face(GFace*);
- static STensor3 search(double,double,double);
- static STensor3 combine(double,double,double);
+ static std::map<MVertex *, std::set<MVertex *> > vertex_to_vertices;
+ static std::map<MVertex *, std::set<MElement *> > vertex_to_elements;
+
+public:
+ static void init_region(GRegion *);
+ static void init_face(GFace *);
+ static STensor3 search(double, double, double);
+ static STensor3 combine(double, double, double);
static void print_field1();
- static void print_field2(GRegion*);
+ static void print_field2(GRegion *);
static void print_segment(const SPoint3 &, const SPoint3 &, double, double,
std::ofstream &);
- static int build_vertex_to_vertices(GEntity* gr, int onWhat, bool initialize=true);
- static int build_vertex_to_elements(GEntity* gr, bool initialize=true);
- static void build_listVertices(GEntity* gr, int dim, bool initialize=true);
- static int buildAnnData(GEntity* ge, int dim);
+ static int build_vertex_to_vertices(GEntity *gr, int onWhat,
+ bool initialize = true);
+ static int build_vertex_to_elements(GEntity *gr, bool initialize = true);
+ static void build_listVertices(GEntity *gr, int dim, bool initialize = true);
+ static int buildAnnData(GEntity *ge, int dim);
static void deleteAnnData();
static int findAnnIndex(const SPoint3 &p);
static STensor3 findCross(double x, double y, double z);
- static void initFace(GFace* gf);
- static void initRegion(GRegion* gr, int n);
+ static void initFace(GFace *gf);
+ static void initRegion(GRegion *gr, int n);
static void buildSmoothness();
static double smoothFace(GFace *gf, int n);
static double smoothRegion(GRegion *gr, int n);
static double smooth();
- static double findBarycenter(std::map<MVertex*, std::set<MVertex*> >::const_iterator iter, STensor3 &m0);
+ static double
+ findBarycenter(std::map<MVertex *, std::set<MVertex *> >::const_iterator iter,
+ STensor3 &m0);
static void save(const std::vector<std::pair<SPoint3, STensor3> > &data,
const std::string &filename);
- static void saveCrossField(const std::string& filename, double scale, bool full=true);
+ static void saveCrossField(const std::string &filename, double scale,
+ bool full = true);
static void continuousCrossField(GRegion *gr, GFace *gf);
- static void recur_connect_vert(FILE*fi, int count, MVertex *v,STensor3 &cross, std::multimap<MVertex*,MVertex*> &v2v, std::set<MVertex*> &touched);
- static void save_energy(GRegion* gr, const std::string& filename);
- static void save_dist(const std::string& filename);
- static void checkAnnData(GEntity* ge, const std::string& filename);
- static GRegion* test();
+ static void recur_connect_vert(FILE *fi, int count, MVertex *v,
+ STensor3 &cross,
+ std::multimap<MVertex *, MVertex *> &v2v,
+ std::set<MVertex *> &touched);
+ static void save_energy(GRegion *gr, const std::string &filename);
+ static void save_dist(const std::string &filename);
+ static void checkAnnData(GEntity *ge, const std::string &filename);
+ static GRegion *test();
static void clear();
};
-class Size_field{
- private:
- static std::vector<std::pair<SPoint3,double> > field;
- static std::map<MVertex*,double> boundary;
- static MElementOctree* octree;
+class Size_field {
+private:
+ static std::vector<std::pair<SPoint3, double> > field;
+ static std::map<MVertex *, double> boundary;
+ static MElementOctree *octree;
#if defined(HAVE_ANN)
- static ANNkd_tree* kd_tree;
+ static ANNkd_tree *kd_tree;
#endif
Size_field();
- public:
- static void init_region(GRegion*);
- static void solve(GRegion*);
- static double search(double,double,double);
- static void print_field(GRegion*);
- static GRegion* test();
+
+public:
+ static void init_region(GRegion *);
+ static void solve(GRegion *);
+ static double search(double, double, double);
+ static void print_field(GRegion *);
+ static GRegion *test();
static void clear();
};
-class Nearest_point{
- private:
+class Nearest_point {
+private:
static std::vector<SPoint3> field;
- static std::vector<MElement*> vicinity;
+ static std::vector<MElement *> vicinity;
#if defined(HAVE_ANN)
- static ANNkd_tree* kd_tree;
+ static ANNkd_tree *kd_tree;
#endif
Nearest_point();
- public:
- static void init_region(GRegion*);
- static bool search(double,double,double,SVector3&);
- static double T(double,double,double,double,double);
+
+public:
+ static void init_region(GRegion *);
+ static bool search(double, double, double, SVector3 &);
+ static double T(double, double, double, double, double);
static SPoint3 closest(MElement *, const SPoint3 &);
- static double clamp(double,double,double);
- static void print_field(GRegion*);
+ static double clamp(double, double, double);
+ static void print_field(GRegion *);
static void print_segment(const SPoint3 &, const SPoint3 &, std::ofstream &);
- static GRegion* test();
+ static GRegion *test();
static void clear();
};
diff --git a/Mesh/filterElements.cpp b/Mesh/filterElements.cpp
index c73a6547c71a5bad89aa66bc937236e3f9606b36..b5533bbccb4121ce1830a5bb43f147a3a1d91969 100644
--- a/Mesh/filterElements.cpp
+++ b/Mesh/filterElements.cpp
@@ -18,27 +18,23 @@
void MElementBB(void *a, double *min, double *max);
int MElementInEle(void *a, double *x);
-struct MElement_Wrapper
-{
+struct MElement_Wrapper {
bool _overlap;
MElement *_e;
- std::vector<MElement*> _notOverlap;
+ std::vector<MElement *> _notOverlap;
MElement_Wrapper(MElement *e, const std::vector<MElement *> ¬Overlap)
- : _overlap(false)
- , _e(e)
- , _notOverlap(notOverlap)
+ : _overlap(false), _e(e), _notOverlap(notOverlap)
{
- std::sort(_notOverlap.begin(),_notOverlap.end());
+ std::sort(_notOverlap.begin(), _notOverlap.end());
}
};
-
-/** OVERLAP TEST IN 2D
+/** OVERLAP TEST IN 2D
only use predicate orient2D :-)
-2 cases
+2 cases
-1-->
+1-->
*---------*
| |
@@ -48,55 +44,55 @@ struct MElement_Wrapper
| | |
*--------*
-2-->
+2-->
**/
-inline double orientationTest (double a[2], double b[2], double c[2]){
- double s = -robustPredicates::orient2d(a,b,c);
+inline double orientationTest(double a[2], double b[2], double c[2])
+{
+ double s = -robustPredicates::orient2d(a, b, c);
return s >= 0 ? 1.0 : s <= 0 ? -1.0 : 0.0;
}
-inline double orientationTest (MVertex *va, MVertex *vb, MVertex *vc){
- double a[2] = {va->x(),va->y()};
- double b[2] = {vb->x(),vb->y()};
- double c[2] = {vc->x(),vc->y()};
- return orientationTest (a,b,c);
+inline double orientationTest(MVertex *va, MVertex *vb, MVertex *vc)
+{
+ double a[2] = {va->x(), va->y()};
+ double b[2] = {vb->x(), vb->y()};
+ double c[2] = {vc->x(), vc->y()};
+ return orientationTest(a, b, c);
}
-inline double orientationTest (SVector3 &va, SVector3 &vb, SVector3 &vc){
- double a[2] = {va.x(),va.y()};
- double b[2] = {vb.x(),vb.y()};
- double c[2] = {vc.x(),vc.y()};
- return orientationTest (a,b,c);
+inline double orientationTest(SVector3 &va, SVector3 &vb, SVector3 &vc)
+{
+ double a[2] = {va.x(), va.y()};
+ double b[2] = {vb.x(), vb.y()};
+ double c[2] = {vc.x(), vc.y()};
+ return orientationTest(a, b, c);
}
+bool intersectEdge2d(const MEdge &ed1, const MEdge &ed2)
+{
+ double xmax1 = std::max(ed1.getVertex(0)->x(), ed1.getVertex(1)->x());
+ double xmax2 = std::max(ed2.getVertex(0)->x(), ed2.getVertex(1)->x());
+ double ymax1 = std::max(ed1.getVertex(0)->y(), ed1.getVertex(1)->y());
+ double ymax2 = std::max(ed2.getVertex(0)->y(), ed2.getVertex(1)->y());
+ double xmin1 = std::min(ed1.getVertex(0)->x(), ed1.getVertex(1)->x());
+ double xmin2 = std::min(ed2.getVertex(0)->x(), ed2.getVertex(1)->x());
+ double ymin1 = std::min(ed1.getVertex(0)->y(), ed1.getVertex(1)->y());
+ double ymin2 = std::min(ed2.getVertex(0)->y(), ed2.getVertex(1)->y());
+
+ if(xmax1 < xmin2) return false;
+ if(xmax2 < xmin1) return false;
+ if(ymax1 < ymin2) return false;
+ if(ymax2 < ymin1) return false;
+
+ if(xmin1 > xmax2) return false;
+ if(xmin2 > xmax1) return false;
+ if(ymin1 > ymax2) return false;
+ if(ymin2 > ymax1) return false;
+
+ // ed2.getVertex(0)->x(),ed2.getVertex(0)->y(),ed2.getVertex(1)->x(),ed2.getVertex(1)->y()
-bool intersectEdge2d(const MEdge &ed1, const MEdge &ed2) {
-
- double xmax1 = std::max(ed1.getVertex(0)->x(),ed1.getVertex(1)->x());
- double xmax2 = std::max(ed2.getVertex(0)->x(),ed2.getVertex(1)->x());
- double ymax1 = std::max(ed1.getVertex(0)->y(),ed1.getVertex(1)->y());
- double ymax2 = std::max(ed2.getVertex(0)->y(),ed2.getVertex(1)->y());
- double xmin1 = std::min(ed1.getVertex(0)->x(),ed1.getVertex(1)->x());
- double xmin2 = std::min(ed2.getVertex(0)->x(),ed2.getVertex(1)->x());
- double ymin1 = std::min(ed1.getVertex(0)->y(),ed1.getVertex(1)->y());
- double ymin2 = std::min(ed2.getVertex(0)->y(),ed2.getVertex(1)->y());
-
- if (xmax1 < xmin2) return false;
- if (xmax2 < xmin1) return false;
- if (ymax1 < ymin2) return false;
- if (ymax2 < ymin1) return false;
-
- if (xmin1 > xmax2) return false;
- if (xmin2 > xmax1) return false;
- if (ymin1 > ymax2) return false;
- if (ymin2 > ymax1) return false;
-
- // ed2.getVertex(0)->x(),ed2.getVertex(0)->y(),ed2.getVertex(1)->x(),ed2.getVertex(1)->y()
-
-
-
/* SVector3 a1(ed1.getVertex(0)->x(), ed1.getVertex(0)->y(), 0);
SVector3 a2(ed1.getVertex(1)->x(), ed1.getVertex(1)->y(), 0);
@@ -108,52 +104,58 @@ bool intersectEdge2d(const MEdge &ed1, const MEdge &ed2) {
SVector3 a1l = a + (a2-a1)*0.55;
SVector3 a2l = a - (a2-a1)*0.55;
-
+
SVector3 b1l = b + (b2-b1)*0.55;
SVector3 b2l = b - (b2-b1)*0.55;
- if (orientationTest (a1l, a2l, b1l) * orientationTest (a1l, a2l, b2l) <= 0 &&
+ if (orientationTest (a1l, a2l, b1l) * orientationTest (a1l, a2l, b2l) <= 0 &&
orientationTest (b1l, b2l, a1l) * orientationTest (b1l, b2l, a2l) <= 0 )
return true;
*/
- if (ed1.getVertex(0) == ed2.getVertex(0) ||
- ed1.getVertex(0) == ed2.getVertex(1) ||
- ed1.getVertex(1) == ed2.getVertex(0) ||
- ed1.getVertex(1) == ed2.getVertex(1) ) return false;
-
- if ((orientationTest (ed1.getVertex(0),ed1.getVertex(1),ed2.getVertex(0)) *
- orientationTest (ed1.getVertex(0),ed1.getVertex(1),ed2.getVertex(1)) <= 0) &&
- (orientationTest (ed2.getVertex(0),ed2.getVertex(1),ed1.getVertex(0)) *
- orientationTest (ed2.getVertex(0),ed2.getVertex(1),ed1.getVertex(1)) <= 0))
- return true;
+ if(ed1.getVertex(0) == ed2.getVertex(0) ||
+ ed1.getVertex(0) == ed2.getVertex(1) ||
+ ed1.getVertex(1) == ed2.getVertex(0) ||
+ ed1.getVertex(1) == ed2.getVertex(1))
+ return false;
+
+ if((orientationTest(ed1.getVertex(0), ed1.getVertex(1), ed2.getVertex(0)) *
+ orientationTest(ed1.getVertex(0), ed1.getVertex(1), ed2.getVertex(1)) <=
+ 0) &&
+ (orientationTest(ed2.getVertex(0), ed2.getVertex(1), ed1.getVertex(0)) *
+ orientationTest(ed2.getVertex(0), ed2.getVertex(1), ed1.getVertex(1)) <=
+ 0))
+ return true;
return false;
}
-bool overlap2D (MElement *e1, MElement *e2) {
- for (int i=0;i<e1->getNumEdges();i++){
- MEdge ed1 = e1->getEdge (i);
- for (int j=0;j<e2->getNumEdges();j++){
- MEdge ed2 = e2->getEdge (j);
- if (intersectEdge2d(ed1,ed2)){
- // printf("apero time nnodes %d %d partitions %d %d : %g %g -- %g %g vs %g %g -- %g %g\n",
- // e1->getNumVertices(),e2->getNumVertices(),
- // e1->getPartition(),e2->getPartition(),
- // ed1.getVertex(0)->x(),ed1.getVertex(0)->y(),ed1.getVertex(1)->x(),ed1.getVertex(1)->y(),
- // ed2.getVertex(0)->x(),ed2.getVertex(0)->y(),ed2.getVertex(1)->x(),ed2.getVertex(1)->y()
- // );
- return true;
+bool overlap2D(MElement *e1, MElement *e2)
+{
+ for(int i = 0; i < e1->getNumEdges(); i++) {
+ MEdge ed1 = e1->getEdge(i);
+ for(int j = 0; j < e2->getNumEdges(); j++) {
+ MEdge ed2 = e2->getEdge(j);
+ if(intersectEdge2d(ed1, ed2)) {
+ // printf("apero time nnodes %d %d partitions %d %d : %g %g -- %g %g
+ //vs %g %g -- %g %g\n",
+ // e1->getNumVertices(),e2->getNumVertices(),
+ // e1->getPartition(),e2->getPartition(),
+ // ed1.getVertex(0)->x(),ed1.getVertex(0)->y(),ed1.getVertex(1)->x(),ed1.getVertex(1)->y(),
+ // ed2.getVertex(0)->x(),ed2.getVertex(0)->y(),ed2.getVertex(1)->x(),ed2.getVertex(1)->y()
+ // );
+ return true;
}
}
}
return false;
}
-bool rtree_callback(MElement *e1,void* pe2)
+bool rtree_callback(MElement *e1, void *pe2)
{
- MElement_Wrapper *wrapper = static_cast<MElement_Wrapper*>(pe2);
+ MElement_Wrapper *wrapper = static_cast<MElement_Wrapper *>(pe2);
MElement *e2 = wrapper->_e;
- if (std::binary_search(wrapper->_notOverlap.begin(),wrapper->_notOverlap.end(),e1))
+ if(std::binary_search(wrapper->_notOverlap.begin(),
+ wrapper->_notOverlap.end(), e1))
return true;
// for (int i=0;i<e1->getNumVertices();i++){
@@ -162,84 +164,83 @@ bool rtree_callback(MElement *e1,void* pe2)
// }
// }
- if (e1->getDim() <= 2 && e2->getDim() <= 2) {
- wrapper->_overlap = overlap2D (e1,e2);
+ if(e1->getDim() <= 2 && e2->getDim() <= 2) {
+ wrapper->_overlap = overlap2D(e1, e2);
return !wrapper->_overlap;
}
Msg::Error("overlapping of elements in 3D not done yet");
return true;
}
-struct Less_Partition : public std::binary_function<MElement*, MElement*, bool> {
+struct Less_Partition
+ : public std::binary_function<MElement *, MElement *, bool> {
bool operator()(const MElement *f1, const MElement *f2) const
{
- return f1->getPartition() < f2->getPartition() ;
+ return f1->getPartition() < f2->getPartition();
}
};
-void filterColumns(std::vector<MElement*> &elem,
- std::map<MElement*,std::vector<MElement*> > &_elemColumns)
+void filterColumns(std::vector<MElement *> &elem,
+ std::map<MElement *, std::vector<MElement *> > &_elemColumns)
{
- std::sort(elem.begin(),elem.end());
- std::vector<MElement*> toKeep;
- for (std::map<MElement*,std::vector<MElement*> >::iterator it = _elemColumns.begin();
- it !=_elemColumns.end() ; ++it){
- const std::vector<MElement*> &c = it->second;
+ std::sort(elem.begin(), elem.end());
+ std::vector<MElement *> toKeep;
+ for(std::map<MElement *, std::vector<MElement *> >::iterator it =
+ _elemColumns.begin();
+ it != _elemColumns.end(); ++it) {
+ const std::vector<MElement *> &c = it->second;
unsigned int MAX = c.size();
// printf("size of column %d\n",c.size());
- for (unsigned int i=0;i<c.size(); i++){
- if (!std::binary_search(elem.begin(),elem.end(),c[i])){
- MAX = i ;
- break;
+ for(unsigned int i = 0; i < c.size(); i++) {
+ if(!std::binary_search(elem.begin(), elem.end(), c[i])) {
+ MAX = i;
+ break;
}
}
- if (!MAX)MAX=1;
+ if(!MAX) MAX = 1;
// if (MAX != c.size()) printf("MAX = %d c = %d\n",MAX,c.size());
- for (unsigned int i=0;i<MAX;i++){
- if (orientationTest (c[i]->getVertex(0),c[i]->getVertex(1),c[i]->getVertex(2))<0)
- c[i]->reverse();
+ for(unsigned int i = 0; i < MAX; i++) {
+ if(orientationTest(c[i]->getVertex(0), c[i]->getVertex(1),
+ c[i]->getVertex(2)) < 0)
+ c[i]->reverse();
toKeep.push_back(c[i]);
}
// for (unsigned int i=MAX;i<c.size();i++){
- /// FIXME !!!
- // delete c[i];
+ /// FIXME !!!
+ // delete c[i];
// }
}
// printf("%d --> %d\n", (int)elem.size(), (int)toKeep.size());
elem = toKeep;
}
-
-
-
-static void filterOverlappingElements (std::vector<MLine*> &lines,
- std::vector<MElement*> &els,
- std::map<MElement*,std::vector<MElement*> > &_elemColumns,
- std::map<MElement*,MElement*> &_toFirst )
+static void filterOverlappingElements(
+ std::vector<MLine *> &lines, std::vector<MElement *> &els,
+ std::map<MElement *, std::vector<MElement *> > &_elemColumns,
+ std::map<MElement *, MElement *> &_toFirst)
{
- std::vector<MElement*> newEls;
- RTree<MElement*,double,3,double> rtree;
+ std::vector<MElement *> newEls;
+ RTree<MElement *, double, 3, double> rtree;
- for (unsigned int i=0;i<lines.size();i++){
+ for(unsigned int i = 0; i < lines.size(); i++) {
MElement *e = lines[i];
- double _min[3],_max[3];
- MElementBB(e,_min,_max);
- rtree.Insert(_min,_max,e);
+ double _min[3], _max[3];
+ MElementBB(e, _min, _max);
+ rtree.Insert(_min, _max, e);
}
-
- for (unsigned int i=0;i<els.size();i++){
+ for(unsigned int i = 0; i < els.size(); i++) {
MElement *e = els[i];
- double _min[3],_max[3];
- MElementBB(e,_min,_max);
+ double _min[3], _max[3];
+ MElementBB(e, _min, _max);
MElement *first = _toFirst[e];
- MElement_Wrapper w(e,_elemColumns[first]);
- rtree.Search(_min,_max,rtree_callback,&w);
- if (w._overlap){
+ MElement_Wrapper w(e, _elemColumns[first]);
+ rtree.Search(_min, _max, rtree_callback, &w);
+ if(w._overlap) {
// delete e;
}
else {
- rtree.Insert(_min,_max,e);
+ rtree.Insert(_min, _max, e);
newEls.push_back(e);
}
}
@@ -249,25 +250,25 @@ static void filterOverlappingElements (std::vector<MLine*> &lines,
// WE SHOULD ADD THE BOUNDARY OF THE DOMAIN IN ORDER TO AVOID
// ELEMENTS THAT ARE OUTSIDE THE DOMAIN --> FIXME
-void filterOverlappingElements (std::vector<MLine*> &bdry,
- std::vector<MTriangle*> &blTris,
- std::vector<MQuadrangle*>&blQuads,
- std::map<MElement*,std::vector<MElement*> > &_elemColumns,
- std::map<MElement*,MElement*> &_toFirst)
+void filterOverlappingElements(
+ std::vector<MLine *> &bdry, std::vector<MTriangle *> &blTris,
+ std::vector<MQuadrangle *> &blQuads,
+ std::map<MElement *, std::vector<MElement *> > &_elemColumns,
+ std::map<MElement *, MElement *> &_toFirst)
{
- std::vector<MElement*> vvv;
- vvv.insert(vvv.begin(),blTris.begin(),blTris.end());
- vvv.insert(vvv.begin(),blQuads.begin(),blQuads.end());
+ std::vector<MElement *> vvv;
+ vvv.insert(vvv.begin(), blTris.begin(), blTris.end());
+ vvv.insert(vvv.begin(), blQuads.begin(), blQuads.end());
Less_Partition lp;
- std::sort(vvv.begin(),vvv.end(), lp);
- filterOverlappingElements (bdry,vvv,_elemColumns,_toFirst);
- filterColumns (vvv,_elemColumns);
+ std::sort(vvv.begin(), vvv.end(), lp);
+ filterOverlappingElements(bdry, vvv, _elemColumns, _toFirst);
+ filterColumns(vvv, _elemColumns);
blTris.clear();
blQuads.clear();
- for (unsigned int i=0;i<vvv.size();i++){
- if (vvv[i]->getType() == TYPE_TRI)blTris.push_back((MTriangle*)vvv[i]);
- else if (vvv[i]->getType() == TYPE_QUA)blQuads.push_back((MQuadrangle*)vvv[i]);
+ for(unsigned int i = 0; i < vvv.size(); i++) {
+ if(vvv[i]->getType() == TYPE_TRI)
+ blTris.push_back((MTriangle *)vvv[i]);
+ else if(vvv[i]->getType() == TYPE_QUA)
+ blQuads.push_back((MQuadrangle *)vvv[i]);
}
-
-
}
diff --git a/Mesh/filterElements.h b/Mesh/filterElements.h
index e9139b6a114d680fe80cec792b8da37afc6bfced..3f4a417c1ba0ec7b08893d61b0f1b5a0dd2f90a4 100644
--- a/Mesh/filterElements.h
+++ b/Mesh/filterElements.h
@@ -14,12 +14,13 @@ class MTriangle;
class MQuadrangle;
class MLine;
-void filterOverlappingElements(std::vector<MLine*> &_lines,
- std::vector<MTriangle*> &blTris,
- std::vector<MQuadrangle*>&blQuads,
- std::map<MElement*,std::vector<MElement*> > &_elemColumns,
- std::map<MElement*,MElement*> &_toFirst);
-void filterColumns(std::vector<MElement*> &elem,
- std::map<MElement*,std::vector<MElement*> > &_elemColumns);
+void filterOverlappingElements(
+ std::vector<MLine *> &_lines, std::vector<MTriangle *> &blTris,
+ std::vector<MQuadrangle *> &blQuads,
+ std::map<MElement *, std::vector<MElement *> > &_elemColumns,
+ std::map<MElement *, MElement *> &_toFirst);
+void filterColumns(
+ std::vector<MElement *> &elem,
+ std::map<MElement *, std::vector<MElement *> > &_elemColumns);
#endif
diff --git a/Mesh/meshDiscreteRegion.cpp b/Mesh/meshDiscreteRegion.cpp
index d506384feecd8b61518e455231b2325102313b13..fe53a7ebc27a158c01f59b589c8c0f798e52249f 100644
--- a/Mesh/meshDiscreteRegion.cpp
+++ b/Mesh/meshDiscreteRegion.cpp
@@ -27,39 +27,41 @@
// Recursive function to generate all combinations of 4 indices between start
// and end indices included
// Jeanne - HEXTREME
-void combination_of_4( int combination[4], int start, int end, int index,
- const std::vector<MVertex*>& vertices, std::vector<MTetrahedron*>& tets)
+void combination_of_4(int combination[4], int start, int end, int index,
+ const std::vector<MVertex *> &vertices,
+ std::vector<MTetrahedron *> &tets)
{
- if (index == 4 ) {
+ if(index == 4) {
// Create the tet and get out
- MVertex* v1 = vertices[combination[0]];
- MVertex* v2 = vertices[combination[1]];
- MVertex* v3 = vertices[combination[2]];
- MVertex* v4 = vertices[combination[3]];
- MTetrahedron* tet = new MTetrahedron(v1, v2, v3, v4);
+ MVertex *v1 = vertices[combination[0]];
+ MVertex *v2 = vertices[combination[1]];
+ MVertex *v3 = vertices[combination[2]];
+ MVertex *v4 = vertices[combination[3]];
+ MTetrahedron *tet = new MTetrahedron(v1, v2, v3, v4);
tets.push_back(tet);
return;
}
- for (int i = start; i <= end+1 -(4-index); i++) {
+ for(int i = start; i <= end + 1 - (4 - index); i++) {
combination[index] = i;
- combination_of_4(combination, i+1, end, index+1, vertices, tets);
+ combination_of_4(combination, i + 1, end, index + 1, vertices, tets);
}
}
// Fill a region with all possible tets genereated from the
// combination of points assigned to it
// Jeanne - HEXTREME
-void create_all_possible_tets(GRegion* region, const std::vector<MVertex*>& vertices)
+void create_all_possible_tets(GRegion *region,
+ const std::vector<MVertex *> &vertices)
{
unsigned int nb_points = vertices.size();
int combinaison[4];
- std::vector<MTetrahedron*> tets;
+ std::vector<MTetrahedron *> tets;
combination_of_4(combinaison, 0, nb_points - 1, 0, vertices, tets);
std::cout << " Number of tets created - all possible combinations - "
<< tets.size() << std::endl;
- for (unsigned int i = 0; i < tets.size(); ++i) {
+ for(unsigned int i = 0; i < tets.size(); ++i) {
region->addTetrahedron(tets[i]);
}
}
@@ -67,44 +69,45 @@ void create_all_possible_tets(GRegion* region, const std::vector<MVertex*>& vert
// triangles are defining the boundary
// internal points are allowed
// This has been done for HEXTREME
-GRegion * createDiscreteRegionFromRawData(GModel *gm, fullMatrix<double> &pts,
- fullMatrix<int> &triangles, bool all_tets)
+GRegion *createDiscreteRegionFromRawData(GModel *gm, fullMatrix<double> &pts,
+ fullMatrix<int> &triangles,
+ bool all_tets)
{
GRegion *gr = new discreteRegion(gm, gm->getMaxElementaryNumber(3) + 1);
GFace *gf = new discreteFace(gm, gm->getMaxElementaryNumber(2) + 1);
gm->add(gr);
gm->add(gf);
- std::vector<GFace*> faces;
+ std::vector<GFace *> faces;
faces.push_back(gf);
gr->set(faces);
// get boundary nodes
std::set<int> bnd;
unsigned int nbTriangles = triangles.size1();
unsigned int nbPts = pts.size1();
- for (unsigned int i = 0; i < nbTriangles; i++) {
+ for(unsigned int i = 0; i < nbTriangles; i++) {
bnd.insert(triangles(i, 0));
bnd.insert(triangles(i, 1));
bnd.insert(triangles(i, 2));
}
// create points
- std::vector<MVertex*> vs(nbPts);
- for (unsigned int i = 0; i < nbPts; i++) {
- if (bnd.find(i) == bnd.end()){
- MVertex *v = new MVertex(pts(i,0), pts(i,1), pts(i,2), gr);
+ std::vector<MVertex *> vs(nbPts);
+ for(unsigned int i = 0; i < nbPts; i++) {
+ if(bnd.find(i) == bnd.end()) {
+ MVertex *v = new MVertex(pts(i, 0), pts(i, 1), pts(i, 2), gr);
gr->mesh_vertices.push_back(v);
vs[i] = v;
}
else {
- MVertex *v = new MFaceVertex(pts(i,0), pts(i,1), pts(i,2), gf, 0, 0);
+ MVertex *v = new MFaceVertex(pts(i, 0), pts(i, 1), pts(i, 2), gf, 0, 0);
gf->mesh_vertices.push_back(v);
vs[i] = v;
}
}
// create triangles
- for (unsigned int i = 0 ; i < nbTriangles; i++) {
- int i0 = triangles(i,0);
- int i1 = triangles(i,1);
- int i2 = triangles(i,2);
+ for(unsigned int i = 0; i < nbTriangles; i++) {
+ int i0 = triangles(i, 0);
+ int i1 = triangles(i, 1);
+ int i2 = triangles(i, 2);
MTriangle *t = new MTriangle(vs[i0], vs[i1], vs[i2]);
gf->triangles.push_back(t);
}
@@ -113,7 +116,7 @@ GRegion * createDiscreteRegionFromRawData(GModel *gm, fullMatrix<double> &pts,
// tetrahedralization is done when recovering the boundary
// create all tets
- if (all_tets) {
+ if(all_tets) {
create_all_possible_tets(gr, vs);
}
@@ -125,12 +128,11 @@ GRegion *createTetrahedralMesh(GModel *gm, fullMatrix<double> &pts,
{
GRegion *gr = createDiscreteRegionFromRawData(gm, pts, triangles, all_tets);
- if (!all_tets){
+ if(!all_tets) {
try {
meshGRegionBoundaryRecovery(gr);
- }
- catch (int err) {
- if (err == 3) {
+ } catch(int err) {
+ if(err == 3) {
Msg::Warning("Self-intersecting surface mesh: TODO!");
}
else {
diff --git a/Mesh/meshGEdge.cpp b/Mesh/meshGEdge.cpp
index 8ce69b39ce0363e2e32c6c7aa5f027592c0057aa..44166b8c0d10f98f2374c1e10bf6471cbcc9535a 100644
--- a/Mesh/meshGEdge.cpp
+++ b/Mesh/meshGEdge.cpp
@@ -384,7 +384,9 @@ static void filterPoints(GEdge *ge, int nMinimumPoints)
if((ge->meshAttributes.method != MESH_TRANSFINITE ||
CTX::instance()->mesh.flexibleTransfinite) &&
CTX::instance()->mesh.algoRecombine != 0) {
- if(CTX::instance()->mesh.recombineAll) { forceOdd = true; }
+ if(CTX::instance()->mesh.recombineAll) {
+ forceOdd = true;
+ }
}
MVertex *v0 = ge->getBeginVertex()->mesh_vertices[0];
@@ -411,7 +413,9 @@ static void filterPoints(GEdge *ge, int nMinimumPoints)
}
double lc = F_LcB()(ge, t);
// double lc = v->getLc();
- if(d < lc * .3) { lengths.push_back(std::make_pair(lc / d, v)); }
+ if(d < lc * .3) {
+ lengths.push_back(std::make_pair(lc / d, v));
+ }
else
v0 = v;
}
@@ -438,7 +442,9 @@ static void filterPoints(GEdge *ge, int nMinimumPoints)
std::vector<MVertex *>::iterator it = std::find(
ge->mesh_vertices.begin(), ge->mesh_vertices.end(), lengths[i].second);
- if(it != ge->mesh_vertices.end()) { ge->mesh_vertices.erase(it); }
+ if(it != ge->mesh_vertices.end()) {
+ ge->mesh_vertices.erase(it);
+ }
delete lengths[i].second;
}
}
@@ -453,7 +459,9 @@ static void createPoints(GVertex *gv, GEdge *ge, BoundaryLayerField *blf,
double LEdge = distance(ge->getBeginVertex()->mesh_vertices[0],
ge->getEndVertex()->mesh_vertices[0]);
while(1) {
- if(L > blf->thickness || L > LEdge * .4) { break; }
+ if(L > blf->thickness || L > LEdge * .4) {
+ break;
+ }
SPoint3 p(gv->x() + dir.x() * L, gv->y() + dir.y() * L, 0.0);
v.push_back(new MEdgeVertex(p.x(), p.y(), p.z(), ge, ge->parFromPoint(p), 0,
diff --git a/Mesh/meshGEdgeExtruded.cpp b/Mesh/meshGEdgeExtruded.cpp
index 7dbe43c9208f2adf5984acfd0c7171ed21e7eb6e..4751d1e13f88a1cbd0650ef10186e33dcaf1b930 100644
--- a/Mesh/meshGEdgeExtruded.cpp
+++ b/Mesh/meshGEdgeExtruded.cpp
@@ -18,7 +18,7 @@ static void extrudeMesh(GVertex *from, GEdge *to)
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
double x = v->x(), y = v->y(), z = v->z();
ep->Extrude(j, k + 1, x, y, z);
- if(j != ep->mesh.NbLayer - 1 || k != ep->mesh.NbElmLayer[j] - 1){
+ if(j != ep->mesh.NbLayer - 1 || k != ep->mesh.NbElmLayer[j] - 1) {
Range<double> r = to->parBounds(0);
double t = r.low() + ep->u(j, k + 1) * (r.high() - r.low());
to->mesh_vertices.push_back(new MEdgeVertex(x, y, z, to, t));
@@ -37,7 +37,7 @@ static void copyMesh(GEdge *from, GEdge *to)
double u_min = u_bounds.low();
double u_max = u_bounds.high();
- for(unsigned int i = 0; i < from->mesh_vertices.size(); i++){
+ for(unsigned int i = 0; i < from->mesh_vertices.size(); i++) {
int index = (direction < 0) ? (from->mesh_vertices.size() - 1 - i) : i;
MVertex *v = from->mesh_vertices[index];
double x = v->x(), y = v->y(), z = v->z();
@@ -54,8 +54,7 @@ int MeshExtrudedCurve(GEdge *ge)
{
ExtrudeParams *ep = ge->meshAttributes.extrude;
- if(!ep || !ep->mesh.ExtrudeMesh)
- return 0;
+ if(!ep || !ep->mesh.ExtrudeMesh) return 0;
Msg::Info("Meshing curve %d (extruded)", ge->tag());
@@ -66,12 +65,12 @@ int MeshExtrudedCurve(GEdge *ge)
else {
GEdge *from = ge->model()->getEdgeByTag(std::abs(ep->geo.Source));
// curve is a copy of another curve (the "top" of the extrusion)
- if(!from){
+ if(!from) {
Msg::Error("Unknown source curve %d for extrusion", ep->geo.Source);
return 0;
}
else if(from->geomType() != GEntity::DiscreteCurve &&
- from->meshStatistics.status != GEdge::DONE){
+ from->meshStatistics.status != GEdge::DONE) {
// cannot mesh this edge yet: will do it later
return 1;
}
@@ -79,12 +78,13 @@ int MeshExtrudedCurve(GEdge *ge)
}
// create elements
- for(unsigned int i = 0; i < ge->mesh_vertices.size() + 1; i++){
- MVertex *v0 = (i == 0) ?
- ge->getBeginVertex()->mesh_vertices[0] : ge->mesh_vertices[i - 1];
+ for(unsigned int i = 0; i < ge->mesh_vertices.size() + 1; i++) {
+ MVertex *v0 = (i == 0) ? ge->getBeginVertex()->mesh_vertices[0] :
+ ge->mesh_vertices[i - 1];
MVertex *v1 = (i == ge->mesh_vertices.size()) ?
- ge->getEndVertex()->mesh_vertices[0] : ge->mesh_vertices[i];
- MLine* newElem = new MLine(v0, v1);
+ ge->getEndVertex()->mesh_vertices[0] :
+ ge->mesh_vertices[i];
+ MLine *newElem = new MLine(v0, v1);
ge->lines.push_back(newElem);
}
diff --git a/Mesh/meshGFace.cpp b/Mesh/meshGFace.cpp
index 2650d32faf8a177ff6cc51303c3b9d676a4f6c47..7dc4bb9ccb15f0404901206183269189ee417dd1 100644
--- a/Mesh/meshGFace.cpp
+++ b/Mesh/meshGFace.cpp
@@ -131,7 +131,7 @@ bool pointInsideParametricDomain(std::vector<SPoint2> &bnd, SPoint2 &p,
void trueBoundary(const char *iii, GFace *gf, std::vector<SPoint2> &bnd)
{
- ///FILE* view_t = Fopen(iii,"w");
+ /// FILE* view_t = Fopen(iii,"w");
// fprintf(view_t,"View \"True Boundary\"{\n");
std::vector<GEdge *> edg = gf->edges();
@@ -149,8 +149,8 @@ void trueBoundary(const char *iii, GFace *gf, std::vector<SPoint2> &bnd)
double xi = r.low() + (r.high() - r.low()) * t;
p[k] = ge->reparamOnFace(gf, xi, i);
if(k > 0) {
- // fprintf(view_t,"SL(%g,%g,%g,%g,%g,%g){1,1};\n",p[k-1].x(),p[k-1].y(),0.0,
- // p[k].x(),p[k].y(),0.0);
+ // fprintf(view_t,"SL(%g,%g,%g,%g,%g,%g){1,1};\n",p[k-1].x(),p[k-1].y(),0.0,
+ // p[k].x(),p[k].y(),0.0);
bnd.push_back(p[k - 1]);
bnd.push_back(p[k]);
}
@@ -1044,11 +1044,12 @@ bool meshGenerator(GFace *gf, int RECUR_ITER, bool repairSelfIntersecting1dMesh,
bool onlyInitialMesh, bool debug,
std::vector<GEdge *> *replacement_edges)
{
- if (CTX::instance()->debugSurface > 0 && gf->tag() != CTX::instance()->debugSurface){
+ if(CTX::instance()->debugSurface > 0 &&
+ gf->tag() != CTX::instance()->debugSurface) {
gf->meshStatistics.status = GFace::DONE;
return true;
}
- if (CTX::instance()->debugSurface > 0) debug = true;
+ if(CTX::instance()->debugSurface > 0) debug = true;
// onlyInitialMesh=true;
BDS_GeomEntity CLASS_F(1, 2);
@@ -1965,11 +1966,12 @@ static bool buildConsecutiveListOfVertices(
static bool meshGeneratorPeriodic(GFace *gf, bool debug = true)
{
- if (CTX::instance()->debugSurface > 0 && gf->tag() != CTX::instance()->debugSurface){
+ if(CTX::instance()->debugSurface > 0 &&
+ gf->tag() != CTX::instance()->debugSurface) {
gf->meshStatistics.status = GFace::DONE;
return true;
}
- if (CTX::instance()->debugSurface > 0) debug = true;
+ if(CTX::instance()->debugSurface > 0) debug = true;
std::map<BDS_Point *, MVertex *, PointLessThan> recoverMap;
@@ -2026,19 +2028,20 @@ static bool meshGeneratorPeriodic(GFace *gf, bool debug = true)
}
{
- std::map<BDS_Point *, MVertex *, PointLessThan>::iterator it = recoverMap.begin();
- std::map<MVertex *, BDS_Point *>INV;
- for (; it != recoverMap.end() ; ++it){
- std::map<MVertex *, BDS_Point *>::iterator it2 = INV.find (it->second);
- if (it2 != INV.end()){
- it->first-> _periodicCounterpart = it2->second;
- it2->second-> _periodicCounterpart = it->first;
- // printf("%d --> %d\n", it2->second->iD,it->first->iD);
+ std::map<BDS_Point *, MVertex *, PointLessThan>::iterator it =
+ recoverMap.begin();
+ std::map<MVertex *, BDS_Point *> INV;
+ for(; it != recoverMap.end(); ++it) {
+ std::map<MVertex *, BDS_Point *>::iterator it2 = INV.find(it->second);
+ if(it2 != INV.end()) {
+ it->first->_periodicCounterpart = it2->second;
+ it2->second->_periodicCounterpart = it->first;
+ // printf("%d --> %d\n", it2->second->iD,it->first->iD);
}
INV[it->second] = it->first;
}
}
-
+
if(nbPointsTotal < 3) {
Msg::Warning("Mesh Generation of Model Face %d Skipped: "
"Only %d Mesh Vertices on The Contours",
@@ -2732,45 +2735,41 @@ void deMeshGFace::operator()(GFace *gf)
gf->correspondingVertices.clear();
}
-
static double TRIANGLE_VALIDITY(GFace *gf, MTriangle *t)
{
- SPoint2 p1,p2,p3;
- reparamMeshVertexOnFace(t->getVertex(0),gf, p1);
- reparamMeshVertexOnFace(t->getVertex(1),gf, p2);
- reparamMeshVertexOnFace(t->getVertex(2),gf, p3);
+ SPoint2 p1, p2, p3;
+ reparamMeshVertexOnFace(t->getVertex(0), gf, p1);
+ reparamMeshVertexOnFace(t->getVertex(1), gf, p2);
+ reparamMeshVertexOnFace(t->getVertex(2), gf, p3);
SVector3 N1 = gf->normal(p1);
SVector3 N2 = gf->normal(p2);
SVector3 N3 = gf->normal(p3);
SVector3 N = N1 + N2 + N3;
N.normalize();
SVector3 d1(t->getVertex(1)->x() - t->getVertex(0)->x(),
- t->getVertex(1)->y() - t->getVertex(0)->y(),
- t->getVertex(1)->z() - t->getVertex(0)->z());
+ t->getVertex(1)->y() - t->getVertex(0)->y(),
+ t->getVertex(1)->z() - t->getVertex(0)->z());
SVector3 d2(t->getVertex(2)->x() - t->getVertex(0)->x(),
- t->getVertex(2)->y() - t->getVertex(0)->y(),
- t->getVertex(2)->z() - t->getVertex(0)->z());
+ t->getVertex(2)->y() - t->getVertex(0)->y(),
+ t->getVertex(2)->z() - t->getVertex(0)->z());
- SVector3 c = crossprod (d1,d2);
-
- return dot (N,c);
-
+ SVector3 c = crossprod(d1, d2);
+
+ return dot(N, c);
}
-static bool isMeshValid (GFace *gf){
+static bool isMeshValid(GFace *gf)
+{
int invalid = 0;
- for (size_t i=0;i<gf->triangles.size(); i++){
+ for(size_t i = 0; i < gf->triangles.size(); i++) {
double v = TRIANGLE_VALIDITY(gf, gf->triangles[i]);
- if (v < 0)invalid ++;
+ if(v < 0) invalid++;
}
- if (invalid == 0 || invalid == gf->triangles.size())return true;
+ if(invalid == 0 || invalid == gf->triangles.size()) return true;
// printf("%d %d %d\n",gf->tag(),gf->triangles.size(),invalid);
return false;
-
-
}
-
// for debugging, change value from -1 to -100;
int debugSurface = -1; //-100;
@@ -2865,14 +2864,15 @@ void meshGFace::operator()(GFace *gf, bool print)
Msg::Warning("Surface %d consists of no elements", gf->tag());
}
- if (algoDelaunay2D(gf) && !isMeshValid (gf)){
- Msg::Warning ("Delaunay based mesher failed on surface %d --> moving to meshadapt",gf->tag());
+ if(algoDelaunay2D(gf) && !isMeshValid(gf)) {
+ Msg::Warning(
+ "Delaunay based mesher failed on surface %d --> moving to meshadapt",
+ gf->tag());
deMeshGFace killer;
- killer (gf);
- gf->setMeshingAlgo (1);
- (*this)(gf,print);
+ killer(gf);
+ gf->setMeshingAlgo(1);
+ (*this)(gf, print);
}
-
}
static bool getGFaceNormalFromVert(GFace *gf, MElement *el, SVector3 &nf)
diff --git a/Mesh/meshGFaceBDS.cpp b/Mesh/meshGFaceBDS.cpp
index 14cbf5a86f16991cf38207fbc1b2ced7b64c01e3..79313303e37ec4a682e9b8cb98d44edec5bbc340 100644
--- a/Mesh/meshGFaceBDS.cpp
+++ b/Mesh/meshGFaceBDS.cpp
@@ -232,7 +232,6 @@ static int edgeSwapTest(GFace *gf, BDS_Edge *e)
static void swapEdgePass(GFace *gf, BDS_Mesh &m, int &nb_swap, int FINALIZE = 0,
double orientation = 1.0)
{
-
BDS_SwapEdgeTest *qual;
if(FINALIZE && gf->getNativeType() != GEntity::GmshModel)
qual = new BDS_SwapEdgeTestNormals(gf, orientation);
@@ -352,25 +351,30 @@ static void splitEdgePass(GFace *gf, BDS_Mesh &m, double MAXE_, int &nb_split,
SPoint2 out(10, 10);
- for (std::set<BDS_Point *, PointLessThan>::iterator it = m.points.begin() ; it != m.points.end() ; ++it){
+ for(std::set<BDS_Point *, PointLessThan>::iterator it = m.points.begin();
+ it != m.points.end(); ++it) {
BDS_Point *p = *it;
- if (!p->_periodicCounterpart && (p->g && p->g->classif_degree == 2)){
- for (size_t i = 0 ; i < p->edges.size(); i++){
- BDS_Point *p1 = p->edges[i]->p1 == p ? p->edges[i]->p2 : p->edges[i]->p1;
- for (size_t j = 0 ; j < i; j++){
- BDS_Point *p2 = p->edges[j]->p1 == p ? p->edges[j]->p2 : p->edges[j]->p1;
- if (!p1->degenerated && !p2->degenerated && p1->_periodicCounterpart && p1->_periodicCounterpart == p2){
- // printf("splitting %d %d\n", p->edges[i]->p1->iD,p->edges[i]->p2->iD);
- // printf("splitting %d %d\n", p->edges[j]->p1->iD,p->edges[j]->p2->iD);
- edges.push_back(std::make_pair(-10.0, p->edges[i]));
- edges.push_back(std::make_pair(-10.0, p->edges[j]));
- }
- }
+ if(!p->_periodicCounterpart && (p->g && p->g->classif_degree == 2)) {
+ for(size_t i = 0; i < p->edges.size(); i++) {
+ BDS_Point *p1 =
+ p->edges[i]->p1 == p ? p->edges[i]->p2 : p->edges[i]->p1;
+ for(size_t j = 0; j < i; j++) {
+ BDS_Point *p2 =
+ p->edges[j]->p1 == p ? p->edges[j]->p2 : p->edges[j]->p1;
+ if(!p1->degenerated && !p2->degenerated && p1->_periodicCounterpart &&
+ p1->_periodicCounterpart == p2) {
+ // printf("splitting %d %d\n",
+ //p->edges[i]->p1->iD,p->edges[i]->p2->iD);
+ // printf("splitting %d %d\n",
+ //p->edges[j]->p1->iD,p->edges[j]->p2->iD);
+ edges.push_back(std::make_pair(-10.0, p->edges[i]));
+ edges.push_back(std::make_pair(-10.0, p->edges[j]));
+ }
+ }
}
}
}
-
std::vector<BDS_Edge *>::const_iterator it = m.edges.begin();
while(it != m.edges.end()) {
if(!(*it)->deleted && (*it)->numfaces() == 2 &&
@@ -399,7 +403,6 @@ static void splitEdgePass(GFace *gf, BDS_Mesh &m, double MAXE_, int &nb_split,
double V = 0.5 * (e->p1->v + e->p2->v);
if(faceDiscrete) middlePoint(gf, e, U, V);
-
GPoint gpp = gf->point(U, V);
bool inside = true;
if(true_boundary) {
@@ -407,11 +410,11 @@ static void splitEdgePass(GFace *gf, BDS_Mesh &m, double MAXE_, int &nb_split,
int N;
if(!pointInsideParametricDomain(*true_boundary, pp, out, N)) {
inside = false;
- // printf("%d %d %g %g\n",e->p1->iD,e->p2->iD,U1,U2);
- // printf("%g %g OUTSIDE ??\n",pp.x(),pp.y());
- // FILE *f = fopen("TOTO.pos","a");
- // fprintf(f,"SP(%g,%g,0){%d};\n",pp.x(),pp.y(),N);
- // fclose(f);
+ // printf("%d %d %g %g\n",e->p1->iD,e->p2->iD,U1,U2);
+ // printf("%g %g OUTSIDE ??\n",pp.x(),pp.y());
+ // FILE *f = fopen("TOTO.pos","a");
+ // fprintf(f,"SP(%g,%g,0){%d};\n",pp.x(),pp.y(),N);
+ // fclose(f);
}
}
if(inside && gpp.succeeded()) {
@@ -432,9 +435,9 @@ static void splitEdgePass(GFace *gf, BDS_Mesh &m, double MAXE_, int &nb_split,
if(mid) {
if(!m.split_edge(e, mid))
m.del_point(mid);
- else{
+ else {
nb_split++;
- }
+ }
}
}
}
@@ -847,7 +850,7 @@ void refineMeshBDS(GFace *gf, BDS_Mesh &m, const int NIT,
double orientation = invalid > (int)m.triangles.size() / 2 ? -1.0 : 1.0;
// printf("NOW FIXING BAD ELEMENTS\n");
-
+
while(1) {
// printf("ITERATION %d\n",ITER);
bad = 0;
@@ -874,23 +877,25 @@ void refineMeshBDS(GFace *gf, BDS_Mesh &m, const int NIT,
pts[2]->config_modified = true;
bad++;
if(val < 0) {
- // printf("%d %d %d invalid\n",pts[0]->iD,pts[1]->iD,pts[2]->iD);
- invalid++;
- }
+ // printf("%d %d %d
+ //invalid\n",pts[0]->iD,pts[1]->iD,pts[2]->iD);
+ invalid++;
+ }
}
// }
}
- if (++ITER == 10){
- if (invalid && !computeNodalSizeField)Msg::Warning("Meshing surface %d : %d elements remain invalid\n", gf->tag(),invalid);
- break;
+ if(++ITER == 10) {
+ if(invalid && !computeNodalSizeField)
+ Msg::Warning("Meshing surface %d : %d elements remain invalid\n",
+ gf->tag(), invalid);
+ break;
}
-
- if (bad != 0){
- int nb_swap = 0;
- int nb_smooth = 0;
- swapEdgePass ( gf, m, nb_swap, 1, orientation);
- // smoothVertexPass(gf, m, nb_smooth, true);
+ if(bad != 0) {
+ int nb_swap = 0;
+ //int nb_smooth = 0;
+ swapEdgePass(gf, m, nb_swap, 1, orientation);
+ // smoothVertexPass(gf, m, nb_smooth, true);
}
else {
// Msg::Info("Meshing surface %d : all elements are oriented
diff --git a/Mesh/meshGFaceBamg.cpp b/Mesh/meshGFaceBamg.cpp
index 6dac76dd36b24ef29c927a66b525c6eb2469c8d4..45d502b8c555bb111a0a43c65a001fc5a1e4f697 100644
--- a/Mesh/meshGFaceBamg.cpp
+++ b/Mesh/meshGFaceBamg.cpp
@@ -25,12 +25,12 @@
long verbosity = 0;
#include "Mesh2d.hpp"
#include "Mesh2.h"
-Mesh2 *Bamg(Mesh2 *Thh, double * args,double *mm11,double *mm12,double *mm22, bool);
-
+Mesh2 *Bamg(Mesh2 *Thh, double *args, double *mm11, double *mm12, double *mm22,
+ bool);
static void computeMeshMetricsForBamg(GFace *gf, int numV,
- Vertex2 *bamgVertices,
- double *mm11, double *mm12, double *mm22)
+ Vertex2 *bamgVertices, double *mm11,
+ double *mm12, double *mm22)
{
// char name[245];
// sprintf(name,"bgmBamg-%d-%d.pos",gf->tag(),iter);
@@ -39,8 +39,8 @@ static void computeMeshMetricsForBamg(GFace *gf, int numV,
// backgroundMesh::current()->print(name, 0);
// }
- fullMatrix<double> J(2,3), JT(3,2),M(3,3),R(2,2),W(2,3);
- for (int i = 0; i < numV; ++i){
+ fullMatrix<double> J(2, 3), JT(3, 2), M(3, 3), R(2, 2), W(2, 3);
+ for(int i = 0; i < numV; ++i) {
double u = bamgVertices[i][0];
double v = bamgVertices[i][1];
GPoint gp = gf->point(SPoint2(u, v));
@@ -49,62 +49,63 @@ static void computeMeshMetricsForBamg(GFace *gf, int numV,
// compute the derivatives of the parametrization
Pair<SVector3, SVector3> der = gf->firstDer(SPoint2(u, v));
- J(0,0) = JT(0,0) = der.first().x();
- J(0,1) = JT(1,0) = der.first().y();
- J(0,2) = JT(2,0) = der.first().z();
- J(1,0) = JT(0,1) = der.second().x();
- J(1,1) = JT(1,1) = der.second().y();
- J(1,2) = JT(2,1) = der.second().z();
+ J(0, 0) = JT(0, 0) = der.first().x();
+ J(0, 1) = JT(1, 0) = der.first().y();
+ J(0, 2) = JT(2, 0) = der.first().z();
+ J(1, 0) = JT(0, 1) = der.second().x();
+ J(1, 1) = JT(1, 1) = der.second().y();
+ J(1, 2) = JT(2, 1) = der.second().z();
m.getMat(M);
- J.mult(M,W);
- W.mult(JT,R);
- bamg::Metric M1(R(0,0),R(1,0),R(1,1));
+ J.mult(M, W);
+ W.mult(JT, R);
+ bamg::Metric M1(R(0, 0), R(1, 0), R(1, 1));
mm11[i] = M1.a11;
mm12[i] = M1.a21;
mm22[i] = M1.a22;
}
}
-
void meshGFaceBamg(GFace *gf)
{
- std::vector<GEdge*> const& edges = gf->edges();
- std::set<MVertex*> bcVertex;
- for (std::vector<GEdge*>::const_iterator it = edges.begin(); it != edges.end(); it++){
- for (unsigned int i = 0; i < (*it)->lines.size(); i++){
+ std::vector<GEdge *> const &edges = gf->edges();
+ std::set<MVertex *> bcVertex;
+ for(std::vector<GEdge *>::const_iterator it = edges.begin();
+ it != edges.end(); it++) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); i++) {
bcVertex.insert((*it)->lines[i]->getVertex(0));
bcVertex.insert((*it)->lines[i]->getVertex(1));
}
}
- //fill mesh data fo bamg (bamgVertices, bamgTriangles, bamgBoundary)
- std::set<MVertex*> all;
- std::map<int,MVertex*> recover;
- for (unsigned int i = 0; i < gf->triangles.size(); i++){
- for (unsigned int j = 0; j < 3; j++)
+ // fill mesh data fo bamg (bamgVertices, bamgTriangles, bamgBoundary)
+ std::set<MVertex *> all;
+ std::map<int, MVertex *> recover;
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
+ for(unsigned int j = 0; j < 3; j++)
all.insert(gf->triangles[i]->getVertex(j));
}
Vertex2 *bamgVertices = new Vertex2[all.size()];
int index = 0;
- for(std::set<MVertex*>::iterator it = all.begin(); it!=all.end(); ++it){
- if ((*it)->onWhat()->dim() <= 1){
- //for(std::set<MVertex*>::iterator it = bcVertex.begin(); it!=bcVertex.end(); ++it){
- SPoint2 p;
- reparamMeshVertexOnFace(*it, gf, p);
- bamgVertices[index][0] = p.x();
- bamgVertices[index][1] = p.y();
- bamgVertices[index].lab = index;
- recover[index] = *it;
- (*it)->setIndex(index++);
- }
+ for(std::set<MVertex *>::iterator it = all.begin(); it != all.end(); ++it) {
+ if((*it)->onWhat()->dim() <= 1) {
+ // for(std::set<MVertex*>::iterator it = bcVertex.begin();
+ // it!=bcVertex.end(); ++it){
+ SPoint2 p;
+ reparamMeshVertexOnFace(*it, gf, p);
+ bamgVertices[index][0] = p.x();
+ bamgVertices[index][1] = p.y();
+ bamgVertices[index].lab = index;
+ recover[index] = *it;
+ (*it)->setIndex(index++);
+ }
}
- //exit(1);
- int nbFixedVertices = index;
- for(std::set<MVertex*>::iterator it = all.begin(); it!=all.end(); ++it){
- //FIXME : SEAMS should have to be taken into account here !!!
- if ((*it)->onWhat()->dim() >= 2){
+ // exit(1);
+ int nbFixedVertices = index;
+ for(std::set<MVertex *>::iterator it = all.begin(); it != all.end(); ++it) {
+ // FIXME : SEAMS should have to be taken into account here !!!
+ if((*it)->onWhat()->dim() >= 2) {
SPoint2 p;
reparamMeshVertexOnFace(*it, gf, p);
bamgVertices[index][0] = p.x();
@@ -114,21 +115,21 @@ void meshGFaceBamg(GFace *gf)
}
}
- std::vector<MElement*> myParamElems;
- std::vector<MVertex*> newVert;
+ std::vector<MElement *> myParamElems;
+ std::vector<MVertex *> newVert;
Triangle2 *bamgTriangles = new Triangle2[gf->triangles.size()];
- for (unsigned int i = 0; i < gf->triangles.size(); i++){
- int nodes [3] = {gf->triangles[i]->getVertex(0)->getIndex(),
- gf->triangles[i]->getVertex(1)->getIndex(),
- gf->triangles[i]->getVertex(2)->getIndex()};
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
+ int nodes[3] = {gf->triangles[i]->getVertex(0)->getIndex(),
+ gf->triangles[i]->getVertex(1)->getIndex(),
+ gf->triangles[i]->getVertex(2)->getIndex()};
double u1(bamgVertices[nodes[0]][0]);
double u2(bamgVertices[nodes[1]][0]);
double u3(bamgVertices[nodes[2]][0]);
double v1(bamgVertices[nodes[0]][1]);
double v2(bamgVertices[nodes[1]][1]);
double v3(bamgVertices[nodes[2]][1]);
- double sign = (u2-u1)*(v3-v1) - (u3-u1)*(v2-v1);
- if (sign < 0){
+ double sign = (u2 - u1) * (v3 - v1) - (u3 - u1) * (v2 - v1);
+ if(sign < 0) {
int temp = nodes[0];
nodes[0] = nodes[1];
nodes[1] = temp;
@@ -138,106 +139,108 @@ void meshGFaceBamg(GFace *gf)
// TODO C++11 std::accumulate
int numEdges = 0;
- for (std::vector<GEdge*>::const_iterator it = edges.begin(); it != edges.end(); ++it){
- numEdges += (*it)->lines.size();
+ for(std::vector<GEdge *>::const_iterator it = edges.begin();
+ it != edges.end(); ++it) {
+ numEdges += (*it)->lines.size();
}
Seg *bamgBoundary = new Seg[numEdges];
int count = 0;
- for (std::vector<GEdge*>::const_iterator it = edges.begin(); it != edges.end(); ++it){
- for (unsigned int i = 0; i < (*it)->lines.size(); ++i){
- int nodes [2] = {(*it)->lines[i]->getVertex(0)->getIndex(),
- (*it)->lines[i]->getVertex(1)->getIndex()};
+ for(std::vector<GEdge *>::const_iterator it = edges.begin();
+ it != edges.end(); ++it) {
+ for(unsigned int i = 0; i < (*it)->lines.size(); ++i) {
+ int nodes[2] = {(*it)->lines[i]->getVertex(0)->getIndex(),
+ (*it)->lines[i]->getVertex(1)->getIndex()};
bamgBoundary[count].init(bamgVertices, nodes, (*it)->tag());
bamgBoundary[count].lab = count;
count++;
}
}
- Mesh2 *bamgMesh = new Mesh2 (all.size(), gf->triangles.size(), numEdges,
- bamgVertices, bamgTriangles, bamgBoundary);
+ Mesh2 *bamgMesh = new Mesh2(all.size(), gf->triangles.size(), numEdges,
+ bamgVertices, bamgTriangles, bamgBoundary);
MElementOctree *_octree = NULL;
Mesh2 *refinedBamgMesh = 0;
int iterMax = 41;
- for (int k= 0; k < iterMax; k++){
-
+ for(int k = 0; k < iterMax; k++) {
int nbVert = bamgMesh->nv;
double *mm11 = new double[nbVert];
double *mm12 = new double[nbVert];
double *mm22 = new double[nbVert];
double args[256];
- for (int i=0;i<256;i++)args[i] = -1.1e100;
+ for(int i = 0; i < 256; i++) args[i] = -1.1e100;
args[16] = CTX::instance()->mesh.anisoMax;
- args[ 7] = CTX::instance()->mesh.smoothRatio;
- //args[ 21] = 90.0;//cutoffrad = 90 degree
- computeMeshMetricsForBamg (gf, nbVert, bamgMesh->vertices, mm11,mm12,mm22);
+ args[7] = CTX::instance()->mesh.smoothRatio;
+ // args[ 21] = 90.0;//cutoffrad = 90 degree
+ computeMeshMetricsForBamg(gf, nbVert, bamgMesh->vertices, mm11, mm12, mm22);
- try{
+ try {
refinedBamgMesh = Bamg(bamgMesh, args, mm11, mm12, mm22, false);
- Msg::Info("bamg succeeded %d vertices %d triangles",
- refinedBamgMesh->nv, refinedBamgMesh->nt);
- }
- catch(...){
+ Msg::Info("bamg succeeded %d vertices %d triangles", refinedBamgMesh->nv,
+ refinedBamgMesh->nt);
+ } catch(...) {
Msg::Error("bamg failed");
return;
}
- delete [] mm11;
- delete [] mm12;
- delete [] mm22;
+ delete[] mm11;
+ delete[] mm12;
+ delete[] mm22;
- int nT = bamgMesh->nt;
+ int nT = bamgMesh->nt;
int nTnow = refinedBamgMesh->nt;
delete bamgMesh;
bamgMesh = refinedBamgMesh;
- if (fabs((double)(nTnow - nT)) < 0.01 * nT) break;
+ if(fabs((double)(nTnow - nT)) < 0.01 * nT) break;
}
- std::map<int,MVertex*> yetAnother;
- for (int i = 0; i < refinedBamgMesh->nv; i++){
+ std::map<int, MVertex *> yetAnother;
+ for(int i = 0; i < refinedBamgMesh->nv; i++) {
Vertex2 &v = refinedBamgMesh->vertices[i];
- if (i >= nbFixedVertices){
+ if(i >= nbFixedVertices) {
GPoint gp = gf->point(SPoint2(v[0], v[1]));
// if (gp.x() > 2.){
// printf("wrong vertex index=%d %g %g %g (%g %g)\n",
// i, gp.x(), gp.y(), gp.z(), v[0], v[1]);
// }
// If point not found because compound edges have been remeshed and
- //boundary triangles have changed then we call our new octree
+ // boundary triangles have changed then we call our new octree
MFaceVertex *x = new MFaceVertex(gp.x(), gp.y(), gp.z(), gf, v[0], v[1]);
yetAnother[i] = x;
gf->mesh_vertices.push_back(x);
}
else {
MVertex *v = recover[i];
- yetAnother[i] =v;
+ yetAnother[i] = v;
}
}
- for (unsigned int i = 0; i < gf->triangles.size(); i++){
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
delete gf->triangles[i];
}
gf->triangles.clear();
- for (int i = 0; i < refinedBamgMesh->nt; i++){
+ for(int i = 0; i < refinedBamgMesh->nt; i++) {
Triangle2 &t = refinedBamgMesh->triangles[i];
Vertex2 &v1 = t[0];
Vertex2 &v2 = t[1];
Vertex2 &v3 = t[2];
gf->triangles.push_back(new MTriangle(yetAnother[(*refinedBamgMesh)(v1)],
- yetAnother[(*refinedBamgMesh)(v2)],
- yetAnother[(*refinedBamgMesh)(v3)]));
+ yetAnother[(*refinedBamgMesh)(v2)],
+ yetAnother[(*refinedBamgMesh)(v3)]));
}
- //delete pointers
- if (refinedBamgMesh) delete refinedBamgMesh;
- if ( _octree) delete _octree;
- for(std::vector<MElement*>::iterator it = myParamElems.begin(); it != myParamElems.end(); it++)
- delete *it;
- for(std::vector<MVertex*>::iterator it = newVert.begin(); it != newVert.end(); it++)
- delete *it;
+ // delete pointers
+ if(refinedBamgMesh) delete refinedBamgMesh;
+ if(_octree) delete _octree;
+ for(std::vector<MElement *>::iterator it = myParamElems.begin();
+ it != myParamElems.end(); it++)
+ delete *it;
+ for(std::vector<MVertex *>::iterator it = newVert.begin();
+ it != newVert.end(); it++)
+ delete *it;
}
#else
diff --git a/Mesh/meshGFaceExtruded.cpp b/Mesh/meshGFaceExtruded.cpp
index b491b6a24bbcbe5a8b6ea5b7a05b792be4bdbb56..f76ebd047a1a08e5b7e3bf688a85eee29fb2cfdc 100644
--- a/Mesh/meshGFaceExtruded.cpp
+++ b/Mesh/meshGFaceExtruded.cpp
@@ -14,21 +14,21 @@
#include "GmshMessage.h"
#include "QuadTriExtruded2D.h"
-static void addTriangle(MVertex* v1, MVertex* v2, MVertex* v3,
- GFace *to)
+static void addTriangle(MVertex *v1, MVertex *v2, MVertex *v3, GFace *to)
{
to->triangles.push_back(new MTriangle(v1, v2, v3));
}
-static void addQuadrangle(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
+static void addQuadrangle(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
GFace *to)
{
to->quadrangles.push_back(new MQuadrangle(v1, v2, v3, v4));
}
-static void createQuaTri(std::vector<MVertex*> &v, GFace *to,
- std::set<std::pair<MVertex*, MVertex*> > *constrainedEdges,
- MLine* source, int tri_quad_flag)
+static void
+createQuaTri(std::vector<MVertex *> &v, GFace *to,
+ std::set<std::pair<MVertex *, MVertex *> > *constrainedEdges,
+ MLine *source, int tri_quad_flag)
{
ExtrudeParams *ep = to->meshAttributes.extrude;
if(v[0] == v[1] || v[1] == v[3])
@@ -37,38 +37,40 @@ static void createQuaTri(std::vector<MVertex*> &v, GFace *to,
addTriangle(v[0], v[1], v[3], to);
else if(v[0] == v[3] || v[1] == v[2])
Msg::Error("Uncoherent extruded quadrangle in surface %d", to->tag());
- else{
+ else {
// Trevor Strickler added the tri_quad_flag stuff here.
- if((ep->mesh.Recombine && tri_quad_flag != 2) || tri_quad_flag == 1){
+ if((ep->mesh.Recombine && tri_quad_flag != 2) || tri_quad_flag == 1) {
if(!constrainedEdges)
- addQuadrangle(v[0], v[1], v[3], v[2], to);
- else{
- std::pair<MVertex*, MVertex*> p1(std::min(v[1], v[2]), std::max(v[1], v[2]));
- std::pair<MVertex*, MVertex*> p2(std::min(v[0], v[3]), std::max(v[0], v[3]));
- if(constrainedEdges->count(p1)){
- addTriangle(v[2], v[1], v[0], to);
- addTriangle(v[2], v[3], v[1], to);
- }
- else if(constrainedEdges->count(p2)){
- addTriangle(v[2], v[3], v[0], to);
- addTriangle(v[0], v[3], v[1], to);
- }
- else
- addQuadrangle(v[0], v[1], v[3], v[2], to);
+ addQuadrangle(v[0], v[1], v[3], v[2], to);
+ else {
+ std::pair<MVertex *, MVertex *> p1(std::min(v[1], v[2]),
+ std::max(v[1], v[2]));
+ std::pair<MVertex *, MVertex *> p2(std::min(v[0], v[3]),
+ std::max(v[0], v[3]));
+ if(constrainedEdges->count(p1)) {
+ addTriangle(v[2], v[1], v[0], to);
+ addTriangle(v[2], v[3], v[1], to);
+ }
+ else if(constrainedEdges->count(p2)) {
+ addTriangle(v[2], v[3], v[0], to);
+ addTriangle(v[0], v[3], v[1], to);
+ }
+ else
+ addQuadrangle(v[0], v[1], v[3], v[2], to);
}
-
}
- else if(!constrainedEdges){
+ else if(!constrainedEdges) {
addTriangle(v[0], v[1], v[3], to);
addTriangle(v[0], v[3], v[2], to);
}
- else{
- std::pair<MVertex*, MVertex*> p(std::min(v[1], v[2]), std::max(v[1], v[2]));
- if(constrainedEdges->count(p)){
+ else {
+ std::pair<MVertex *, MVertex *> p(std::min(v[1], v[2]),
+ std::max(v[1], v[2]));
+ if(constrainedEdges->count(p)) {
addTriangle(v[2], v[1], v[0], to);
addTriangle(v[2], v[3], v[1], to);
}
- else{
+ else {
addTriangle(v[2], v[3], v[0], to);
addTriangle(v[0], v[3], v[1], to);
}
@@ -76,36 +78,37 @@ static void createQuaTri(std::vector<MVertex*> &v, GFace *to,
}
}
-static void extrudeMesh(GEdge *from, GFace *to, MVertexRTree &pos,
- std::set<std::pair<MVertex*, MVertex*> > *constrainedEdges)
+static void
+extrudeMesh(GEdge *from, GFace *to, MVertexRTree &pos,
+ std::set<std::pair<MVertex *, MVertex *> > *constrainedEdges)
{
ExtrudeParams *ep = to->meshAttributes.extrude;
// create vertices (if the edges are constrained, they already exist)
- if(!constrainedEdges){
- for(unsigned int i = 0; i < from->mesh_vertices.size(); i++){
- std::vector<MVertex*> extruded_vertices;
+ if(!constrainedEdges) {
+ for(unsigned int i = 0; i < from->mesh_vertices.size(); i++) {
+ std::vector<MVertex *> extruded_vertices;
MVertex *v = from->mesh_vertices[i];
- MEdgeVertex *mv = (MEdgeVertex*) v;
+ MEdgeVertex *mv = (MEdgeVertex *)v;
mv->bl_data = new MVertexBoundaryLayerData();
for(int j = 0; j < ep->mesh.NbLayer; j++) {
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
double x = v->x(), y = v->y(), z = v->z();
ep->Extrude(j, k + 1, x, y, z);
- if(j != ep->mesh.NbLayer - 1 || k != ep->mesh.NbElmLayer[j] - 1){
+ if(j != ep->mesh.NbLayer - 1 || k != ep->mesh.NbElmLayer[j] - 1) {
MVertex *newv = 0;
if(to->geomType() != GEntity::DiscreteSurface &&
- to->geomType() != GEntity::BoundaryLayerSurface){
+ to->geomType() != GEntity::BoundaryLayerSurface) {
SPoint3 xyz(x, y, z);
SPoint2 uv = to->parFromPoint(xyz);
newv = new MFaceVertex(x, y, z, to, uv[0], uv[1]);
}
- else{
+ else {
newv = new MVertex(x, y, z, to);
}
to->mesh_vertices.push_back(newv);
pos.insert(newv);
- extruded_vertices.push_back(newv);
+ extruded_vertices.push_back(newv);
}
}
}
@@ -121,37 +124,42 @@ static void extrudeMesh(GEdge *from, GFace *to, MVertexRTree &pos,
// override, 1 = mesh with quads, 2 = mesh with triangles.)
bool detectQuadToTriLateral = false;
int tri_quad_flag = 0;
- bool quadToTri_valid = IsValidQuadToTriLateral(to, &tri_quad_flag, &detectQuadToTriLateral);
+ bool quadToTri_valid =
+ IsValidQuadToTriLateral(to, &tri_quad_flag, &detectQuadToTriLateral);
if(detectQuadToTriLateral && !quadToTri_valid)
- Msg::Error("In MeshGFaceExtrudedSurface::extrudeMesh(), Mesh of QuadToTri Lateral "
- "surface %d likely has errors.", to->tag());
+ Msg::Error(
+ "In MeshGFaceExtrudedSurface::extrudeMesh(), Mesh of QuadToTri Lateral "
+ "surface %d likely has errors.",
+ to->tag());
// create elements (note that it would be faster to access the
// *interior* nodes by direct indexing, but it's just simpler to
// query everything by position)
- for(unsigned int i = 0; i < from->lines.size(); i++){
+ for(unsigned int i = 0; i < from->lines.size(); i++) {
MVertex *v0 = from->lines[i]->getVertex(0);
MVertex *v1 = from->lines[i]->getVertex(1);
for(int j = 0; j < ep->mesh.NbLayer; j++) {
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
- std::vector<MVertex*> verts;
+ std::vector<MVertex *> verts;
double x[4] = {v0->x(), v1->x(), v0->x(), v1->x()};
double y[4] = {v0->y(), v1->y(), v0->y(), v1->y()};
double z[4] = {v0->z(), v1->z(), v0->z(), v1->z()};
- for(int p = 0; p < 2; p++){
+ for(int p = 0; p < 2; p++) {
ep->Extrude(j, k, x[p], y[p], z[p]);
ep->Extrude(j, k + 1, x[p + 2], y[p + 2], z[p + 2]);
}
- for(int p = 0; p < 4; p++){
+ for(int p = 0; p < 4; p++) {
MVertex *tmp = pos.find(x[p], y[p], z[p]);
- if(!tmp){
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) in surface %d",
+ if(!tmp) {
+ Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) "
+ "in surface %d",
x[p], y[p], z[p], to->tag());
return;
}
verts.push_back(tmp);
}
- createQuaTri(verts, to, constrainedEdges, from->lines[i], tri_quad_flag);
+ createQuaTri(verts, to, constrainedEdges, from->lines[i],
+ tri_quad_flag);
}
}
}
@@ -162,26 +170,26 @@ static void copyMesh(GFace *from, GFace *to, MVertexRTree &pos)
ExtrudeParams *ep = to->meshAttributes.extrude;
// interior vertices
- std::vector<MVertex*> mesh_vertices = from->mesh_vertices;
+ std::vector<MVertex *> mesh_vertices = from->mesh_vertices;
// add all embedded vertices
- std::vector<MVertex*> embedded = from->getEmbeddedMeshVertices();
+ std::vector<MVertex *> embedded = from->getEmbeddedMeshVertices();
mesh_vertices.insert(mesh_vertices.end(), embedded.begin(), embedded.end());
// create extruded vertices
- for(unsigned int i = 0; i < mesh_vertices.size(); i++){
+ for(unsigned int i = 0; i < mesh_vertices.size(); i++) {
MVertex *v = mesh_vertices[i];
double x = v->x(), y = v->y(), z = v->z();
ep->Extrude(ep->mesh.NbLayer - 1, ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1],
x, y, z);
MVertex *newv = 0;
if(to->geomType() != GEntity::DiscreteSurface &&
- to->geomType() != GEntity::BoundaryLayerSurface){
+ to->geomType() != GEntity::BoundaryLayerSurface) {
SPoint3 xyz(x, y, z);
SPoint2 uv = to->parFromPoint(xyz);
newv = new MFaceVertex(x, y, z, to, uv[0], uv[1]);
}
- else{
+ else {
newv = new MVertex(x, y, z, to);
}
to->mesh_vertices.push_back(newv);
@@ -192,41 +200,45 @@ static void copyMesh(GFace *from, GFace *to, MVertexRTree &pos)
// the source. The vertices and triangles can be copied directly
// though. First, of course, do some checks and make sure this is a
// valid QuadToTri top surface before engaging in QuadToTri meshing.
- int quadToTri= NO_QUADTRI;
+ int quadToTri = NO_QUADTRI;
bool detectQuadToTriTop = false;
- int quadToTri_valid = IsValidQuadToTriTop(to, &quadToTri, &detectQuadToTriTop);
+ int quadToTri_valid =
+ IsValidQuadToTriTop(to, &quadToTri, &detectQuadToTriTop);
bool is_toroidal = quadToTri_valid >= 2 ? true : false;
bool is_noaddverts = quadToTri_valid == 3 ? true : false;
- if(detectQuadToTriTop && !quadToTri_valid && !is_toroidal){
+ if(detectQuadToTriTop && !quadToTri_valid && !is_toroidal) {
Msg::Error("In MeshGFaceExtrudedSurface::copyMesh(), Mesh of QuadToTri top "
- "surface %d likely has errors.", to->tag());
+ "surface %d likely has errors.",
+ to->tag());
}
// if this is toroidal No New Vertices QuadToTri, then replace the root
// dependency face's boundary quads with triangles for better meshing.
- if(is_toroidal && is_noaddverts){
+ if(is_toroidal && is_noaddverts) {
GFace *root = findRootSourceFaceForFace(from);
- if(root == from){
+ if(root == from) {
ReplaceBndQuadsInFace(root);
- Msg::Warning("To facilitate QuadToTri interface on surface %d, source "
- "surface %d was re-meshed with all triangles on boundary. "
- "To avoid this, use QuadTriAddVerts instead of QuadTriNoNewVerts",
- to->tag(), root->tag());
+ Msg::Warning(
+ "To facilitate QuadToTri interface on surface %d, source "
+ "surface %d was re-meshed with all triangles on boundary. "
+ "To avoid this, use QuadTriAddVerts instead of QuadTriNoNewVerts",
+ to->tag(), root->tag());
}
}
// create triangle elements
- for(unsigned int i = 0; i < from->triangles.size(); i++){
- std::vector<MVertex*> verts;
- for(int j = 0; j < 3; j++){
+ for(unsigned int i = 0; i < from->triangles.size(); i++) {
+ std::vector<MVertex *> verts;
+ for(int j = 0; j < 3; j++) {
MVertex *v = from->triangles[i]->getVertex(j);
double x = v->x(), y = v->y(), z = v->z();
- ep->Extrude(ep->mesh.NbLayer - 1, ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1],
- x, y, z);
+ ep->Extrude(ep->mesh.NbLayer - 1,
+ ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1], x, y, z);
MVertex *tmp = pos.find(x, y, z);
if(!tmp) {
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) in surface %d",
- x, y, z, to->tag());
+ Msg::Error(
+ "Could not find extruded vertex (%.16g, %.16g, %.16g) in surface %d",
+ x, y, z, to->tag());
return;
}
verts.push_back(tmp);
@@ -235,26 +247,29 @@ static void copyMesh(GFace *from, GFace *to, MVertexRTree &pos)
}
// Add triangles for divided quads for QuadTri -- Trevor Strickler
- // if quadtotri and not part of a toroidal extrusion, mesh the top surface accordingly
- if(detectQuadToTriTop && !is_toroidal){
+ // if quadtotri and not part of a toroidal extrusion, mesh the top surface
+ // accordingly
+ if(detectQuadToTriTop && !is_toroidal) {
if(!MeshQuadToTriTopSurface(from, to, pos))
Msg::Error("In MeshExtrudedSurface()::copyMesh(), mesh of QuadToTri top "
- "surface %d failed.", to->tag() );
+ "surface %d failed.",
+ to->tag());
return;
}
// create quadrangle elements if NOT QuadToTri and NOT toroidal
- for(unsigned int i = 0; i < from->quadrangles.size(); i++){
- std::vector<MVertex*> verts;
- for(int j = 0; j < 4; j++){
+ for(unsigned int i = 0; i < from->quadrangles.size(); i++) {
+ std::vector<MVertex *> verts;
+ for(int j = 0; j < 4; j++) {
MVertex *v = from->quadrangles[i]->getVertex(j);
double x = v->x(), y = v->y(), z = v->z();
- ep->Extrude(ep->mesh.NbLayer - 1, ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1],
- x, y, z);
+ ep->Extrude(ep->mesh.NbLayer - 1,
+ ep->mesh.NbElmLayer[ep->mesh.NbLayer - 1], x, y, z);
MVertex *tmp = pos.find(x, y, z);
if(!tmp) {
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g) in surface %d",
- x, y, z, to->tag());
+ Msg::Error(
+ "Could not find extruded vertex (%.16g, %.16g, %.16g) in surface %d",
+ x, y, z, to->tag());
return;
}
verts.push_back(tmp);
@@ -263,21 +278,20 @@ static void copyMesh(GFace *from, GFace *to, MVertexRTree &pos)
}
}
-int MeshExtrudedSurface(GFace *gf,
- std::set<std::pair<MVertex*, MVertex*> > *constrainedEdges)
+int MeshExtrudedSurface(
+ GFace *gf, std::set<std::pair<MVertex *, MVertex *> > *constrainedEdges)
{
ExtrudeParams *ep = gf->meshAttributes.extrude;
- if(!ep || !ep->mesh.ExtrudeMesh)
- return 0;
+ if(!ep || !ep->mesh.ExtrudeMesh) return 0;
Msg::Info("Meshing surface %d (extruded)", gf->tag());
// build an rtree with all the vertices on the boundary of the face gf
MVertexRTree pos(CTX::instance()->geom.tolerance * CTX::instance()->lc);
- std::vector<GEdge*> const& edges = gf->edges();
- std::vector<GEdge*>::const_iterator it = edges.begin();
- while(it != edges.end()){
+ std::vector<GEdge *> const &edges = gf->edges();
+ std::vector<GEdge *>::const_iterator it = edges.begin();
+ while(it != edges.end()) {
pos.insert((*it)->mesh_vertices);
pos.insert((*it)->getBeginVertex()->mesh_vertices);
pos.insert((*it)->getEndVertex()->mesh_vertices);
@@ -286,14 +300,14 @@ int MeshExtrudedSurface(GFace *gf,
// if the edges of the mesh are constrained, the vertices already
// exist on the face--so we add them to the set
- if(constrainedEdges){
+ if(constrainedEdges) {
pos.insert(gf->mesh_vertices);
}
if(ep->geo.Mode == EXTRUDED_ENTITY) {
// surface is extruded from a curve
GEdge *from = gf->model()->getEdgeByTag(std::abs(ep->geo.Source));
- if(!from){
+ if(!from) {
Msg::Error("Unknown source curve %d for extrusion", ep->geo.Source);
return 0;
}
@@ -302,12 +316,12 @@ int MeshExtrudedSurface(GFace *gf,
else {
// surface is a copy of another surface (the "top" of the extrusion)
GFace *from = gf->model()->getFaceByTag(std::abs(ep->geo.Source));
- if(!from){
+ if(!from) {
Msg::Error("Unknown source surface %d for extrusion", ep->geo.Source);
return 0;
}
else if(from->geomType() != GEntity::DiscreteSurface &&
- from->meshStatistics.status != GFace::DONE){
+ from->meshStatistics.status != GFace::DONE) {
// cannot mesh the face yet (the source face is not meshed):
// will do it later
return 1;
diff --git a/Mesh/meshGFaceLloyd.cpp b/Mesh/meshGFaceLloyd.cpp
index c7b3a3729cef39516bd0f832556ca7fb52f549cd..5ececbbea9373f1a994dd9b877c202b008ccb998 100644
--- a/Mesh/meshGFaceLloyd.cpp
+++ b/Mesh/meshGFaceLloyd.cpp
@@ -31,11 +31,12 @@
#include "meshGFaceOptimize.h"
#include <algorithm>
-class metric{
- private :
- double a,b,c,d;
- public :
- metric(double,double,double,double);
+class metric {
+private:
+ double a, b, c, d;
+
+public:
+ metric(double, double, double, double);
metric();
~metric();
void set_a(double);
@@ -48,8 +49,8 @@ class metric{
double get_d();
};
-class voronoi_vertex{
- private :
+class voronoi_vertex {
+private:
SPoint2 point;
int index1;
int index2;
@@ -57,58 +58,61 @@ class voronoi_vertex{
SVector3 normal;
bool duplicate;
double h;
- public :
- voronoi_vertex(const SPoint2 &);
- voronoi_vertex();
- ~voronoi_vertex();
- SPoint2 get_point();
- int get_index1();
- int get_index2();
- int get_index3();
- SVector3 get_normal();
- bool get_duplicate();
- double get_h();
- void set_point(const SPoint2 &);
- void set_index1(int);
- void set_index2(int);
- void set_index3(int);
- void set_normal(const SVector3 &);
- void set_duplicate(bool);
- void set_h(double);
+
+public:
+ voronoi_vertex(const SPoint2 &);
+ voronoi_vertex();
+ ~voronoi_vertex();
+ SPoint2 get_point();
+ int get_index1();
+ int get_index2();
+ int get_index3();
+ SVector3 get_normal();
+ bool get_duplicate();
+ double get_h();
+ void set_point(const SPoint2 &);
+ void set_index1(int);
+ void set_index2(int);
+ void set_index3(int);
+ void set_normal(const SVector3 &);
+ void set_duplicate(bool);
+ void set_h(double);
};
-class voronoi_element{
- private :
+class voronoi_element {
+private:
voronoi_vertex v1;
voronoi_vertex v2;
voronoi_vertex v3;
double dh_dx;
double dh_dy;
metric m;
- public :
- voronoi_element(const voronoi_vertex &, const voronoi_vertex &,
- const voronoi_vertex &);
- voronoi_element();
- ~voronoi_element();
- voronoi_vertex get_v1();
- voronoi_vertex get_v2();
- voronoi_vertex get_v3();
- double get_h(double, double);
- double get_dh_dx();
- double get_dh_dy();
- metric get_metric();
- void set_v1(const voronoi_vertex &);
- void set_v2(const voronoi_vertex &);
- void set_v3(const voronoi_vertex &);
- void set_metric(const metric &);
- void deriv_h(int);
- double get_quality();
+
+public:
+ voronoi_element(const voronoi_vertex &, const voronoi_vertex &,
+ const voronoi_vertex &);
+ voronoi_element();
+ ~voronoi_element();
+ voronoi_vertex get_v1();
+ voronoi_vertex get_v2();
+ voronoi_vertex get_v3();
+ double get_h(double, double);
+ double get_dh_dx();
+ double get_dh_dy();
+ metric get_metric();
+ void set_v1(const voronoi_vertex &);
+ void set_v2(const voronoi_vertex &);
+ void set_v3(const voronoi_vertex &);
+ void set_metric(const metric &);
+ void deriv_h(int);
+ double get_quality();
};
-class voronoi_cell{
- private :
+class voronoi_cell {
+private:
std::vector<voronoi_vertex> vertices;
- public :
+
+public:
voronoi_cell();
~voronoi_cell();
int get_number_vertices();
@@ -117,13 +121,14 @@ class voronoi_cell{
void clear();
};
-class segment{
- private :
+class segment {
+private:
int index1;
int index2;
int reference;
- public :
- segment(int,int,int);
+
+public:
+ segment(int, int, int);
segment();
~segment();
int get_index1();
@@ -132,54 +137,56 @@ class segment{
void set_index1(int);
void set_index2(int);
void set_reference(int);
- bool equal(int,int);
+ bool equal(int, int);
};
-class segment_list{
- private :
+class segment_list {
+private:
std::vector<segment> segments;
- public :
+
+public:
segment_list();
~segment_list();
int get_number_segments();
segment get_segment(int);
- bool add_segment(int,int,int);
+ bool add_segment(int, int, int);
bool add_segment(segment);
};
-class wrapper{
- private :
+class wrapper {
+private:
int p;
int dimension;
- GFace* gf;
+ GFace *gf;
int iteration;
int max;
double start;
- DocRecord* triangulator;
- MElementOctree* octree;
- public :
+ DocRecord *triangulator;
+ MElementOctree *octree;
+
+public:
wrapper();
~wrapper();
int get_p();
void set_p(int);
int get_dimension();
void set_dimension(int);
- GFace* get_face();
- void set_face(GFace*);
+ GFace *get_face();
+ void set_face(GFace *);
int get_iteration();
void set_iteration(int);
int get_max();
void set_max(int);
double get_start();
void set_start(double);
- DocRecord* get_triangulator();
- void set_triangulator(DocRecord*);
- MElementOctree* get_octree();
- void set_octree(MElementOctree*);
+ DocRecord *get_triangulator();
+ void set_triangulator(DocRecord *);
+ MElementOctree *get_octree();
+ void set_octree(MElementOctree *);
};
-class lpcvt{
- private :
+class lpcvt {
+private:
std::list<voronoi_element> clipped;
std::queue<int> fifo;
std::vector<segment_list> borders;
@@ -188,7 +195,8 @@ class lpcvt{
fullMatrix<double> gauss_points;
fullVector<double> gauss_weights;
int gauss_num;
- public :
+
+public:
lpcvt();
~lpcvt();
double angle(const SPoint2 &, const SPoint2 &, const SPoint2 &);
@@ -196,43 +204,43 @@ class lpcvt{
SPoint2 mid(const SPoint2 &, const SPoint2 &);
bool same_side(const SPoint2 &, const SPoint2 &, const SPoint2 &,
const SPoint2 &);
- bool interior(DocRecord&,GFace*,int);
+ bool interior(DocRecord &, GFace *, int);
bool interior(DocRecord &, segment, segment, double, const SPoint2 &);
- bool invisible(DocRecord&,GFace*,int);
- bool real(DocRecord&,int,int,int);
+ bool invisible(DocRecord &, GFace *, int);
+ bool real(DocRecord &, int, int, int);
double triangle_area(const SPoint2 &, const SPoint2 &, const SPoint2 &);
bool sliver(const SPoint2 &, const SPoint2 &, const SPoint2 &);
SPoint2 intersection(DocRecord &, segment, segment, const SPoint2 &,
const SPoint2 &, bool &, SVector3 &, segment &);
SPoint2 intersection(const SPoint2 &, const SPoint2 &, const SPoint2 &,
const SPoint2 &, bool &);
- SPoint2 convert(DocRecord&,int);
- SPoint2 circumcircle(DocRecord&,int,int,int);
- SPoint2 seed(DocRecord&,GFace*);
- void step1(DocRecord&,GFace*);
- void step2(DocRecord&,GFace*);
- void step3(DocRecord&,GFace*);
- void step4(DocRecord&,GFace*);
- void step5(DocRecord&,GFace*);
- void clip_cells(DocRecord&,GFace*);
+ SPoint2 convert(DocRecord &, int);
+ SPoint2 circumcircle(DocRecord &, int, int, int);
+ SPoint2 seed(DocRecord &, GFace *);
+ void step1(DocRecord &, GFace *);
+ void step2(DocRecord &, GFace *);
+ void step3(DocRecord &, GFace *);
+ void step4(DocRecord &, GFace *);
+ void step5(DocRecord &, GFace *);
+ void clip_cells(DocRecord &, GFace *);
void clear();
double total_area();
void print_voronoi1();
void print_voronoi2();
- void print_delaunay(DocRecord&);
+ void print_delaunay(DocRecord &);
void print_segment(const SPoint2 &, const SPoint2 &, std::ofstream &);
- void compute_parameters(GFace*,int);
+ void compute_parameters(GFace *, int);
double get_ratio(GFace *, const SPoint2 &);
- double compute_rho(double,int);
- void write(DocRecord&,GFace*,int);
- void eval(DocRecord&,std::vector<SVector3>&,double&,int);
+ double compute_rho(double, int);
+ void write(DocRecord &, GFace *, int);
+ void eval(DocRecord &, std::vector<SVector3> &, double &, int);
void swap();
void get_gauss();
- double F(voronoi_element,int);
- SVector3 simple(voronoi_element,int);
- SVector3 dF_dC1(voronoi_element,int);
- SVector3 dF_dC2(voronoi_element,int);
+ double F(voronoi_element, int);
+ SVector3 simple(voronoi_element, int);
+ SVector3 dF_dC1(voronoi_element, int);
+ SVector3 dF_dC2(voronoi_element, int);
double f(const SPoint2 &, const SPoint2 &, metric, int);
double df_dx(const SPoint2 &, const SPoint2 &, metric, int);
double df_dy(const SPoint2 &, const SPoint2 &, metric, int);
@@ -245,17 +253,19 @@ class lpcvt{
const SPoint2 &, const SVector3 &);
};
-bool domain_search(MElementOctree* octree,double x,double y)
+bool domain_search(MElementOctree *octree, double x, double y)
{
- MElement* element;
+ MElement *element;
- element = (MElement*)octree->find(x,y,0.0,2,true);
- if(element!=NULL) return 1;
- else return 0;
+ element = (MElement *)octree->find(x, y, 0.0, 2, true);
+ if(element != NULL)
+ return 1;
+ else
+ return 0;
}
-void callback(const alglib::real_1d_array& x,double& func,
- alglib::real_1d_array& grad,void* ptr)
+void callback(const alglib::real_1d_array &x, double &func,
+ alglib::real_1d_array &grad, void *ptr)
{
int i;
int p;
@@ -275,14 +285,14 @@ void callback(const alglib::real_1d_array& x,double& func,
double u;
double v;
SPoint2 val;
- GFace* gf;
- DocRecord* pointer;
- wrapper* w;
- MElementOctree* octree;
+ GFace *gf;
+ DocRecord *pointer;
+ wrapper *w;
+ MElementOctree *octree;
lpcvt obj;
std::vector<SVector3> gradients;
- w = static_cast<wrapper*>(ptr);
+ w = static_cast<wrapper *>(ptr);
p = w->get_p();
dimension = w->get_dimension();
gf = w->get_face();
@@ -298,11 +308,11 @@ void callback(const alglib::real_1d_array& x,double& func,
error3 = 0;
index = 0;
- for(i=0;i<num;i++){
- if(obj.interior(*pointer,gf,i)){
+ for(i = 0; i < num; i++) {
+ if(obj.interior(*pointer, gf, i)) {
u = x[index];
- v = x[index + dimension/2];
- inside = domain_search(octree,u,v);
+ v = x[index + dimension / 2];
+ inside = domain_search(octree, u, v);
if(!inside) error1 = 1;
pointer->points[i].where.h = u;
pointer->points[i].where.v = v;
@@ -311,121 +321,121 @@ void callback(const alglib::real_1d_array& x,double& func,
}
}
- if(iteration>=max){
+ if(iteration >= max) {
error2 = 1;
}
- if(!error1 && !error2){
+ if(!error1 && !error2) {
pointer->Voronoi();
pointer->build_edges();
conformity = pointer->delaunay_conformity(gf);
if(!conformity) error3 = 1;
pointer->clear_edges();
- if(!error3){
- val = obj.seed(*pointer,gf);
- pointer->concave(val.x(),val.y(),gf);
- obj.clip_cells(*pointer,gf);
+ if(!error3) {
+ val = obj.seed(*pointer, gf);
+ pointer->concave(val.x(), val.y(), gf);
+ obj.clip_cells(*pointer, gf);
obj.swap();
- obj.compute_parameters(gf,p);
+ obj.compute_parameters(gf, p);
obj.get_gauss();
- obj.eval(*pointer,gradients,energy,p);
+ obj.eval(*pointer, gradients, energy, p);
func = energy;
- //obj.print_voronoi1();
- //obj.print_voronoi2();
+ // obj.print_voronoi1();
+ // obj.print_voronoi2();
}
}
- if(error1 || error2 || error3){
+ if(error1 || error2 || error3) {
energy = 1000000000.0;
- for(i=0;i<num;i++){
- gradients[i] = SVector3(0.0,0.0,0.0);
+ for(i = 0; i < num; i++) {
+ gradients[i] = SVector3(0.0, 0.0, 0.0);
}
func = energy;
}
- if(error1){
+ if(error1) {
printf("Vertices outside domain.\n");
}
- if(error2){
+ if(error2) {
printf("Maximum number of iterations reached.\n");
}
- if(error3){
+ if(error3) {
printf("Boundary intersection.\n");
}
- if(start>0.0 && !error1 && !error2 && !error3){
- printf("Lloyd: %d %.3f\n",iteration,100.0*(start-energy)/start);
- w->set_iteration(iteration+1);
+ if(start > 0.0 && !error1 && !error2 && !error3) {
+ printf("Lloyd: %d %.3f\n", iteration, 100.0 * (start - energy) / start);
+ w->set_iteration(iteration + 1);
}
- else if(!error1 && !error2 && !error3){
+ else if(!error1 && !error2 && !error3) {
w->set_start(energy);
}
- for(i=0;i<num;i++){
- if(obj.interior(*pointer,gf,i)){
+ for(i = 0; i < num; i++) {
+ if(obj.interior(*pointer, gf, i)) {
identificator = pointer->points[i].identificator;
grad[identificator] = gradients[i].x();
- grad[identificator + dimension/2] = gradients[i].y();
+ grad[identificator + dimension / 2] = gradients[i].y();
}
}
}
-void verification(alglib::real_1d_array& x,void* ptr)
+void verification(alglib::real_1d_array &x, void *ptr)
{
int index;
int dimension;
double e;
double func;
- double R,L,U,D;
- wrapper* w;
+ double R, L, U, D;
+ wrapper *w;
- w = static_cast<wrapper*>(ptr);
+ w = static_cast<wrapper *>(ptr);
dimension = w->get_dimension();
srand(time(NULL));
- index = rand()%(dimension/2);
+ index = rand() % (dimension / 2);
e = 0.0000001;
alglib::real_1d_array grad;
grad.setlength(dimension);
x[index] = x[index] + e;
- callback(x,R,grad,ptr);
+ callback(x, R, grad, ptr);
x[index] = x[index] - e;
x[index] = x[index] - e;
- callback(x,L,grad,ptr);
+ callback(x, L, grad, ptr);
x[index] = x[index] + e;
- x[index + dimension/2] = x[index + dimension/2] + e;
- callback(x,U,grad,ptr);
- x[index + dimension/2] = x[index + dimension/2] - e;
+ x[index + dimension / 2] = x[index + dimension / 2] + e;
+ callback(x, U, grad, ptr);
+ x[index + dimension / 2] = x[index + dimension / 2] - e;
- x[index + dimension/2] = x[index + dimension/2] - e;
- callback(x,D,grad,ptr);
- x[index + dimension/2] = x[index + dimension/2] + e;
+ x[index + dimension / 2] = x[index + dimension / 2] - e;
+ callback(x, D, grad, ptr);
+ x[index + dimension / 2] = x[index + dimension / 2] + e;
- callback(x,func,grad,ptr);
+ callback(x, func, grad, ptr);
- printf("%f %f\n",(R-L)/(2.0*e),(U-D)/(2.0*e));
- printf("%f %f\n",grad[index],grad[index + dimension/2]);
+ printf("%f %f\n", (R - L) / (2.0 * e), (U - D) / (2.0 * e));
+ printf("%f %f\n", grad[index], grad[index + dimension / 2]);
}
-smoothing::smoothing(int param1,int param2)
+smoothing::smoothing(int param1, int param2)
{
ITER_MAX = param1;
NORM = param2;
}
-void smoothing::optimize_face(GFace* gf)
+void smoothing::optimize_face(GFace *gf)
{
- if(gf->getNumMeshElements()==0) return;
+ if(gf->getNumMeshElements() == 0) return;
- std::set<MVertex*> all;
+ std::set<MVertex *> all;
// get all the points of the face ...
- for (unsigned int i = 0; i < gf->getNumMeshElements(); i++){
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
MElement *e = gf->getMeshElement(i);
- for (std::size_t j = 0;j<e->getNumVertices(); j++){
+ for(std::size_t j = 0; j < e->getNumVertices(); j++) {
MVertex *v = e->getVertex(j);
all.insert(v);
}
@@ -436,28 +446,28 @@ void smoothing::optimize_face(GFace* gf)
// Create a triangulator
DocRecord triangulator(all.size());
- Range<double> du = gf->parBounds(0) ;
- Range<double> dv = gf->parBounds(1) ;
+ Range<double> du = gf->parBounds(0);
+ Range<double> dv = gf->parBounds(1);
- const double LC2D = sqrt((du.high()-du.low())*(du.high()-du.low()) +
- (dv.high()-dv.low())*(dv.high()-dv.low()));
+ const double LC2D = sqrt((du.high() - du.low()) * (du.high() - du.low()) +
+ (dv.high() - dv.low()) * (dv.high() - dv.low()));
- //printf("Lloyd on face %d %d elements %d nodes LC %g\n", gf->tag(),
+ // printf("Lloyd on face %d %d elements %d nodes LC %g\n", gf->tag(),
// gf->getNumMeshElements(), (int)all.size(), LC2D);
int i = 0;
- for (std::set<MVertex*>::iterator it = all.begin(); it != all.end(); ++it){
+ for(std::set<MVertex *>::iterator it = all.begin(); it != all.end(); ++it) {
SPoint2 p;
bool success = reparamMeshVertexOnFace(*it, gf, p);
- if (!success) {
- Msg::Error("Impossible to apply Lloyd to model face %d",gf->tag());
+ if(!success) {
+ Msg::Error("Impossible to apply Lloyd to model face %d", gf->tag());
Msg::Error("A mesh vertex cannot be reparametrized");
return;
}
double XX = CTX::instance()->mesh.randFactor * LC2D * (double)rand() /
- (double)RAND_MAX;
+ (double)RAND_MAX;
double YY = CTX::instance()->mesh.randFactor * LC2D * (double)rand() /
- (double)RAND_MAX;
+ (double)RAND_MAX;
triangulator.x(i) = p.x() + XX;
triangulator.y(i) = p.y() + YY;
triangulator.data(i++) = (*it);
@@ -465,9 +475,9 @@ void smoothing::optimize_face(GFace* gf)
// compute the Voronoi diagram
triangulator.Voronoi();
- //printf("hullSize = %d\n",triangulator.hullSize());
- //triangulator.makePosView("LloydInit.pos");
- //triangulator.printMedialAxis("medialAxis.pos");
+ // printf("hullSize = %d\n",triangulator.hullSize());
+ // triangulator.makePosView("LloydInit.pos");
+ // triangulator.printMedialAxis("medialAxis.pos");
int exponent;
int num_interior;
@@ -475,21 +485,21 @@ void smoothing::optimize_face(GFace* gf)
double epsg;
double epsf;
double epsx;
- double varx,vary;
+ double varx, vary;
double ratio;
double factor;
lpcvt obj;
- double* initial_conditions = static_cast<double*>
- (malloc(2*triangulator.numPoints*sizeof(double)));
- double* variables_scales = static_cast<double*>
- (malloc(2*triangulator.numPoints*sizeof(double)));
+ double *initial_conditions =
+ static_cast<double *>(malloc(2 * triangulator.numPoints * sizeof(double)));
+ double *variables_scales =
+ static_cast<double *>(malloc(2 * triangulator.numPoints * sizeof(double)));
alglib::ae_int_t maxits;
alglib::minlbfgsstate state;
alglib::minlbfgsreport rep;
alglib::real_1d_array x;
alglib::real_1d_array scales;
wrapper w;
- MElementOctree* octree;
+ MElementOctree *octree;
exponent = NORM;
epsg = 0;
@@ -498,38 +508,38 @@ void smoothing::optimize_face(GFace* gf)
maxits = ITER_MAX;
num_interior = 0;
- for(int i=0;i<triangulator.numPoints;i++){
- if(obj.interior(triangulator,gf,i)){
+ for(int i = 0; i < triangulator.numPoints; i++) {
+ if(obj.interior(triangulator, gf, i)) {
num_interior++;
}
}
factor = 2.0;
index = 0;
- for(int i=0;i<triangulator.numPoints;i++){
- if(obj.interior(triangulator,gf,i)){
+ for(int i = 0; i < triangulator.numPoints; i++) {
+ if(obj.interior(triangulator, gf, i)) {
varx = triangulator.points[i].where.h;
vary = triangulator.points[i].where.v;
initial_conditions[index] = varx;
- initial_conditions[index+num_interior] = vary;
- ratio = obj.get_ratio(gf,SPoint2(varx,vary));
- variables_scales[index] = factor*backgroundMesh::current()->operator()
- (varx,vary,0.0)*ratio;
- variables_scales[index+num_interior] = factor*backgroundMesh::current()->operator()
- (varx,vary,0.0)*ratio;
+ initial_conditions[index + num_interior] = vary;
+ ratio = obj.get_ratio(gf, SPoint2(varx, vary));
+ variables_scales[index] =
+ factor * backgroundMesh::current()->operator()(varx, vary, 0.0) * ratio;
+ variables_scales[index + num_interior] =
+ factor * backgroundMesh::current()->operator()(varx, vary, 0.0) * ratio;
index++;
}
}
- x.setcontent(2*num_interior,initial_conditions);
- scales.setcontent(2*num_interior,variables_scales);
+ x.setcontent(2 * num_interior, initial_conditions);
+ scales.setcontent(2 * num_interior, variables_scales);
octree = backgroundMesh::current()->get_octree();
w.set_p(exponent);
- w.set_dimension(2*num_interior);
+ w.set_dimension(2 * num_interior);
w.set_face(gf);
- w.set_max(2*ITER_MAX);
+ w.set_max(2 * ITER_MAX);
w.set_triangulator(&triangulator);
w.set_octree(octree);
@@ -537,13 +547,13 @@ void smoothing::optimize_face(GFace* gf)
verification(x,&w);
}*/
- if(num_interior>1){
- minlbfgscreate(2*num_interior,4,x,state);
- minlbfgssetscale(state,scales);
+ if(num_interior > 1) {
+ minlbfgscreate(2 * num_interior, 4, x, state);
+ minlbfgssetscale(state, scales);
minlbfgssetprecscale(state);
- minlbfgssetcond(state,epsg,epsf,epsx,maxits);
- minlbfgsoptimize(state,callback,NULL,&w);
- minlbfgsresults(state,x,rep);
+ minlbfgssetcond(state, epsg, epsf, epsx, maxits);
+ minlbfgsoptimize(state, callback, NULL, &w);
+ minlbfgsresults(state, x, rep);
}
/*lpcvt obj2;
@@ -557,8 +567,8 @@ void smoothing::optimize_face(GFace* gf)
*/
index = 0;
- for(i=0;i<triangulator.numPoints;i++){
- if(obj.interior(triangulator,gf,i)){
+ for(i = 0; i < triangulator.numPoints; i++) {
+ if(obj.interior(triangulator, gf, i)) {
triangulator.points[i].where.h = x[index];
triangulator.points[i].where.v = x[index + num_interior];
index++;
@@ -567,14 +577,15 @@ void smoothing::optimize_face(GFace* gf)
triangulator.Voronoi();
// now create the vertices
- std::vector<MVertex*> mesh_vertices;
- for (int i=0; i<triangulator.numPoints;i++){
+ std::vector<MVertex *> mesh_vertices;
+ for(int i = 0; i < triangulator.numPoints; i++) {
// get the ith vertex
PointRecord &pt = triangulator.points[i];
- MVertex *v = (MVertex*)pt.data;
- if (v->onWhat() == gf && !triangulator.onHull(i)){
- GPoint gp = gf->point (pt.where.h,pt.where.v);
- MFaceVertex *v = new MFaceVertex(gp.x(),gp.y(),gp.z(),gf,gp.u(),gp.v());
+ MVertex *v = (MVertex *)pt.data;
+ if(v->onWhat() == gf && !triangulator.onHull(i)) {
+ GPoint gp = gf->point(pt.where.h, pt.where.v);
+ MFaceVertex *v =
+ new MFaceVertex(gp.x(), gp.y(), gp.z(), gf, gp.u(), gp.v());
mesh_vertices.push_back(v);
}
}
@@ -605,40 +616,39 @@ void smoothing::optimize_face(GFace* gf)
void smoothing::optimize_model()
{
- GFace*gf;
- GModel*model = GModel::current();
+ GFace *gf;
+ GModel *model = GModel::current();
GModel::fiter it;
- for(it=model->firstFace();it!=model->lastFace();it++)
- {
+ for(it = model->firstFace(); it != model->lastFace(); it++) {
gf = *it;
- if(gf->getNumMeshElements()>0){
+ if(gf->getNumMeshElements() > 0) {
optimize_face(gf);
- //recombineIntoQuads(gf,1,1);
+ // recombineIntoQuads(gf,1,1);
}
}
}
-lpcvt::lpcvt(){}
+lpcvt::lpcvt() {}
-lpcvt::~lpcvt(){}
+lpcvt::~lpcvt() {}
double lpcvt::angle(const SPoint2 &p1, const SPoint2 &p2, const SPoint2 &p3)
{
- double x1,x2;
- double y1,y2;
+ double x1, x2;
+ double y1, y2;
double product;
- double norm1,norm2;
+ double norm1, norm2;
double angle;
x1 = p2.x() - p1.x();
y1 = p2.y() - p1.y();
x2 = p3.x() - p1.x();
y2 = p3.y() - p1.y();
- norm1 = sqrt(x1*x1 + y1*y1);
- norm2 = sqrt(x2*x2 + y2*y2);
- product = x1*x2 + y1*y2;
- angle = product/(norm1*norm2);
- angle = 180.0*myacos(angle)/M_PI;
+ norm1 = sqrt(x1 * x1 + y1 * y1);
+ norm2 = sqrt(x2 * x2 + y2 * y2);
+ product = x1 * x2 + y1 * y2;
+ angle = product / (norm1 * norm2);
+ angle = 180.0 * myacos(angle) / M_PI;
return angle;
}
@@ -649,7 +659,7 @@ SVector3 lpcvt::normal(const SPoint2 &p1, const SPoint2 &p2)
SVector3 val;
x = p2.x() - p1.x();
y = p2.y() - p1.y();
- val = SVector3(-y,x,0.0);
+ val = SVector3(-y, x, 0.0);
return val;
}
@@ -657,101 +667,107 @@ SPoint2 lpcvt::mid(const SPoint2 &p1, const SPoint2 &p2)
{
double x;
double y;
- x = 0.5*(p1.x() + p2.x());
- y = 0.5*(p1.y() + p2.y());
- return SPoint2(x,y);
+ x = 0.5 * (p1.x() + p2.x());
+ y = 0.5 * (p1.y() + p2.y());
+ return SPoint2(x, y);
}
bool lpcvt::same_side(const SPoint2 &p1, const SPoint2 &p2, const SPoint2 &p3,
const SPoint2 &p4)
{
- double x1,y1;
- double x2,y2;
- double x3,y3;
+ double x1, y1;
+ double x2, y2;
+ double x3, y3;
double product1;
double product2;
- x1 = p2.x()-p1.x();
- y1 = p2.y()-p1.y();
- x2 = p3.x()-p1.x();
- y2 = p3.y()-p1.y();
- x3 = p4.x()-p1.x();
- y3 = p4.y()-p1.y();
- product1 = x2*y1 - x1*y2;
- product2 = x3*y1 - x1*y3;
- if(product1>0.0 && product2>0.0){
+ x1 = p2.x() - p1.x();
+ y1 = p2.y() - p1.y();
+ x2 = p3.x() - p1.x();
+ y2 = p3.y() - p1.y();
+ x3 = p4.x() - p1.x();
+ y3 = p4.y() - p1.y();
+ product1 = x2 * y1 - x1 * y2;
+ product2 = x3 * y1 - x1 * y3;
+ if(product1 > 0.0 && product2 > 0.0) {
return 1;
}
- else if(product1<0.0 && product2<0.0){
+ else if(product1 < 0.0 && product2 < 0.0) {
return 1;
}
- else return 0;
+ else
+ return 0;
}
-bool lpcvt::interior(DocRecord& triangulator,GFace* gf,int index)
+bool lpcvt::interior(DocRecord &triangulator, GFace *gf, int index)
{
- PointRecord& temp = triangulator.points[index];
- MVertex* vertex = (MVertex*)temp.data;
- if(vertex->onWhat()==gf && !triangulator.onHull(index)){
+ PointRecord &temp = triangulator.points[index];
+ MVertex *vertex = (MVertex *)temp.data;
+ if(vertex->onWhat() == gf && !triangulator.onHull(index)) {
return 1;
}
- else return 0;
+ else
+ return 0;
}
bool lpcvt::interior(DocRecord &triangulator, segment s1, segment s2,
double angle, const SPoint2 &p)
{
- SPoint2 p1,p2,p3,p4;
- SPoint2 reference1,reference2;
- bool condition1,condition2;
- p1 = convert(triangulator,s1.get_index1());
- p2 = convert(triangulator,s1.get_index2());
- p3 = convert(triangulator,s2.get_index1());
- p4 = convert(triangulator,s2.get_index2());
- reference1 = convert(triangulator,s1.get_reference());
- reference2 = convert(triangulator,s2.get_reference());
- condition1 = same_side(p1,p2,reference1,p);
- condition2 = same_side(p3,p4,reference2,p);
- if(angle>=180.0){
- if(condition1 || condition2) return 1;
- else return 0;
+ SPoint2 p1, p2, p3, p4;
+ SPoint2 reference1, reference2;
+ bool condition1, condition2;
+ p1 = convert(triangulator, s1.get_index1());
+ p2 = convert(triangulator, s1.get_index2());
+ p3 = convert(triangulator, s2.get_index1());
+ p4 = convert(triangulator, s2.get_index2());
+ reference1 = convert(triangulator, s1.get_reference());
+ reference2 = convert(triangulator, s2.get_reference());
+ condition1 = same_side(p1, p2, reference1, p);
+ condition2 = same_side(p3, p4, reference2, p);
+ if(angle >= 180.0) {
+ if(condition1 || condition2)
+ return 1;
+ else
+ return 0;
}
- else{
- if(condition1 && condition2) return 1;
- else return 0;
+ else {
+ if(condition1 && condition2)
+ return 1;
+ else
+ return 0;
}
}
-bool lpcvt::invisible(DocRecord& triangulator,GFace* gf,int index)
+bool lpcvt::invisible(DocRecord &triangulator, GFace *gf, int index)
{
int i;
int num;
int index2;
num = triangulator._adjacencies[index].t_length;
- for(i=0;i<num;i++){
+ for(i = 0; i < num; i++) {
index2 = triangulator._adjacencies[index].t[i];
- if(interior(triangulator,gf,index2)){
- return 0;
- }
+ if(interior(triangulator, gf, index2)) {
+ return 0;
+ }
}
return 1;
}
-bool lpcvt::real(DocRecord& triangulator,int index1,int index2,int index3)
+bool lpcvt::real(DocRecord &triangulator, int index1, int index2, int index3)
{
- return triangulator.contain(index1,index2,index3);
+ return triangulator.contain(index1, index2, index3);
}
double lpcvt::triangle_area(const SPoint2 &p1, const SPoint2 &p2,
const SPoint2 &p3)
{
double area;
- double x1,y1;
- double x2,y2;
+ double x1, y1;
+ double x2, y2;
x1 = p2.x() - p1.x();
y1 = p2.y() - p1.y();
x2 = p3.x() - p1.x();
y2 = p3.y() - p1.y();
- area = 0.5*fabs(x1*y2 - x2*y1);
+ area = 0.5 * fabs(x1 * y2 - x2 * y1);
return area;
}
@@ -760,9 +776,11 @@ bool lpcvt::sliver(const SPoint2 &p1, const SPoint2 &p2, const SPoint2 &p3)
double area;
double e;
e = 0.000000001;
- area = triangle_area(p1,p2,p3);
- if(area<e) return 1;
- else return 0;
+ area = triangle_area(p1, p2, p3);
+ if(area < e)
+ return 1;
+ else
+ return 0;
}
SPoint2 lpcvt::intersection(DocRecord &triangulator, segment s1, segment s2,
@@ -777,40 +795,40 @@ SPoint2 lpcvt::intersection(DocRecord &triangulator, segment s1, segment s2,
SPoint2 p6;
SPoint2 val1;
SPoint2 val2;
- p3 = convert(triangulator,s1.get_index1());
- p4 = convert(triangulator,s1.get_index2());
- p5 = convert(triangulator,s2.get_index1());
- p6 = convert(triangulator,s2.get_index2());
- val1 = intersection(p3,p4,p1,p2,flag1);
- val2 = intersection(p5,p6,p1,p2,flag2);
- if(flag1){
+ p3 = convert(triangulator, s1.get_index1());
+ p4 = convert(triangulator, s1.get_index2());
+ p5 = convert(triangulator, s2.get_index1());
+ p6 = convert(triangulator, s2.get_index2());
+ val1 = intersection(p3, p4, p1, p2, flag1);
+ val2 = intersection(p5, p6, p1, p2, flag2);
+ if(flag1) {
flag = 1;
- vec = normal(p3,p4);
+ vec = normal(p3, p4);
s = s1;
return val1;
}
- else if(flag2){
+ else if(flag2) {
flag = 1;
- vec = normal(p5,p6);
+ vec = normal(p5, p6);
s = s2;
return val2;
}
- else{
+ else {
flag = 0;
- vec = SVector3(0.0,0.0,0.0);
- s = segment(-1,-1,-1);
- return SPoint2(0.0,0.0);
+ vec = SVector3(0.0, 0.0, 0.0);
+ s = segment(-1, -1, -1);
+ return SPoint2(0.0, 0.0);
}
}
SPoint2 lpcvt::intersection(const SPoint2 &p1, const SPoint2 &p2,
const SPoint2 &p3, const SPoint2 &p4, bool &flag)
{
- double x1,y1;
- double x2,y2;
- double x3,y3;
- double x4,y4;
- double ua,ub;
+ double x1, y1;
+ double x2, y2;
+ double x3, y3;
+ double x4, y4;
+ double ua, ub;
double num_ua;
double num_ub;
double denom;
@@ -824,132 +842,139 @@ SPoint2 lpcvt::intersection(const SPoint2 &p1, const SPoint2 &p2,
x4 = p4.x();
y4 = p4.y();
e = 0.00000000001;
- denom = (y4-y3)*(x2-x1) - (x4-x3)*(y2-y1);
- if(fabs(denom)<e){
+ denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+ if(fabs(denom) < e) {
flag = 0;
- return SPoint2(0.0,0.0);
+ return SPoint2(0.0, 0.0);
}
- num_ua = (x4-x3)*(y1-y3) - (y4-y3)*(x1-x3);
- num_ub = (x2-x1)*(y1-y3) - (y2-y1)*(x1-x3);
- ua = num_ua/denom;
- ub = num_ub/denom;
- if(ua<=1.0 && ua>=0.0 && ub<=1.0 && ub>=0.0){
+ num_ua = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+ num_ub = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+ ua = num_ua / denom;
+ ub = num_ub / denom;
+ if(ua <= 1.0 && ua >= 0.0 && ub <= 1.0 && ub >= 0.0) {
flag = 1;
- return SPoint2(x1+ua*(x2-x1),y1+ua*(y2-y1));
+ return SPoint2(x1 + ua * (x2 - x1), y1 + ua * (y2 - y1));
}
- else{
+ else {
flag = 0;
- return SPoint2(0.0,0.0);
+ return SPoint2(0.0, 0.0);
}
}
-SPoint2 lpcvt::convert(DocRecord& triangulator,int index)
+SPoint2 lpcvt::convert(DocRecord &triangulator, int index)
{
SPoint2 p;
- double _p[2] = {triangulator.points[index].where.h,triangulator.points[index].where.v};
- p = SPoint2(_p[0],_p[1]);
+ double _p[2] = {triangulator.points[index].where.h,
+ triangulator.points[index].where.v};
+ p = SPoint2(_p[0], _p[1]);
return p;
}
-SPoint2 lpcvt::circumcircle(DocRecord& triangulator,int index1,int index2,int index3)
+SPoint2 lpcvt::circumcircle(DocRecord &triangulator, int index1, int index2,
+ int index3)
{
double _C[2];
SPoint2 C;
- double _x1[2] = {triangulator.points[index1].where.h,triangulator.points[index1].where.v};
- double _x2[2] = {triangulator.points[index2].where.h,triangulator.points[index2].where.v};
- double _x3[2] = {triangulator.points[index3].where.h,triangulator.points[index3].where.v};
- circumCenterXY(_x1,_x2,_x3,_C);
- C = SPoint2(_C[0],_C[1]);
+ double _x1[2] = {triangulator.points[index1].where.h,
+ triangulator.points[index1].where.v};
+ double _x2[2] = {triangulator.points[index2].where.h,
+ triangulator.points[index2].where.v};
+ double _x3[2] = {triangulator.points[index3].where.h,
+ triangulator.points[index3].where.v};
+ circumCenterXY(_x1, _x2, _x3, _C);
+ C = SPoint2(_C[0], _C[1]);
return C;
}
-SPoint2 lpcvt::seed(DocRecord& triangulator,GFace* gf)
+SPoint2 lpcvt::seed(DocRecord &triangulator, GFace *gf)
{
int i;
int j;
int num;
int index1;
int index2;
- double x,y;
- SPoint2 x0,x1,x2;
+ double x, y;
+ SPoint2 x0, x1, x2;
- for(i=0;i<triangulator.numPoints;i++){
- if(interior(triangulator,gf,i)){
+ for(i = 0; i < triangulator.numPoints; i++) {
+ if(interior(triangulator, gf, i)) {
num = triangulator._adjacencies[i].t_length;
- for(j=0;j<num;j++){
+ for(j = 0; j < num; j++) {
index1 = triangulator._adjacencies[i].t[j];
- index2 = triangulator._adjacencies[i].t[(j+1)%num];
- x0 = convert(triangulator,i);
- x1 = convert(triangulator,index1);
- x2 = convert(triangulator,index2);
- x = (x0.x() + x1.x() + x2.x())/3.0;
- y = (x0.y() + x1.y() + x2.y())/3.0;
- return SPoint2(x,y);
+ index2 = triangulator._adjacencies[i].t[(j + 1) % num];
+ x0 = convert(triangulator, i);
+ x1 = convert(triangulator, index1);
+ x2 = convert(triangulator, index2);
+ x = (x0.x() + x1.x() + x2.x()) / 3.0;
+ y = (x0.y() + x1.y() + x2.y()) / 3.0;
+ return SPoint2(x, y);
}
}
}
- return SPoint2(0.0,0.0);
+ return SPoint2(0.0, 0.0);
}
-void lpcvt::step1(DocRecord& triangulator,GFace* gf)
+void lpcvt::step1(DocRecord &triangulator, GFace *gf)
{
int i;
int j;
int num;
- int index1,index2,index3;
- bool ok_triangle1,ok_triangle2;
- SPoint2 x0,x1,x2,x3;
+ int index1, index2, index3;
+ bool ok_triangle1, ok_triangle2;
+ SPoint2 x0, x1, x2, x3;
borders.resize(triangulator.numPoints);
angles.resize(triangulator.numPoints);
- for(i=0;i<triangulator.numPoints;i++){
+ for(i = 0; i < triangulator.numPoints; i++) {
angles[i] = 0.0;
}
temp.resize(triangulator.numPoints);
- for(i=0;i<triangulator.numPoints;i++){
- if(!interior(triangulator,gf,i) && !invisible(triangulator,gf,i)){
+ for(i = 0; i < triangulator.numPoints; i++) {
+ if(!interior(triangulator, gf, i) && !invisible(triangulator, gf, i)) {
num = triangulator._adjacencies[i].t_length;
- for(j=0;j<num;j++){
+ for(j = 0; j < num; j++) {
index1 = triangulator._adjacencies[i].t[j];
- index2 = triangulator._adjacencies[i].t[(j+1)%num];
- index3 = triangulator._adjacencies[i].t[(j+2)%num];
- x0 = convert(triangulator,i);
- x1 = convert(triangulator,index1);
- x2 = convert(triangulator,index2);
- x3 = convert(triangulator,index3);
- ok_triangle1 = real(triangulator,i,index1,index2) && !sliver(x0,x1,x2);
- ok_triangle2 = real(triangulator,i,index2,index3) && !sliver(x0,x2,x3);
- if(ok_triangle1 && !ok_triangle2){
- borders[i].add_segment(i,index2,index1);
+ index2 = triangulator._adjacencies[i].t[(j + 1) % num];
+ index3 = triangulator._adjacencies[i].t[(j + 2) % num];
+ x0 = convert(triangulator, i);
+ x1 = convert(triangulator, index1);
+ x2 = convert(triangulator, index2);
+ x3 = convert(triangulator, index3);
+ ok_triangle1 =
+ real(triangulator, i, index1, index2) && !sliver(x0, x1, x2);
+ ok_triangle2 =
+ real(triangulator, i, index2, index3) && !sliver(x0, x2, x3);
+ if(ok_triangle1 && !ok_triangle2) {
+ borders[i].add_segment(i, index2, index1);
}
- else if(!ok_triangle1 && ok_triangle2){
- borders[i].add_segment(i,index2,index3);
+ else if(!ok_triangle1 && ok_triangle2) {
+ borders[i].add_segment(i, index2, index3);
}
- if(ok_triangle1){
- angles[i] = angles[i] + angle(x0,x1,x2);
+ if(ok_triangle1) {
+ angles[i] = angles[i] + angle(x0, x1, x2);
}
}
}
}
}
-void lpcvt::step2(DocRecord& triangulator,GFace* gf)
+void lpcvt::step2(DocRecord &triangulator, GFace *gf)
{
int i;
int j;
int num;
- int index1,index2;
+ int index1, index2;
SPoint2 C;
voronoi_vertex vertex;
- for(i=0;i<triangulator.numPoints;i++){
- if(interior(triangulator,gf,i)){
+ for(i = 0; i < triangulator.numPoints; i++) {
+ if(interior(triangulator, gf, i)) {
num = triangulator._adjacencies[i].t_length;
- for(j=0;j<num;j++){
+ for(j = 0; j < num; j++) {
index1 = triangulator._adjacencies[i].t[j];
- index2 = triangulator._adjacencies[i].t[(j+1)%num];
- C = circumcircle(triangulator,i,index1,index2);
+ index2 = triangulator._adjacencies[i].t[(j + 1) % num];
+ C = circumcircle(triangulator, i, index1, index2);
vertex = voronoi_vertex(C);
vertex.set_index1(i);
vertex.set_index2(index1);
@@ -960,53 +985,55 @@ void lpcvt::step2(DocRecord& triangulator,GFace* gf)
}
}
-void lpcvt::step3(DocRecord& triangulator,GFace* gf)
+void lpcvt::step3(DocRecord &triangulator, GFace *gf)
{
int i;
int j;
int num;
double angle;
- bool ok_triangle1,ok_triangle2;
- bool is_inside,is_inside1,is_inside2;
- bool flag,flag1,flag2;
- SPoint2 x0,x1,x2,x3;
- SPoint2 C,C1,C2;
+ bool ok_triangle1, ok_triangle2;
+ bool is_inside, is_inside1, is_inside2;
+ bool flag, flag1, flag2;
+ SPoint2 x0, x1, x2, x3;
+ SPoint2 C, C1, C2;
SPoint2 val;
- SPoint2 first,second,median,any;
- SVector3 vec,vecA,vecB;
- segment s,s1,s2,s3,s4;
- voronoi_vertex vertex,vertex1,vertex2,vertex3;
- for(i=0;i<triangulator.numPoints;i++){
- if(!interior(triangulator,gf,i) && !invisible(triangulator,gf,i)){
+ SPoint2 first, second, median, any;
+ SVector3 vec, vecA, vecB;
+ segment s, s1, s2, s3, s4;
+ voronoi_vertex vertex, vertex1, vertex2, vertex3;
+ for(i = 0; i < triangulator.numPoints; i++) {
+ if(!interior(triangulator, gf, i) && !invisible(triangulator, gf, i)) {
num = triangulator._adjacencies[i].t_length;
if(borders[i].get_number_segments() < 2) continue;
s1 = borders[i].get_segment(0);
s2 = borders[i].get_segment(1);
angle = angles[i];
- for(j=0;j<num;j++){
+ for(j = 0; j < num; j++) {
int index1 = triangulator._adjacencies[i].t[j];
- int index2 = triangulator._adjacencies[i].t[(j+1)%num];
- int index3 = triangulator._adjacencies[i].t[(j+2)%num];
- x0 = convert(triangulator,i);
- x1 = convert(triangulator,index1);
- x2 = convert(triangulator,index2);
- x3 = convert(triangulator,index3);
- ok_triangle1 = real(triangulator,i,index1,index2) && !sliver(x0,x1,x2);
- ok_triangle2 = real(triangulator,i,index2,index3) && !sliver(x0,x2,x3);
- if(ok_triangle1 && ok_triangle2){
- C1 = circumcircle(triangulator,i,index1,index2);
- C2 = circumcircle(triangulator,i,index2,index3);
- is_inside1 = interior(triangulator,s1,s2,angle,C1);
- is_inside2 = interior(triangulator,s1,s2,angle,C2);
- if(is_inside1 && is_inside2){
+ int index2 = triangulator._adjacencies[i].t[(j + 1) % num];
+ int index3 = triangulator._adjacencies[i].t[(j + 2) % num];
+ x0 = convert(triangulator, i);
+ x1 = convert(triangulator, index1);
+ x2 = convert(triangulator, index2);
+ x3 = convert(triangulator, index3);
+ ok_triangle1 =
+ real(triangulator, i, index1, index2) && !sliver(x0, x1, x2);
+ ok_triangle2 =
+ real(triangulator, i, index2, index3) && !sliver(x0, x2, x3);
+ if(ok_triangle1 && ok_triangle2) {
+ C1 = circumcircle(triangulator, i, index1, index2);
+ C2 = circumcircle(triangulator, i, index2, index3);
+ is_inside1 = interior(triangulator, s1, s2, angle, C1);
+ is_inside2 = interior(triangulator, s1, s2, angle, C2);
+ if(is_inside1 && is_inside2) {
vertex = voronoi_vertex(C1);
vertex.set_index1(i);
vertex.set_index2(index1);
vertex.set_index3(index2);
temp[i].add_vertex(vertex);
}
- else if(is_inside1){
- val = intersection(triangulator,s1,s2,C1,C2,flag,vec,s);
+ else if(is_inside1) {
+ val = intersection(triangulator, s1, s2, C1, C2, flag, vec, s);
vertex1 = voronoi_vertex(C1);
vertex1.set_index1(i);
vertex1.set_index2(index1);
@@ -1018,12 +1045,12 @@ void lpcvt::step3(DocRecord& triangulator,GFace* gf)
temp[i].add_vertex(vertex1);
temp[i].add_vertex(vertex2);
flag = borders[index2].add_segment(s);
- if(flag){
+ if(flag) {
fifo.push(index2);
}
}
- else if(is_inside2){
- val = intersection(triangulator,s1,s2,C1,C2,flag,vec,s);
+ else if(is_inside2) {
+ val = intersection(triangulator, s1, s2, C1, C2, flag, vec, s);
vertex1 = voronoi_vertex(x0);
vertex1.set_duplicate(1);
vertex2 = voronoi_vertex(val);
@@ -1033,16 +1060,18 @@ void lpcvt::step3(DocRecord& triangulator,GFace* gf)
temp[i].add_vertex(vertex1);
temp[i].add_vertex(vertex2);
flag = borders[index2].add_segment(s);
- if(flag){
+ if(flag) {
fifo.push(index2);
}
}
- else{
- any = intersection(triangulator,s1,s2,C1,C2,flag,vec,s);
- if(flag){
- median = mid(x0,x2);
- first = intersection(triangulator,s1,s2,C1,median,flag,vecA,s3);
- second = intersection(triangulator,s1,s2,C2,median,flag,vecB,s4);
+ else {
+ any = intersection(triangulator, s1, s2, C1, C2, flag, vec, s);
+ if(flag) {
+ median = mid(x0, x2);
+ first =
+ intersection(triangulator, s1, s2, C1, median, flag, vecA, s3);
+ second =
+ intersection(triangulator, s1, s2, C2, median, flag, vecB, s4);
vertex1 = voronoi_vertex(x0);
vertex1.set_duplicate(1);
vertex2 = voronoi_vertex(first);
@@ -1058,17 +1087,17 @@ void lpcvt::step3(DocRecord& triangulator,GFace* gf)
temp[i].add_vertex(vertex3);
flag1 = borders[index2].add_segment(s3);
flag2 = borders[index2].add_segment(s4);
- if(flag1 || flag2){
+ if(flag1 || flag2) {
fifo.push(index2);
}
}
}
}
- else if(ok_triangle1){
- C = circumcircle(triangulator,i,index1,index2);
- is_inside = interior(triangulator,s1,s2,angle,C);
- if(is_inside){
- val = mid(x0,x2);
+ else if(ok_triangle1) {
+ C = circumcircle(triangulator, i, index1, index2);
+ is_inside = interior(triangulator, s1, s2, angle, C);
+ if(is_inside) {
+ val = mid(x0, x2);
vertex1 = voronoi_vertex(C);
vertex1.set_index1(i);
vertex1.set_index2(index1);
@@ -1078,11 +1107,11 @@ void lpcvt::step3(DocRecord& triangulator,GFace* gf)
temp[i].add_vertex(vertex2);
}
}
- else if(ok_triangle2){
- C = circumcircle(triangulator,i,index2,index3);
- is_inside = interior(triangulator,s1,s2,angle,C);
- if(is_inside){
- val = mid(x0,x2);
+ else if(ok_triangle2) {
+ C = circumcircle(triangulator, i, index2, index3);
+ is_inside = interior(triangulator, s1, s2, angle, C);
+ if(is_inside) {
+ val = mid(x0, x2);
vertex1 = voronoi_vertex(x0);
vertex1.set_duplicate(1);
vertex2 = voronoi_vertex(val);
@@ -1095,50 +1124,51 @@ void lpcvt::step3(DocRecord& triangulator,GFace* gf)
}
}
-void lpcvt::step4(DocRecord& triangulator,GFace* gf)
+void lpcvt::step4(DocRecord &triangulator, GFace *gf)
{
int i;
int j;
int num;
int index;
int start;
- int opposite=0;
- bool flag1,flag2;
+ int opposite = 0;
+ bool flag1, flag2;
SPoint2 val;
- SPoint2 C1,C2;
- SPoint2 p1,p2;
- voronoi_vertex vertex1,vertex2;
+ SPoint2 C1, C2;
+ SPoint2 p1, p2;
+ voronoi_vertex vertex1, vertex2;
segment s;
- while(!fifo.empty()){
+ while(!fifo.empty()) {
index = fifo.front();
fifo.pop();
num = temp[index].get_number_vertices();
- if(interior(triangulator,gf,index)){
+ if(interior(triangulator, gf, index)) {
start = 0;
}
- else start = 2;
- for(i=start;i<borders[index].get_number_segments();i++){
+ else
+ start = 2;
+ for(i = start; i < borders[index].get_number_segments(); i++) {
s = borders[index].get_segment(i);
- p1 = convert(triangulator,s.get_index1());
- p2 = convert(triangulator,s.get_index2());
- for(j=0;j<num;j++){
+ p1 = convert(triangulator, s.get_index1());
+ p2 = convert(triangulator, s.get_index2());
+ for(j = 0; j < num; j++) {
vertex1 = temp[index].get_vertex(j);
- vertex2 = temp[index].get_vertex((j+1)%num);
+ vertex2 = temp[index].get_vertex((j + 1) % num);
C1 = vertex1.get_point();
C2 = vertex2.get_point();
- val = intersection(C1,C2,p1,p2,flag1);
- if(flag1){
- if(vertex1.get_index3()!=-1){
+ val = intersection(C1, C2, p1, p2, flag1);
+ if(flag1) {
+ if(vertex1.get_index3() != -1) {
opposite = vertex1.get_index3();
}
- else if(vertex1.get_index2()!=-1){
+ else if(vertex1.get_index2() != -1) {
opposite = vertex1.get_index2();
}
- else if(vertex2.get_index2()!=-1){
+ else if(vertex2.get_index2() != -1) {
opposite = vertex2.get_index2();
}
flag2 = borders[opposite].add_segment(s);
- if(flag2){
+ if(flag2) {
fifo.push(opposite);
}
}
@@ -1147,7 +1177,7 @@ void lpcvt::step4(DocRecord& triangulator,GFace* gf)
}
}
-void lpcvt::step5(DocRecord& triangulator,GFace* gf)
+void lpcvt::step5(DocRecord &triangulator, GFace *gf)
{
int i;
int j;
@@ -1156,41 +1186,42 @@ void lpcvt::step5(DocRecord& triangulator,GFace* gf)
int start;
int opposite = 0;
bool flag;
- SPoint2 p1,p2,p3,p4,reference,val;
+ SPoint2 p1, p2, p3, p4, reference, val;
SVector3 n;
segment s;
- voronoi_vertex vertex,vertex1,vertex2;
+ voronoi_vertex vertex, vertex1, vertex2;
voronoi_cell cell;
- for(i=0;i<triangulator.numPoints;i++){
+ for(i = 0; i < triangulator.numPoints; i++) {
cell.clear();
- if(interior(triangulator,gf,i)){
+ if(interior(triangulator, gf, i)) {
start = 0;
}
- else start = 2;
- for(j=start;j<borders[i].get_number_segments();j++){
+ else
+ start = 2;
+ for(j = start; j < borders[i].get_number_segments(); j++) {
s = borders[i].get_segment(j);
- p3 = convert(triangulator,s.get_index1());
- p4 = convert(triangulator,s.get_index2());
- reference = convert(triangulator,s.get_reference());
- n = normal(p3,p4);
+ p3 = convert(triangulator, s.get_index1());
+ p4 = convert(triangulator, s.get_index2());
+ reference = convert(triangulator, s.get_reference());
+ n = normal(p3, p4);
num = temp[i].get_number_vertices();
- for(k=0;k<num;k++){
+ for(k = 0; k < num; k++) {
vertex1 = temp[i].get_vertex(k);
- vertex2 = temp[i].get_vertex((k+1)%num);
+ vertex2 = temp[i].get_vertex((k + 1) % num);
p1 = vertex1.get_point();
p2 = vertex2.get_point();
- if(same_side(p3,p4,reference,p1)){
+ if(same_side(p3, p4, reference, p1)) {
cell.add_vertex(vertex1);
}
- val = intersection(p1,p2,p3,p4,flag);
- if(flag){
- if(vertex1.get_index3()!=-1){
+ val = intersection(p1, p2, p3, p4, flag);
+ if(flag) {
+ if(vertex1.get_index3() != -1) {
opposite = vertex1.get_index3();
}
- else if(vertex1.get_index2()!=-1){
+ else if(vertex1.get_index2() != -1) {
opposite = vertex1.get_index2();
}
- else if(vertex2.get_index2()!=-1){
+ else if(vertex2.get_index2() != -1) {
opposite = vertex2.get_index2();
}
vertex = voronoi_vertex(val);
@@ -1201,37 +1232,37 @@ void lpcvt::step5(DocRecord& triangulator,GFace* gf)
}
}
temp[i].clear();
- for(k=0;k<cell.get_number_vertices();k++){
+ for(k = 0; k < cell.get_number_vertices(); k++) {
temp[i].add_vertex(cell.get_vertex(k));
}
cell.clear();
}
num = temp[i].get_number_vertices();
- for(j=0;j<num;j++){
- vertex = voronoi_vertex(convert(triangulator,i));
+ for(j = 0; j < num; j++) {
+ vertex = voronoi_vertex(convert(triangulator, i));
vertex.set_index1(i);
vertex1 = temp[i].get_vertex(j);
- vertex2 = temp[i].get_vertex((j+1)%num);
- if(!vertex1.get_duplicate() && !vertex2.get_duplicate()){
- clipped.push_back(voronoi_element(vertex,vertex1,vertex2));
+ vertex2 = temp[i].get_vertex((j + 1) % num);
+ if(!vertex1.get_duplicate() && !vertex2.get_duplicate()) {
+ clipped.push_back(voronoi_element(vertex, vertex1, vertex2));
}
}
}
}
-void lpcvt::clip_cells(DocRecord& triangulator,GFace* gf)
+void lpcvt::clip_cells(DocRecord &triangulator, GFace *gf)
{
- step1(triangulator,gf);
- step2(triangulator,gf);
- step3(triangulator,gf);
- step4(triangulator,gf);
- step5(triangulator,gf);
+ step1(triangulator, gf);
+ step2(triangulator, gf);
+ step3(triangulator, gf);
+ step4(triangulator, gf);
+ step5(triangulator, gf);
}
void lpcvt::clear()
{
unsigned int i;
- for(i=0;i<fifo.size();i++){
+ for(i = 0; i < fifo.size(); i++) {
fifo.pop();
}
clipped.clear();
@@ -1243,44 +1274,46 @@ void lpcvt::clear()
double lpcvt::total_area()
{
double total;
- SPoint2 p1,p2,p3;
- voronoi_vertex v1,v2,v3;
+ SPoint2 p1, p2, p3;
+ voronoi_vertex v1, v2, v3;
std::list<voronoi_element>::iterator it;
total = 0.0;
- for(it=clipped.begin();it!=clipped.end();it++){
+ for(it = clipped.begin(); it != clipped.end(); it++) {
v1 = it->get_v1();
v2 = it->get_v2();
v3 = it->get_v3();
p1 = v1.get_point();
p2 = v2.get_point();
p3 = v3.get_point();
- total = total + triangle_area(p1,p2,p3);
+ total = total + triangle_area(p1, p2, p3);
}
return total;
}
void lpcvt::print_voronoi1()
{
- SPoint2 p1,p2,p3;
- voronoi_vertex v1,v2,v3;
+ SPoint2 p1, p2, p3;
+ voronoi_vertex v1, v2, v3;
std::list<voronoi_element>::iterator it;
std::ofstream file("voronoi1.pos");
file << "View \"test\" {\n";
- for(it=clipped.begin();it!=clipped.end();it++){
+ for(it = clipped.begin(); it != clipped.end(); it++) {
v1 = it->get_v1();
v2 = it->get_v2();
v3 = it->get_v3();
p1 = v1.get_point();
p2 = v2.get_point();
p3 = v3.get_point();
- print_segment(p2,p3,file);
- //metric m = it->get_metric(); //Modification
- //double h = it->get_h(0,0); //Modification
- //double x = (p1.x() + p2.x() + p3.x())/3.0; //Modification
- //double y = (p1.y() + p2.y() + p3.y())/3.0; //Modification
- //double k = 0.4; //Modification
- //print_segment(SPoint2(x,y),SPoint2(x+k*h*m.get_a(),y+k*h*m.get_b()),file); //Modification
- //print_segment(SPoint2(x,y),SPoint2(x+k*h*m.get_c(),y+k*h*m.get_d()),file); //Modification
+ print_segment(p2, p3, file);
+ // metric m = it->get_metric(); //Modification
+ // double h = it->get_h(0,0); //Modification
+ // double x = (p1.x() + p2.x() + p3.x())/3.0; //Modification
+ // double y = (p1.y() + p2.y() + p3.y())/3.0; //Modification
+ // double k = 0.4; //Modification
+ // print_segment(SPoint2(x,y),SPoint2(x+k*h*m.get_a(),y+k*h*m.get_b()),file);
+ // //Modification
+ // print_segment(SPoint2(x,y),SPoint2(x+k*h*m.get_c(),y+k*h*m.get_d()),file);
+ // //Modification
}
file << "};\n";
}
@@ -1290,42 +1323,42 @@ void lpcvt::print_voronoi2()
unsigned int i;
int j;
int num;
- SPoint2 p1,p2;
- voronoi_vertex v1,v2;
+ SPoint2 p1, p2;
+ voronoi_vertex v1, v2;
std::ofstream file("voronoi2.pos");
file << "View \"test\" {\n";
- for(i=0;i<temp.size();i++){
+ for(i = 0; i < temp.size(); i++) {
num = temp[i].get_number_vertices();
- for(j=0;j<num;j++){
+ for(j = 0; j < num; j++) {
v1 = temp[i].get_vertex(j);
- v2 = temp[i].get_vertex((j+1)%num);
+ v2 = temp[i].get_vertex((j + 1) % num);
p1 = v1.get_point();
p2 = v2.get_point();
- print_segment(p1,p2,file);
+ print_segment(p1, p2, file);
}
}
file << "};\n";
}
-void lpcvt::print_delaunay(DocRecord& triangulator)
+void lpcvt::print_delaunay(DocRecord &triangulator)
{
int i;
int j;
int num;
int index1;
int index2;
- SPoint2 x1,x2;
+ SPoint2 x1, x2;
std::ofstream file("delaunay.pos");
file << "View \"test\" {\n";
- for(i=0;i<triangulator.numPoints;i++){
+ for(i = 0; i < triangulator.numPoints; i++) {
num = triangulator._adjacencies[i].t_length;
- for(j=0;j<num;j++){
+ for(j = 0; j < num; j++) {
index1 = triangulator._adjacencies[i].t[j];
- index2 = triangulator._adjacencies[i].t[(j+1)%num];
- if(triangulator.contain(i,index1,index2)){
- x1 = convert(triangulator,index1);
- x2 = convert(triangulator,index2);
- print_segment(x1,x2,file);
+ index2 = triangulator._adjacencies[i].t[(j + 1) % num];
+ if(triangulator.contain(i, index1, index2)) {
+ x1 = convert(triangulator, index1);
+ x2 = convert(triangulator, index2);
+ print_segment(x1, x2, file);
}
}
}
@@ -1335,42 +1368,43 @@ void lpcvt::print_delaunay(DocRecord& triangulator)
void lpcvt::print_segment(const SPoint2 &p1, const SPoint2 &p2,
std::ofstream &file)
{
- file << "SL (" << p1.x() << ", " << p1.y() << ", 0, "
- << p2.x() << ", " << p2.y() << ", 0){"
- << "10, 20};\n";
+ file << "SL (" << p1.x() << ", " << p1.y() << ", 0, " << p2.x() << ", "
+ << p2.y() << ", 0){"
+ << "10, 20};\n";
}
-void lpcvt::compute_parameters(GFace* gf,int p)
+void lpcvt::compute_parameters(GFace *gf, int p)
{
- double h1,h2,h3;
+ double h1, h2, h3;
double k;
double ratio;
double angle;
double cosinus;
double sinus;
SPoint2 center;
- SPoint2 p1,p2,p3;
- voronoi_vertex v1,v2,v3;
+ SPoint2 p1, p2, p3;
+ voronoi_vertex v1, v2, v3;
metric m;
std::list<voronoi_element>::iterator it;
k = 1.0;
- for(it=clipped.begin();it!=clipped.end();it++){
+ for(it = clipped.begin(); it != clipped.end(); it++) {
v1 = it->get_v1();
v2 = it->get_v2();
v3 = it->get_v3();
p1 = v1.get_point();
p2 = v2.get_point();
p3 = v3.get_point();
- center = SPoint2((p1.x()+p2.x()+p3.x())/3.0,(p1.y()+p2.y()+p3.y())/3.0);
- ratio = get_ratio(gf,center);
- h1 = k*backgroundMesh::current()->operator()(p1.x(),p1.y(),0.0)*ratio;
- h2 = k*backgroundMesh::current()->operator()(p2.x(),p2.y(),0.0)*ratio;
- h3 = k*backgroundMesh::current()->operator()(p3.x(),p3.y(),0.0)*ratio;
- angle = backgroundMesh::current()->getAngle(p1.x(),p1.y(),0.0);
+ center = SPoint2((p1.x() + p2.x() + p3.x()) / 3.0,
+ (p1.y() + p2.y() + p3.y()) / 3.0);
+ ratio = get_ratio(gf, center);
+ h1 = k * backgroundMesh::current()->operator()(p1.x(), p1.y(), 0.0) * ratio;
+ h2 = k * backgroundMesh::current()->operator()(p2.x(), p2.y(), 0.0) * ratio;
+ h3 = k * backgroundMesh::current()->operator()(p3.x(), p3.y(), 0.0) * ratio;
+ angle = backgroundMesh::current()->getAngle(p1.x(), p1.y(), 0.0);
cosinus = cos(angle);
sinus = sin(angle);
- m = metric(cosinus,sinus,-sinus,cosinus);
+ m = metric(cosinus, sinus, -sinus, cosinus);
v1.set_h(h1);
v2.set_h(h2);
v3.set_h(h3);
@@ -1390,31 +1424,31 @@ double lpcvt::get_ratio(GFace *gf, const SPoint2 &point)
uv[0] = point.x();
uv[1] = point.y();
- buildMetric(gf,uv,tab);
- val = 1.0/pow(tab[0]*tab[2]-tab[1]*tab[1],0.25);
+ buildMetric(gf, uv, tab);
+ val = 1.0 / pow(tab[0] * tab[2] - tab[1] * tab[1], 0.25);
return val;
}
-double lpcvt::compute_rho(double h,int p)
+double lpcvt::compute_rho(double h, int p)
{
double rho;
- rho = pow_int(1.0/h,p+2);
+ rho = pow_int(1.0 / h, p + 2);
return rho;
}
-void lpcvt::write(DocRecord& triangulator,GFace* gf,int p)
+void lpcvt::write(DocRecord &triangulator, GFace *gf, int p)
{
int i;
double energy;
SVector3 grad;
std::vector<SVector3> gradients(triangulator.numPoints);
- eval(triangulator,gradients,energy,p);
+ eval(triangulator, gradients, energy, p);
std::ofstream file("gradient");
- for(i=0;i<triangulator.numPoints;i++){
- if(interior(triangulator,gf,i)){
+ for(i = 0; i < triangulator.numPoints; i++) {
+ if(interior(triangulator, gf, i)) {
grad = gradients[i];
file << grad.x() << " ";
file << grad.y() << " ";
@@ -1423,8 +1457,8 @@ void lpcvt::write(DocRecord& triangulator,GFace* gf,int p)
}
}
-void lpcvt::eval(DocRecord& triangulator,std::vector<SVector3>& gradients,
- double& energy,int p)
+void lpcvt::eval(DocRecord &triangulator, std::vector<SVector3> &gradients,
+ double &energy, int p)
{
unsigned int i;
int index;
@@ -1433,21 +1467,21 @@ void lpcvt::eval(DocRecord& triangulator,std::vector<SVector3>& gradients,
int index3;
double e;
SPoint2 generator;
- SPoint2 C1,C2;
- SPoint2 p1,p2,p3;
- SVector3 grad1,grad2;
+ SPoint2 C1, C2;
+ SPoint2 p1, p2, p3;
+ SVector3 grad1, grad2;
SVector3 normal;
- voronoi_vertex v1,v2,v3;
+ voronoi_vertex v1, v2, v3;
std::list<voronoi_element>::iterator it;
- for(i=0;i<gradients.size();i++){
- gradients[i] = SVector3(0.0,0.0,0.0);
+ for(i = 0; i < gradients.size(); i++) {
+ gradients[i] = SVector3(0.0, 0.0, 0.0);
}
energy = 0.0;
e = 0.000001;
- for(it=clipped.begin();it!=clipped.end();it++){
- if(it->get_quality()<e) continue; //not exact
+ for(it = clipped.begin(); it != clipped.end(); it++) {
+ if(it->get_quality() < e) continue; // not exact
v1 = it->get_v1();
v2 = it->get_v2();
v3 = it->get_v3();
@@ -1455,49 +1489,59 @@ void lpcvt::eval(DocRecord& triangulator,std::vector<SVector3>& gradients,
C1 = v2.get_point();
C2 = v3.get_point();
index = v1.get_index1();
- energy = energy + F(*it,p);
- gradients[index] = gradients[index] + simple(*it,p);
- grad1 = dF_dC1(*it,p);
- grad2 = dF_dC2(*it,p);
- if(v2.get_index3()!=-1){
+ energy = energy + F(*it, p);
+ gradients[index] = gradients[index] + simple(*it, p);
+ grad1 = dF_dC1(*it, p);
+ grad2 = dF_dC2(*it, p);
+ if(v2.get_index3() != -1) {
index1 = v2.get_index1();
index2 = v2.get_index2();
index3 = v2.get_index3();
- p1 = convert(triangulator,index1);
- p2 = convert(triangulator,index2);
- p3 = convert(triangulator,index3);
- gradients[index1] = gradients[index1] + inner_dFdx0(grad1,C1,p1,p2,p3);
- gradients[index2] = gradients[index2] + inner_dFdx0(grad1,C1,p2,p1,p3);
- gradients[index3] = gradients[index3] + inner_dFdx0(grad1,C1,p3,p1,p2);
+ p1 = convert(triangulator, index1);
+ p2 = convert(triangulator, index2);
+ p3 = convert(triangulator, index3);
+ gradients[index1] =
+ gradients[index1] + inner_dFdx0(grad1, C1, p1, p2, p3);
+ gradients[index2] =
+ gradients[index2] + inner_dFdx0(grad1, C1, p2, p1, p3);
+ gradients[index3] =
+ gradients[index3] + inner_dFdx0(grad1, C1, p3, p1, p2);
}
- else if(v2.get_index2()!=-1){
+ else if(v2.get_index2() != -1) {
index1 = v2.get_index1();
index2 = v2.get_index2();
normal = v2.get_normal();
- p1 = convert(triangulator,index1);
- p2 = convert(triangulator,index2);
- gradients[index1] = gradients[index1] + boundary_dFdx0(grad1,C1,p1,p2,normal);
- gradients[index2] = gradients[index2] + boundary_dFdx0(grad1,C1,p2,p1,normal);
+ p1 = convert(triangulator, index1);
+ p2 = convert(triangulator, index2);
+ gradients[index1] =
+ gradients[index1] + boundary_dFdx0(grad1, C1, p1, p2, normal);
+ gradients[index2] =
+ gradients[index2] + boundary_dFdx0(grad1, C1, p2, p1, normal);
}
- if(v3.get_index3()!=-1){
+ if(v3.get_index3() != -1) {
index1 = v3.get_index1();
index2 = v3.get_index2();
index3 = v3.get_index3();
- p1 = convert(triangulator,index1);
- p2 = convert(triangulator,index2);
- p3 = convert(triangulator,index3);
- gradients[index1] = gradients[index1] + inner_dFdx0(grad2,C2,p1,p2,p3);
- gradients[index2] = gradients[index2] + inner_dFdx0(grad2,C2,p2,p1,p3);
- gradients[index3] = gradients[index3] + inner_dFdx0(grad2,C2,p3,p1,p2);
+ p1 = convert(triangulator, index1);
+ p2 = convert(triangulator, index2);
+ p3 = convert(triangulator, index3);
+ gradients[index1] =
+ gradients[index1] + inner_dFdx0(grad2, C2, p1, p2, p3);
+ gradients[index2] =
+ gradients[index2] + inner_dFdx0(grad2, C2, p2, p1, p3);
+ gradients[index3] =
+ gradients[index3] + inner_dFdx0(grad2, C2, p3, p1, p2);
}
- else if(v3.get_index2()!=-1){
+ else if(v3.get_index2() != -1) {
index1 = v3.get_index1();
index2 = v3.get_index2();
normal = v3.get_normal();
- p1 = convert(triangulator,index1);
- p2 = convert(triangulator,index2);
- gradients[index1] = gradients[index1] + boundary_dFdx0(grad2,C2,p1,p2,normal);
- gradients[index2] = gradients[index2] + boundary_dFdx0(grad2,C2,p2,p1,normal);
+ p1 = convert(triangulator, index1);
+ p2 = convert(triangulator, index2);
+ gradients[index1] =
+ gradients[index1] + boundary_dFdx0(grad2, C2, p1, p2, normal);
+ gradients[index2] =
+ gradients[index2] + boundary_dFdx0(grad2, C2, p2, p1, normal);
}
}
}
@@ -1506,8 +1550,9 @@ void lpcvt::swap()
{
voronoi_vertex vertex;
std::list<voronoi_element>::iterator it;
- for(it=clipped.begin();it!=clipped.end();it++){
- if(J(it->get_v1().get_point(),it->get_v2().get_point(),it->get_v3().get_point())<0.0){
+ for(it = clipped.begin(); it != clipped.end(); it++) {
+ if(J(it->get_v1().get_point(), it->get_v2().get_point(),
+ it->get_v3().get_point()) < 0.0) {
vertex = it->get_v3();
it->set_v3(it->get_v2());
it->set_v2(vertex);
@@ -1519,11 +1564,11 @@ void lpcvt::get_gauss()
{
int order;
order = 8;
- gaussIntegration::getTriangle(order,gauss_points,gauss_weights);
+ gaussIntegration::getTriangle(order, gauss_points, gauss_weights);
gauss_num = gauss_points.size1();
}
-double lpcvt::F(voronoi_element element,int p)
+double lpcvt::F(voronoi_element element, int p)
{
int i;
double u;
@@ -1533,8 +1578,8 @@ double lpcvt::F(voronoi_element element,int p)
double energy;
double weight;
double rho;
- SPoint2 point,generator,C1,C2;
- voronoi_vertex v1,v2,v3;
+ SPoint2 point, generator, C1, C2;
+ voronoi_vertex v1, v2, v3;
metric m;
v1 = element.get_v1();
@@ -1546,21 +1591,21 @@ double lpcvt::F(voronoi_element element,int p)
energy = 0.0;
m = element.get_metric();
- for(i=0;i<gauss_num;i++){
- u = gauss_points(i,0);
- v = gauss_points(i,1);
- x = Tx(u,v,generator,C1,C2);
- y = Ty(u,v,generator,C1,C2);
- point = SPoint2(x,y);
+ for(i = 0; i < gauss_num; i++) {
+ u = gauss_points(i, 0);
+ v = gauss_points(i, 1);
+ x = Tx(u, v, generator, C1, C2);
+ y = Ty(u, v, generator, C1, C2);
+ point = SPoint2(x, y);
weight = gauss_weights(i);
- rho = compute_rho(element.get_h(u,v),p);
- energy = energy + weight*rho*f(generator,point,m,p);
+ rho = compute_rho(element.get_h(u, v), p);
+ energy = energy + weight * rho * f(generator, point, m, p);
}
- energy = J(generator,C1,C2)*energy;
+ energy = J(generator, C1, C2) * energy;
return energy;
}
-SVector3 lpcvt::simple(voronoi_element element,int p)
+SVector3 lpcvt::simple(voronoi_element element, int p)
{
int i;
double u;
@@ -1572,8 +1617,8 @@ SVector3 lpcvt::simple(voronoi_element element,int p)
double weight;
double rho;
double jacobian;
- SPoint2 point,generator,C1,C2;
- voronoi_vertex v1,v2,v3;
+ SPoint2 point, generator, C1, C2;
+ voronoi_vertex v1, v2, v3;
metric m;
v1 = element.get_v1();
@@ -1584,26 +1629,26 @@ SVector3 lpcvt::simple(voronoi_element element,int p)
C2 = v3.get_point();
comp_x = 0.0;
comp_y = 0.0;
- jacobian = J(generator,C1,C2);
+ jacobian = J(generator, C1, C2);
m = element.get_metric();
- for(i=0;i<gauss_num;i++){
- u = gauss_points(i,0);
- v = gauss_points(i,1);
- x = Tx(u,v,generator,C1,C2);
- y = Ty(u,v,generator,C1,C2);
- point = SPoint2(x,y);
+ for(i = 0; i < gauss_num; i++) {
+ u = gauss_points(i, 0);
+ v = gauss_points(i, 1);
+ x = Tx(u, v, generator, C1, C2);
+ y = Ty(u, v, generator, C1, C2);
+ point = SPoint2(x, y);
weight = gauss_weights(i);
- rho = compute_rho(element.get_h(u,v),p);
- comp_x = comp_x + weight*rho*df_dx(generator,point,m,p);
- comp_y = comp_y + weight*rho*df_dy(generator,point,m,p);
+ rho = compute_rho(element.get_h(u, v), p);
+ comp_x = comp_x + weight * rho * df_dx(generator, point, m, p);
+ comp_y = comp_y + weight * rho * df_dy(generator, point, m, p);
}
- comp_x = jacobian*comp_x;
- comp_y = jacobian*comp_y;
- return SVector3(comp_x,comp_y,0.0);
+ comp_x = jacobian * comp_x;
+ comp_y = jacobian * comp_y;
+ return SVector3(comp_x, comp_y, 0.0);
}
-SVector3 lpcvt::dF_dC1(voronoi_element element,int p)
+SVector3 lpcvt::dF_dC1(voronoi_element element, int p)
{
int i;
double u;
@@ -1618,8 +1663,8 @@ SVector3 lpcvt::dF_dC1(voronoi_element element,int p)
double drho_dy;
double jacobian;
double distance;
- SPoint2 point,generator,C1,C2;
- voronoi_vertex v1,v2,v3;
+ SPoint2 point, generator, C1, C2;
+ voronoi_vertex v1, v2, v3;
metric m;
v1 = element.get_v1();
@@ -1630,31 +1675,35 @@ SVector3 lpcvt::dF_dC1(voronoi_element element,int p)
C2 = v3.get_point();
comp_x = 0.0;
comp_y = 0.0;
- jacobian = J(generator,C1,C2);
+ jacobian = J(generator, C1, C2);
m = element.get_metric();
- for(i=0;i<gauss_num;i++){
- u = gauss_points(i,0);
- v = gauss_points(i,1);
- x = Tx(u,v,generator,C1,C2);
- y = Ty(u,v,generator,C1,C2);
- point = SPoint2(x,y);
+ for(i = 0; i < gauss_num; i++) {
+ u = gauss_points(i, 0);
+ v = gauss_points(i, 1);
+ x = Tx(u, v, generator, C1, C2);
+ y = Ty(u, v, generator, C1, C2);
+ point = SPoint2(x, y);
weight = gauss_weights(i);
- rho = compute_rho(element.get_h(u,v),p);
- drho_dx = (-p-2)*pow_int(1.0/element.get_h(u,v),p+3)*element.get_dh_dx();
- drho_dy = (-p-2)*pow_int(1.0/element.get_h(u,v),p+3)*element.get_dh_dy();
- distance = f(point,generator,m,p);
- comp_x = comp_x + weight*rho*df_dx(point,generator,m,p)*u*jacobian;
- comp_x = comp_x + weight*rho*distance*(C2.y()-generator.y());
- comp_x = comp_x + weight*drho_dx*u*distance*jacobian;
- comp_y = comp_y + weight*rho*df_dy(point,generator,m,p)*u*jacobian;
- comp_y = comp_y + weight*rho*distance*(generator.x()-C2.x());
- comp_y = comp_y + weight*drho_dy*u*distance*jacobian;
+ rho = compute_rho(element.get_h(u, v), p);
+ drho_dx = (-p - 2) * pow_int(1.0 / element.get_h(u, v), p + 3) *
+ element.get_dh_dx();
+ drho_dy = (-p - 2) * pow_int(1.0 / element.get_h(u, v), p + 3) *
+ element.get_dh_dy();
+ distance = f(point, generator, m, p);
+ comp_x =
+ comp_x + weight * rho * df_dx(point, generator, m, p) * u * jacobian;
+ comp_x = comp_x + weight * rho * distance * (C2.y() - generator.y());
+ comp_x = comp_x + weight * drho_dx * u * distance * jacobian;
+ comp_y =
+ comp_y + weight * rho * df_dy(point, generator, m, p) * u * jacobian;
+ comp_y = comp_y + weight * rho * distance * (generator.x() - C2.x());
+ comp_y = comp_y + weight * drho_dy * u * distance * jacobian;
}
- return SVector3(comp_x,comp_y,0.0);
+ return SVector3(comp_x, comp_y, 0.0);
}
-SVector3 lpcvt::dF_dC2(voronoi_element element,int p)
+SVector3 lpcvt::dF_dC2(voronoi_element element, int p)
{
int i;
double u;
@@ -1669,8 +1718,8 @@ SVector3 lpcvt::dF_dC2(voronoi_element element,int p)
double drho_dy;
double jacobian;
double distance;
- SPoint2 point,generator,C1,C2;
- voronoi_vertex v1,v2,v3;
+ SPoint2 point, generator, C1, C2;
+ voronoi_vertex v1, v2, v3;
metric m;
v1 = element.get_v1();
@@ -1681,28 +1730,32 @@ SVector3 lpcvt::dF_dC2(voronoi_element element,int p)
C2 = v3.get_point();
comp_x = 0.0;
comp_y = 0.0;
- jacobian = J(generator,C1,C2);
+ jacobian = J(generator, C1, C2);
m = element.get_metric();
- for(i=0;i<gauss_num;i++){
- u = gauss_points(i,0);
- v = gauss_points(i,1);
- x = Tx(u,v,generator,C1,C2);
- y = Ty(u,v,generator,C1,C2);
- point = SPoint2(x,y);
+ for(i = 0; i < gauss_num; i++) {
+ u = gauss_points(i, 0);
+ v = gauss_points(i, 1);
+ x = Tx(u, v, generator, C1, C2);
+ y = Ty(u, v, generator, C1, C2);
+ point = SPoint2(x, y);
weight = gauss_weights(i);
- rho = compute_rho(element.get_h(u,v),p);
- drho_dx = (-p-2)*pow_int(1.0/element.get_h(u,v),p+3)*element.get_dh_dx();
- drho_dy = (-p-2)*pow_int(1.0/element.get_h(u,v),p+3)*element.get_dh_dy();
- distance = f(point,generator,m,p);
- comp_x = comp_x + weight*rho*df_dx(point,generator,m,p)*v*jacobian;
- comp_x = comp_x + weight*rho*distance*(generator.y()-C1.y());
- comp_x = comp_x + weight*drho_dx*v*distance*jacobian;
- comp_y = comp_y + weight*rho*df_dy(point,generator,m,p)*v*jacobian;
- comp_y = comp_y + weight*rho*distance*(C1.x()-generator.x());
- comp_y = comp_y + weight*drho_dy*v*distance*jacobian;
+ rho = compute_rho(element.get_h(u, v), p);
+ drho_dx = (-p - 2) * pow_int(1.0 / element.get_h(u, v), p + 3) *
+ element.get_dh_dx();
+ drho_dy = (-p - 2) * pow_int(1.0 / element.get_h(u, v), p + 3) *
+ element.get_dh_dy();
+ distance = f(point, generator, m, p);
+ comp_x =
+ comp_x + weight * rho * df_dx(point, generator, m, p) * v * jacobian;
+ comp_x = comp_x + weight * rho * distance * (generator.y() - C1.y());
+ comp_x = comp_x + weight * drho_dx * v * distance * jacobian;
+ comp_y =
+ comp_y + weight * rho * df_dy(point, generator, m, p) * v * jacobian;
+ comp_y = comp_y + weight * rho * distance * (C1.x() - generator.x());
+ comp_y = comp_y + weight * drho_dy * v * distance * jacobian;
}
- return SVector3(comp_x,comp_y,0.0);
+ return SVector3(comp_x, comp_y, 0.0);
}
double lpcvt::f(const SPoint2 &p1, const SPoint2 &p2, metric m, int p)
@@ -1727,9 +1780,9 @@ double lpcvt::f(const SPoint2 &p1, const SPoint2 &p2, metric m, int p)
b = m.get_b();
c = m.get_c();
d = m.get_d();
- val1 = a*(x1-x2) + b*(y1-y2);
- val2 = c*(x1-x2) + d*(y1-y2);
- val = pow_int(val1,p) + pow_int(val2,p);
+ val1 = a * (x1 - x2) + b * (y1 - y2);
+ val2 = c * (x1 - x2) + d * (y1 - y2);
+ val = pow_int(val1, p) + pow_int(val2, p);
return val;
}
@@ -1755,9 +1808,10 @@ double lpcvt::df_dx(const SPoint2 &p1, const SPoint2 &p2, metric m, int p)
b = m.get_b();
c = m.get_c();
d = m.get_d();
- val1 = a*(x1-x2) + b*(y1-y2);
- val2 = c*(x1-x2) + d*(y1-y2);
- val = ((double)p)*pow_int(val1,p-1)*a + ((double)p)*pow_int(val2,p-1)*c;
+ val1 = a * (x1 - x2) + b * (y1 - y2);
+ val2 = c * (x1 - x2) + d * (y1 - y2);
+ val = ((double)p) * pow_int(val1, p - 1) * a +
+ ((double)p) * pow_int(val2, p - 1) * c;
return val;
}
@@ -1783,9 +1837,10 @@ double lpcvt::df_dy(const SPoint2 &p1, const SPoint2 &p2, metric m, int p)
b = m.get_b();
c = m.get_c();
d = m.get_d();
- val1 = a*(x1-x2) + b*(y1-y2);
- val2 = c*(x1-x2) + d*(y1-y2);
- val = ((double)p)*pow_int(val1,p-1)*b + ((double)p)*pow_int(val2,p-1)*d;
+ val1 = a * (x1 - x2) + b * (y1 - y2);
+ val2 = c * (x1 - x2) + d * (y1 - y2);
+ val = ((double)p) * pow_int(val1, p - 1) * b +
+ ((double)p) * pow_int(val2, p - 1) * d;
return val;
}
@@ -1793,7 +1848,7 @@ double lpcvt::Tx(double u, double v, const SPoint2 &p1, const SPoint2 &p2,
const SPoint2 &p3)
{
double val;
- val = (1.0-u-v)*p1.x() + u*p2.x() + v*p3.x();
+ val = (1.0 - u - v) * p1.x() + u * p2.x() + v * p3.x();
return val;
}
@@ -1801,14 +1856,15 @@ double lpcvt::Ty(double u, double v, const SPoint2 &p1, const SPoint2 &p2,
const SPoint2 &p3)
{
double val;
- val = (1.0-u-v)*p1.y() + u*p2.y() + v*p3.y();
+ val = (1.0 - u - v) * p1.y() + u * p2.y() + v * p3.y();
return val;
}
double lpcvt::J(const SPoint2 &p1, const SPoint2 &p2, const SPoint2 &p3)
{
double val;
- val = (p2.x()-p1.x())*(p3.y()-p1.y()) - (p3.x()-p1.x())*(p2.y()-p1.y());
+ val = (p2.x() - p1.x()) * (p3.y() - p1.y()) -
+ (p3.x() - p1.x()) * (p2.y() - p1.y());
return val;
}
@@ -1820,48 +1876,50 @@ SVector3 lpcvt::inner_dFdx0(const SVector3 &dFdC, const SPoint2 &C,
double A[2][2];
double B[2][2];
double M[2][2];
- det = (x1.x()-x0.x())*(x2.y()-x0.y()) - (x1.y() - x0.y())*(x2.x() - x0.x());
- A[0][0] = (x2.y() - x0.y())/det;
- A[0][1] = -(x1.y() - x0.y())/det;
- A[1][0] = -(x2.x() - x0.x())/det;
- A[1][1] = (x1.x() - x0.x())/det;
+ det = (x1.x() - x0.x()) * (x2.y() - x0.y()) -
+ (x1.y() - x0.y()) * (x2.x() - x0.x());
+ A[0][0] = (x2.y() - x0.y()) / det;
+ A[0][1] = -(x1.y() - x0.y()) / det;
+ A[1][0] = -(x2.x() - x0.x()) / det;
+ A[1][1] = (x1.x() - x0.x()) / det;
B[0][0] = C.x() - x0.x();
B[0][1] = C.y() - x0.y();
B[1][0] = C.x() - x0.x();
B[1][1] = C.y() - x0.y();
- M[0][0] = A[0][0]*B[0][0] + A[0][1]*B[1][0];
- M[0][1] = A[0][0]*B[0][1] + A[0][1]*B[1][1];
- M[1][0] = A[1][0]*B[0][0] + A[1][1]*B[1][0];
- M[1][1] = A[1][0]*B[0][1] + A[1][1]*B[1][1];
- return SVector3(dFdC.x()*M[0][0]+dFdC.y()*M[1][0],dFdC.x()*M[0][1]+dFdC.y()*M[1][1],0.0);
+ M[0][0] = A[0][0] * B[0][0] + A[0][1] * B[1][0];
+ M[0][1] = A[0][0] * B[0][1] + A[0][1] * B[1][1];
+ M[1][0] = A[1][0] * B[0][0] + A[1][1] * B[1][0];
+ M[1][1] = A[1][0] * B[0][1] + A[1][1] * B[1][1];
+ return SVector3(dFdC.x() * M[0][0] + dFdC.y() * M[1][0],
+ dFdC.x() * M[0][1] + dFdC.y() * M[1][1], 0.0);
}
SVector3 lpcvt::boundary_dFdx0(const SVector3 &dFdC, const SPoint2 &C,
const SPoint2 &x0, const SPoint2 &x1,
const SVector3 &normal)
{
- fullMatrix<double> A(2,2);
- fullMatrix<double> B(2,2);
- fullMatrix<double> M(2,2);
- fullMatrix<double> _dFdC(1,2);
- fullMatrix<double> _val(1,2);
- A(0,0) = x1.x() - x0.x();
- A(0,1) = x1.y() - x0.y();
- A(1,0) = normal.x();
- A(1,1) = normal.y();
+ fullMatrix<double> A(2, 2);
+ fullMatrix<double> B(2, 2);
+ fullMatrix<double> M(2, 2);
+ fullMatrix<double> _dFdC(1, 2);
+ fullMatrix<double> _val(1, 2);
+ A(0, 0) = x1.x() - x0.x();
+ A(0, 1) = x1.y() - x0.y();
+ A(1, 0) = normal.x();
+ A(1, 1) = normal.y();
A.invertInPlace();
- B(0,0) = C.x() - x0.x();
- B(0,1) = C.y() - x0.y();
- B(1,0) = 0.0;
- B(1,1) = 0.0;
- A.mult_naive(B,M);
- _dFdC(0,0) = dFdC.x();
- _dFdC(0,1) = dFdC.y();
- _dFdC.mult_naive(M,_val);
- return SVector3(_val(0,0),_val(0,1),0.0);
+ B(0, 0) = C.x() - x0.x();
+ B(0, 1) = C.y() - x0.y();
+ B(1, 0) = 0.0;
+ B(1, 1) = 0.0;
+ A.mult_naive(B, M);
+ _dFdC(0, 0) = dFdC.x();
+ _dFdC(0, 1) = dFdC.y();
+ _dFdC.mult_naive(M, _val);
+ return SVector3(_val(0, 0), _val(0, 1), 0.0);
}
-metric::metric(double new_a,double new_b,double new_c,double new_d)
+metric::metric(double new_a, double new_b, double new_c, double new_d)
{
a = new_a;
b = new_b;
@@ -1869,49 +1927,25 @@ metric::metric(double new_a,double new_b,double new_c,double new_d)
d = new_d;
}
-metric::metric(){}
+metric::metric() {}
-metric::~metric(){}
+metric::~metric() {}
-void metric::set_a(double new_a)
-{
- a = new_a;
-}
+void metric::set_a(double new_a) { a = new_a; }
-void metric::set_b(double new_b)
-{
- b = new_b;
-}
+void metric::set_b(double new_b) { b = new_b; }
-void metric::set_c(double new_c)
-{
- c = new_c;
-}
+void metric::set_c(double new_c) { c = new_c; }
-void metric::set_d(double new_d)
-{
- d = new_d;
-}
+void metric::set_d(double new_d) { d = new_d; }
-double metric::get_a()
-{
- return a;
-}
+double metric::get_a() { return a; }
-double metric::get_b()
-{
- return b;
-}
+double metric::get_b() { return b; }
-double metric::get_c()
-{
- return c;
-}
+double metric::get_c() { return c; }
-double metric::get_d()
-{
- return d;
-}
+double metric::get_d() { return d; }
voronoi_vertex::voronoi_vertex(const SPoint2 &new_point)
{
@@ -1919,64 +1953,35 @@ voronoi_vertex::voronoi_vertex(const SPoint2 &new_point)
index1 = -1;
index2 = -1;
index3 = -1;
- normal = SVector3(0.0,0.0,0.0);
+ normal = SVector3(0.0, 0.0, 0.0);
duplicate = 0;
}
-voronoi_vertex::voronoi_vertex(){}
+voronoi_vertex::voronoi_vertex() {}
-voronoi_vertex::~voronoi_vertex(){}
+voronoi_vertex::~voronoi_vertex() {}
-SPoint2 voronoi_vertex::get_point(){
- return point;
-}
+SPoint2 voronoi_vertex::get_point() { return point; }
-int voronoi_vertex::get_index1()
-{
- return index1;
-}
+int voronoi_vertex::get_index1() { return index1; }
-int voronoi_vertex::get_index2()
-{
- return index2;
-}
+int voronoi_vertex::get_index2() { return index2; }
-int voronoi_vertex::get_index3()
-{
- return index3;
-}
+int voronoi_vertex::get_index3() { return index3; }
-SVector3 voronoi_vertex::get_normal()
-{
- return normal;
-}
+SVector3 voronoi_vertex::get_normal() { return normal; }
-bool voronoi_vertex::get_duplicate()
-{
- return duplicate;
-}
+bool voronoi_vertex::get_duplicate() { return duplicate; }
-double voronoi_vertex::get_h()
-{
- return h;
-}
+double voronoi_vertex::get_h() { return h; }
void voronoi_vertex::set_point(const SPoint2 &new_point) { point = new_point; }
-void voronoi_vertex::set_index1(int new_index1)
-{
- index1 = new_index1;
-}
+void voronoi_vertex::set_index1(int new_index1) { index1 = new_index1; }
-void voronoi_vertex::set_index2(int new_index2)
-{
- index2 = new_index2;
-}
+void voronoi_vertex::set_index2(int new_index2) { index2 = new_index2; }
-void voronoi_vertex::set_index3(int new_index3)
-{
- index3 = new_index3;
-}
+void voronoi_vertex::set_index3(int new_index3) { index3 = new_index3; }
void voronoi_vertex::set_normal(const SVector3 &new_normal)
{
@@ -1988,10 +1993,7 @@ void voronoi_vertex::set_duplicate(bool new_duplicate)
duplicate = new_duplicate;
}
-void voronoi_vertex::set_h(double new_h)
-{
- h = new_h;
-}
+void voronoi_vertex::set_h(double new_h) { h = new_h; }
voronoi_element::voronoi_element(const voronoi_vertex &new_v1,
const voronoi_vertex &new_v2,
@@ -2002,26 +2004,17 @@ voronoi_element::voronoi_element(const voronoi_vertex &new_v1,
v3 = new_v3;
}
-voronoi_element::voronoi_element(){}
+voronoi_element::voronoi_element() {}
-voronoi_element::~voronoi_element(){}
+voronoi_element::~voronoi_element() {}
-voronoi_vertex voronoi_element::get_v1()
-{
- return v1;
-}
+voronoi_vertex voronoi_element::get_v1() { return v1; }
-voronoi_vertex voronoi_element::get_v2()
-{
- return v2;
-}
+voronoi_vertex voronoi_element::get_v2() { return v2; }
-voronoi_vertex voronoi_element::get_v3()
-{
- return v3;
-}
+voronoi_vertex voronoi_element::get_v3() { return v3; }
-double voronoi_element::get_h(double u,double v)
+double voronoi_element::get_h(double u, double v)
{
double h1;
double h2;
@@ -2031,24 +2024,15 @@ double voronoi_element::get_h(double u,double v)
h1 = v1.get_h();
h2 = v2.get_h();
h3 = v3.get_h();
- h = h1*(1.0-u-v) + h2*u + h3*v;
+ h = h1 * (1.0 - u - v) + h2 * u + h3 * v;
return h;
}
-double voronoi_element::get_dh_dx()
-{
- return dh_dx;
-}
+double voronoi_element::get_dh_dx() { return dh_dx; }
-double voronoi_element::get_dh_dy()
-{
- return dh_dy;
-}
+double voronoi_element::get_dh_dy() { return dh_dy; }
-metric voronoi_element::get_metric()
-{
- return m;
-}
+metric voronoi_element::get_metric() { return m; }
void voronoi_element::set_v1(const voronoi_vertex &new_v1) { v1 = new_v1; }
@@ -2088,25 +2072,25 @@ void voronoi_element::deriv_h(int p)
b = p3.x() - p1.x();
c = p2.y() - p1.y();
d = p3.y() - p1.y();
- jacobian = a*d-b*c;
- dh_du = h2-h1;
- dh_dv = h3-h1;
- du_dx = d/jacobian;
- dv_dx = -c/jacobian;
- du_dy = -b/jacobian;
- dv_dy = a/jacobian;
- dh_dx = dh_du*du_dx + dh_dv*dv_dx;
- dh_dy = dh_du*du_dy + dh_dv*dv_dy;
+ jacobian = a * d - b * c;
+ dh_du = h2 - h1;
+ dh_dv = h3 - h1;
+ du_dx = d / jacobian;
+ dv_dx = -c / jacobian;
+ du_dy = -b / jacobian;
+ dv_dy = a / jacobian;
+ dh_dx = dh_du * du_dx + dh_dv * dv_dx;
+ dh_dy = dh_du * du_dy + dh_dv * dv_dy;
}
double voronoi_element::get_quality()
{
- double x1,y1;
- double x2,y2;
- double x3,y3;
+ double x1, y1;
+ double x2, y2;
+ double x3, y3;
double quality;
- double l1,l2,l3;
- double min_l,max_l;
+ double l1, l2, l3;
+ double min_l, max_l;
x1 = v1.get_point().x();
y1 = v1.get_point().y();
@@ -2115,120 +2099,88 @@ double voronoi_element::get_quality()
x3 = v3.get_point().x();
y3 = v3.get_point().y();
- l1 = sqrt(pow_int(x2-x1,2) + pow_int(y2-y1,2));
- l2 = sqrt(pow_int(x3-x1,2) + pow_int(y3-y1,2));
- l3 = sqrt(pow_int(x3-x2,2) + pow_int(y3-y2,2));
+ l1 = sqrt(pow_int(x2 - x1, 2) + pow_int(y2 - y1, 2));
+ l2 = sqrt(pow_int(x3 - x1, 2) + pow_int(y3 - y1, 2));
+ l3 = sqrt(pow_int(x3 - x2, 2) + pow_int(y3 - y2, 2));
- min_l = std::min(std::min(l1,l2),l3);
- max_l = std::max(std::max(l1,l2),l3);
+ min_l = std::min(std::min(l1, l2), l3);
+ max_l = std::max(std::max(l1, l2), l3);
- quality = min_l/max_l;
+ quality = min_l / max_l;
return quality;
}
-voronoi_cell::voronoi_cell(){}
+voronoi_cell::voronoi_cell() {}
-voronoi_cell::~voronoi_cell(){}
+voronoi_cell::~voronoi_cell() {}
-int voronoi_cell::get_number_vertices()
-{
- return vertices.size();
-}
+int voronoi_cell::get_number_vertices() { return vertices.size(); }
-voronoi_vertex voronoi_cell::get_vertex(int index)
-{
- return vertices[index];
-}
+voronoi_vertex voronoi_cell::get_vertex(int index) { return vertices[index]; }
void voronoi_cell::add_vertex(const voronoi_vertex &vertex)
{
vertices.push_back(vertex);
}
-void voronoi_cell::clear()
-{
- vertices.clear();
-}
+void voronoi_cell::clear() { vertices.clear(); }
-segment::segment(int new_index1,int new_index2,int new_reference)
+segment::segment(int new_index1, int new_index2, int new_reference)
{
index1 = new_index1;
index2 = new_index2;
reference = new_reference;
}
-segment::segment(){}
+segment::segment() {}
-segment::~segment(){}
+segment::~segment() {}
-int segment::get_index1()
-{
- return index1;
-}
+int segment::get_index1() { return index1; }
-int segment::get_index2()
-{
- return index2;
-}
+int segment::get_index2() { return index2; }
-int segment::get_reference()
-{
- return reference;
-}
+int segment::get_reference() { return reference; }
-void segment::set_index1(int new_index1)
-{
- index1 = new_index1;
-}
+void segment::set_index1(int new_index1) { index1 = new_index1; }
-void segment::set_index2(int new_index2)
-{
- index2 = new_index2;
-}
+void segment::set_index2(int new_index2) { index2 = new_index2; }
-void segment::set_reference(int new_reference)
-{
- reference = new_reference;
-}
+void segment::set_reference(int new_reference) { reference = new_reference; }
-bool segment::equal(int index3,int index4)
+bool segment::equal(int index3, int index4)
{
- if(index1==index3 && index2==index4){
+ if(index1 == index3 && index2 == index4) {
return 1;
}
- else if(index1==index4 && index2==index3){
+ else if(index1 == index4 && index2 == index3) {
return 1;
}
- else return 0;
+ else
+ return 0;
}
-segment_list::segment_list(){}
+segment_list::segment_list() {}
-segment_list::~segment_list(){}
+segment_list::~segment_list() {}
-int segment_list::get_number_segments()
-{
- return segments.size();
-}
+int segment_list::get_number_segments() { return segments.size(); }
-segment segment_list::get_segment(int index)
-{
- return segments[index];
-}
+segment segment_list::get_segment(int index) { return segments[index]; }
-bool segment_list::add_segment(int index1,int index2,int reference)
+bool segment_list::add_segment(int index1, int index2, int reference)
{
unsigned int i;
- for(i=0;i<segments.size();i++){
- if(segments[i].equal(index1,index2)) return 0;
+ for(i = 0; i < segments.size(); i++) {
+ if(segments[i].equal(index1, index2)) return 0;
}
- segments.push_back(segment(index1,index2,reference));
+ segments.push_back(segment(index1, index2, reference));
return 1;
}
bool segment_list::add_segment(segment s)
{
- return add_segment(s.get_index1(),s.get_index2(),s.get_reference());
+ return add_segment(s.get_index1(), s.get_index2(), s.get_reference());
}
wrapper::wrapper()
@@ -2237,86 +2189,41 @@ wrapper::wrapper()
start = -1000000.0;
}
-wrapper::~wrapper(){}
+wrapper::~wrapper() {}
-int wrapper::get_p()
-{
- return p;
-}
+int wrapper::get_p() { return p; }
-void wrapper::set_p(int new_p)
-{
- p = new_p;
-}
+void wrapper::set_p(int new_p) { p = new_p; }
-int wrapper::get_dimension()
-{
- return dimension;
-}
+int wrapper::get_dimension() { return dimension; }
-void wrapper::set_dimension(int new_dimension)
-{
- dimension = new_dimension;
-}
+void wrapper::set_dimension(int new_dimension) { dimension = new_dimension; }
-GFace* wrapper::get_face()
-{
- return gf;
-}
+GFace *wrapper::get_face() { return gf; }
-void wrapper::set_face(GFace* new_gf)
-{
- gf = new_gf;
-}
+void wrapper::set_face(GFace *new_gf) { gf = new_gf; }
-int wrapper::get_iteration()
-{
- return iteration;
-}
+int wrapper::get_iteration() { return iteration; }
-void wrapper::set_iteration(int new_iteration)
-{
- iteration = new_iteration;
-}
+void wrapper::set_iteration(int new_iteration) { iteration = new_iteration; }
-int wrapper::get_max()
-{
- return max;
-}
+int wrapper::get_max() { return max; }
-void wrapper::set_max(int new_max)
-{
- max = new_max;
-}
+void wrapper::set_max(int new_max) { max = new_max; }
-double wrapper::get_start()
-{
- return start;
-}
+double wrapper::get_start() { return start; }
-void wrapper::set_start(double new_start)
-{
- start = new_start;
-}
+void wrapper::set_start(double new_start) { start = new_start; }
-DocRecord* wrapper::get_triangulator()
-{
- return triangulator;
-}
+DocRecord *wrapper::get_triangulator() { return triangulator; }
-void wrapper::set_triangulator(DocRecord* new_triangulator)
+void wrapper::set_triangulator(DocRecord *new_triangulator)
{
triangulator = new_triangulator;
}
-MElementOctree* wrapper::get_octree()
-{
- return octree;
-}
+MElementOctree *wrapper::get_octree() { return octree; }
-void wrapper::set_octree(MElementOctree* new_octree)
-{
- octree = new_octree;
-}
+void wrapper::set_octree(MElementOctree *new_octree) { octree = new_octree; }
#endif
diff --git a/Mesh/meshGFaceLloyd.h b/Mesh/meshGFaceLloyd.h
index 5a2faeb610547eb1679cf38aeda11f43d8e78308..8a1143947d879a87ef1f1f414d34f8e61a317a11 100644
--- a/Mesh/meshGFaceLloyd.h
+++ b/Mesh/meshGFaceLloyd.h
@@ -14,12 +14,13 @@
class GFace;
-class smoothing{
+class smoothing {
int ITER_MAX;
int NORM;
- public :
- smoothing(int,int);
- void optimize_face(GFace*);
+
+public:
+ smoothing(int, int);
+ void optimize_face(GFace *);
void optimize_model();
};
diff --git a/Mesh/meshGFaceOptimize.cpp b/Mesh/meshGFaceOptimize.cpp
index 797b256cc0c798985dfbf4c825c391c37d7d526c..44e65e3d7a4fda791e1f13e0d23f9a3f2bb6c93d 100644
--- a/Mesh/meshGFaceOptimize.cpp
+++ b/Mesh/meshGFaceOptimize.cpp
@@ -37,8 +37,7 @@ extern "C" int perfect_match(int ncount, CCdatagroup *dat, int ecount,
#endif
edge_angle::edge_angle(MVertex *_v1, MVertex *_v2, MElement *t1, MElement *t2)
- : v1(_v1)
- , v2(_v2)
+ : v1(_v1), v2(_v2)
{
if(!t2)
angle = 0;
@@ -199,7 +198,9 @@ void computeEquivalences(GFace *gf, bidimMeshData &data)
v[j] = t->getVertex(j);
std::map<MVertex *, MVertex *>::iterator it =
data.equivalence->find(v[j]);
- if(it != data.equivalence->end()) { v[j] = it->second; }
+ if(it != data.equivalence->end()) {
+ v[j] = it->second;
+ }
}
if(v[0] != v[1] && v[0] != v[2] && v[2] != v[1])
newT.push_back(new MTriangle(v[0], v[1], v[2]));
@@ -255,7 +256,8 @@ bool computeEquivalentTriangles(GFace *gf,
if(WTF.size()) {
Msg::Info("%d triangles are equivalent", WTF.size());
- for(unsigned int i = 0; i < WTF.size(); i++) {}
+ for(unsigned int i = 0; i < WTF.size(); i++) {
+ }
return true;
}
return false;
@@ -472,7 +474,9 @@ int _removeThreeTrianglesNodes(GFace *gf)
MTriangle *newt = new MTriangle(v1, v2, v3);
n++;
gf->triangles.push_back(newt);
- for(int i = 0; i < 3; i++) { touched.insert(lt[i]); }
+ for(int i = 0; i < 3; i++) {
+ touched.insert(lt[i]);
+ }
}
it++;
}
@@ -540,7 +544,9 @@ static int _removeTwoQuadsNodes(GFace *gf)
MQuadrangle *q = new MQuadrangle(v1, v2, v3, v4);
double s1 = 0; // surfaceFaceUV(q,gf);
double s2 = 1; // surfaceFaceUV(q1,gf) + surfaceFaceUV(q2,gf);;
- if(s1 > s2) { delete q; }
+ if(s1 > s2) {
+ delete q;
+ }
else {
touched.insert(q1);
touched.insert(q2);
@@ -647,7 +653,9 @@ static bool _tryToCollapseThatVertex2(GFace *gf, std::vector<MElement *> &e1,
for(unsigned int j = 0; j < e.size(); ++j) {
if(e[j] != q) {
for(int k = 0; k < 4; k++) {
- if(e[j]->getVertex(k) == v2) { e[j]->setVertex(k, v1); }
+ if(e[j]->getVertex(k) == v2) {
+ e[j]->setVertex(k, v1);
+ }
}
}
}
@@ -733,7 +741,9 @@ static bool _tryToCollapseThatVertex(GFace *gf, std::vector<MElement *> &e1,
for(unsigned int j = 0; j < e.size(); ++j) {
if(e[j] != q) {
for(int k = 0; k < 4; k++) {
- if(e[j]->getVertex(k) == v2) { e[j]->setVertex(k, v1); }
+ if(e[j]->getVertex(k) == v2) {
+ e[j]->setVertex(k, v1);
+ }
}
}
}
diff --git a/Mesh/meshGFaceOptimize.h b/Mesh/meshGFaceOptimize.h
index 455b5da45433dfe059cab4daf3d794fb06789659..0dd2af2f5429a94d5b3fa0d5ecac489c14d333d5 100644
--- a/Mesh/meshGFaceOptimize.h
+++ b/Mesh/meshGFaceOptimize.h
@@ -117,8 +117,7 @@ struct RecombineTriangle {
MVertex *n1, *n2, *n3, *n4;
RecombineTriangle(const MEdge &me, MElement *_t1, MElement *_t2)
- : t1(_t1)
- , t2(_t2)
+ : t1(_t1), t2(_t2)
{
n1 = me.getVertex(0);
n2 = me.getVertex(1);
diff --git a/Mesh/meshGFaceQuadrilateralize.cpp b/Mesh/meshGFaceQuadrilateralize.cpp
index 75b12b699cc66658bc2da42637b8646420ccb5d1..91885d440d3fb6e9c382d35b41cf1cc33d6c2a57 100644
--- a/Mesh/meshGFaceQuadrilateralize.cpp
+++ b/Mesh/meshGFaceQuadrilateralize.cpp
@@ -14,36 +14,39 @@
#include "SVector3.h"
class edgeFront {
- public:
+public:
typedef std::set<BDS_Edge *>::const_iterator eiter;
- private:
+
+private:
BDS_Mesh *m;
GFace *gf;
- void getFrontEdges(BDS_Point *p, eiter & it1, eiter & it2) const;
- void getFrontEdges(BDS_Point *p, std::vector<eiter> & f) const;
- public:
- std::set<BDS_Edge *> edges;
- std::set<BDS_Edge*> stat[5];
+ void getFrontEdges(BDS_Point *p, eiter &it1, eiter &it2) const;
+ void getFrontEdges(BDS_Point *p, std::vector<eiter> &f) const;
+
+public:
+ std::set<BDS_Edge *> edges;
+ std::set<BDS_Edge *> stat[5];
eiter begin() { return edges.begin(); }
eiter end() { return edges.end(); }
edgeFront(BDS_Mesh *_m, GFace *_gf) : m(_m), gf(_gf) {}
// initiate edges in the front i.e.
- // take all edges that have one neighbor
- // and all edges that have a quad and a triangle
+ // take all edges that have one neighbor
+ // and all edges that have a quad and a triangle
// neighbor
void initiate();
// compute normal vector to an edge that points
// inside the domain
- SVector3 normal(BDS_Edge *e) const;
+ SVector3 normal(BDS_Edge *e) const;
// compute the state of a front edge
- // 0 both vertices have edge angles < 60 deg
- // 1 e->p1 have and edge angle > 60 deg
- // 2 e->p2 have and edge angle > 60 deg
- // 3 both vertices have edge angles > 60 deg
+ // 0 both vertices have edge angles < 60 deg
+ // 1 e->p1 have and edge angle > 60 deg
+ // 2 e->p2 have and edge angle > 60 deg
+ // 3 both vertices have edge angles > 60 deg
int computeStatus(BDS_Edge *e) const;
- inline bool inFront(BDS_Edge *e) const{ return getStatus(e) != -1; }
- inline int getStatus(BDS_Edge *e) const{
- for(int i = 0; i < 5; i++){
+ inline bool inFront(BDS_Edge *e) const { return getStatus(e) != -1; }
+ inline int getStatus(BDS_Edge *e) const
+ {
+ for(int i = 0; i < 5; i++) {
if(stat[i].find(e) != stat[i].end()) return i;
}
return -1;
@@ -57,14 +60,15 @@ class edgeFront {
// form a quad now
bool formQuad(BDS_Edge *e, BDS_Edge *left, BDS_Edge *right);
// delete the cavity delimitated by 4 edges
- void emptyCavity(BDS_Edge *bottom, BDS_Edge *top, BDS_Edge *left, BDS_Edge *right);
+ void emptyCavity(BDS_Edge *bottom, BDS_Edge *top, BDS_Edge *left,
+ BDS_Edge *right);
// delete an edge from the front
void deleteFromFront(BDS_Edge *e)
{
edges.erase(e);
- for(int i = 0; i < 5; i++){
- std::set<BDS_Edge*>::iterator it = stat[i].find(e);
- if(it != stat[i].end()){
+ for(int i = 0; i < 5; i++) {
+ std::set<BDS_Edge *>::iterator it = stat[i].find(e);
+ if(it != stat[i].end()) {
stat[i].erase(it);
return;
}
@@ -76,9 +80,9 @@ class edgeFront {
void edgeFront::updateStatus(BDS_Edge *e)
{
- for(int i = 0; i < 5; i++){
- std::set<BDS_Edge*>::iterator it = stat[i].find(e);
- if(it !=stat[i].end()){
+ for(int i = 0; i < 5; i++) {
+ std::set<BDS_Edge *>::iterator it = stat[i].find(e);
+ if(it != stat[i].end()) {
stat[i].erase(it);
stat[computeStatus(e)].insert(e);
return;
@@ -89,61 +93,60 @@ void edgeFront::updateStatus(BDS_Edge *e)
SVector3 norm_edge(BDS_Point *p1, BDS_Point *p2)
{
- SVector3 n(p2->X-p1->X,p2->Y-p1->Y,p2->Z-p1->Z);
+ SVector3 n(p2->X - p1->X, p2->Y - p1->Y, p2->Z - p1->Z);
n.normalize();
return n;
}
-void recur_empty_cavity(BDS_Face *f,
- BDS_Edge *be[4],
- BDS_Point *bv[4],
- std::set<BDS_Face*> & faces,
- std::set<BDS_Edge*> & edges,
- std::set<BDS_Point*> & vertices)
+void recur_empty_cavity(BDS_Face *f, BDS_Edge *be[4], BDS_Point *bv[4],
+ std::set<BDS_Face *> &faces,
+ std::set<BDS_Edge *> &edges,
+ std::set<BDS_Point *> &vertices)
{
if(faces.find(f) != faces.end()) return;
faces.insert(f);
- BDS_Edge *ee[3] = {f->e1,f->e2,f->e3};
- for(int i=0;i<3;i++){
+ BDS_Edge *ee[3] = {f->e1, f->e2, f->e3};
+ for(int i = 0; i < 3; i++) {
BDS_Edge *e = ee[i];
- if(e != be[0] && e != be[1] && e != be[2] && e != be[3]){
+ if(e != be[0] && e != be[1] && e != be[2] && e != be[3]) {
edges.insert(e);
BDS_Face *of = e->otherFace(f);
- recur_empty_cavity(of,be,bv,faces,edges,vertices);
+ recur_empty_cavity(of, be, bv, faces, edges, vertices);
}
}
}
-void edgeFront::emptyCavity(BDS_Edge *bottom, BDS_Edge *top, BDS_Edge *left,
+void edgeFront::emptyCavity(BDS_Edge *bottom, BDS_Edge *top, BDS_Edge *left,
BDS_Edge *right)
{
// not optimal for now, will be improved further away
BDS_Face *f = 0;
- if(bottom->faces(0) && bottom->faces(0)->numEdges() == 3) f=bottom->faces(0);
- else if(bottom->faces(1))f = bottom->faces(1);
-
- std::set<BDS_Face*> m_faces;
- std::set<BDS_Edge*> m_edges;
- std::set<BDS_Point*> m_vertices;
- BDS_Edge *be[4] = {bottom,top,left,right};
- BDS_Point *bv[4] = {bottom->commonvertex(left),
- left->commonvertex(top),
- top->commonvertex(right),
- right->commonvertex(bottom)};
+ if(bottom->faces(0) && bottom->faces(0)->numEdges() == 3)
+ f = bottom->faces(0);
+ else if(bottom->faces(1))
+ f = bottom->faces(1);
+
+ std::set<BDS_Face *> m_faces;
+ std::set<BDS_Edge *> m_edges;
+ std::set<BDS_Point *> m_vertices;
+ BDS_Edge *be[4] = {bottom, top, left, right};
+ BDS_Point *bv[4] = {bottom->commonvertex(left), left->commonvertex(top),
+ top->commonvertex(right), right->commonvertex(bottom)};
recur_empty_cavity(f, be, bv, m_faces, m_edges, m_vertices);
// printf("%d edges %d faces\n",m_edges.size(),m_faces.size());
- for(std::set<BDS_Face*>::iterator it = m_faces.begin();
- it != m_faces.end(); ++it) m->del_face(*it);
- for(std::set<BDS_Edge*>::iterator it = m_edges.begin();
- it != m_edges.end(); ++it) m->del_edge(*it);
+ for(std::set<BDS_Face *>::iterator it = m_faces.begin(); it != m_faces.end();
+ ++it)
+ m->del_face(*it);
+ for(std::set<BDS_Edge *>::iterator it = m_edges.begin(); it != m_edges.end();
+ ++it)
+ m->del_edge(*it);
}
-
-SVector3 edgeFront::normal(BDS_Edge*e) const
+SVector3 edgeFront::normal(BDS_Edge *e) const
{
BDS_Face *t = e->faces(0);
- if(e->numfaces() == 2 && e->faces(1)->numEdges() == 3)t=e->faces(1);
+ if(e->numfaces() == 2 && e->faces(1)->numEdges() == 3) t = e->faces(1);
/*
points p1, p2 and p3
@@ -151,7 +154,7 @@ SVector3 edgeFront::normal(BDS_Edge*e) const
p = p1 (1-u-v) + p2 u + p3 v;
J = [p2-p1 p3-p1 (p2-p1)x(p3-p1)]
N = - J^-1 * {0,1,0}
- n = N/|N|
+ n = N/|N|
*/
BDS_Point *p1 = e->p1;
BDS_Point *p2 = e->p2;
@@ -166,60 +169,59 @@ SVector3 edgeFront::normal(BDS_Edge*e) const
Msg::Error("Could not compute fron normal");
return SVector3();
}
-
- SVector3 t1(p2->X-p1->X,p2->Y-p1->Y,p2->Z-p1->Z);
- SVector3 t2(p3->X-p1->X,p3->Y-p1->Y,p3->Z-p1->Z);
- SVector3 t3 = crossprod(t1,t2);
- double m[3][3] = {{t1.x(),t2.x(),t3.x()},
- {t1.y(),t2.y(),t3.y()},
- {t1.z(),t2.z(),t3.z()}};
+
+ SVector3 t1(p2->X - p1->X, p2->Y - p1->Y, p2->Z - p1->Z);
+ SVector3 t2(p3->X - p1->X, p3->Y - p1->Y, p3->Z - p1->Z);
+ SVector3 t3 = crossprod(t1, t2);
+ double m[3][3] = {{t1.x(), t2.x(), t3.x()},
+ {t1.y(), t2.y(), t3.y()},
+ {t1.z(), t2.z(), t3.z()}};
double im[3][3];
- inv3x3(m,im);
- SVector3 n(im[1][0],im[1][1],im[1][2]);
+ inv3x3(m, im);
+ SVector3 n(im[1][0], im[1][1], im[1][2]);
n.normalize();
return n;
}
-void edgeFront::getFrontEdges(BDS_Point *p, std::vector<eiter> & fe) const
+void edgeFront::getFrontEdges(BDS_Point *p, std::vector<eiter> &fe) const
{
- for(std::list<BDS_Edge*>::iterator itp = p->edges.begin();
- itp != p->edges.end(); ++ itp){
- eiter it = edges.find(*itp);
- if(it != edges.end())
- fe.push_back(it);
+ for(std::list<BDS_Edge *>::iterator itp = p->edges.begin();
+ itp != p->edges.end(); ++itp) {
+ eiter it = edges.find(*itp);
+ if(it != edges.end()) fe.push_back(it);
}
}
-void edgeFront::getFrontEdges(BDS_Point *p, eiter & it1, eiter & it2) const
+void edgeFront::getFrontEdges(BDS_Point *p, eiter &it1, eiter &it2) const
{
int count = 0;
- for(std::list<BDS_Edge*>::iterator itp = p->edges.begin();
- itp != p->edges.end(); ++ itp){
- if(count == 0){
- it1 = edges.find(*itp);
+ for(std::list<BDS_Edge *>::iterator itp = p->edges.begin();
+ itp != p->edges.end(); ++itp) {
+ if(count == 0) {
+ it1 = edges.find(*itp);
if(it1 != edges.end()) count++;
}
- else if(count == 1){
- it2 = edges.find(*itp);
+ else if(count == 1) {
+ it2 = edges.find(*itp);
if(it2 != edges.end()) return;
}
- }
- Msg::Error("point %d is in the front but has only %d edges\n",p->iD,count);
+ }
+ Msg::Error("point %d is in the front but has only %d edges\n", p->iD, count);
}
void edgeFront::initiate()
{
edges.clear();
for(int i = 0; i < 5; i++) stat[i].clear();
- std::list<BDS_Edge*>::iterator it = m->edges.begin();
- while(it != m->edges.end()){
+ std::list<BDS_Edge *>::iterator it = m->edges.begin();
+ while(it != m->edges.end()) {
if(((*it)->numfaces() == 1 && (*it)->faces(0)->e4 == 0) ||
- ((*it)->numfaces() == 2 && (*it)->numTriangles() == 1)) {
+ ((*it)->numfaces() == 2 && (*it)->numTriangles() == 1)) {
edges.insert(*it);
}
++it;
}
- for(eiter it2 = begin(); it2 !=end(); ++it2){
+ for(eiter it2 = begin(); it2 != end(); ++it2) {
int status = computeStatus(*it2);
stat[status].insert(*it2);
}
@@ -229,22 +231,22 @@ static double angle3Points(BDS_Point *p1, BDS_Point *p2, BDS_Point *p3)
{
SVector3 a(p1->X - p2->X, p1->Y - p2->Y, p1->Z - p2->Z);
SVector3 b(p3->X - p2->X, p3->Y - p2->Y, p3->Z - p2->Z);
- SVector3 c = crossprod(a,b);
+ SVector3 c = crossprod(a, b);
double sinA = c.norm();
- double cosA = dot(a,b);
+ double cosA = dot(a, b);
// printf("%d %d %d -> %g %g\n",p1->iD,p2->iD,p3->iD,cosA,sinA);
return atan2(sinA, cosA);
}
int edgeFront::computeStatus(BDS_Edge *e) const
{
- eiter it11, it12, it21,it22;
- getFrontEdges(e->p1, it11, it12);
- getFrontEdges(e->p2, it21, it22);
-
+ eiter it11, it12, it21, it22;
+ getFrontEdges(e->p1, it11, it12);
+ getFrontEdges(e->p2, it21, it22);
+
BDS_Edge *e1 = (*it11) == e ? *it12 : *it11;
BDS_Edge *e2 = (*it21) == e ? *it22 : *it21;
-
+
double angle1 = angle3Points((*it11)->othervertex(e->p1), e->p1,
(*it12)->othervertex(e->p1));
double angle2 = angle3Points((*it21)->othervertex(e->p2), e->p2,
@@ -253,10 +255,10 @@ int edgeFront::computeStatus(BDS_Edge *e) const
SVector3 n1 = normal(e);
SVector3 n2 = norm_edge(e->p1, e1->othervertex(e->p1));
SVector3 n3 = norm_edge(e->p2, e2->othervertex(e->p2));
- if(dot(n1,n2) < 0)angle1 = M_PI;
- if(dot(n1,n3) < 0)angle2 = M_PI;
+ if(dot(n1, n2) < 0) angle1 = M_PI;
+ if(dot(n1, n3) < 0) angle2 = M_PI;
- const double angleLimit = 3 * M_PI/4.;
+ const double angleLimit = 3 * M_PI / 4.;
if(angle1 > angleLimit && angle2 > angleLimit) return 0;
if(angle1 > angleLimit && angle2 < angleLimit) return 1;
@@ -266,21 +268,18 @@ int edgeFront::computeStatus(BDS_Edge *e) const
bool edgeFront::formQuad(BDS_Edge *e, BDS_Edge *left, BDS_Edge *right)
{
+ printf("e (%d,%d), l(%d,%d), r(%d,%d)\n", e->p1->iD, e->p2->iD, left->p1->iD,
+ left->p2->iD, right->p1->iD, right->p2->iD);
- printf("e (%d,%d), l(%d,%d), r(%d,%d)\n",
- e->p1->iD,e->p2->iD,
- left->p1->iD,left->p2->iD,
- right->p1->iD,right->p2->iD);
-
// outputScalarField(m->triangles, "deb_before.pos", 0);
- std::vector<BDS_Point*> toUpdate;
+ std::vector<BDS_Point *> toUpdate;
- BDS_Point *pleft = left->othervertex(e->p1);
+ BDS_Point *pleft = left->othervertex(e->p1);
BDS_Point *pright = right->othervertex(e->p2);
-
+
// recover edge pleft->pright
- BDS_Edge *top = m->find_edge(pleft,pright);
+ BDS_Edge *top = m->find_edge(pleft, pright);
/*
We first have to ensure that, if left or right
@@ -293,7 +292,7 @@ bool edgeFront::formQuad(BDS_Edge *e, BDS_Edge *left, BDS_Edge *right)
// top = m->recover_edge_fast(pleft,pright);
// if(!top)
bool _fatallyFailed;
- top = m->recover_edge(pleft->iD, pright->iD,_fatallyFailed);
+ top = m->recover_edge(pleft->iD, pright->iD, _fatallyFailed);
// printf("recover done %p\n",top);
if(!top) return false;
}
@@ -314,45 +313,50 @@ bool edgeFront::formQuad(BDS_Edge *e, BDS_Edge *left, BDS_Edge *right)
*/
// outputScalarField(m->triangles, "deb.pos", 0);
-
// if left edge was in the front, then it leaves the front
// because it has either 2 neighboring quads or one quad
// and the void
// if the left edge was not in the front, then it becomes
- // part of it.
+ // part of it.
// printf("coucou1\n");
- if(inFront(left)) deleteFromFront(left);
- else edges.insert(left);
+ if(inFront(left))
+ deleteFromFront(left);
+ else
+ edges.insert(left);
// printf("coucou2\n");
- if(inFront(right)) deleteFromFront(right);
- else edges.insert(right);
+ if(inFront(right))
+ deleteFromFront(right);
+ else
+ edges.insert(right);
// printf("coucou3\n");
- if(inFront(top)) deleteFromFront(top);
- else edges.insert(top);
-
+ if(inFront(top))
+ deleteFromFront(top);
+ else
+ edges.insert(top);
+
toUpdate.push_back(e->p1);
toUpdate.push_back(e->p2);
toUpdate.push_back(pleft);
toUpdate.push_back(pright);
- for(unsigned int i = 0; i < toUpdate.size(); i++){
+ for(unsigned int i = 0; i < toUpdate.size(); i++) {
toUpdate[i]->config_modified = true;
- //bool done =
+ // bool done =
m->smooth_point_parametric(toUpdate[i], gf);
// printf("smooth done %d (g %d)\n",done,toUpdate[i]->g->classif_degree);
}
- for(unsigned int i = 0; i < toUpdate.size(); i++){
+ for(unsigned int i = 0; i < toUpdate.size(); i++) {
BDS_Point *p = toUpdate[i];
- for(std::list<BDS_Edge*>::iterator itp = p->edges.begin();
- itp != p->edges.end(); ++ itp){
- if(inFront(*itp)){
- updateStatus(*itp);
- }
+ for(std::list<BDS_Edge *>::iterator itp = p->edges.begin();
+ itp != p->edges.end(); ++itp) {
+ if(inFront(*itp)) {
+ updateStatus(*itp);
+ }
}
- }
+ }
return true;
}
@@ -367,69 +371,69 @@ BDS_Edge *edgeFront::findOptimalEdge(BDS_Point *p, BDS_Point *avoid)
n.normalize();
// printf("POINT %g %g %g N %g %g %g\n",p->X,p->Y,p->Z,n.x(),n.y(),n.z());
-
+
double lowerBound = cos(M_PI / 6.0);
BDS_Edge *found = 0;
- for(std::list<BDS_Edge*>::iterator itp = p->edges.begin();
- itp != p->edges.end(); ++ itp){
+ for(std::list<BDS_Edge *>::iterator itp = p->edges.begin();
+ itp != p->edges.end(); ++itp) {
// the edge is not in the front and is not bounded by quads only
- if(*it1 != *itp && *it2 != *itp && (*itp)->numTriangles()){
+ if(*it1 != *itp && *it2 != *itp && (*itp)->numTriangles()) {
BDS_Point *q = (*itp)->othervertex(p);
SVector3 d(q->X - p->X, q->Y - p->Y, q->Z - p->Z);
d.normalize();
- double COS = dot(n,d);
- if(COS > lowerBound && q != avoid){
+ double COS = dot(n, d);
+ if(COS > lowerBound && q != avoid) {
lowerBound = COS;
found = *itp;
- }
- }
+ }
+ }
}
- if(found) return found;
- else{
- std::list<BDS_Face*> ts;
+ if(found)
+ return found;
+ else {
+ std::list<BDS_Face *> ts;
double x[2];
- const double L = 0.5*sqrt(3.0)*((*it2)->length() * (*it1)->length());
+ const double L = 0.5 * sqrt(3.0) * ((*it2)->length() * (*it1)->length());
p->getTriangles(ts);
- std::list<BDS_Face*>::iterator it = ts.begin();
- std::list<BDS_Face*>::iterator ite = ts.end();
+ std::list<BDS_Face *>::iterator it = ts.begin();
+ std::list<BDS_Face *>::iterator ite = ts.end();
while(it != ite) {
BDS_Face *t = *it;
- if(!t->e4){
+ if(!t->e4) {
BDS_Edge *e = t->oppositeEdge(p);
- if(e->numfaces() == 2){
+ if(e->numfaces() == 2) {
BDS_Face *f = e->otherFace(t);
- if(!f->e4){
+ if(!f->e4) {
BDS_Point *target = f->oppositeVertex(e);
// ONLY WORKS IN 2D for now !!!!!!!!!!!!!!!!!!!
- Intersect_Edges_2d(e->p1->X, e->p1->Y,
- e->p2->X, e->p2->Y,
- p->X, p->Y,
- p->X + n.x(), p->Y + n.y(), x);
- if(x[0] >= 0 && x[0] <= 1){
- SVector3 d(target->X-p->X,target->Y-p->Y,target->Z-p->Z);
+ Intersect_Edges_2d(e->p1->X, e->p1->Y, e->p2->X, e->p2->Y, p->X,
+ p->Y, p->X + n.x(), p->Y + n.y(), x);
+ if(x[0] >= 0 && x[0] <= 1) {
+ SVector3 d(target->X - p->X, target->Y - p->Y, target->Z - p->Z);
d.normalize();
- double COS = dot(n,d);
- double L2 = sqrt((target->X - p->X) *(target->X - p->X) +
- (target->X - p->Y) *(target->X - p->Y) +
- (target->X - p->Z) *(target->X - p->Z) );
-
- // swapping the edge alllow to find an edgge that has the right direction and
- // right size
- if(COS > cos(M_PI/6.0) && L2 < L){
- m->swap_edge(e, BDS_SwapEdgeTestQuality(false,false));
- BDS_Edge *newE = m->find_edge(p,target);
+ double COS = dot(n, d);
+ double L2 = sqrt((target->X - p->X) * (target->X - p->X) +
+ (target->X - p->Y) * (target->X - p->Y) +
+ (target->X - p->Z) * (target->X - p->Z));
+
+ // swapping the edge alllow to find an edgge that has the right
+ // direction and right size
+ if(COS > cos(M_PI / 6.0) && L2 < L) {
+ m->swap_edge(e, BDS_SwapEdgeTestQuality(false, false));
+ BDS_Edge *newE = m->find_edge(p, target);
// printf("swapping -> %p\n",newE);
- return newE;
+ return newE;
}
// split the edge
- else{
+ else {
BDS_Point *mid;
- mid = m->add_point(++m->MAXPOINTNUMBER,(1.-x[0])*e->p1->u + x[0]*e->p2->u,
- (1.-x[0])*e->p1->v + x[0]*e->p2->v,gf);
- mid->lc() = 0.5 * (p->lc() + target->lc());
+ mid = m->add_point(
+ ++m->MAXPOINTNUMBER, (1. - x[0]) * e->p1->u + x[0] * e->p2->u,
+ (1. - x[0]) * e->p1->v + x[0] * e->p2->v, gf);
+ mid->lc() = 0.5 * (p->lc() + target->lc());
mid->g = e->p1->g;
m->split_edge(e, mid);
- BDS_Edge *newE = m->find_edge(p,mid);
+ BDS_Edge *newE = m->find_edge(p, mid);
// printf("splitting -> %p %p\n",newE,e->p1->g);
// m->cleanup();
return newE;
@@ -439,7 +443,7 @@ BDS_Edge *edgeFront::findOptimalEdge(BDS_Point *p, BDS_Point *avoid)
}
}
++it;
- }
+ }
}
printf("zarbi\n");
return 0;
@@ -454,31 +458,35 @@ bool edgeFront::emptyFront(int tag)
eiter it1, it2;
std::vector<eiter> fe1, fe2;
-
+
printf("front edges %d %d tag %d\n", e->p1->iD, e->p2->iD, tag);
- switch(tag){
+ switch(tag) {
// both left and right neighboring edges are
// sufficiently angled in order to allow to
// form the quad
- case 3:
- {
- getFrontEdges(e->p1, it1, it2);
- if(*it1 == e) left=*it2;
- else left = *it1;
- getFrontEdges(e->p2, it1, it2);
- if(*it1 == e) right = *it2;
- else right = *it1;
- // printf("case 3\n");
- }
- break;
+ case 3: {
+ getFrontEdges(e->p1, it1, it2);
+ if(*it1 == e)
+ left = *it2;
+ else
+ left = *it1;
+ getFrontEdges(e->p2, it1, it2);
+ if(*it1 == e)
+ right = *it2;
+ else
+ right = *it1;
+ // printf("case 3\n");
+ } break;
// right edge is angled with current edge
// we therefore find a new front edge in the
// mesh that allows to move to tag 3
case 2:
getFrontEdges(e->p1, it1, it2);
- if(*it1 == e) left = *it2;
- else left = *it1;
+ if(*it1 == e)
+ left = *it2;
+ else
+ left = *it1;
// printf("case 2 left edge %p\n",left);
right = findOptimalEdge(e->p2, left->othervertex(e->p1));
if(right) getFrontEdges(right->othervertex(e->p2), fe2);
@@ -488,8 +496,10 @@ bool edgeFront::emptyFront(int tag)
// mesh that allows to move to tag 3
case 1:
getFrontEdges(e->p2, it1, it2);
- if(*it2 == e) right = *it1;
- else right = *it2;
+ if(*it2 == e)
+ right = *it1;
+ else
+ right = *it2;
// printf("case 1 right edge %p %p\n",e,right);
left = findOptimalEdge(e->p1, right->othervertex(e->p2));
if(left) getFrontEdges(left->othervertex(e->p1), fe1);
@@ -499,17 +509,15 @@ bool edgeFront::emptyFront(int tag)
// mesh that allows to move to tag 3
case 0:
left = findOptimalEdge(e->p1, 0);
- if(left) right= findOptimalEdge(e->p2, left->othervertex(e->p1));
+ if(left) right = findOptimalEdge(e->p2, left->othervertex(e->p1));
if(right) getFrontEdges(right->othervertex(e->p2), fe2);
if(left) getFrontEdges(left->othervertex(e->p1), fe1);
// printf("strange\n");
break;
- default:
- Msg::Error("Unknown case in emptyFront");
- return false;
+ default: Msg::Error("Unknown case in emptyFront"); return false;
}
- if(fe1.size() || fe2.size() || !left || !right || !formQuad(e, left, right)){
+ if(fe1.size() || fe2.size() || !left || !right || !formQuad(e, left, right)) {
// printf("front cloeses : algo has to be finished\n");
stat[tag].erase(stat[tag].begin());
stat[4].insert(e);
@@ -520,8 +528,8 @@ bool edgeFront::emptyFront(int tag)
static int numQuads(BDS_Mesh *m)
{
int N = 0;
- for(std::list<BDS_Face*>::iterator it = m->triangles.begin();
- it != m->triangles.end(); ++it){
+ for(std::list<BDS_Face *>::iterator it = m->triangles.begin();
+ it != m->triangles.end(); ++it) {
if((*it)->e4) N++;
}
return N;
@@ -530,45 +538,45 @@ static int numQuads(BDS_Mesh *m)
int gmshQMorph(GFace *gf)
{
// assert first that there exist a triangulation of
- // the face
- if(!gf->triangles.size()){
+ // the face
+ if(!gf->triangles.size()) {
Msg::Warning("Cannot Quadrilaterize a face that has not been triangulated");
return -1;
}
// create data structures for mesh manipulations
- std::list<GFace*> l; l.push_back(gf);
+ std::list<GFace *> l;
+ l.push_back(gf);
BDS_Mesh *pm = gmsh2BDS(l);
// create the front
- edgeFront front(pm,gf);
+ edgeFront front(pm, gf);
front.initiate();
-
+
int ITER = 1;
-
+
// empty the front for front edges tagged 3, 2, 1 then 0
int _numQuads = 0;
- while(1){
- if(front.emptyFront(3)){
- if(front.emptyFront(2)){
- if(front.emptyFront(1)){
- if(front.emptyFront(0)){
+ while(1) {
+ if(front.emptyFront(3)) {
+ if(front.emptyFront(2)) {
+ if(front.emptyFront(1)) {
+ if(front.emptyFront(0)) {
int ns;
- smoothVertexPass(gf,*pm,ns,false);
- printf("nex row iter %6d->>>\n",ITER);
+ smoothVertexPass(gf, *pm, ns, false);
+ printf("nex row iter %6d->>>\n", ITER);
front.initiate();
int _numQuadsNew = numQuads(pm);
- if(front.edges.size() == 0 || _numQuads == _numQuadsNew)
- break;
+ if(front.edges.size() == 0 || _numQuads == _numQuadsNew) break;
_numQuads = _numQuadsNew;
}
}
}
}
ITER++;
- if(1 || ITER%100 == 0){
+ if(1 || ITER % 100 == 0) {
char name[256];
- sprintf(name,"qmorph-face%d-iter%d.pos",gf->tag(),ITER);
+ sprintf(name, "qmorph-face%d-iter%d.pos", gf->tag(), ITER);
outputScalarField(pm->triangles, name, 0);
}
// if(ITER == 1123)break;
diff --git a/Mesh/meshGFaceQuadrilateralize.h b/Mesh/meshGFaceQuadrilateralize.h
index 15955a087a81f897585c202fc6b2ebac1f650b7a..0ceb0d4802f6b01b571643e6f96815e8c50f5891 100644
--- a/Mesh/meshGFaceQuadrilateralize.h
+++ b/Mesh/meshGFaceQuadrilateralize.h
@@ -7,6 +7,6 @@
#define _MESH_GFACE_QUADRILATERALIZE_
class GFace;
-int gmshQMorph (GFace *gf);
+int gmshQMorph(GFace *gf);
#endif
diff --git a/Mesh/meshGFaceRecombine.cpp b/Mesh/meshGFaceRecombine.cpp
index 3a16793158debabaef270b054acf4ab2b4e5064c..456056a1de23744ab9969296c86fb133eaff9e20 100644
--- a/Mesh/meshGFaceRecombine.cpp
+++ b/Mesh/meshGFaceRecombine.cpp
@@ -22,24 +22,23 @@
#define REC2D_WAIT_TM_3 .001
#ifdef HAVE_FLTK
- #define REC2D_DRAW
- #ifdef REC2D_DRAW
- #define DRAW_ALL_TIME_STEP
- //#define DRAW_WHEN_SELECTED
- //#define DRAW_EVERY_CHANGE
- #define DRAW_BEST_SEQ
- #define DRAW_IF_ERROR
- #endif
+#define REC2D_DRAW
+#ifdef REC2D_DRAW
+#define DRAW_ALL_TIME_STEP
+//#define DRAW_WHEN_SELECTED
+//#define DRAW_EVERY_CHANGE
+#define DRAW_BEST_SEQ
+#define DRAW_IF_ERROR
+#endif
#endif
#ifdef REC2D_DRAW
- #include "drawContext.h"
- #include "FlGui.h"
+#include "drawContext.h"
+#include "FlGui.h"
#endif
- #include "Context.h"
- #include "OS.h"
- #include "CreateFile.h"
-
+#include "Context.h"
+#include "OS.h"
+#include "CreateFile.h"
#define E(x) Msg::Error x
#define F(x) Msg::Fatal x
@@ -50,7 +49,6 @@
// It''s RElement that should give Blossom Qual !
// test
-
Recombine2D *Recombine2D::_cur = NULL;
Rec2DData *Rec2DData::_cur = NULL;
double **Rec2DVertex::_qualVSnum = NULL;
@@ -76,8 +74,7 @@ namespace {
Recombine2D::drawStateOrigin();
CTX::instance()->mesh.changed = ENT_ALL;
drawContext::global()->draw();
- while (Cpu()-time < dt)
- FlGui::instance()->check();
+ while(Cpu() - time < dt) FlGui::instance()->check();
}
void __drawWait(double time, double dt)
@@ -85,63 +82,62 @@ namespace {
Recombine2D::drawStateOrigin();
CTX::instance()->mesh.changed = ENT_ALL;
drawContext::global()->draw();
- while (Cpu()-time < dt)
- FlGui::instance()->check();
+ while(Cpu() - time < dt) FlGui::instance()->check();
}
#endif
- bool edgesAreInOrder(Rec2DEdge const*const*const edges, const int numEdges)
+ bool edgesAreInOrder(Rec2DEdge const *const *const edges, const int numEdges)
{
Rec2DVertex **v, *v0, *v1;
- v = new Rec2DVertex*[numEdges];
+ v = new Rec2DVertex *[numEdges];
v0 = edges[0]->getVertex(0);
v1 = edges[0]->getVertex(1);
- if (edges[1]->getVertex(0) == v0 || edges[1]->getVertex(1) == v0) {
+ if(edges[1]->getVertex(0) == v0 || edges[1]->getVertex(1) == v0) {
v[0] = v0;
- if (edges[1]->getVertex(0) == v0)
+ if(edges[1]->getVertex(0) == v0)
v[1] = edges[1]->getVertex(1);
else
v[1] = edges[1]->getVertex(0);
}
- else if (edges[1]->getVertex(0) == v1 || edges[1]->getVertex(1) == v1) {
+ else if(edges[1]->getVertex(0) == v1 || edges[1]->getVertex(1) == v1) {
v[0] = v1;
- if (edges[1]->getVertex(0) == v1)
+ if(edges[1]->getVertex(0) == v1)
v[1] = edges[1]->getVertex(1);
else
v[1] = edges[1]->getVertex(0);
}
else {
Msg::Error("edges not in order (1)");
- for (int i = 0; i < numEdges; ++i) {
+ for(int i = 0; i < numEdges; ++i) {
edges[i]->print();
}
delete[] v;
return false;
}
- for (int i = 2; i < numEdges; ++i) {
- if (edges[i]->getVertex(0) == v[i-1])
+ for(int i = 2; i < numEdges; ++i) {
+ if(edges[i]->getVertex(0) == v[i - 1])
v[i] = edges[i]->getVertex(1);
- else if (edges[i]->getVertex(1) == v[i-1])
+ else if(edges[i]->getVertex(1) == v[i - 1])
v[i] = edges[i]->getVertex(0);
else {
Msg::Error("edges not in order (2)");
- for (int i = 0; i < numEdges; ++i) {
+ for(int i = 0; i < numEdges; ++i) {
edges[i]->print();
}
delete[] v;
return false;
}
}
- if ((v[0] == v1 && v[numEdges-1] != v0) ||
- (v[0] == v0 && v[numEdges-1] != v1) ) {
+ if((v[0] == v1 && v[numEdges - 1] != v0) ||
+ (v[0] == v0 && v[numEdges - 1] != v1)) {
Msg::Error("edges not in order (3)");
- for (int i = 0; i < numEdges; ++i) {
+ for(int i = 0; i < numEdges; ++i) {
edges[i]->print();
}
delete[] v;
return false;
}
- delete[] v;
+ delete[] v;
return true;
}
@@ -151,32 +147,29 @@ namespace {
Recombine2D::drawStateOrigin();
int a[2];
int e = 0;
- for (int i = 0; i < 10000000; ++i) e+=a[i];
- Msg::Info("%d",e);
+ for(int i = 0; i < 10000000; ++i) e += a[i];
+ Msg::Info("%d", e);
}
void __wait(double dt = REC2D_WAIT_TM_3)
{
- #ifdef REC2D_DRAW
+#ifdef REC2D_DRAW
Msg::Info(" ");
double time = Cpu();
- while (Cpu()-time < dt)
- FlGui::instance()->check();
- #endif
+ while(Cpu() - time < dt) FlGui::instance()->check();
+#endif
}
int otherParity(const int a)
{
- if (a % 2)
- return a - 1;
+ if(a % 2) return a - 1;
return a + 1;
}
}
namespace std // specialization of std::swap(..) for Rec2DData::Action class
{
- template <>
- void swap(Rec2DData::Action& a0, Rec2DData::Action& a1)
+ template <> void swap(Rec2DData::Action &a0, Rec2DData::Action &a1)
{
const Rec2DAction *tmp = a0.action;
a0.action = a1.action;
@@ -184,16 +177,14 @@ namespace std // specialization of std::swap(..) for Rec2DData::Action class
a0.update();
a1.update();
}
-}
-
+} // namespace std
/** Rec2DContainer **/
/**********************/
-template <typename T>
-int Rec2DContainer<T>::add(T t)
+template <typename T> int Rec2DContainer<T>::add(T t)
{
typename std::set<T>::iterator it = _set.find(t);
- if (it == _set.end()) {
+ if(it == _set.end()) {
_set.insert(t);
_vec.push_back(t);
return 1;
@@ -201,28 +192,27 @@ int Rec2DContainer<T>::add(T t)
return 0;
}
-template <typename T>
-int Rec2DContainer<T>::rmv(T t)
+template <typename T> int Rec2DContainer<T>::rmv(T t)
{
typename std::set<T>::iterator it = _set.find(t);
- if (it != _set.end()) {
+ if(it != _set.end()) {
_set.erase(it);
return 1;
}
return 0;
}
-template <typename T>
-T Rec2DContainer<T>::getRandom()
+template <typename T> T Rec2DContainer<T>::getRandom()
{
- while (_set.size()) {
+ while(_set.size()) {
int index = rand() % _vec.size();
T t = _vec[index];
- if (_set.find(t) == _set.end()) {
+ if(_set.find(t) == _set.end()) {
_vec[index] = _vec.back();
_vec.pop_back();
}
- else return t;
+ else
+ return t;
}
_vec.clear();
return NULL;
@@ -231,26 +221,20 @@ T Rec2DContainer<T>::getRandom()
/** Recombine2D **/
/*******************/
Recombine2D::Recombine2D(GFace *gf, bool col)
- : _gf(gf), _bgm(NULL), _numChange(0), _collapses(col),
- _strategy(0), _horizon(0), _qualCriterion(BlossomQuality), //_qualCriterion(NoCrit),
- _checkIfNotAllQuad(1), _avoidIfNotAllQuad(1),
- _revertIfNotAllQuad(0), _oneActionHavePriority(1),
- _noProblemIfObsolete(0),
- _weightEdgeBase(2),
- _weightEdgeQuad(1),
- _weightAngleTri(1),
- _weightAngleQuad(2),
- _coefAngleQual(.5),
- _coefDegreeQual(.5),
- _coefLengthQual(.5),
- _coefOrientQual(.5),
- _recombineWithBlossom(1), elist(NULL)
-{
- if (Recombine2D::_cur) {
- Msg::Warning("[Recombine2D] An instance already exists. Can't create another.");
+ : _gf(gf), _bgm(NULL), _numChange(0), _collapses(col), _strategy(0),
+ _horizon(0), _qualCriterion(BlossomQuality), //_qualCriterion(NoCrit),
+ _checkIfNotAllQuad(1), _avoidIfNotAllQuad(1), _revertIfNotAllQuad(0),
+ _oneActionHavePriority(1), _noProblemIfObsolete(0), _weightEdgeBase(2),
+ _weightEdgeQuad(1), _weightAngleTri(1), _weightAngleQuad(2),
+ _coefAngleQual(.5), _coefDegreeQual(.5), _coefLengthQual(.5),
+ _coefOrientQual(.5), _recombineWithBlossom(1), elist(NULL)
+{
+ if(Recombine2D::_cur) {
+ Msg::Warning(
+ "[Recombine2D] An instance already exists. Can't create another.");
return;
}
- if (Rec2DData::hasInstance()) {
+ if(Rec2DData::hasInstance()) {
Msg::Error("[Recombine2D] Data instance exists, should not !");
return;
}
@@ -263,20 +247,19 @@ Recombine2D::Recombine2D(GFace *gf, bool col)
Recombine2D::~Recombine2D()
{
- if (_iamCurrent()) {
+ if(_iamCurrent()) {
Recombine2D::_cur = NULL;
- if (_data)
- delete _data;
+ if(_data) delete _data;
}
}
bool Recombine2D::construct()
{
- if (!_iamCurrent()) {
+ if(!_iamCurrent()) {
Msg::Warning("[Recombine2D] I can't construct...");
return false;
}
- if (Rec2DData::hasInstance()) {
+ if(Rec2DData::hasInstance()) {
Msg::Error("[Recombine2D] Data instance exists, should not !");
return false;
}
@@ -286,26 +269,29 @@ bool Recombine2D::construct()
Rec2DVertex::initStaticTable();
Msg::Info("Before backgroundMesh");
Msg::Info(" ");
- backgroundMesh::set(_gf); // this doesn't work after call 'recombineWithBlossom()'
+ backgroundMesh::set(
+ _gf); // this doesn't work after call 'recombineWithBlossom()'
Msg::Info("After backgroundMesh");
Msg::Info(" ");
_bgm = backgroundMesh::current();
_data = new Rec2DData();
static int po = -1;
- if (++po < 1) {
- Msg::Warning("FIXME Why {mesh 2} then {mesh 0} then {mesh 2} imply not corner vertices");
+ if(++po < 1) {
+ Msg::Warning("FIXME Why {mesh 2} then {mesh 0} then {mesh 2} imply not "
+ "corner vertices");
Msg::Warning("FIXME Why more vertices after first mesh generation");
- Msg::Warning("FIXME Update of Action pointing to edge and vertex (when change)");
+ Msg::Warning(
+ "FIXME Update of Action pointing to edge and vertex (when change)");
}
// Be able to compute geometrical angle at corners
- std::map<MVertex*, AngleData> mapCornerVert;
+ std::map<MVertex *, AngleData> mapCornerVert;
{
- std::list<GEdge*> listge = _gf->edges();
- std::list<GEdge*>::iterator itge = listge.begin();
+ std::list<GEdge *> listge = _gf->edges();
+ std::list<GEdge *>::iterator itge = listge.begin();
int iii = 0;
- for (; itge != listge.end(); ++itge) {
+ for(; itge != listge.end(); ++itge) {
Msg::Info("%d", ++iii);
*itge;
(*itge)->getBeginVertex();
@@ -322,23 +308,22 @@ bool Recombine2D::construct()
}
// Create the 'Rec2DVertex', the 'Rec2DEdge' and the 'Rec2DElement'
{
- std::map<MVertex*, Rec2DVertex*> mapVert;
- std::map<MVertex*, Rec2DVertex*>::iterator itV;
- std::map<MVertex*, AngleData>::iterator itCorner;
+ std::map<MVertex *, Rec2DVertex *> mapVert;
+ std::map<MVertex *, Rec2DVertex *>::iterator itV;
+ std::map<MVertex *, AngleData>::iterator itCorner;
// triangles
- for (unsigned int i = 0; i < _gf->triangles.size(); ++i) {
+ for(unsigned int i = 0; i < _gf->triangles.size(); ++i) {
MTriangle *t = _gf->triangles[i];
Rec2DVertex *rv[3];
- for (int j = 0; j < 3; ++j) {
+ for(int j = 0; j < 3; ++j) {
MVertex *v = t->getVertex(j);
- if ( (itCorner = mapCornerVert.find(v)) != mapCornerVert.end() ) {
- if (!itCorner->second._rv)
- itCorner->second._rv = new Rec2DVertex(v);
+ if((itCorner = mapCornerVert.find(v)) != mapCornerVert.end()) {
+ if(!itCorner->second._rv) itCorner->second._rv = new Rec2DVertex(v);
rv[j] = itCorner->second._rv;
- itCorner->second._mElements.push_back((MElement*)t);
+ itCorner->second._mElements.push_back((MElement *)t);
}
- else if ( (itV = mapVert.find(v)) != mapVert.end() ) {
+ else if((itV = mapVert.find(v)) != mapVert.end()) {
rv[j] = itV->second;
}
else {
@@ -347,27 +332,26 @@ bool Recombine2D::construct()
}
}
const Rec2DEdge *re[3];
- for (int j = 0; j < 3; ++j) {
- if ( !(re[j] = Rec2DVertex::getCommonEdge(rv[j], rv[(j+1)%3])) )
- re[j] = new Rec2DEdge(rv[j], rv[(j+1)%3]);
+ for(int j = 0; j < 3; ++j) {
+ if(!(re[j] = Rec2DVertex::getCommonEdge(rv[j], rv[(j + 1) % 3])))
+ re[j] = new Rec2DEdge(rv[j], rv[(j + 1) % 3]);
}
new Rec2DElement(t, re, rv);
}
// quadrangles
- for (unsigned int i = 0; i < _gf->quadrangles.size(); ++i) {
+ for(unsigned int i = 0; i < _gf->quadrangles.size(); ++i) {
MQuadrangle *q = _gf->quadrangles[i];
Rec2DVertex *rv[4];
- for (int j = 0; j < 4; ++j) {
+ for(int j = 0; j < 4; ++j) {
MVertex *v = q->getVertex(j);
- if ( (itCorner = mapCornerVert.find(v)) != mapCornerVert.end() ) {
- if (!itCorner->second._rv)
- itCorner->second._rv = new Rec2DVertex(v);
+ if((itCorner = mapCornerVert.find(v)) != mapCornerVert.end()) {
+ if(!itCorner->second._rv) itCorner->second._rv = new Rec2DVertex(v);
rv[j] = itCorner->second._rv;
- itCorner->second._mElements.push_back((MElement*)q);
+ itCorner->second._mElements.push_back((MElement *)q);
}
- else if ( (itV = mapVert.find(v)) == mapVert.end() ) {
+ else if((itV = mapVert.find(v)) == mapVert.end()) {
rv[j] = itV->second;
}
else {
@@ -376,9 +360,9 @@ bool Recombine2D::construct()
}
}
const Rec2DEdge *re[4];
- for (int j = 0; j < 4; ++j) {
- if ( !(re[j] = Rec2DVertex::getCommonEdge(rv[i], rv[(i+1)%3])) )
- re[j] = new Rec2DEdge(rv[i], rv[(i+1)%3]);
+ for(int j = 0; j < 4; ++j) {
+ if(!(re[j] = Rec2DVertex::getCommonEdge(rv[i], rv[(i + 1) % 3])))
+ re[j] = new Rec2DEdge(rv[i], rv[(i + 1) % 3]);
}
new Rec2DElement(q, re, rv);
@@ -386,11 +370,10 @@ bool Recombine2D::construct()
}
// update corner
{
- std::map<MVertex*, AngleData>::iterator it = mapCornerVert.begin();
- for (; it != mapCornerVert.end(); ++it) {
- double angle = _geomAngle(it->first,
- it->second._gEdges,
- it->second._mElements);
+ std::map<MVertex *, AngleData>::iterator it = mapCornerVert.begin();
+ for(; it != mapCornerVert.end(); ++it) {
+ double angle =
+ _geomAngle(it->first, it->second._gEdges, it->second._mElements);
new Rec2DVertex(it->second._rv, angle);
}
}
@@ -398,22 +381,23 @@ bool Recombine2D::construct()
// update boundary, create the 'Rec2DTwoTri2Quad' and the 'Rec2DCollapse'
{
Rec2DData::iter_re it = Rec2DData::firstEdge();
- for (; it != Rec2DData::lastEdge(); ++it) {
+ for(; it != Rec2DData::lastEdge(); ++it) {
Rec2DVertex *rv0 = (*it)->getVertex(0), *rv1 = (*it)->getVertex(1);
- if ((*it)->isOnBoundary()) {
+ if((*it)->isOnBoundary()) {
rv0->setOnBoundary();
rv1->setOnBoundary();
}
else {
- std::vector<Rec2DElement*> elem;
+ std::vector<Rec2DElement *> elem;
Rec2DVertex::getCommonElements(rv0, rv1, elem);
- if (elem.size() != 2)
- Msg::Error("[Recombine2D] %d elements instead of 2 for neighbour link",
- elem.size() );
+ if(elem.size() != 2)
+ Msg::Error(
+ "[Recombine2D] %d elements instead of 2 for neighbour link",
+ elem.size());
else {
elem[0]->addNeighbour(*it, elem[1]);
elem[1]->addNeighbour(*it, elem[0]);
- if (Recombine2D::onlyRecombinations())
+ if(Recombine2D::onlyRecombinations())
new Rec2DTwoTri2Quad(elem[0], elem[1]);
else
new Rec2DCollapse(new Rec2DTwoTri2Quad(elem[0], elem[1]));
@@ -424,15 +408,15 @@ bool Recombine2D::construct()
// set parity on boundary, (create the 'Rec2DFourTri2Quad')
{
Rec2DData::iter_rv it = Rec2DData::firstVertex();
- for (; it != Rec2DData::lastVertex(); ++it) {
+ for(; it != Rec2DData::lastVertex(); ++it) {
Rec2DVertex *rv = *it;
- if (rv->getOnBoundary()) {
- if (!rv->getParity()) {
+ if(rv->getOnBoundary()) {
+ if(!rv->getParity()) {
int base = Rec2DData::getNewParity();
- rv->setBoundaryParity(base, base+1);
+ rv->setBoundaryParity(base, base + 1);
}
}
- else if (rv->getNumElements() == 4) {
+ else if(rv->getNumElements() == 4) {
;
}
}
@@ -444,10 +428,11 @@ bool Recombine2D::construct()
Msg::Info("Before recombining with Blossom");
Msg::Info(" ");
- if (_recombineWithBlossom) {
+ if(_recombineWithBlossom) {
_blossomTime = Cpu();
- //recombineWithBlossom(_gf, .0, .16, elist, t2n);// no more in the code (see Amaury)
- _blossomTime = Cpu()-_blossomTime;
+ // recombineWithBlossom(_gf, .0, .16, elist, t2n);// no more in the code
+ // (see Amaury)
+ _blossomTime = Cpu() - _blossomTime;
}
_gf->quadrangles.clear();
//
@@ -456,17 +441,19 @@ bool Recombine2D::construct()
bool Recombine2D::recombine()
{
- if (!_iamCurrent()) {
- Msg::Warning("[Recombine2D] If I can't construct myself, I can't recombine :)");
+ if(!_iamCurrent()) {
+ Msg::Warning(
+ "[Recombine2D] If I can't construct myself, I can't recombine :)");
return false;
}
- if (!Rec2DData::hasInstance()) {
- Msg::Error("[Recombine2D] Data instance dosen't exist. Have you called construct() ?");
+ if(!Rec2DData::hasInstance()) {
+ Msg::Error("[Recombine2D] Data instance dosen't exist. Have you called "
+ "construct() ?");
return false;
}
- I(("Recombining... #actions = %d, horizon = %d",
- Rec2DData::getNumAction(), _horizon ));
+ I(("Recombining... #actions = %d, horizon = %d", Rec2DData::getNumAction(),
+ _horizon));
#ifdef REC2D_DRAW
__draw(.0);
#endif
@@ -478,7 +465,7 @@ bool Recombine2D::recombine()
Rec2DNode *root = new Rec2DNode(NULL, NULL, _horizon);
Rec2DNode *currentNode = Rec2DNode::selectBestNode(root);
- while (currentNode) {
+ while(currentNode) {
currentNode->lookahead(_horizon);
currentNode = Rec2DNode::selectBestNode(currentNode);
}
@@ -487,29 +474,29 @@ bool Recombine2D::recombine()
__draw(.0);
#endif
_lastRunTime = Cpu() - globtime;
- I(( "... done recombining, in %f seconds", _lastRunTime ));
+ I(("... done recombining, in %f seconds", _lastRunTime));
return true;
}
bool Recombine2D::recombineNewAlgo(int horiz, int code)
{
- if (!_iamCurrent()) {
- Msg::Warning("[Recombine2D] If I can't construct myself, I can't recombine :)");
+ if(!_iamCurrent()) {
+ Msg::Warning(
+ "[Recombine2D] If I can't construct myself, I can't recombine :)");
return false;
}
- if (!Rec2DData::hasInstance()) {
- Msg::Error("[Recombine2D] Data instance dosen't exist. Have you called construct() ?");
+ if(!Rec2DData::hasInstance()) {
+ Msg::Error("[Recombine2D] Data instance dosen't exist. Have you called "
+ "construct() ?");
return false;
}
-
-
- if (horiz < 0 || code < 0) {
- if (!Rec2DAlgo::paramOK()) return false;
+ if(horiz < 0 || code < 0) {
+ if(!Rec2DAlgo::paramOK()) return false;
Rec2DAlgo::getParam(horiz, code);
}
else {
- if (!Rec2DAlgo::setParam(horiz, code)) return false;
+ if(!Rec2DAlgo::setParam(horiz, code)) return false;
}
I(("Recombining... code = %d, horizon = %d", code, horiz));
@@ -518,26 +505,28 @@ bool Recombine2D::recombineNewAlgo(int horiz, int code)
Rec2DAlgo::execute();
_lastRunTime = Cpu() - globtime;
- I(( "... done recombining, in %f seconds", _lastRunTime ));
+ I(("... done recombining, in %f seconds", _lastRunTime));
return true;
}
bool Recombine2D::recombineSimpleAlgo(int horiz)
{
- if (!_iamCurrent()) {
- Msg::Warning("[Recombine2D] If I can't construct myself, I can't recombine :)");
+ if(!_iamCurrent()) {
+ Msg::Warning(
+ "[Recombine2D] If I can't construct myself, I can't recombine :)");
return false;
}
- if (!Rec2DData::hasInstance()) {
- Msg::Error("[Recombine2D] Data instance dosen't exist. Have you called construct() ?");
+ if(!Rec2DData::hasInstance()) {
+ Msg::Error("[Recombine2D] Data instance dosen't exist. Have you called "
+ "construct() ?");
return false;
}
- if (horiz < 0) {
- if (!Rec2DAlgo::paramOKSimpleAlgo()) return false;
+ if(horiz < 0) {
+ if(!Rec2DAlgo::paramOKSimpleAlgo()) return false;
}
else {
- if (!Rec2DAlgo::setParam(horiz, 0)) return false;
+ if(!Rec2DAlgo::setParam(horiz, 0)) return false;
}
I(("Recombining... Simple, horizon = %d", horiz));
@@ -546,26 +535,28 @@ bool Recombine2D::recombineSimpleAlgo(int horiz)
Rec2DAlgo::execute();
_lastRunTime = Cpu() - globtime;
- I(( "... done recombining, in %f seconds", _lastRunTime ));
+ I(("... done recombining, in %f seconds", _lastRunTime));
return true;
}
bool Recombine2D::recombineComplete(int horiz)
{
- if (!_iamCurrent()) {
- Msg::Warning("[Recombine2D] If I can't construct myself, I can't recombine :)");
+ if(!_iamCurrent()) {
+ Msg::Warning(
+ "[Recombine2D] If I can't construct myself, I can't recombine :)");
return false;
}
- if (!Rec2DData::hasInstance()) {
- Msg::Error("[Recombine2D] Data instance dosen't exist. Have you called construct() ?");
+ if(!Rec2DData::hasInstance()) {
+ Msg::Error("[Recombine2D] Data instance dosen't exist. Have you called "
+ "construct() ?");
return false;
}
- if (horiz < 0) {
- if (!Rec2DAlgo::paramOKSimpleAlgo()) return false;
+ if(horiz < 0) {
+ if(!Rec2DAlgo::paramOKSimpleAlgo()) return false;
}
else {
- if (!Rec2DAlgo::setParam(horiz, 0)) return false;
+ if(!Rec2DAlgo::setParam(horiz, 0)) return false;
}
I(("Recombining... Complete, horizon = %d", horiz));
@@ -574,7 +565,7 @@ bool Recombine2D::recombineComplete(int horiz)
Rec2DAlgo::execute(true);
_lastRunTime = Cpu() - globtime;
- I(( "... done recombining, in %f seconds", _lastRunTime ));
+ I(("... done recombining, in %f seconds", _lastRunTime));
return true;
}
@@ -588,25 +579,25 @@ double Recombine2D::recombine(int depth)
static double dx = .0, dy = .0;
#endif
#ifdef DRAW_WHEN_SELECTED
- __draw(REC2D_WAIT_SELECTED);
+ __draw(REC2D_WAIT_SELECTED);
#endif
Rec2DNode *root = new Rec2DNode(NULL, NULL, depth);
Rec2DNode *currentNode = Rec2DNode::selectBestNode(root);
- while (currentNode) {
+ while(currentNode) {
I(("boucle recombine"));
#ifdef DRAW_ALL_TIME_STEP
FlGui::instance()->check();
- if ( !((i+1) % ((int)std::sqrt(num)+1)) ) {
- dx = .0; dy -= 1.1;
+ if(!((i + 1) % ((int)std::sqrt(num) + 1))) {
+ dx = .0;
+ dy -= 1.1;
}
else
dx += 1.1;
drawState(dx, dy);
CTX::instance()->mesh.changed = ENT_ALL;
drawContext::global()->draw();
- while (Cpu()-time < REC2D_WAIT_SELECTED)
- FlGui::instance()->check();
+ while(Cpu() - time < REC2D_WAIT_SELECTED) FlGui::instance()->check();
++i;
time = Cpu();
#endif
@@ -621,48 +612,45 @@ double Recombine2D::recombine(int depth)
void Recombine2D::recombineSameAsBlossom() // check if quality ok
{
- if (!Recombine2D::blossomRec()) {
+ if(!Recombine2D::blossomRec()) {
Msg::Warning("Cannot do anything !");
}
setQualCriterion(BlossomQuality);
Msg::Error("..............begin..............");
- //recombineWithBlossom(_gf, .0, 1.1, elist, t2n);
+ // recombineWithBlossom(_gf, .0, 1.1, elist, t2n);
_data->_quad = _gf->quadrangles;
Recombine2D::drawStateOrigin();
- std::map<int, Rec2DElement*> n2rel;
- std::map<MElement*,int>::iterator it = t2n.begin();
- for (; it != t2n.end(); ++it) {
+ std::map<int, Rec2DElement *> n2rel;
+ std::map<MElement *, int>::iterator it = t2n.begin();
+ for(; it != t2n.end(); ++it) {
n2rel[it->second] = Rec2DData::getRElement(it->first);
}
int blosQual = 0;
- for (int i = 0; i < _cur->elist[0]; ++i) {
- Rec2DElement *tri1 = n2rel[_cur->elist[3*i+1]];
- Rec2DElement *tri2 = n2rel[_cur->elist[3*i+2]];
- blosQual += _cur->elist[3*i+3];
+ for(int i = 0; i < _cur->elist[0]; ++i) {
+ Rec2DElement *tri1 = n2rel[_cur->elist[3 * i + 1]];
+ Rec2DElement *tri2 = n2rel[_cur->elist[3 * i + 2]];
+ blosQual += _cur->elist[3 * i + 3];
Rec2DAction *ra = new Rec2DTwoTri2Quad(tri1, tri2);
- int realRew = (int) ra->getRealReward();
- if (realRew > ra->getRealReward()+.3) --realRew;
- if (realRew < ra->getRealReward()-.3) ++realRew;
- if ((int) ra->getRealReward()+_cur->elist[3*i+3] != 100)
+ int realRew = (int)ra->getRealReward();
+ if(realRew > ra->getRealReward() + .3) --realRew;
+ if(realRew < ra->getRealReward() - .3) ++realRew;
+ if((int)ra->getRealReward() + _cur->elist[3 * i + 3] != 100)
Msg::Info("%d(%d-%g) - %d (%d, %d) => blosQual %d",
- (int) ra->getRealReward(),
- realRew,
- ra->getRealReward(),
- _cur->elist[3*i+3],
- _cur->elist[3*i+2],
- _cur->elist[3*i+1],
- blosQual);
+ (int)ra->getRealReward(), realRew, ra->getRealReward(),
+ _cur->elist[3 * i + 3], _cur->elist[3 * i + 2],
+ _cur->elist[3 * i + 1], blosQual);
Rec2DDataChange *dc = Rec2DData::getNewDataChange();
- std::vector<Rec2DAction*> *v = NULL;
+ std::vector<Rec2DAction *> *v = NULL;
ra->apply(dc, v);
drawStateOrigin();
}
- Msg::Info("Recombine2D Blossom Quality %d => %d", Rec2DData::getBlosQual(), 100*_cur->elist[0]-Rec2DData::getBlosQual());
+ Msg::Info("Recombine2D Blossom Quality %d => %d", Rec2DData::getBlosQual(),
+ 100 * _cur->elist[0] - Rec2DData::getBlosQual());
Msg::Info("vs Blossom Blossom Quality %d", blosQual);
- if (blosQual == 100*_cur->elist[0]-Rec2DData::getBlosQual())
+ if(blosQual == 100 * _cur->elist[0] - Rec2DData::getBlosQual())
Msg::Info("It is ok :-)");
else
Msg::Info("Not ok :-(...");
@@ -672,45 +660,43 @@ void Recombine2D::recombineSameAsHeuristic()
{
double globtime = Cpu();
_noProblemIfObsolete = true;
- //recombineHeuristic(_gf, .0, 1.1, elist, t2n);// no more in the code (see Amaury)
+ // recombineHeuristic(_gf, .0, 1.1, elist, t2n);// no more in the code (see
+ // Amaury)
_lastRunTime = Cpu() - globtime;
_data->_quad = _gf->quadrangles;
drawStateOrigin();
- std::map<int, Rec2DElement*> n2rel;
- std::map<MElement*,int>::iterator it = t2n.begin();
- for (; it != t2n.end(); ++it) {
+ std::map<int, Rec2DElement *> n2rel;
+ std::map<MElement *, int>::iterator it = t2n.begin();
+ for(; it != t2n.end(); ++it) {
n2rel[it->second] = Rec2DData::getRElement(it->first);
}
int heurQual = 0;
- for (int i = 0; i < _cur->elist[0]; ++i) {
- Rec2DElement *tri1 = n2rel[_cur->elist[3*i+1]];
- Rec2DElement *tri2 = n2rel[_cur->elist[3*i+2]];
- heurQual += _cur->elist[3*i+3];
+ for(int i = 0; i < _cur->elist[0]; ++i) {
+ Rec2DElement *tri1 = n2rel[_cur->elist[3 * i + 1]];
+ Rec2DElement *tri2 = n2rel[_cur->elist[3 * i + 2]];
+ heurQual += _cur->elist[3 * i + 3];
Rec2DAction *ra = new Rec2DTwoTri2Quad(tri1, tri2);
- int realRew = (int) ra->getRealReward();
- if (realRew > ra->getRealReward()+.3) --realRew;
- if (realRew < ra->getRealReward()-.3) ++realRew;
- if ((int) ra->getRealReward()+_cur->elist[3*i+3] != 100)
+ int realRew = (int)ra->getRealReward();
+ if(realRew > ra->getRealReward() + .3) --realRew;
+ if(realRew < ra->getRealReward() - .3) ++realRew;
+ if((int)ra->getRealReward() + _cur->elist[3 * i + 3] != 100)
Msg::Info("%d(%d-%g) - %d (%d, %d) => blosQual %d",
- (int) ra->getRealReward(),
- realRew,
- ra->getRealReward(),
- _cur->elist[3*i+3],
- _cur->elist[3*i+2],
- _cur->elist[3*i+1],
- heurQual);
+ (int)ra->getRealReward(), realRew, ra->getRealReward(),
+ _cur->elist[3 * i + 3], _cur->elist[3 * i + 2],
+ _cur->elist[3 * i + 1], heurQual);
Rec2DDataChange *dc = Rec2DData::getNewDataChange();
- std::vector<Rec2DAction*> *v = NULL;
+ std::vector<Rec2DAction *> *v = NULL;
ra->apply(dc, v);
drawStateOrigin();
}
_noProblemIfObsolete = false;
- Msg::Info("Recombine2D Blossom Quality %d => %d", Rec2DData::getBlosQual(), 100*_cur->elist[0]-Rec2DData::getBlosQual());
+ Msg::Info("Recombine2D Blossom Quality %d => %d", Rec2DData::getBlosQual(),
+ 100 * _cur->elist[0] - Rec2DData::getBlosQual());
Msg::Info("vs Heuristic Blossom Quality %d", heurQual);
- if (heurQual == 100*_cur->elist[0]-Rec2DData::getBlosQual())
+ if(heurQual == 100 * _cur->elist[0] - Rec2DData::getBlosQual())
Msg::Info("It is ok :-)");
else
Msg::Info("Not ok :-(...");
@@ -719,10 +705,10 @@ void Recombine2D::recombineSameAsHeuristic()
void Recombine2D::recombineGreedy(bool constrained)
{
double globtime = Cpu();
- if (!constrained) _noProblemIfObsolete = true;
- while (Rec2DAction *ra = Rec2DData::getBestAction()) {
+ if(!constrained) _noProblemIfObsolete = true;
+ while(Rec2DAction *ra = Rec2DData::getBestAction()) {
Rec2DDataChange *dc = Rec2DData::getNewDataChange();
- std::vector<Rec2DAction*> *v = NULL;
+ std::vector<Rec2DAction *> *v = NULL;
ra->apply(dc, v);
drawStateOrigin();
}
@@ -731,7 +717,7 @@ void Recombine2D::recombineGreedy(bool constrained)
drawStateOrigin();
}
-//bool Recombine2D::developTree()
+// bool Recombine2D::developTree()
//{
// Rec2DNode root(NULL, NULL);
// _data->printState();
@@ -750,8 +736,8 @@ void Recombine2D::clearChanges() // revert to initial state
Rec2DData::clearChanges();
updateMesh();
#ifdef REC2D_DRAW_WHEN_CLEARED
- CTX::instance()->mesh.changed = ENT_ALL;
- drawContext::global()->draw();
+ CTX::instance()->mesh.changed = ENT_ALL;
+ drawContext::global()->draw();
#endif
}
@@ -773,46 +759,47 @@ void Recombine2D::saveStats(std::fstream *fout)
*fout << " & " << _lastRunTime << " s";
}
-void Recombine2D::nextTreeActions(std::vector<Rec2DAction*> &actions,
- const std::vector<Rec2DElement*> &neighbourEl,
- const Rec2DNode *const node )
+void Recombine2D::nextTreeActions(
+ std::vector<Rec2DAction *> &actions,
+ const std::vector<Rec2DElement *> &neighbourEl, const Rec2DNode *const node)
{
static int a = 0;
- if (++a == 1) Msg::Warning("FIXME check entities");
- //DEBUG(Rec2DData::checkEntities();)
+ if(++a == 1) Msg::Warning("FIXME check entities");
+ // DEBUG(Rec2DData::checkEntities();)
actions.clear();
const Rec2DNode *treeNode = node;
- if (Recombine2D::onlyRecombinations() && Recombine2D::priorityOfOneAction()) {
- if (neighbourEl.size()) { // check if there is one in neighbour
- for (unsigned int i = 0; i < neighbourEl.size(); ++i) {
- if (neighbourEl[i]->getNumActions() == 1)
+ if(Recombine2D::onlyRecombinations() && Recombine2D::priorityOfOneAction()) {
+ if(neighbourEl.size()) { // check if there is one in neighbour
+ for(unsigned int i = 0; i < neighbourEl.size(); ++i) {
+ if(neighbourEl[i]->getNumActions() == 1)
actions.push_back(neighbourEl[i]->getAction(0));
}
- if (actions.size()) {
- Rec2DAction *ra = (*std::max_element(actions.begin(), actions.end(), lessRec2DAction()));
- //Rec2DAction *ra = actions[rand() % actions.size()];
+ if(actions.size()) {
+ Rec2DAction *ra = (*std::max_element(actions.begin(), actions.end(),
+ lessRec2DAction()));
+ // Rec2DAction *ra = actions[rand() % actions.size()];
actions.clear();
actions.push_back(ra);
- //I(("uio 1"));
+ // I(("uio 1"));
return;
}
}
- else if (treeNode) { // try to find one in the sequence
+ else if(treeNode) { // try to find one in the sequence
treeNode = treeNode->getFather();
- while (treeNode && treeNode->isInSequence()) {
- std::vector<Rec2DElement*> elem;
+ while(treeNode && treeNode->isInSequence()) {
+ std::vector<Rec2DElement *> elem;
treeNode->getAction()->getNeighbElemWithActions(elem);
- for (unsigned int i = 0; i < elem.size(); ++i) {
- if (elem[i]->getNumActions() == 1) {
+ for(unsigned int i = 0; i < elem.size(); ++i) {
+ if(elem[i]->getNumActions() == 1) {
actions.push_back(elem[i]->getAction(0));
}
}
- if (actions.size()) {
+ if(actions.size()) {
Rec2DAction *ra = actions[rand() % actions.size()];
actions.clear();
actions.push_back(ra);
- //I(("uio 2"));
+ // I(("uio 2"));
return;
}
treeNode = treeNode->getFather();
@@ -820,160 +807,159 @@ void Recombine2D::nextTreeActions(std::vector<Rec2DAction*> &actions,
}
Rec2DData::getUniqueOneActions(actions); // get all One Action
- if (actions.size()) {
+ if(actions.size()) {
Rec2DAction *ra = actions[rand() % actions.size()];
actions.clear();
actions.push_back(ra);
- //I(("uio 3"));
+ // I(("uio 3"));
return;
}
}
-
- std::vector<Rec2DElement*> elements;
+ std::vector<Rec2DElement *> elements;
Rec2DAction *ra = NULL;
Rec2DElement *rel = NULL;
const Rec2DNode *tmpNode = NULL;
treeNode = NULL;
- switch (_cur->_strategy) {
- // 0 = every step, choose random triangle
- // 1 = every step, choose best triangle
- //
- // 2 = every step, choose random neighbour triangle
- // 3 = every step, choose best neighbour triangle
- //
- // 4 = FIFS : first in, first surrounded.
- // 5 = treeFIFS, first in, first surrounded in the subtree.
- // 6 = treeFIFS with subtree being deleted every time step.
- case 4 :
- if (!_cur->_curNode->isInSequence()) {
- std::vector<Rec2DElement*> elem;
-
- if (_cur->_curNode->getFather()) {
- _cur->_curNode->getAction()->getNeighbElemWithActions(elem);
- if (elem.size()) {
- rel = elem[rand() % (int)elem.size()];
- break;
- }
+ switch(_cur->_strategy) {
+ // 0 = every step, choose random triangle
+ // 1 = every step, choose best triangle
+ //
+ // 2 = every step, choose random neighbour triangle
+ // 3 = every step, choose best neighbour triangle
+ //
+ // 4 = FIFS : first in, first surrounded.
+ // 5 = treeFIFS, first in, first surrounded in the subtree.
+ // 6 = treeFIFS with subtree being deleted every time step.
+ case 4:
+ if(!_cur->_curNode->isInSequence()) {
+ std::vector<Rec2DElement *> elem;
+
+ if(_cur->_curNode->getFather()) {
+ _cur->_curNode->getAction()->getNeighbElemWithActions(elem);
+ if(elem.size()) {
+ rel = elem[rand() % (int)elem.size()];
+ break;
}
+ }
- while (_cur->_curNode->notInSubTree()) {
- _cur->_curNode = _cur->_curNode->getSon();
- _cur->_curNode->getAction()->getNeighbElemWithActions(elem);
- if (elem.size()) {
- rel = elem[rand() % (int)elem.size()];
- break;
- }
+ while(_cur->_curNode->notInSubTree()) {
+ _cur->_curNode = _cur->_curNode->getSon();
+ _cur->_curNode->getAction()->getNeighbElemWithActions(elem);
+ if(elem.size()) {
+ rel = elem[rand() % (int)elem.size()];
+ break;
}
- if (rel) break;
- // if not, goto case 5 (i.e. try to find in the sequence)
}
+ if(rel) break;
+ // if not, goto case 5 (i.e. try to find in the sequence)
+ }
- case 6 :
- case 5 :
- {
- while (_cur->_curNode->notInSubTree()) _cur->_curNode = _cur->_curNode->getSon();
- std::vector<Rec2DElement*> elem;
+ case 6:
+ case 5: {
+ while(_cur->_curNode->notInSubTree())
+ _cur->_curNode = _cur->_curNode->getSon();
+ std::vector<Rec2DElement *> elem;
- treeNode = _cur->_curNode;
- while (treeNode != node) {
- tmpNode = node;
- while (tmpNode->getFather() != treeNode) tmpNode = tmpNode->getFather();
- treeNode = tmpNode;
+ treeNode = _cur->_curNode;
+ while(treeNode != node) {
+ tmpNode = node;
+ while(tmpNode->getFather() != treeNode) tmpNode = tmpNode->getFather();
+ treeNode = tmpNode;
- treeNode->getAction()->getNeighbElemWithActions(elem);
- if (elem.size()) {
- rel = elem[rand() % (int)elem.size()];
- break;
- }
+ treeNode->getAction()->getNeighbElemWithActions(elem);
+ if(elem.size()) {
+ rel = elem[rand() % (int)elem.size()];
+ break;
}
- if (rel) break;
- }
-
- default :
- case 3 : // triangle of best neighbour action
- //I(("3"));
- for (unsigned int i = 0; i < neighbourEl.size(); ++i)
- neighbourEl[i]->getMoreUniqueActions(actions);
- if (actions.size()) {
- (*std::max_element(actions.begin(), actions.end(), lessRec2DAction()))
- ->getElements(elements);
- for (unsigned int i = 0; i < elements.size(); ++i) {
- for (unsigned int j = 0; j < neighbourEl.size(); ++j) {
- if (elements[i] == neighbourEl[j]) {
- rel = elements[i];
- goto end;
- }
+ }
+ if(rel) break;
+ }
+
+ default:
+ case 3: // triangle of best neighbour action
+ // I(("3"));
+ for(unsigned int i = 0; i < neighbourEl.size(); ++i)
+ neighbourEl[i]->getMoreUniqueActions(actions);
+ if(actions.size()) {
+ (*std::max_element(actions.begin(), actions.end(), lessRec2DAction()))
+ ->getElements(elements);
+ for(unsigned int i = 0; i < elements.size(); ++i) {
+ for(unsigned int j = 0; j < neighbourEl.size(); ++j) {
+ if(elements[i] == neighbourEl[j]) {
+ rel = elements[i];
+ goto end;
}
}
}
- end :
- if (rel) break;
+ }
+ end:
+ if(rel) break;
- case 2 : // random neighbour triangle
- //I(("2"));
- if (neighbourEl.size()) {
- rel = neighbourEl[rand() % (int)neighbourEl.size()];
- break;
- }
+ case 2: // random neighbour triangle
+ // I(("2"));
+ if(neighbourEl.size()) {
+ rel = neighbourEl[rand() % (int)neighbourEl.size()];
+ break;
+ }
- case 1 : // random triangle of best action
- //I(("1"));
- if (Recombine2D::onlyRecombinations() && _cur->_strategy != 1 && node) {
- static int aa = 0;
- if (++aa == 1) Msg::Warning("Why should I keep this ? Why only if only rec");
- treeNode = node->getFather();
- while (treeNode && treeNode->isInSequence()) {
- std::vector<Rec2DElement*> elem;
- treeNode->getAction()->getNeighbElemWithActions(elem);
- for (unsigned int i = 0; i < elem.size(); ++i)
- elem[i]->getMoreUniqueActions(actions);
- if (actions.size()) {
- (*std::max_element(actions.begin(), actions.end(), lessRec2DAction()))
- ->getElements(elements);
- for (unsigned int i = 0; i < elements.size(); ++i) {
- for (unsigned int j = 0; j < elem.size(); ++j) {
- if (elements[i] == elem[j]) {
- rel = elements[i];
- goto end2;
- }
+ case 1: // random triangle of best action
+ // I(("1"));
+ if(Recombine2D::onlyRecombinations() && _cur->_strategy != 1 && node) {
+ static int aa = 0;
+ if(++aa == 1)
+ Msg::Warning("Why should I keep this ? Why only if only rec");
+ treeNode = node->getFather();
+ while(treeNode && treeNode->isInSequence()) {
+ std::vector<Rec2DElement *> elem;
+ treeNode->getAction()->getNeighbElemWithActions(elem);
+ for(unsigned int i = 0; i < elem.size(); ++i)
+ elem[i]->getMoreUniqueActions(actions);
+ if(actions.size()) {
+ (*std::max_element(actions.begin(), actions.end(), lessRec2DAction()))
+ ->getElements(elements);
+ for(unsigned int i = 0; i < elements.size(); ++i) {
+ for(unsigned int j = 0; j < elem.size(); ++j) {
+ if(elements[i] == elem[j]) {
+ rel = elements[i];
+ goto end2;
}
}
}
- actions.clear();
- treeNode = treeNode->getFather();
}
-end2 :
- if (rel) break;
+ actions.clear();
+ treeNode = treeNode->getFather();
}
- ra = Rec2DData::getBestAction();
- if (!ra) return;
- rel = ra->getRandomElement();
- break;
- case 0 : // random triangle of random action
- ra = Rec2DData::getRandomAction();
- if (!ra) return;
- rel = ra->getRandomElement();
- break;
+ end2:
+ if(rel) break;
+ }
+ ra = Rec2DData::getBestAction();
+ if(!ra) return;
+ rel = ra->getRandomElement();
+ break;
+ case 0: // random triangle of random action
+ ra = Rec2DData::getRandomAction();
+ if(!ra) return;
+ rel = ra->getRandomElement();
+ break;
}
-//#ifdef REC2D_DRAW
-// unsigned int col = CTX::instance()->packColor(90, 128, 85, 255);
-// rel->getMElement()->setCol(col);
-//#endif
+ //#ifdef REC2D_DRAW
+ // unsigned int col = CTX::instance()->packColor(90, 128, 85, 255);
+ // rel->getMElement()->setCol(col);
+ //#endif
rel->getActions(actions);
unsigned int i = 0;
- while (i < actions.size()) {
- if (actions[i]->isObsolete()) {
+ while(i < actions.size()) {
+ if(actions[i]->isObsolete()) {
E(("SHOULD I BE HERE ??"));
#ifdef DRAW_IF_ERROR
static int a = 0;
- if (++a == 1) Msg::Warning("FIXME Normal to be here ?");
+ if(++a == 1) Msg::Warning("FIXME Normal to be here ?");
actions[i]->color(190, 0, 0);
double time = Cpu();
CTX::instance()->mesh.changed = ENT_ALL;
drawContext::global()->draw();
- while (Cpu()-time < 5)
- FlGui::instance()->check();
+ while(Cpu() - time < 5) FlGui::instance()->check();
#endif
actions[i] = actions.back();
actions.pop_back();
@@ -981,23 +967,24 @@ end2 :
else
++i;
}
- //I(( "get %d actions", actions.size() ));
+ // I(( "get %d actions", actions.size() ));
}
void Recombine2D::compareWithBlossom()
{
Msg::Error("..............begin..............");
- //recombineWithBlossom(_gf, .0, 1.1, elist, t2n);// no more in the code (see Amaury)
+ // recombineWithBlossom(_gf, .0, 1.1, elist, t2n);// no more in the code (see
+ // Amaury)
_data->_quad = _gf->quadrangles;
Recombine2D::drawStateOrigin();
__wait(3);
- drawState(.0,-1.1);
+ drawState(.0, -1.1);
setStrategy(3);
int num = 2;
double dx = .0, dy = .0, time = Cpu();
- for (int d = 1; d < 7; ++d) {
+ for(int d = 1; d < 7; ++d) {
recombine(d);
- if ( d % ((int)std::sqrt(num)+1) ) {
+ if(d % ((int)std::sqrt(num) + 1)) {
dx += 3.3;
}
else {
@@ -1008,36 +995,34 @@ void Recombine2D::compareWithBlossom()
CTX::instance()->mesh.changed = ENT_ALL;
#ifdef REC2D_DRAW
drawContext::global()->draw();
- //while (Cpu()-time < REC2D_WAIT_TIME)
+ // while (Cpu()-time < REC2D_WAIT_TIME)
// FlGui::instance()->check();
#endif
time = Cpu();
}
int totalBlossom = 0;
- for (int k = 0; k < _cur->elist[0]; ++k) totalBlossom += 100-_cur->elist[1+3*k+2];
+ for(int k = 0; k < _cur->elist[0]; ++k)
+ totalBlossom += 100 - _cur->elist[1 + 3 * k + 2];
Msg::Info("Blossom %d", totalBlossom);
delete elist;
t2n.clear();
Rec2DData::clearChanges();
#ifdef DRAW_WHEN_SELECTED // draw state at origin
- __drawWait(time, REC2D_WAIT_SELECTED);
+ __drawWait(time, REC2D_WAIT_SELECTED);
#endif
}
int Recombine2D::computeQualBlossom() const
{
int qualBlos = 0;
- for (int i = 0; i < elist[0]; ++i) {
- qualBlos += elist[3*i+3];
+ for(int i = 0; i < elist[0]; ++i) {
+ qualBlos += elist[3 * i + 3];
}
- return 100*elist[0]-qualBlos;
+ return 100 * elist[0] - qualBlos;
}
-void Recombine2D::printState() const
-{
- _data->printState();
-}
+void Recombine2D::printState() const { _data->printState(); }
void Recombine2D::drawState(double shiftx, double shifty, bool color) const
{
@@ -1072,57 +1057,57 @@ void Recombine2D::add(MTriangle *t)
_cur->_data->_tri.push_back(t);
}
-
void Recombine2D::colorFromBlossom(const Rec2DElement *tri1,
const Rec2DElement *tri2,
- const Rec2DElement *quad )
+ const Rec2DElement *quad)
{
#ifdef REC2D_DRAW
- if (!_cur->elist) {
+ if(!_cur->elist) {
Msg::Error("no list");
return;
}
int i1 = _cur->t2n[tri1->getMElement()];
int i2 = _cur->t2n[tri2->getMElement()];
int k = -1;
- while (++k < _cur->elist[0] &&
- _cur->elist[1+3*k] != i1 &&
- _cur->elist[1+3*k] != i2 );
- if (k < _cur->elist[0] && (_cur->elist[1+3*k+1] == i1 ||
- _cur->elist[1+3*k+1] == i2 )) {
+ while(++k < _cur->elist[0] && _cur->elist[1 + 3 * k] != i1 &&
+ _cur->elist[1 + 3 * k] != i2)
+ ;
+ if(k < _cur->elist[0] &&
+ (_cur->elist[1 + 3 * k + 1] == i1 || _cur->elist[1 + 3 * k + 1] == i2)) {
unsigned int col = CTX::instance()->packColor(200, 120, 225, 255);
- //quad->getMElement()->setCol(col);// no more in the code (see Amaury)
+ // quad->getMElement()->setCol(col);// no more in the code (see Amaury)
}
#endif
}
void Recombine2D::colorFromBlossom(const Rec2DElement *tri1,
const Rec2DElement *tri2,
- const MElement *quad )
+ const MElement *quad)
{
- if (!_cur->elist) {
+ if(!_cur->elist) {
Msg::Error("no list");
return;
}
int i1 = _cur->t2n[tri1->getMElement()];
int i2 = _cur->t2n[tri2->getMElement()];
int k = -1;
- while (++k < _cur->elist[0] && _cur->elist[1+3*k] != i1 && _cur->elist[1+3*k] != i2);
- if (k < _cur->elist[0] &&
- (_cur->elist[1+3*k+1] == i1 || _cur->elist[1+3*k+1] == i2)) {
+ while(++k < _cur->elist[0] && _cur->elist[1 + 3 * k] != i1 &&
+ _cur->elist[1 + 3 * k] != i2)
+ ;
+ if(k < _cur->elist[0] &&
+ (_cur->elist[1 + 3 * k + 1] == i1 || _cur->elist[1 + 3 * k + 1] == i2)) {
unsigned int col = CTX::instance()->packColor(200, 120, 225, 255);
//((MElement*)quad)->setCol(col);// no more in the code (see Amaury)
}
}
-
double Recombine2D::_geomAngle(const MVertex *v,
- const std::vector<GEdge*> &gEdge,
- const std::vector<MElement*> &elem) const //*
+ const std::vector<GEdge *> &gEdge,
+ const std::vector<MElement *> &elem) const //*
{
- if (gEdge.size() != 2) {
+ if(gEdge.size() != 2) {
Msg::Error("[Recombine2D] Wrong number of edge : %d, returning pi/2",
- gEdge.size() );
+ gEdge.size());
return M_PI / 2.;
}
static const double prec = 100.;
@@ -1130,23 +1115,22 @@ double Recombine2D::_geomAngle(const MVertex *v,
SVector3 vectv = SVector3(v->x(), v->y(), v->z());
SVector3 firstDer0, firstDer1;
- for (unsigned int k = 0; k < 2; ++k) {
+ for(unsigned int k = 0; k < 2; ++k) {
GEdge *ge = gEdge[k];
SVector3 vectlb = ge->position(ge->getLowerBound());
SVector3 vectub = ge->position(ge->getUpperBound());
vectlb -= vectv;
vectub -= vectv;
double normlb, normub;
- if ((normlb = norm(vectlb)) > prec * (normub = norm(vectub)))
+ if((normlb = norm(vectlb)) > prec * (normub = norm(vectub)))
firstDer1 = -1. * ge->firstDer(ge->getUpperBound());
- else if (normub > prec * normlb)
+ else if(normub > prec * normlb)
firstDer1 = ge->firstDer(ge->getLowerBound());
else {
Msg::Error("[Recombine2D] Bad precision, returning pi/2");
return M_PI / 2.;
}
- if (k == 0)
- firstDer0 = firstDer1;
+ if(k == 0) firstDer0 = firstDer1;
}
firstDer0 = firstDer0 * (1. / norm(firstDer0));
@@ -1156,45 +1140,46 @@ double Recombine2D::_geomAngle(const MVertex *v,
double angle2 = 2. * M_PI - angle1;
double angleMesh = .0;
- for (unsigned int i = 0; i < elem.size(); ++i) {
+ for(unsigned int i = 0; i < elem.size(); ++i) {
MElement *el = elem[i];
int k = 0, numV = el->getNumVertices();
- while (el->getVertex(k) != v && k < numV) ++k;
- if (k == numV) {
+ while(el->getVertex(k) != v && k < numV) ++k;
+ if(k == numV) {
Msg::Error("[Recombine2D] Wrong element, returning pi/2");
return M_PI / 2.;
}
- if (el->getNumVertices() > 3)
- Msg::Warning("[Recombine2D] angle3Vertices() ok for triangle... but not for other");
- angleMesh += angle3Vertices(el->getVertex((k+numV-1) % numV), v,
- el->getVertex((k+1) % numV) );
+ if(el->getNumVertices() > 3)
+ Msg::Warning(
+ "[Recombine2D] angle3Vertices() ok for triangle... but not for other");
+ angleMesh += angle3Vertices(el->getVertex((k + numV - 1) % numV), v,
+ el->getVertex((k + 1) % numV));
}
- if (angleMesh < M_PI)
- return angle1;
+ if(angleMesh < M_PI) return angle1;
return angle2;
}
-
/** Rec2DData **/
/*****************/
-bool Rec2DData::gterAction::operator()(const Action *ra1, const Action *ra2) const
+bool Rec2DData::gterAction::operator()(const Action *ra1,
+ const Action *ra2) const
{
return *ra2->action < *ra1->action;
}
-bool Rec2DData::lessAction::operator()(const Action *ra1, const Action *ra2) const
+bool Rec2DData::lessAction::operator()(const Action *ra1,
+ const Action *ra2) const
{
return *ra1->action < *ra2->action;
}
void Rec2DData::Action::update()
{
- ((Rec2DAction*)action)->_dataAction = this;
+ ((Rec2DAction *)action)->_dataAction = this;
}
Rec2DData::Rec2DData()
{
- if (Rec2DData::_cur != NULL) {
+ if(Rec2DData::_cur != NULL) {
Msg::Error("[Rec2DData] An instance in execution");
return;
}
@@ -1206,86 +1191,69 @@ Rec2DData::Rec2DData()
Rec2DData::~Rec2DData()
{
- if (Rec2DData::_cur == this)
- Rec2DData::_cur = NULL;
+ if(Rec2DData::_cur == this) Rec2DData::_cur = NULL;
}
double Rec2DData::getValVert(Rec2DQualCrit crit)
{
- if (crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
+ if(crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
- switch (crit) {
- case BlossomQuality :
- return -1.;
+ switch(crit) {
+ case BlossomQuality: return -1.;
- case VertQuality :
- return static_cast<double>(_cur->_1valVert);
+ case VertQuality: return static_cast<double>(_cur->_1valVert);
- case VertEdgeQuality :
- return static_cast<double>(_cur->_2valVert);
+ case VertEdgeQuality: return static_cast<double>(_cur->_2valVert);
- default :
- Msg::Error("[Rec2DData:getValVert] Unknown quality criterion");
+ default: Msg::Error("[Rec2DData:getValVert] Unknown quality criterion");
}
return -1.;
}
void Rec2DData::elementChgAction(Rec2DElement *re, int from, int to)
{
- if (from == to) return;
+ if(from == to) return;
- if (to < 0 || to > 3) Msg::Error("[Rec2DData::elementChgAction] Wrong argument");
+ if(to < 0 || to > 3)
+ Msg::Error("[Rec2DData::elementChgAction] Wrong argument");
- switch (from) {
+ switch(from) {
case 0: break;
- case 1:
- _cur->_el_1Actions.rmv(re);
- break;
- case 2:
- _cur->_el_2Actions.rmv(re);
- break;
- case 3:
- _cur->_el_3Actions.rmv(re);
- break;
- default:
- Msg::Error("[Rec2DData::elementChgAction] Wrong argument");
- return;
+ case 1: _cur->_el_1Actions.rmv(re); break;
+ case 2: _cur->_el_2Actions.rmv(re); break;
+ case 3: _cur->_el_3Actions.rmv(re); break;
+ default: Msg::Error("[Rec2DData::elementChgAction] Wrong argument"); return;
}
- switch (to) {
- case 1:
- _cur->_el_1Actions.add(re);
- break;
- case 2:
- _cur->_el_2Actions.add(re);
- break;
- case 3:
- _cur->_el_3Actions.add(re);
- break;
+ switch(to) {
+ case 1: _cur->_el_1Actions.add(re); break;
+ case 2: _cur->_el_2Actions.add(re); break;
+ case 3: _cur->_el_3Actions.add(re); break;
}
}
void Rec2DData::add(const Rec2DEdge *re)
{
- if (re->_pos > -1) {
+ if(re->_pos > -1) {
Msg::Error("[Rec2DData] edge already there");
return;
}
- ((Rec2DEdge*)re)->_pos = _cur->_edges.size();
- _cur->_edges.push_back((Rec2DEdge*)re);
+ ((Rec2DEdge *)re)->_pos = _cur->_edges.size();
+ _cur->_edges.push_back((Rec2DEdge *)re);
_cur->_numEdge += re->getWeight();
- _cur->_2valEdge +=re->getWeightedQual();
+ _cur->_2valEdge += re->getWeightedQual();
}
void Rec2DData::add(const Rec2DVertex *rv)
{
- if (rv->_pos > -1) {
- Msg::Error("[Rec2DData] vert %d already there (size %d)", rv, _cur->_vertices.size());
+ if(rv->_pos > -1) {
+ Msg::Error("[Rec2DData] vert %d already there (size %d)", rv,
+ _cur->_vertices.size());
return;
}
- ((Rec2DVertex*)rv)->_pos = _cur->_vertices.size();
- _cur->_vertices.push_back((Rec2DVertex*)rv);
+ ((Rec2DVertex *)rv)->_pos = _cur->_vertices.size();
+ _cur->_vertices.push_back((Rec2DVertex *)rv);
++_cur->_numVert;
_cur->_1valVert += rv->getQual(VertQuality);
@@ -1294,47 +1262,47 @@ void Rec2DData::add(const Rec2DVertex *rv)
void Rec2DData::add(const Rec2DElement *rel)
{
- if (rel->_pos > -1) {
+ if(rel->_pos > -1) {
Msg::Error("[Rec2DData] elem already there");
return;
}
- ((Rec2DElement*)rel)->_pos = _cur->_elements.size();
- _cur->_elements.push_back((Rec2DElement*)rel);
- _cur->_mel2rel[rel->getMElement()] = (Rec2DElement*)rel;
+ ((Rec2DElement *)rel)->_pos = _cur->_elements.size();
+ _cur->_elements.push_back((Rec2DElement *)rel);
+ _cur->_mel2rel[rel->getMElement()] = (Rec2DElement *)rel;
-#if 1//def REC2D_DRAW
+#if 1 // def REC2D_DRAW
MTriangle *t = rel->getMTriangle();
MQuadrangle *q = rel->getMQuadrangle();
- if (t) _cur->_tri.push_back(t);
- if (q) _cur->_quad.push_back(q);
+ if(t) _cur->_tri.push_back(t);
+ if(q) _cur->_quad.push_back(q);
#endif
}
void Rec2DData::rmv(const Rec2DEdge *re)
{
- if (re->_pos < 0) {
+ if(re->_pos < 0) {
Msg::Error("[Rec2DData] edge not there");
return;
}
_cur->_edges.back()->_pos = re->_pos;
_cur->_edges[re->_pos] = _cur->_edges.back();
_cur->_edges.pop_back();
- ((Rec2DEdge*)re)->_pos = -1;
+ ((Rec2DEdge *)re)->_pos = -1;
_cur->_numEdge -= re->getWeight();
- _cur->_2valEdge -=re->getWeightedQual();
+ _cur->_2valEdge -= re->getWeightedQual();
}
void Rec2DData::rmv(const Rec2DVertex *rv)
{
- if (rv->_pos < 0) {
+ if(rv->_pos < 0) {
Msg::Error("[Rec2DData] vert not there");
return;
}
_cur->_vertices.back()->_pos = rv->_pos;
_cur->_vertices[rv->_pos] = _cur->_vertices.back();
_cur->_vertices.pop_back();
- ((Rec2DVertex*)rv)->_pos = -1;
+ ((Rec2DVertex *)rv)->_pos = -1;
--_cur->_numVert;
_cur->_1valVert -= rv->getQual(VertQuality);
@@ -1343,21 +1311,21 @@ void Rec2DData::rmv(const Rec2DVertex *rv)
void Rec2DData::rmv(const Rec2DElement *rel)
{
- if (rel->_pos < 0) {
+ if(rel->_pos < 0) {
Msg::Error("[Rec2DData] vert not there");
return;
}
_cur->_elements.back()->_pos = rel->_pos;
_cur->_elements[rel->_pos] = _cur->_elements.back();
_cur->_elements.pop_back();
- ((Rec2DElement*)rel)->_pos = -1;
+ ((Rec2DElement *)rel)->_pos = -1;
_cur->_mel2rel.erase(rel->getMElement());
-#if 1//def REC2D_DRAW
+#if 1 // def REC2D_DRAW
MTriangle *t = rel->getMTriangle();
- if (t) {
- for (unsigned int i = 0; i < _cur->_tri.size(); ++i) {
- if (_cur->_tri[i] == t) {
+ if(t) {
+ for(unsigned int i = 0; i < _cur->_tri.size(); ++i) {
+ if(_cur->_tri[i] == t) {
_cur->_tri[i] = _cur->_tri.back();
_cur->_tri.pop_back();
return;
@@ -1366,9 +1334,9 @@ void Rec2DData::rmv(const Rec2DElement *rel)
Msg::Warning("[Rec2DData] Didn't erased mtriangle :(");
}
MQuadrangle *q = rel->getMQuadrangle();
- if (q) {
- for (unsigned int i = 0; i < _cur->_quad.size(); ++i) {
- if (_cur->_quad[i] == q) {
+ if(q) {
+ for(unsigned int i = 0; i < _cur->_quad.size(); ++i) {
+ if(_cur->_quad[i] == q) {
_cur->_quad[i] = _cur->_quad.back();
delete _cur->_quad.back();
_cur->_quad.pop_back();
@@ -1382,40 +1350,36 @@ void Rec2DData::rmv(const Rec2DElement *rel)
void Rec2DData::add(const Rec2DAction *ra)
{
- if (ra->_dataAction) {
+ if(ra->_dataAction) {
Msg::Error("[Rec2DData] action already there");
ra->printIdentity();
return;
}
_cur->_actions.push_back(new Action(ra, _cur->_actions.size()));
- ((Rec2DAction*)ra)->_dataAction = _cur->_actions.back();
+ ((Rec2DAction *)ra)->_dataAction = _cur->_actions.back();
- _cur->_sortedActions.insert((Rec2DAction*)ra);
+ _cur->_sortedActions.insert((Rec2DAction *)ra);
}
void Rec2DData::rmv(const Rec2DAction *ra)
{
- if (!ra->_dataAction) {
+ if(!ra->_dataAction) {
Msg::Error("[Rec2DData] action not there");
return;
}
- std::swap(*((Action*)ra->_dataAction), *_cur->_actions.back());
- ((Rec2DAction*)ra)->_dataAction = NULL;
+ std::swap(*((Action *)ra->_dataAction), *_cur->_actions.back());
+ ((Rec2DAction *)ra)->_dataAction = NULL;
delete _cur->_actions.back();
_cur->_actions.pop_back();
- _cur->_sortedActions.erase((Rec2DAction*)ra);
+ _cur->_sortedActions.erase((Rec2DAction *)ra);
}
-bool Rec2DData::has(const Rec2DAction *ra)
-{
- return ra->_dataAction;
-}
+bool Rec2DData::has(const Rec2DAction *ra) { return ra->_dataAction; }
-Rec2DAction* Rec2DData::getBestAction()
+Rec2DAction *Rec2DData::getBestAction()
{
- if (_cur->_actions.size() == 0)
- return NULL;
+ if(_cur->_actions.size() == 0) return NULL;
/*Action *ac = *std::max_element(_cur->_actions.begin(),
_cur->_actions.end(), lessAction());
@@ -1423,61 +1387,58 @@ Rec2DAction* Rec2DData::getBestAction()
return *(_cur->_sortedActions.begin());
}
-Rec2DAction* Rec2DData::getRandomAction()
+Rec2DAction *Rec2DData::getRandomAction()
{
- if (_cur->_actions.size() == 0)
- return NULL;
+ if(_cur->_actions.size() == 0) return NULL;
int index = rand() % (int)_cur->_actions.size();
- return (Rec2DAction*)_cur->_actions[index]->action;
+ return (Rec2DAction *)_cur->_actions[index]->action;
}
void Rec2DData::checkObsolete()
{
- std::vector<Rec2DAction*> obsoletes;
- for (unsigned int i = 0; i < _cur->_actions.size(); ++i) {
- if (_cur->_actions[i]->action->isObsolete())
- obsoletes.push_back((Rec2DAction*)_cur->_actions[i]->action);
+ std::vector<Rec2DAction *> obsoletes;
+ for(unsigned int i = 0; i < _cur->_actions.size(); ++i) {
+ if(_cur->_actions[i]->action->isObsolete())
+ obsoletes.push_back((Rec2DAction *)_cur->_actions[i]->action);
}
- for (unsigned int i = 0; i < obsoletes.size(); ++i)
- delete obsoletes[i];
+ for(unsigned int i = 0; i < obsoletes.size(); ++i) delete obsoletes[i];
}
-Rec2DElement* Rec2DData::getBestLessAction()
+Rec2DElement *Rec2DData::getBestLessAction()
{
Msg::Fatal("[Rec2DData::getBestAction] Need definition");
return NULL;
}
-Rec2DElement* Rec2DData::getRandomLessAction()
+Rec2DElement *Rec2DData::getRandomLessAction()
{
Rec2DElement *re;
re = _cur->_el_1Actions.getRandom();
- if (re) return re;
+ if(re) return re;
re = _cur->_el_2Actions.getRandom();
- if (re) return re;
+ if(re) return re;
re = _cur->_el_3Actions.getRandom();
return re;
}
void Rec2DData::addHasZeroAction(const Rec2DElement *rel)
{
- std::pair<std::set<Rec2DElement*>::iterator, bool> rep;
- rep = _cur->_elementWithZeroAction.insert((Rec2DElement*)rel);
- if (!rep.second)
- Msg::Error("[Rec2DData] elementWithZeroAction already there");
+ std::pair<std::set<Rec2DElement *>::iterator, bool> rep;
+ rep = _cur->_elementWithZeroAction.insert((Rec2DElement *)rel);
+ if(!rep.second) Msg::Error("[Rec2DData] elementWithZeroAction already there");
}
void Rec2DData::rmvHasZeroAction(const Rec2DElement *rel)
{
- if (!_cur->_elementWithZeroAction.erase((Rec2DElement*)rel))
+ if(!_cur->_elementWithZeroAction.erase((Rec2DElement *)rel))
Msg::Error("[Rec2DData] elementWithZeroAction not there");
}
bool Rec2DData::hasHasZeroAction(const Rec2DElement *rel)
{
- return _cur->_elementWithZeroAction.find((Rec2DElement*)rel)
- != _cur->_elementWithZeroAction.end();
+ return _cur->_elementWithZeroAction.find((Rec2DElement *)rel) !=
+ _cur->_elementWithZeroAction.end();
}
int Rec2DData::getNumZeroAction()
@@ -1487,69 +1448,67 @@ int Rec2DData::getNumZeroAction()
void Rec2DData::addHasOneAction(const Rec2DElement *rel, Rec2DAction *ra)
{
- std::pair<std::set<Rec2DElement*>::iterator, bool> rep;
- rep = _cur->_elementWithOneAction.insert((Rec2DElement*)rel);
- if (!rep.second)
- Msg::Error("[Rec2DData] elementWithOneAction already there");
+ std::pair<std::set<Rec2DElement *>::iterator, bool> rep;
+ rep = _cur->_elementWithOneAction.insert((Rec2DElement *)rel);
+ if(!rep.second) Msg::Error("[Rec2DData] elementWithOneAction already there");
- std::pair<std::set<Rec2DAction*, gterRec2DAction>::iterator, bool> p;
+ std::pair<std::set<Rec2DAction *, gterRec2DAction>::iterator, bool> p;
p = _cur->_sortedOActions.insert(ra);
- if (p.second) _cur->_OActions.push_back(ra);
+ if(p.second) _cur->_OActions.push_back(ra);
}
void Rec2DData::rmvHasOneAction(const Rec2DElement *rel, Rec2DAction *ra)
{
- if (!_cur->_elementWithOneAction.erase((Rec2DElement*)rel))
+ if(!_cur->_elementWithOneAction.erase((Rec2DElement *)rel))
Msg::Error("[Rec2DData] elementWithOneAction not there");
Rec2DElement *el;
- if (ra->getElement(0) == rel) el = ra->getElement(1);
- else if (ra->getElement(1) == rel) el = ra->getElement(0);
+ if(ra->getElement(0) == rel)
+ el = ra->getElement(1);
+ else if(ra->getElement(1) == rel)
+ el = ra->getElement(0);
else {
Msg::Fatal("Does not work as expected");
return;
}
- if ((el->getNumActions() != 1 || el->getAction(0) != ra) &&
- !_cur->_sortedOActions.erase(ra))
+ if((el->getNumActions() != 1 || el->getAction(0) != ra) &&
+ !_cur->_sortedOActions.erase(ra))
Msg::Fatal("Does not work as expected 2");
}
bool Rec2DData::hasHasOneAction(const Rec2DElement *rel)
{
- return _cur->_elementWithOneAction.find((Rec2DElement*)rel)
- != _cur->_elementWithOneAction.end();
+ return _cur->_elementWithOneAction.find((Rec2DElement *)rel) !=
+ _cur->_elementWithOneAction.end();
}
-int Rec2DData::getNumOneAction()
-{
- return _cur->_elementWithOneAction.size();
-}
+int Rec2DData::getNumOneAction() { return _cur->_elementWithOneAction.size(); }
-Rec2DAction* Rec2DData::getOneAction()
+Rec2DAction *Rec2DData::getOneAction()
{
- if (_cur->_elementWithOneAction.size())
+ if(_cur->_elementWithOneAction.size())
return (*_cur->_elementWithOneAction.begin())->getAction(0);
return NULL;
}
-void Rec2DData::getElementsOneAction(std::vector<Rec2DElement*> &v)
+void Rec2DData::getElementsOneAction(std::vector<Rec2DElement *> &v)
{
v.clear();
- std::set<Rec2DElement*>::iterator it = _cur->_elementWithOneAction.begin();
- while (it != _cur->_elementWithOneAction.end()) {
+ std::set<Rec2DElement *>::iterator it = _cur->_elementWithOneAction.begin();
+ while(it != _cur->_elementWithOneAction.end()) {
v.push_back(*it);
++it;
}
}
-void Rec2DData::getUniqueOneActions(std::vector<Rec2DAction*> &vec)
+void Rec2DData::getUniqueOneActions(std::vector<Rec2DAction *> &vec)
{
- std::set<Rec2DElement*> elemWOA = _cur->_elementWithOneAction;
- std::set<Rec2DElement*>::iterator it = elemWOA.begin();
- std::vector<Rec2DAction*> *v;
+ std::set<Rec2DElement *> elemWOA = _cur->_elementWithOneAction;
+ std::set<Rec2DElement *>::iterator it = elemWOA.begin();
+ std::vector<Rec2DAction *> *v;
int minNum = 0;
- if (it != elemWOA.end()) {
+ if(it != elemWOA.end()) {
Rec2DAction *ra = (*it)->getAction(0);
Rec2DDataChange *dataChange = Rec2DData::getNewDataChange();
ra->apply(dataChange, v);
@@ -1558,19 +1517,19 @@ void Rec2DData::getUniqueOneActions(std::vector<Rec2DAction*> &vec)
vec.push_back(ra);
++it;
}
- while (it != elemWOA.end()) {
+ while(it != elemWOA.end()) {
Rec2DAction *ra = (*it)->getAction(0);
Rec2DDataChange *dataChange = Rec2DData::getNewDataChange();
ra->apply(dataChange, v);
- if (minNum > Rec2DData::getNumOneAction()) {
+ if(minNum > Rec2DData::getNumOneAction()) {
minNum = Rec2DData::getNumOneAction();
vec.clear();
vec.push_back(ra);
}
- else if (minNum == Rec2DData::getNumOneAction()) {
+ else if(minNum == Rec2DData::getNumOneAction()) {
unsigned int i = 0;
- while (i < vec.size() && vec[i] != ra) ++i;
- if (i == vec.size()) vec.push_back(ra);
+ while(i < vec.size() && vec[i] != ra) ++i;
+ if(i == vec.size()) vec.push_back(ra);
}
Rec2DData::revertDataChange(dataChange);
++it;
@@ -1579,69 +1538,68 @@ void Rec2DData::getUniqueOneActions(std::vector<Rec2DAction*> &vec)
int Rec2DData::getNewParity()
{
- if (_cur->_parities.empty())
- return 2;
- std::map<int, std::vector<Rec2DVertex*> >::iterator it;
+ if(_cur->_parities.empty()) return 2;
+ std::map<int, std::vector<Rec2DVertex *> >::iterator it;
it = _cur->_parities.end();
- return ((--it)->first/2)*2 + 2;
+ return ((--it)->first / 2) * 2 + 2;
}
void Rec2DData::removeParity(const Rec2DVertex *rv, int p)
{
- std::map<int, std::vector<Rec2DVertex*> >::iterator it;
- if ( (it = _cur->_parities.find(p)) == _cur->_parities.end() ) {
+ std::map<int, std::vector<Rec2DVertex *> >::iterator it;
+ if((it = _cur->_parities.find(p)) == _cur->_parities.end()) {
Msg::Error("[Rec2DData] Don't have parity %d", p);
return;
}
bool b = false;
- std::vector<Rec2DVertex*> *vect = &it->second;
+ std::vector<Rec2DVertex *> *vect = &it->second;
unsigned int i = 0;
- while (i < vect->size()) {
- if (vect->at(i) == rv) {
+ while(i < vect->size()) {
+ if(vect->at(i) == rv) {
vect->at(i) = vect->back();
vect->pop_back();
- if (b)
- Msg::Error("[Rec2DData] Two or more times same vertex");
+ if(b) Msg::Error("[Rec2DData] Two or more times same vertex");
b = true;
}
else
++i;
}
- if (!b)
+ if(!b)
Msg::Error("[Rec2DData] No vertex 1");
- else if (vect->empty())
+ else if(vect->empty())
_cur->_parities.erase(it);
}
void Rec2DData::associateParity(int pOld, int pNew, Rec2DDataChange *rdc)
{
- if (pOld/2 == pNew/2) {
+ if(pOld / 2 == pNew / 2) {
Msg::Error("[Rec2DData] Do you want to make a mess of parities ?");
return;
}
- if (_cur->_parities.find(pNew) == _cur->_parities.end()) {
+ if(_cur->_parities.find(pNew) == _cur->_parities.end()) {
Msg::Warning("[Rec2DData] That's strange, isn't it ?");
static int a = 0;
- if (++a == 10)
+ if(++a == 10)
Msg::Warning("[Rec2DData] AND LOOK AT ME WHEN I TALK TO YOU !");
}
- std::map<int, std::vector<Rec2DVertex*> >::iterator it;
- std::vector<Rec2DVertex*> *vect, *vectNew;
+ std::map<int, std::vector<Rec2DVertex *> >::iterator it;
+ std::vector<Rec2DVertex *> *vect, *vectNew;
{
it = _cur->_parities.find(pOld);
- if (it == _cur->_parities.end()) {
+ if(it == _cur->_parities.end()) {
static int a = 0;
- if (++a == 1)
- Msg::Error("[Rec2DData] You are mistaken, I'll never talk to you again !");
+ if(++a == 1)
+ Msg::Error(
+ "[Rec2DData] You are mistaken, I'll never talk to you again !");
return;
}
vect = &it->second;
- if (rdc) {
+ if(rdc) {
rdc->saveParity(*vect);
- //rdc->checkObsoleteActions(_vertices, 4);
+ // rdc->checkObsoleteActions(_vertices, 4);
}
- for (unsigned int i = 0; i < vect->size(); ++i)
+ for(unsigned int i = 0; i < vect->size(); ++i)
(*vect)[i]->setParityWD(pOld, pNew);
rdc->checkObsoleteActions(&(*vect)[0], vect->size());
vectNew = &_cur->_parities[pNew];
@@ -1653,14 +1611,13 @@ void Rec2DData::associateParity(int pOld, int pNew, Rec2DDataChange *rdc)
pNew = otherParity(pNew);
{
it = _cur->_parities.find(pOld);
- if (it == _cur->_parities.end()) {
+ if(it == _cur->_parities.end()) {
Msg::Error("[Rec2DData] What ?");
return;
}
vect = &it->second;
- if (rdc)
- rdc->saveParity(*vect);
- for (unsigned int i = 0; i < vect->size(); ++i)
+ if(rdc) rdc->saveParity(*vect);
+ for(unsigned int i = 0; i < vect->size(); ++i)
(*vect)[i]->setParityWD(pOld, pNew);
rdc->checkObsoleteActions(&(*vect)[0], vect->size());
vectNew = &_cur->_parities[pNew];
@@ -1669,7 +1626,7 @@ void Rec2DData::associateParity(int pOld, int pNew, Rec2DDataChange *rdc)
}
}
-Rec2DDataChange* Rec2DData::getNewDataChange()
+Rec2DDataChange *Rec2DData::getNewDataChange()
{
_cur->_changes.push_back(new Rec2DDataChange());
return _cur->_changes.back();
@@ -1677,8 +1634,7 @@ Rec2DDataChange* Rec2DData::getNewDataChange()
bool Rec2DData::revertDataChange(Rec2DDataChange *rdc)
{
- if (_cur->_changes.back() != rdc)
- return false;
+ if(_cur->_changes.back() != rdc) return false;
_cur->_changes.pop_back();
rdc->revert();
delete rdc;
@@ -1687,7 +1643,7 @@ bool Rec2DData::revertDataChange(Rec2DDataChange *rdc)
void Rec2DData::clearChanges()
{
- for (int i = (int) _cur->_changes.size() - 1; i > -1; --i) {
+ for(int i = (int)_cur->_changes.size() - 1; i > -1; --i) {
_cur->_changes[i]->revert();
delete _cur->_changes[i];
}
@@ -1697,61 +1653,54 @@ void Rec2DData::clearChanges()
double Rec2DData::getGlobalQuality(Rec2DQualCrit crit)
{
- if (crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
+ if(crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
switch(crit) {
- case BlossomQuality :
- return _cur->_0blossomQuality;
+ case BlossomQuality: return _cur->_0blossomQuality;
- case VertQuality :
- return static_cast<double>(_cur->_1valVert) / _cur->_numVert;
+ case VertQuality:
+ return static_cast<double>(_cur->_1valVert) / _cur->_numVert;
- case VertEdgeQuality :
- return static_cast<double>(_cur->_2valVert) / _cur->_numVert
- *static_cast<double>(_cur->_2valEdge) / _cur->_numEdge;
+ case VertEdgeQuality:
+ return static_cast<double>(_cur->_2valVert) / _cur->_numVert *
+ static_cast<double>(_cur->_2valEdge) / _cur->_numEdge;
- default :
- Msg::Error("[Rec2DData:getGlobalQuality] Unknown quality criterion");
+ default: Msg::Error("[Rec2DData:getGlobalQuality] Unknown quality criterion");
}
return -1.;
}
-double Rec2DData::getGlobalQuality(int numVert, double valVert,
- int numEdge, double valEdge,
- Rec2DQualCrit crit )
+double Rec2DData::getGlobalQuality(int numVert, double valVert, int numEdge,
+ double valEdge, Rec2DQualCrit crit)
{
- if (crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
+ if(crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
- switch (crit) {
- case BlossomQuality :
- return _cur->_0blossomQuality;
+ switch(crit) {
+ case BlossomQuality: return _cur->_0blossomQuality;
- case VertQuality :
- return (static_cast<double>(_cur->_1valVert) + valVert) / (_cur->_numVert + numVert);
+ case VertQuality:
+ return (static_cast<double>(_cur->_1valVert) + valVert) /
+ (_cur->_numVert + numVert);
- case VertEdgeQuality :
- return (static_cast<double>(_cur->_2valVert) + valVert) / (_cur->_numVert + numVert)
- *(static_cast<double>(_cur->_2valEdge) + valEdge) / (_cur->_numEdge + numEdge);
+ case VertEdgeQuality:
+ return (static_cast<double>(_cur->_2valVert) + valVert) /
+ (_cur->_numVert + numVert) *
+ (static_cast<double>(_cur->_2valEdge) + valEdge) /
+ (_cur->_numEdge + numEdge);
- default :
- Msg::Error("[Rec2DData:getGlobalQuality] Unknown quality criterion");
+ default: Msg::Error("[Rec2DData:getGlobalQuality] Unknown quality criterion");
}
return -1.;
}
void Rec2DData::updateVertQual(double val, Rec2DQualCrit crit)
{
- switch (crit) {
- case VertQuality :
- _cur->_1valVert += val;
- return;
+ switch(crit) {
+ case VertQuality: _cur->_1valVert += val; return;
- case VertEdgeQuality :
- _cur->_2valVert += val;
- return;
+ case VertEdgeQuality: _cur->_2valVert += val; return;
- default :
- Msg::Error("[Rec2DData:updateVertQual] Unknown quality criterion");
+ default: Msg::Error("[Rec2DData:updateVertQual] Unknown quality criterion");
}
}
@@ -1790,39 +1739,39 @@ bool Rec2DData::checkEntities()
Msg::Error("Need redefinition");
__crash();
iter_rv itv;
- for (itv = firstVertex(); itv != lastVertex(); ++itv) {
- if (!(*itv)->checkCoherence()) {
+ for(itv = firstVertex(); itv != lastVertex(); ++itv) {
+ if(!(*itv)->checkCoherence()) {
Msg::Error("Incoherence vertex");
//__crash();
return false;
}
- if (!(*itv)->checkQuality()) {
+ if(!(*itv)->checkQuality()) {
Msg::Error("Wrong qualities vertex");
//__crash();
return false;
}
}
iter_re ite;
- for (ite = firstEdge(); ite != lastEdge(); ++ite) {
- if (!(*ite)->checkCoherence()) {
+ for(ite = firstEdge(); ite != lastEdge(); ++ite) {
+ if(!(*ite)->checkCoherence()) {
Msg::Error("Incoherence edge");
//__crash();
return false;
}
}
iter_rel itel;
- for (itel = firstElement(); itel != lastElement(); ++itel) {
- if (!(*itel)->checkCoherence()) {
+ for(itel = firstElement(); itel != lastElement(); ++itel) {
+ if(!(*itel)->checkCoherence()) {
Msg::Error("Incoherence element");
//__crash();
return false;
}
}
- if (Recombine2D::onlyRecombinations()) {
- std::set<Rec2DElement*>::iterator it = _cur->_elementWithOneAction.begin();
- while (it != _cur->_elementWithOneAction.end()) {
- if ((*it)->getNumActions() != 1) {
+ if(Recombine2D::onlyRecombinations()) {
+ std::set<Rec2DElement *>::iterator it = _cur->_elementWithOneAction.begin();
+ while(it != _cur->_elementWithOneAction.end()) {
+ if((*it)->getNumActions() != 1) {
Msg::Error("Incoherence element with one action");
//__crash();
return false;
@@ -1830,8 +1779,8 @@ bool Rec2DData::checkEntities()
++it;
}
it = _cur->_elementWithZeroAction.begin();
- while (it != _cur->_elementWithZeroAction.end()) {
- if ((*it)->getNumActions() != 0) {
+ while(it != _cur->_elementWithZeroAction.end()) {
+ if((*it)->getNumActions() != 0) {
Msg::Error("Incoherence element with zero action");
//__crash();
return false;
@@ -1839,23 +1788,22 @@ bool Rec2DData::checkEntities()
++it;
}
}
- for (unsigned int i = 0; i < _cur->_actions.size(); ++i) {
- if (_cur->_actions[i]->position != i ||
- _cur->_actions[i]->action->getDataAction() != _cur->_actions[i]) {
+ for(unsigned int i = 0; i < _cur->_actions.size(); ++i) {
+ if(_cur->_actions[i]->position != i ||
+ _cur->_actions[i]->action->getDataAction() != _cur->_actions[i]) {
Msg::Error("Wrong link Action <-> Rec2DAction");
//__crash();
- //return false;
+ // return false;
}
- if (!_cur->_actions[i]->action->checkCoherence()) {
+ if(!_cur->_actions[i]->action->checkCoherence()) {
_cur->printState();
#ifdef REC2D_DRAW
double time = Cpu();
- while (Cpu()-time < REC2D_WAIT_TM_2)
- FlGui::instance()->check();
+ while(Cpu() - time < REC2D_WAIT_TM_2) FlGui::instance()->check();
#endif
Msg::Error("Incoherence action");
//__crash();
- //return false;
+ // return false;
}
}
return true;
@@ -1868,20 +1816,24 @@ void Rec2DData::checkQuality() const
iter_re ite;
long double valEdge = .0;
int numEdge = 0;
- for (ite = firstEdge(); ite != lastEdge(); ++ite) {
+ for(ite = firstEdge(); ite != lastEdge(); ++ite) {
valEdge += (long double)(*ite)->getWeightedQual();
numEdge += (*ite)->getWeight();
}
iter_rv itv;
long double valVert = .0;
int numVert = 0;
- for (itv = firstVertex(); itv != lastVertex(); ++itv) {
+ for(itv = firstVertex(); itv != lastVertex(); ++itv) {
valVert += (long double)(*itv)->getQual();
numVert += 2;
}
- if (fabs(valVert - _2valVert) > 1e-14 || fabs(valEdge - _2valEdge) > 1e-14) {
- Msg::Error("Vert : %g >< %g (%g), %d >< %d", (double)valVert, (double)_2valVert, (double)(valVert-_2valVert), numVert, _numVert);
- Msg::Error("Edge : %g >< %g (%g), %d >< %d", (double)valEdge, (double)_2valEdge, (double)(valEdge-_2valEdge), numEdge, _numEdge);
+ if(fabs(valVert - _2valVert) > 1e-14 || fabs(valEdge - _2valEdge) > 1e-14) {
+ Msg::Error("Vert : %g >< %g (%g), %d >< %d", (double)valVert,
+ (double)_2valVert, (double)(valVert - _2valVert), numVert,
+ _numVert);
+ Msg::Error("Edge : %g >< %g (%g), %d >< %d", (double)valEdge,
+ (double)_2valEdge, (double)(valEdge - _2valEdge), numEdge,
+ _numEdge);
}
}
@@ -1890,57 +1842,56 @@ void Rec2DData::printState() const
Msg::Info(" ");
Msg::Info("State");
Msg::Info("-----");
- Msg::Info("numEdge %d (%d), valEdge %g => %g", _numEdge, _edges.size(), (double)_2valEdge, (double)_2valEdge/(double)_numEdge);
- Msg::Info("numVert %d (%d), valVert %g => %g", _numVert, _vertices.size(), (double)_2valVert, (double)_2valVert/(double)_numVert);
+ Msg::Info("numEdge %d (%d), valEdge %g => %g", _numEdge, _edges.size(),
+ (double)_2valEdge, (double)_2valEdge / (double)_numEdge);
+ Msg::Info("numVert %d (%d), valVert %g => %g", _numVert, _vertices.size(),
+ (double)_2valVert, (double)_2valVert / (double)_numVert);
Msg::Info("Element (%d)", _elements.size());
Msg::Info("global Value %g", Rec2DData::getGlobalQuality());
Msg::Info("num action %d", _actions.size());
- std::map<int, std::vector<Rec2DVertex*> >::const_iterator it = _parities.begin();
- for (; it != _parities.end(); ++it) {
+ std::map<int, std::vector<Rec2DVertex *> >::const_iterator it =
+ _parities.begin();
+ for(; it != _parities.end(); ++it) {
Msg::Info("par %d, #%d", it->first, it->second.size());
}
Msg::Info(" ");
iter_re ite;
long double valEdge = .0;
int numEdge = 0;
- for (ite = firstEdge(); ite != lastEdge(); ++ite) {
+ for(ite = firstEdge(); ite != lastEdge(); ++ite) {
valEdge += (long double)(*ite)->getWeightedQual();
numEdge += (*ite)->getWeight();
}
Msg::Info("valEdge : %g >< %g, numEdge %d >< %d (real><data)",
- (double)valEdge, (double)_2valEdge,
- numEdge, _numEdge);
+ (double)valEdge, (double)_2valEdge, numEdge, _numEdge);
iter_rv itv;
long double valVert = .0;
int numVert = 0;
- for (itv = firstVertex(); itv != lastVertex(); ++itv) {
+ for(itv = firstVertex(); itv != lastVertex(); ++itv) {
valVert += (long double)(*itv)->getQual(VertEdgeQuality);
- if ((*itv)->getParity() == -1 || (*itv)->getParity() == 1)
+ if((*itv)->getParity() == -1 || (*itv)->getParity() == 1)
Msg::Error("parity %d, I'm very angry", (*itv)->getParity());
++numVert;
}
Msg::Info("valVert : %g >< %g, numVert %d >< %d (real><data)",
- (double)valVert, (double)_2valVert,
- numVert, _numVert);
+ (double)valVert, (double)_2valVert, numVert, _numVert);
Msg::Info("----- (end)");
}
void Rec2DData::printActions() const
{
std::map<int, std::vector<double> > data;
- for (unsigned int i = 0; i < _actions.size(); ++i) {
- std::vector<Rec2DElement*> tri;
+ for(unsigned int i = 0; i < _actions.size(); ++i) {
+ std::vector<Rec2DElement *> tri;
_actions[i]->action->getElements(tri);
- Msg::Info("action %d (%d, %d) -> reward %g",
- _actions[i]->action,
- tri[0]->getNum(),
- tri[1]->getNum(),
- ((Rec2DAction*)_actions[i]->action)->getReward());
- //Msg::Info("action %d -> reward %g", *it, _actions[i]->getReward());
+ Msg::Info("action %d (%d, %d) -> reward %g", _actions[i]->action,
+ tri[0]->getNum(), tri[1]->getNum(),
+ ((Rec2DAction *)_actions[i]->action)->getReward());
+ // Msg::Info("action %d -> reward %g", *it, _actions[i]->getReward());
data[tri[0]->getNum()].resize(1);
data[tri[1]->getNum()].resize(1);
- //data[tri[0]->getNum()][0] = (*it)->getReward();
- //data[tri[1]->getNum()][0] = (*it)->getReward();
+ // data[tri[0]->getNum()][0] = (*it)->getReward();
+ // data[tri[1]->getNum()][0] = (*it)->getReward();
//(*it)->print();
}
#ifdef HAVE_FLTK
@@ -1952,30 +1903,28 @@ void Rec2DData::printActions() const
void Rec2DData::drawTriangles(double shiftx, double shifty) const
{
iter_rel it = firstElement();
- for (; it != lastElement(); ++it) {
- if ((*it)->isTri())
- (*it)->createElement(shiftx, shifty);
+ for(; it != lastElement(); ++it) {
+ if((*it)->isTri()) (*it)->createElement(shiftx, shifty);
}
}
void Rec2DData::drawElements(double shiftx, double shifty) const
{
iter_rel it = firstElement();
- for (; it != lastElement(); ++it)
- (*it)->createElement(shiftx, shifty);
+ for(; it != lastElement(); ++it) (*it)->createElement(shiftx, shifty);
}
void Rec2DData::drawChanges(double shiftx, double shifty, bool color) const
{
std::map<int, std::vector<double> > data;
int k = 0;
- for (unsigned int i = 0; i < _changes.size(); ++i) {
- if (_changes[i]->getAction()->haveElem()) {
+ for(unsigned int i = 0; i < _changes.size(); ++i) {
+ if(_changes[i]->getAction()->haveElem()) {
MElement *el = _changes[i]->getAction()->createMElement(shiftx, shifty);
- if (color)
+ if(color)
Recombine2D::colorFromBlossom(_changes[i]->getAction()->getElement(0),
_changes[i]->getAction()->getElement(1),
- el );
+ el);
data[el->getNum()].push_back(++k);
}
}
@@ -1987,37 +1936,35 @@ void Rec2DData::drawChanges(double shiftx, double shifty, bool color) const
void Rec2DData::addEndNode(const Rec2DNode *rn)
{
static int k = 0;
- if (_cur->_endNodes.size() > 9999) {
+ if(_cur->_endNodes.size() > 9999) {
Msg::Info("%d", ++k);
sortEndNode();
int newLast = 4999;
- for (unsigned int i = newLast + 1; i < 10000; ++i) {
- if (_cur->_endNodes[i]->canBeDeleted())
+ for(unsigned int i = newLast + 1; i < 10000; ++i) {
+ if(_cur->_endNodes[i]->canBeDeleted())
delete _cur->_endNodes[i];
else
_cur->_endNodes[++newLast] = _cur->_endNodes[i];
}
_cur->_endNodes.resize(newLast + 1);
}
- _cur->_endNodes.push_back((Rec2DNode*)rn);
+ _cur->_endNodes.push_back((Rec2DNode *)rn);
}
void Rec2DData::sortEndNode()
{
- std::sort(_cur->_endNodes.begin(),
- _cur->_endNodes.end(),
- gterRec2DNode());
+ std::sort(_cur->_endNodes.begin(), _cur->_endNodes.end(), gterRec2DNode());
}
void Rec2DData::drawEndNode(int num)
{
double dx = .0, dy = .0;
- for (int i = 0; i < num && i < (int)_cur->_endNodes.size(); ++i) {
+ for(int i = 0; i < num && i < (int)_cur->_endNodes.size(); ++i) {
std::map<int, std::vector<double> > data;
Rec2DNode *currentNode = _cur->_endNodes[i];
- //Msg::Info("%d -> %g", i+1, currentNode->getGlobQual());
- //int k = 0;
- if ( !((i+1) % ((int)std::sqrt(num)+1)) ) {
+ // Msg::Info("%d -> %g", i+1, currentNode->getGlobQual());
+ // int k = 0;
+ if(!((i + 1) % ((int)std::sqrt(num) + 1))) {
dx = .0;
dy -= 1.2;
}
@@ -2033,16 +1980,17 @@ void Rec2DData::drawEndNode(int num)
currentNode = currentNode->getFather();
}*/
#ifdef HAVE_FLTK
- //new PView("Jmin_bad", "ElementData", Recombine2D::getGFace()->model(), data);
+ // new PView("Jmin_bad", "ElementData", Recombine2D::getGFace()->model(),
+ // data);
#endif
}
}
-Rec2DElement* Rec2DData::getRElement(MElement *mel)
+Rec2DElement *Rec2DData::getRElement(MElement *mel)
{
- std::map<MElement*, Rec2DElement*>::iterator it;
+ std::map<MElement *, Rec2DElement *>::iterator it;
it = _cur->_mel2rel.find(mel);
- if (it == _cur->_mel2rel.end()) return NULL;
+ if(it == _cur->_mel2rel.end()) return NULL;
return it->second;
}
@@ -2057,7 +2005,7 @@ Rec2DChange::Rec2DChange(int a) : _info(NULL)
Rec2DChange::Rec2DChange(Rec2DEdge *re, bool toHide) : _entity(re), _info(NULL)
{
- if (toHide) {
+ if(toHide) {
re->hide();
_type = HideEdge;
}
@@ -2065,9 +2013,10 @@ Rec2DChange::Rec2DChange(Rec2DEdge *re, bool toHide) : _entity(re), _info(NULL)
_type = CreatedEdge;
}
-Rec2DChange::Rec2DChange(Rec2DVertex *rv, bool toHide) : _entity(rv), _info(NULL)
+Rec2DChange::Rec2DChange(Rec2DVertex *rv, bool toHide)
+ : _entity(rv), _info(NULL)
{
- if (toHide) {
+ if(toHide) {
rv->hide();
_type = HideVertex;
}
@@ -2075,9 +2024,10 @@ Rec2DChange::Rec2DChange(Rec2DVertex *rv, bool toHide) : _entity(rv), _info(NULL
_type = CreatedVertex;
}
-Rec2DChange::Rec2DChange(Rec2DElement *rel, bool toHide) : _entity(rel), _info(NULL)
+Rec2DChange::Rec2DChange(Rec2DElement *rel, bool toHide)
+ : _entity(rel), _info(NULL)
{
- if (toHide) {
+ if(toHide) {
rel->hide();
_type = HideElement;
}
@@ -2085,27 +2035,28 @@ Rec2DChange::Rec2DChange(Rec2DElement *rel, bool toHide) : _entity(rel), _info(N
_type = CreatedElement;
}
-Rec2DChange::Rec2DChange(Rec2DAction *ra, bool toHide) : _entity(ra), _info(NULL)
+Rec2DChange::Rec2DChange(Rec2DAction *ra, bool toHide)
+ : _entity(ra), _info(NULL)
{
- if (toHide) {
+ if(toHide) {
ra->hide();
_type = HideAction;
}
else {
static int a = 0;
- if (++a == 1) Msg::Warning("FIXME peut pas faire sans pointing ?");
+ if(++a == 1) Msg::Warning("FIXME peut pas faire sans pointing ?");
_type = CreatedAction;
}
}
-Rec2DChange::Rec2DChange(const std::vector<Rec2DAction*> &actions, bool toHide) : _info(NULL)
+Rec2DChange::Rec2DChange(const std::vector<Rec2DAction *> &actions, bool toHide)
+ : _info(NULL)
{
- std::vector<Rec2DAction*> *vect = new std::vector<Rec2DAction*>();
+ std::vector<Rec2DAction *> *vect = new std::vector<Rec2DAction *>();
*vect = actions;
_entity = vect;
- if (toHide) {
- for (unsigned int i = 0; i < actions.size(); ++i)
- actions[i]->hide();
+ if(toHide) {
+ for(unsigned int i = 0; i < actions.size(); ++i) actions[i]->hide();
_type = HideActions;
}
else
@@ -2114,7 +2065,7 @@ Rec2DChange::Rec2DChange(const std::vector<Rec2DAction*> &actions, bool toHide)
Rec2DChange::Rec2DChange(Rec2DVertex *rv, int newPar, Rec2DChangeType type)
{
- if (type == ChangePar) {
+ if(type == ChangePar) {
_type = ChangePar;
_entity = rv;
int *oldPar = new int;
@@ -2127,17 +2078,17 @@ Rec2DChange::Rec2DChange(Rec2DVertex *rv, int newPar, Rec2DChangeType type)
_entity = _info = NULL;
}
-Rec2DChange::Rec2DChange(const std::vector<Rec2DVertex*> &verts,
- Rec2DChangeType type )
+Rec2DChange::Rec2DChange(const std::vector<Rec2DVertex *> &verts,
+ Rec2DChangeType type)
{
- if (type == SavePar) {
+ if(type == SavePar) {
_type = SavePar;
- std::vector<Rec2DVertex*> *vect = new std::vector<Rec2DVertex*>();
+ std::vector<Rec2DVertex *> *vect = new std::vector<Rec2DVertex *>();
*vect = verts;
_entity = vect;
std::vector<int> *parities = new std::vector<int>(verts.size());
_info = parities;
- for (unsigned int i = 0; i < verts.size(); ++i)
+ for(unsigned int i = 0; i < verts.size(); ++i)
(*parities)[i] = verts[i]->getParity();
return;
}
@@ -2146,7 +2097,7 @@ Rec2DChange::Rec2DChange(const std::vector<Rec2DVertex*> &verts,
}
Rec2DChange::Rec2DChange(Rec2DVertex *rv, SPoint2 newCoord)
-: _type(Relocate), _entity(rv)
+ : _type(Relocate), _entity(rv)
{
SPoint2 *oldCoord = new SPoint2();
rv->getParam(oldCoord);
@@ -2155,47 +2106,44 @@ Rec2DChange::Rec2DChange(Rec2DVertex *rv, SPoint2 newCoord)
}
Rec2DChange::Rec2DChange(Rec2DVertex *rv,
- const std::vector<Rec2DElement*> &elem,
- Rec2DChangeType type )
+ const std::vector<Rec2DElement *> &elem,
+ Rec2DChangeType type)
{
- std::vector<Rec2DElement*> *vect = new std::vector<Rec2DElement*>();
+ std::vector<Rec2DElement *> *vect = new std::vector<Rec2DElement *>();
_type = type;
_entity = rv;
_info = vect;
- switch (type) {
- case AddElem :
- *vect = elem;
- for (unsigned int i = 0; i < elem.size(); ++i)
- rv->add(elem[i]);
- break;
+ switch(type) {
+ case AddElem:
+ *vect = elem;
+ for(unsigned int i = 0; i < elem.size(); ++i) rv->add(elem[i]);
+ break;
- case RemoveElem :
- *vect = elem;
- for (int i = (int)elem.size()-1; i > -1; --i)
- rv->rmv(elem[i]);
- break;
+ case RemoveElem:
+ *vect = elem;
+ for(int i = (int)elem.size() - 1; i > -1; --i) rv->rmv(elem[i]);
+ break;
- default :
- delete vect;
- _type = Error;
- _entity = _info = NULL;
+ default:
+ delete vect;
+ _type = Error;
+ _entity = _info = NULL;
}
}
Rec2DChange::Rec2DChange(Rec2DVertex *rv0, Rec2DVertex *rv1,
- const std::vector<Rec2DEdge*> &edges,
- Rec2DChangeType type )
+ const std::vector<Rec2DEdge *> &edges,
+ Rec2DChangeType type)
{
- if (type == SwapVertInEdge) {
+ if(type == SwapVertInEdge) {
_type = type;
- std::vector<Rec2DEdge*> *vect = new std::vector<Rec2DEdge*>();
+ std::vector<Rec2DEdge *> *vect = new std::vector<Rec2DEdge *>();
*vect = edges;
_entity = vect;
- std::pair<Rec2DVertex*, Rec2DVertex*> *pairVert;
- pairVert = new std::pair<Rec2DVertex*, Rec2DVertex*>(rv1, rv0);
+ std::pair<Rec2DVertex *, Rec2DVertex *> *pairVert;
+ pairVert = new std::pair<Rec2DVertex *, Rec2DVertex *>(rv1, rv0);
_info = pairVert;
- for (unsigned int i = 0; i < edges.size(); ++i)
- edges[i]->swap(rv0, rv1);
+ for(unsigned int i = 0; i < edges.size(); ++i) edges[i]->swap(rv0, rv1);
return;
}
_type = Error;
@@ -2203,19 +2151,18 @@ Rec2DChange::Rec2DChange(Rec2DVertex *rv0, Rec2DVertex *rv1,
}
Rec2DChange::Rec2DChange(Rec2DVertex *rv0, Rec2DVertex *rv1,
- const std::vector<Rec2DAction*> &actions,
- Rec2DChangeType type )
+ const std::vector<Rec2DAction *> &actions,
+ Rec2DChangeType type)
{
- if (type == SwapVertInAction) {
+ if(type == SwapVertInAction) {
_type = type;
- std::vector<Rec2DAction*> *vect = new std::vector<Rec2DAction*>();
+ std::vector<Rec2DAction *> *vect = new std::vector<Rec2DAction *>();
*vect = actions;
_entity = vect;
- std::pair<Rec2DVertex*, Rec2DVertex*> *pairVert;
- pairVert = new std::pair<Rec2DVertex*, Rec2DVertex*>(rv1, rv0);
+ std::pair<Rec2DVertex *, Rec2DVertex *> *pairVert;
+ pairVert = new std::pair<Rec2DVertex *, Rec2DVertex *>(rv1, rv0);
_info = pairVert;
- for (unsigned int i = 0; i < actions.size(); ++i)
- actions[i]->swap(rv0, rv1);
+ for(unsigned int i = 0; i < actions.size(); ++i) actions[i]->swap(rv0, rv1);
return;
}
_type = Error;
@@ -2223,18 +2170,18 @@ Rec2DChange::Rec2DChange(Rec2DVertex *rv0, Rec2DVertex *rv1,
}
Rec2DChange::Rec2DChange(Rec2DVertex *rv0, Rec2DVertex *rv1,
- const std::vector<Rec2DElement*> &elem,
- Rec2DChangeType type )
+ const std::vector<Rec2DElement *> &elem,
+ Rec2DChangeType type)
{
- if (type == SwapMVertInElement) {
+ if(type == SwapMVertInElement) {
_type = type;
- std::vector<Rec2DElement*> *vect = new std::vector<Rec2DElement*>();
+ std::vector<Rec2DElement *> *vect = new std::vector<Rec2DElement *>();
*vect = elem;
_entity = vect;
- std::pair<Rec2DVertex*, Rec2DVertex*> *pairVert;
- pairVert = new std::pair<Rec2DVertex*, Rec2DVertex*>(rv1, rv0);
+ std::pair<Rec2DVertex *, Rec2DVertex *> *pairVert;
+ pairVert = new std::pair<Rec2DVertex *, Rec2DVertex *>(rv1, rv0);
_info = pairVert;
- for (unsigned int i = 0; i < elem.size(); ++i)
+ for(unsigned int i = 0; i < elem.size(); ++i)
elem[i]->swapMVertex(rv0, rv1);
return;
}
@@ -2243,40 +2190,38 @@ Rec2DChange::Rec2DChange(Rec2DVertex *rv0, Rec2DVertex *rv1,
}
Rec2DChange::Rec2DChange(Rec2DEdge *re0, Rec2DEdge *re1,
- const std::vector<Rec2DAction*> &actions,
- Rec2DChangeType type )
+ const std::vector<Rec2DAction *> &actions,
+ Rec2DChangeType type)
{
- if (type == SwapEdgeInAction) {
+ if(type == SwapEdgeInAction) {
_type = type;
- std::vector<Rec2DAction*> *vect = new std::vector<Rec2DAction*>();
+ std::vector<Rec2DAction *> *vect = new std::vector<Rec2DAction *>();
*vect = actions;
_entity = vect;
- std::pair<Rec2DEdge*, Rec2DEdge*> *pairVert;
- pairVert = new std::pair<Rec2DEdge*, Rec2DEdge*>(re1, re0);
+ std::pair<Rec2DEdge *, Rec2DEdge *> *pairVert;
+ pairVert = new std::pair<Rec2DEdge *, Rec2DEdge *>(re1, re0);
_info = pairVert;
- for (unsigned int i = 0; i < actions.size(); ++i)
- actions[i]->swap(re0, re1);
+ for(unsigned int i = 0; i < actions.size(); ++i) actions[i]->swap(re0, re1);
return;
}
_type = Error;
_entity = _info = NULL;
}
-Rec2DChange::Rec2DChange(Rec2DEdge *re0, Rec2DEdge *re1,
- Rec2DChangeType type )
+Rec2DChange::Rec2DChange(Rec2DEdge *re0, Rec2DEdge *re1, Rec2DChangeType type)
{
- if (type == SwapEdgeInElem) {
+ if(type == SwapEdgeInElem) {
_type = type;
Rec2DElement *rel = Rec2DEdge::getTheOnlyElement(re0);
- if (!rel) {
+ if(!rel) {
Msg::Error("[Rec2DDataChange] invalid swapping edges");
_type = Error;
_entity = _info = NULL;
return;
}
_entity = rel;
- std::pair<Rec2DEdge*, Rec2DEdge*> *pairEdge;
- pairEdge = new std::pair<Rec2DEdge*, Rec2DEdge*>(re1, re0);
+ std::pair<Rec2DEdge *, Rec2DEdge *> *pairEdge;
+ pairEdge = new std::pair<Rec2DEdge *, Rec2DEdge *>(re1, re0);
_info = pairEdge;
rel->swap(re0, re1);
return;
@@ -2285,208 +2230,159 @@ Rec2DChange::Rec2DChange(Rec2DEdge *re0, Rec2DEdge *re1,
_entity = _info = NULL;
}
-void Rec2DChange::getHiddenActions(std::set<Rec2DAction*> &set)
+void Rec2DChange::getHiddenActions(std::set<Rec2DAction *> &set)
{
- switch (_type) {
- case HideAction :
- set.insert((Rec2DAction*)_entity);
- return;
+ switch(_type) {
+ case HideAction: set.insert((Rec2DAction *)_entity); return;
- case HideActions :
- set.insert(((std::vector<Rec2DAction*>*)_entity)->begin(),
- ((std::vector<Rec2DAction*>*)_entity)->end());
- return;
+ case HideActions:
+ set.insert(((std::vector<Rec2DAction *> *)_entity)->begin(),
+ ((std::vector<Rec2DAction *> *)_entity)->end());
+ return;
- default :
- return;
+ default: return;
}
}
void Rec2DChange::revert()
{
- switch (_type) {
- case ValQuad :
- Rec2DData::addBlosQual(-*(int*)_entity);
- delete (int*)_entity;
- break;
-
- case HideEdge :
- ((Rec2DEdge*)_entity)->reveal();
- break;
-
- case HideVertex :
- ((Rec2DVertex*)_entity)->reveal();
- break;
-
- case HideElement :
- ((Rec2DElement*)_entity)->reveal();
- break;
-
- case CreatedEdge :
- delete (Rec2DEdge*)_entity;
- break;
-
- case CreatedVertex :
- delete (Rec2DVertex*)_entity;
- break;
-
- case CreatedElement :
- delete (Rec2DElement*)_entity;
- break;
-
- case HideAction :
- ((Rec2DAction*)_entity)->reveal();
- break;
-
- case CreatedAction :
- delete (Rec2DAction*)_entity;
- break;
-
- case HideActions :
- {
- std::vector<Rec2DAction*> *vect = (std::vector<Rec2DAction*>*)_entity;
- for (unsigned int i = 0; i < vect->size(); ++i)
- (*vect)[i]->reveal();
- delete vect;
- }
- break;
-
- case CreatedActions :
- {
- std::vector<Rec2DAction*> *vect = (std::vector<Rec2DAction*>*)_entity;
- for (unsigned int i = 0; i < vect->size(); ++i)
- delete (*vect)[i];
- delete vect;
- }
- break;
-
- case SwapEdgeInAction :
- {
- std::vector<Rec2DAction*> *vect = (std::vector<Rec2DAction*>*)_entity;
- std::pair<Rec2DEdge*, Rec2DEdge*> *pairEdge;
- pairEdge = (std::pair<Rec2DEdge*, Rec2DEdge*>*)_info;
- for (unsigned int i = 0; i < vect->size(); ++i)
- (*vect)[i]->swap(pairEdge->first, pairEdge->second);
- delete vect;
- delete pairEdge;
- }
- break;
-
- case SwapEdgeInElem :
- {
- std::pair<Rec2DEdge*, Rec2DEdge*> *pairEdge;
- pairEdge = (std::pair<Rec2DEdge*, Rec2DEdge*>*)_info;
- ((Rec2DElement*)_entity)->swap(pairEdge->first, pairEdge->second);
- delete pairEdge;
- }
- break;
-
- case SwapVertInAction :
- {
- std::vector<Rec2DAction*> *vect = (std::vector<Rec2DAction*>*)_entity;
- std::pair<Rec2DVertex*, Rec2DVertex*> *pairVert;
- pairVert = (std::pair<Rec2DVertex*, Rec2DVertex*>*)_info;
- for (unsigned int i = 0; i < vect->size(); ++i)
- (*vect)[i]->swap(pairVert->first, pairVert->second);
- delete vect;
- delete pairVert;
- }
- break;
-
- case SwapVertInEdge :
- {
- std::vector<Rec2DEdge*> *edges = (std::vector<Rec2DEdge*>*)_entity;
- std::pair<Rec2DVertex*, Rec2DVertex*> *pairVert;
- pairVert = (std::pair<Rec2DVertex*, Rec2DVertex*>*)_info;
- for (unsigned int i = 0; i < edges->size(); ++i)
- (*edges)[i]->swap(pairVert->first, pairVert->second);
- delete edges;
- delete pairVert;
- }
- break;
-
- case SwapMVertInElement :
- {
- std::vector<Rec2DElement*> *elem = (std::vector<Rec2DElement*>*)_entity;
- std::pair<Rec2DVertex*, Rec2DVertex*> *pairVert;
- pairVert = (std::pair<Rec2DVertex*, Rec2DVertex*>*)_info;
- for (unsigned int i = 0; i < elem->size(); ++i)
- (*elem)[i]->swapMVertex(pairVert->first, pairVert->second);
- delete elem;
- delete pairVert;
- }
- break;
-
- case RemoveElem :
- {
- std::vector<Rec2DElement*> *elem = (std::vector<Rec2DElement*>*)_info;
- for (unsigned int i = 0; i < elem->size(); ++i)
- ((Rec2DVertex*)_entity)->add((*elem)[i]);
- delete elem;
- }
- break;
-
- case AddElem :
- {
- std::vector<Rec2DElement*> *elem = (std::vector<Rec2DElement*>*)_info;
- for (unsigned int i = 0; i < elem->size(); ++i)
- ((Rec2DVertex*)_entity)->rmv((*elem)[i]);
- delete elem;
- }
- break;
+ switch(_type) {
+ case ValQuad:
+ Rec2DData::addBlosQual(-*(int *)_entity);
+ delete(int *)_entity;
+ break;
- case Relocate :
- ((Rec2DVertex*)_entity)->relocate(*(SPoint2*)_info);
- delete (SPoint2*)_info;
- break;
+ case HideEdge: ((Rec2DEdge *)_entity)->reveal(); break;
+
+ case HideVertex: ((Rec2DVertex *)_entity)->reveal(); break;
+
+ case HideElement: ((Rec2DElement *)_entity)->reveal(); break;
+
+ case CreatedEdge: delete(Rec2DEdge *)_entity; break;
+
+ case CreatedVertex: delete(Rec2DVertex *)_entity; break;
+
+ case CreatedElement: delete(Rec2DElement *)_entity; break;
+
+ case HideAction: ((Rec2DAction *)_entity)->reveal(); break;
+
+ case CreatedAction: delete(Rec2DAction *)_entity; break;
+
+ case HideActions: {
+ std::vector<Rec2DAction *> *vect = (std::vector<Rec2DAction *> *)_entity;
+ for(unsigned int i = 0; i < vect->size(); ++i) (*vect)[i]->reveal();
+ delete vect;
+ } break;
+
+ case CreatedActions: {
+ std::vector<Rec2DAction *> *vect = (std::vector<Rec2DAction *> *)_entity;
+ for(unsigned int i = 0; i < vect->size(); ++i) delete(*vect)[i];
+ delete vect;
+ } break;
+
+ case SwapEdgeInAction: {
+ std::vector<Rec2DAction *> *vect = (std::vector<Rec2DAction *> *)_entity;
+ std::pair<Rec2DEdge *, Rec2DEdge *> *pairEdge;
+ pairEdge = (std::pair<Rec2DEdge *, Rec2DEdge *> *)_info;
+ for(unsigned int i = 0; i < vect->size(); ++i)
+ (*vect)[i]->swap(pairEdge->first, pairEdge->second);
+ delete vect;
+ delete pairEdge;
+ } break;
+
+ case SwapEdgeInElem: {
+ std::pair<Rec2DEdge *, Rec2DEdge *> *pairEdge;
+ pairEdge = (std::pair<Rec2DEdge *, Rec2DEdge *> *)_info;
+ ((Rec2DElement *)_entity)->swap(pairEdge->first, pairEdge->second);
+ delete pairEdge;
+ } break;
+
+ case SwapVertInAction: {
+ std::vector<Rec2DAction *> *vect = (std::vector<Rec2DAction *> *)_entity;
+ std::pair<Rec2DVertex *, Rec2DVertex *> *pairVert;
+ pairVert = (std::pair<Rec2DVertex *, Rec2DVertex *> *)_info;
+ for(unsigned int i = 0; i < vect->size(); ++i)
+ (*vect)[i]->swap(pairVert->first, pairVert->second);
+ delete vect;
+ delete pairVert;
+ } break;
+
+ case SwapVertInEdge: {
+ std::vector<Rec2DEdge *> *edges = (std::vector<Rec2DEdge *> *)_entity;
+ std::pair<Rec2DVertex *, Rec2DVertex *> *pairVert;
+ pairVert = (std::pair<Rec2DVertex *, Rec2DVertex *> *)_info;
+ for(unsigned int i = 0; i < edges->size(); ++i)
+ (*edges)[i]->swap(pairVert->first, pairVert->second);
+ delete edges;
+ delete pairVert;
+ } break;
+
+ case SwapMVertInElement: {
+ std::vector<Rec2DElement *> *elem = (std::vector<Rec2DElement *> *)_entity;
+ std::pair<Rec2DVertex *, Rec2DVertex *> *pairVert;
+ pairVert = (std::pair<Rec2DVertex *, Rec2DVertex *> *)_info;
+ for(unsigned int i = 0; i < elem->size(); ++i)
+ (*elem)[i]->swapMVertex(pairVert->first, pairVert->second);
+ delete elem;
+ delete pairVert;
+ } break;
+
+ case RemoveElem: {
+ std::vector<Rec2DElement *> *elem = (std::vector<Rec2DElement *> *)_info;
+ for(unsigned int i = 0; i < elem->size(); ++i)
+ ((Rec2DVertex *)_entity)->add((*elem)[i]);
+ delete elem;
+ } break;
+
+ case AddElem: {
+ std::vector<Rec2DElement *> *elem = (std::vector<Rec2DElement *> *)_info;
+ for(unsigned int i = 0; i < elem->size(); ++i)
+ ((Rec2DVertex *)_entity)->rmv((*elem)[i]);
+ delete elem;
+ } break;
+
+ case Relocate:
+ ((Rec2DVertex *)_entity)->relocate(*(SPoint2 *)_info);
+ delete(SPoint2 *)_info;
+ break;
- case ChangePar :
- ((Rec2DVertex*)_entity)->setParity(*(int*)_info);
- delete (int*)_info;
- break;
+ case ChangePar:
+ ((Rec2DVertex *)_entity)->setParity(*(int *)_info);
+ delete(int *)_info;
+ break;
- case SavePar :
- {
- std::vector<Rec2DVertex*> *verts = (std::vector<Rec2DVertex*>*)_entity;
- std::vector<int> *parities = (std::vector<int>*)_info;
- for (unsigned int i = 0; i < verts->size(); ++i)
- (*verts)[i]->setParity((*parities)[i]);
- delete verts;
- delete parities;
- }
- break;
+ case SavePar: {
+ std::vector<Rec2DVertex *> *verts = (std::vector<Rec2DVertex *> *)_entity;
+ std::vector<int> *parities = (std::vector<int> *)_info;
+ for(unsigned int i = 0; i < verts->size(); ++i)
+ (*verts)[i]->setParity((*parities)[i]);
+ delete verts;
+ delete parities;
+ } break;
- case Error :
- Msg::Error("[Rec2DChange] There was an error");
- return;
+ case Error: Msg::Error("[Rec2DChange] There was an error"); return;
- case Reverted :
- Msg::Error("[Rec2DChange] Multiple revert");
- return;
+ case Reverted: Msg::Error("[Rec2DChange] Multiple revert"); return;
- default :
- Msg::Error("[Rec2DChange] Unknown type (%d)", _type);
- return;
+ default: Msg::Error("[Rec2DChange] Unknown type (%d)", _type); return;
}
_type = Reverted;
}
-
/** Rec2DDataChange **/
/***********************/
Rec2DDataChange::~Rec2DDataChange()
{
- for (unsigned int i = 0; i < _changes.size(); ++i)
- delete _changes[i];
+ for(unsigned int i = 0; i < _changes.size(); ++i) delete _changes[i];
}
void Rec2DDataChange::swapFor(Rec2DEdge *re0, Rec2DEdge *re1)
{
- std::vector<Rec2DAction*> actions;
+ std::vector<Rec2DAction *> actions;
Rec2DElement *elem[2];
Rec2DEdge::getElements(re0, elem);
- if (elem[0]) elem[0]->getMoreUniqueActions(actions);
- if (elem[1]) elem[1]->getMoreUniqueActions(actions);
+ if(elem[0]) elem[0]->getMoreUniqueActions(actions);
+ if(elem[1]) elem[1]->getMoreUniqueActions(actions);
Rec2DAction::removeDuplicate(actions);
_changes.push_back(new Rec2DChange(re0, re1, actions, SwapEdgeInAction));
_changes.push_back(new Rec2DChange(re0, re1, SwapEdgeInElem));
@@ -2494,12 +2390,12 @@ void Rec2DDataChange::swapFor(Rec2DEdge *re0, Rec2DEdge *re1)
void Rec2DDataChange::swapFor(Rec2DVertex *rv0, Rec2DVertex *rv1)
{
- std::vector<Rec2DElement*> elem;
- std::vector<Rec2DEdge*> edges;
- std::vector<Rec2DAction*> actions;
+ std::vector<Rec2DElement *> elem;
+ std::vector<Rec2DEdge *> edges;
+ std::vector<Rec2DAction *> actions;
rv0->getElements(elem);
rv0->getEdges(edges);
- for (unsigned int i = 0; i < elem.size(); ++i)
+ for(unsigned int i = 0; i < elem.size(); ++i)
elem[i]->getMoreUniqueActions(actions);
Rec2DAction::removeDuplicate(actions);
_changes.push_back(new Rec2DChange(rv0, elem, RemoveElem));
@@ -2509,88 +2405,87 @@ void Rec2DDataChange::swapFor(Rec2DVertex *rv0, Rec2DVertex *rv1)
_changes.push_back(new Rec2DChange(rv0, rv1, elem, SwapMVertInElement));
}
-void Rec2DDataChange::checkObsoleteActions(Rec2DVertex *const*verts, int size)
+void Rec2DDataChange::checkObsoleteActions(Rec2DVertex *const *verts, int size)
{
- std::vector<Rec2DAction*> actions;
- for (int i = 0; i < size; ++i) {
+ std::vector<Rec2DAction *> actions;
+ for(int i = 0; i < size; ++i) {
verts[i]->getMoreUniqueActions(actions);
}
- for (unsigned int i = 0; i < actions.size(); ++i) {
- if (actions[i]->isObsolete())
- hide(actions[i]);
+ for(unsigned int i = 0; i < actions.size(); ++i) {
+ if(actions[i]->isObsolete()) hide(actions[i]);
}
}
-void Rec2DDataChange::getHiddenActions(std::set<Rec2DAction*> &set)
+void Rec2DDataChange::getHiddenActions(std::set<Rec2DAction *> &set)
{
- for (unsigned int i = 0; i < _changes.size(); ++i) {
- _changes[i]->getHiddenActions(set);
+ for(unsigned int i = 0; i < _changes.size(); ++i) {
+ _changes[i]->getHiddenActions(set);
}
}
void Rec2DDataChange::revert()
{
- for (int i = (int)_changes.size() - 1; i > -1; --i)
- _changes[i]->revert();
+ for(int i = (int)_changes.size() - 1; i > -1; --i) _changes[i]->revert();
}
-
/** Rec2DAction **/
/*******************/
-bool lessRec2DAction::operator()(const Rec2DAction *ra1, const Rec2DAction *ra2) const
+bool lessRec2DAction::operator()(const Rec2DAction *ra1,
+ const Rec2DAction *ra2) const
{
return *ra1 < *ra2;
}
-bool gterRec2DAction::operator()(const Rec2DAction *ra1, const Rec2DAction *ra2) const
+bool gterRec2DAction::operator()(const Rec2DAction *ra1,
+ const Rec2DAction *ra2) const
{
return *ra2 < *ra1;
}
Rec2DAction::Rec2DAction()
-: _globQualIfExecuted(.0), _lastUpdate(-2), _numPointing(0), _dataAction(NULL)
+ : _globQualIfExecuted(.0), _lastUpdate(-2), _numPointing(0), _dataAction(NULL)
{
}
double Rec2DAction::getReward() const
{
- if (_lastUpdate < Recombine2D::getNumChange())
- ((Rec2DAction*)this)->_computeGlobQual();
+ if(_lastUpdate < Recombine2D::getNumChange())
+ ((Rec2DAction *)this)->_computeGlobQual();
- return _globQualIfExecuted/* - Rec2DData::getGlobalQuality()*/;
+ return _globQualIfExecuted /* - Rec2DData::getGlobalQuality()*/;
}
double Rec2DAction::getRealReward() const
{
- if (_lastUpdate < Recombine2D::getNumChange())
- ((Rec2DAction*)this)->_computeReward();
+ if(_lastUpdate < Recombine2D::getNumChange())
+ ((Rec2DAction *)this)->_computeReward();
return _reward;
}
-
bool Rec2DAction::operator<(const Rec2DAction &other) const
{
- //return getReward() < other.getReward();
- if (getRealReward() == other.getRealReward())
+ // return getReward() < other.getReward();
+ if(getRealReward() == other.getRealReward())
return this < &other;
else
return getRealReward() < other.getRealReward();
}
-void Rec2DAction::removeDuplicate(std::vector<Rec2DAction*> &actions)
+void Rec2DAction::removeDuplicate(std::vector<Rec2DAction *> &actions)
{
unsigned int i = -1;
- while (++i < actions.size()) {
+ while(++i < actions.size()) {
Rec2DAction *ra = actions[i]->getBase();
- if (ra) for (unsigned int j = 0; j < actions.size(); ++j) {
- if (ra == actions[j]) {
- actions[i] = actions.back();
- actions.pop_back();
- --i;
- break;
+ if(ra)
+ for(unsigned int j = 0; j < actions.size(); ++j) {
+ if(ra == actions[j]) {
+ actions[i] = actions.back();
+ actions.pop_back();
+ --i;
+ break;
+ }
}
- }
}
}
@@ -2609,23 +2504,21 @@ Rec2DTwoTri2Quad::Rec2DTwoTri2Quad(Rec2DElement *el0, Rec2DElement *el1)
_edges[4] = Rec2DElement::getCommonEdge(el0, el1);
// get edges
- std::vector<Rec2DEdge*> edges;
+ std::vector<Rec2DEdge *> edges;
el0->getMoreEdges(edges);
el1->getMoreEdges(edges);
int k = -1;
- for (unsigned int i = 0; i < edges.size(); ++i) {
- if (edges[i] != _edges[4])
- _edges[++k] = edges[i];
+ for(unsigned int i = 0; i < edges.size(); ++i) {
+ if(edges[i] != _edges[4]) _edges[++k] = edges[i];
}
- if (k > 3)
- Msg::Error("[Rec2DTwoTri2Quad] too much edges");
+ if(k > 3) Msg::Error("[Rec2DTwoTri2Quad] too much edges");
// reoder edges if needed
- if (edges[1] == _edges[4]) {
+ if(edges[1] == _edges[4]) {
Rec2DEdge *re = _edges[0];
_edges[0] = _edges[1];
_edges[1] = re;
}
- if (edges[4] == _edges[4]) {
+ if(edges[4] == _edges[4]) {
Rec2DEdge *re = _edges[2];
_edges[2] = _edges[3];
_edges[3] = re;
@@ -2637,37 +2530,39 @@ Rec2DTwoTri2Quad::Rec2DTwoTri2Quad(Rec2DElement *el0, Rec2DElement *el1)
_vertices[2] = _triangles[0]->getOtherVertex(_vertices[0], _vertices[1]);
_vertices[3] = _triangles[1]->getOtherVertex(_vertices[0], _vertices[1]);
// reorder if needed
- if (_vertices[0] == _edges[1]->getOtherVertex(_vertices[2])) {
+ if(_vertices[0] == _edges[1]->getOtherVertex(_vertices[2])) {
Rec2DVertex *rv = _vertices[0];
_vertices[0] = _vertices[1];
_vertices[1] = rv;
}
//
- _rt = new RecombineTriangle(MEdge(_vertices[0]->getMVertex(),
- _vertices[1]->getMVertex() ),
- _triangles[0]->getMElement(),
- _triangles[1]->getMElement() );
+ _rt = new RecombineTriangle(
+ MEdge(_vertices[0]->getMVertex(), _vertices[1]->getMVertex()),
+ _triangles[0]->getMElement(), _triangles[1]->getMElement());
reveal();
- if (!edgesAreInOrder(_edges, 4)) Msg::Error("recomb |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ if(!edgesAreInOrder(_edges, 4))
+ Msg::Error("recomb |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
}
void Rec2DTwoTri2Quad::operator delete(void *p)
{
- if (!p) return;
- Rec2DTwoTri2Quad *ra = (Rec2DTwoTri2Quad*)p;
- if (ra->_dataAction) { // ra->hide()
+ if(!p) return;
+ Rec2DTwoTri2Quad *ra = (Rec2DTwoTri2Quad *)p;
+ if(ra->_dataAction) { // ra->hide()
ra->_triangles[0]->rmv(ra);
ra->_triangles[1]->rmv(ra);
Rec2DData::rmv(ra);
}
- if (!ra->_numPointing) {
- //Msg::Info("del ac %d", p);
- if (ra->_col) {
+ if(!ra->_numPointing) {
+ // Msg::Info("del ac %d", p);
+ if(ra->_col) {
static int a = 0;
- if (++a == 1) Msg::Warning("FIXME Il faut supprimer les hidden a la fin...");
- Rec2DData::addHidden((Rec2DAction*)p);
+ if(++a == 1)
+ Msg::Warning("FIXME Il faut supprimer les hidden a la fin...");
+ Rec2DData::addHidden((Rec2DAction *)p);
}
else
free(p);
@@ -2676,19 +2571,15 @@ void Rec2DTwoTri2Quad::operator delete(void *p)
void Rec2DTwoTri2Quad::hide()
{
- if (_triangles[0])
- _triangles[0]->rmv(this);
- if (_triangles[1])
- _triangles[1]->rmv(this);
+ if(_triangles[0]) _triangles[0]->rmv(this);
+ if(_triangles[1]) _triangles[1]->rmv(this);
Rec2DData::rmv(this);
}
void Rec2DTwoTri2Quad::reveal()
{
- if (_triangles[0])
- _triangles[0]->add(this);
- if (_triangles[1])
- _triangles[1]->add(this);
+ if(_triangles[0]) _triangles[0]->add(this);
+ if(_triangles[1]) _triangles[1]->add(this);
Rec2DData::add(this);
}
@@ -2699,19 +2590,20 @@ bool Rec2DTwoTri2Quad::isObsolete() const
p[1] = _vertices[1]->getParity();
p[2] = _vertices[2]->getParity();
p[3] = _vertices[3]->getParity();
- return (p[0]/2 == p[1]/2 && p[0] != p[1]) ||
- (p[2]/2 == p[3]/2 && p[2] != p[3]) ||
+ return (p[0] / 2 == p[1] / 2 && p[0] != p[1]) ||
+ (p[2] / 2 == p[3] / 2 && p[2] != p[3]) ||
(p[0] && (p[0] == p[2] || p[0] == p[3])) ||
- (p[1] && (p[1] == p[2] || p[1] == p[3])) ;
+ (p[1] && (p[1] == p[2] || p[1] == p[3]));
}
-void Rec2DTwoTri2Quad::apply(std::vector<Rec2DVertex*> &newPar)
+void Rec2DTwoTri2Quad::apply(std::vector<Rec2DVertex *> &newPar)
{
static int a = 0;
- if (++a == 1) Msg::Error("FIXME Need new definition Rec2DTwoTri2Quad::apply(newPar)");
+ if(++a == 1)
+ Msg::Error("FIXME Need new definition Rec2DTwoTri2Quad::apply(newPar)");
/*if (isObsolete()) {
- Msg::Error("[Rec2DTwoTri2Quad] No way ! I won't apply ! Find someone else...");
- return;
+ Msg::Error("[Rec2DTwoTri2Quad] No way ! I won't apply ! Find someone
+ else..."); return;
}
int min = Rec2DData::getNewParity(), index = -1;
@@ -2766,11 +2658,12 @@ void Rec2DTwoTri2Quad::apply(std::vector<Rec2DVertex*> &newPar)
}
void Rec2DTwoTri2Quad::apply(Rec2DDataChange *rdc,
- std::vector<Rec2DAction*> *&createdActions,
+ std::vector<Rec2DAction *> *&createdActions,
bool color) const
{
- //I(( "applying Recombine |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum() ));
- if (isObsolete() && !Recombine2D::canIsolateTriangle()) {
+ // I(( "applying Recombine |%d|%d|", _triangles[0]->getNum(),
+ // _triangles[1]->getNum() ));
+ if(isObsolete() && !Recombine2D::canIsolateTriangle()) {
printIdentity();
int p[4];
p[0] = _vertices[0]->getParity();
@@ -2779,7 +2672,7 @@ void Rec2DTwoTri2Quad::apply(Rec2DDataChange *rdc,
p[3] = _vertices[3]->getParity();
Msg::Info("%d %d %d %d", p[0], p[1], p[2], p[3]);
Msg::Error("[Rec2DTwoTri2Quad] I was obsolete !");
- if (Rec2DData::checkEntities()) {
+ if(Rec2DData::checkEntities()) {
Msg::Error("check entities is ok. Should not have been aware of me");
}
__crash();
@@ -2787,44 +2680,49 @@ void Rec2DTwoTri2Quad::apply(Rec2DDataChange *rdc,
#ifdef REC2D_DRAW
rdc->setAction(this);
#endif
- std::vector<Rec2DAction*> actions;
+ std::vector<Rec2DAction *> actions;
_triangles[0]->getMoreUniqueActions(actions);
_triangles[1]->getMoreUniqueActions(actions);
rdc->hide(actions);
- if (!Recombine2D::canIsolateTriangle())
- _doWhatYouHaveToDoWithParity(rdc);
+ if(!Recombine2D::canIsolateTriangle()) _doWhatYouHaveToDoWithParity(rdc);
rdc->hide(_triangles[0]);
rdc->hide(_triangles[1]);
rdc->hide(_edges[4]);
- Rec2DElement *rel = new Rec2DElement((MQuadrangle*)NULL, (const Rec2DEdge**)_edges);
+ Rec2DElement *rel =
+ new Rec2DElement((MQuadrangle *)NULL, (const Rec2DEdge **)_edges);
rdc->append(rel);
- //rdc->add((int)_rt->total_gain); // _reward if blossom// no more in the code (see Amaury)
- if (color) Recombine2D::colorFromBlossom(_triangles[0], _triangles[1], rel);
+ // rdc->add((int)_rt->total_gain); // _reward if blossom// no more in the code
+ // (see Amaury)
+ if(color) Recombine2D::colorFromBlossom(_triangles[0], _triangles[1], rel);
static int a = 0;
- if (++a == 1) Msg::Warning("FIXME reward is int for blossom");
+ if(++a == 1) Msg::Warning("FIXME reward is int for blossom");
}
void Rec2DTwoTri2Quad::swap(Rec2DVertex *rv0, Rec2DVertex *rv1)
{
- for (int i = 0; i < 4; ++i) {
- if (_vertices[i] == rv0) {
+ for(int i = 0; i < 4; ++i) {
+ if(_vertices[i] == rv0) {
_vertices[i] = rv1;
return;
}
}
- Msg::Error("[Rec2DTwoTri2Quad] Can't swap your vertex (%d -> %d)", rv0->getNum(), rv1->getNum());
- Msg::Warning("[Rec2DTwoTri2Quad] I have %d %d %d %d", _vertices[0]->getNum(), _vertices[1]->getNum(), _vertices[2]->getNum(), _vertices[3]->getNum());
+ Msg::Error("[Rec2DTwoTri2Quad] Can't swap your vertex (%d -> %d)",
+ rv0->getNum(), rv1->getNum());
+ Msg::Warning("[Rec2DTwoTri2Quad] I have %d %d %d %d", _vertices[0]->getNum(),
+ _vertices[1]->getNum(), _vertices[2]->getNum(),
+ _vertices[3]->getNum());
}
void Rec2DTwoTri2Quad::swap(Rec2DEdge *re0, Rec2DEdge *re1)
{
- for (int i = 0; i < 4; ++i) {
- if (_edges[i] == re0) {
+ for(int i = 0; i < 4; ++i) {
+ if(_edges[i] == re0) {
_edges[i] = re1;
return;
}
}
- Msg::Error("[Rec2DTwoTri2Quad] Can't swap your edge (is middle : %d)", re0 == _edges[4]);
+ Msg::Error("[Rec2DTwoTri2Quad] Can't swap your edge (is middle : %d)",
+ re0 == _edges[4]);
}
bool Rec2DTwoTri2Quad::has(const Rec2DElement *rel) const
@@ -2832,51 +2730,56 @@ bool Rec2DTwoTri2Quad::has(const Rec2DElement *rel) const
return rel == _triangles[0] || rel == _triangles[1];
}
-Rec2DElement* Rec2DTwoTri2Quad::getRandomElement() const
+Rec2DElement *Rec2DTwoTri2Quad::getRandomElement() const
{
return _triangles[rand() % 2];
}
-void Rec2DTwoTri2Quad::getElements(std::vector<Rec2DElement*> &elem) const
+void Rec2DTwoTri2Quad::getElements(std::vector<Rec2DElement *> &elem) const
{
elem.clear();
elem.push_back(_triangles[0]);
elem.push_back(_triangles[1]);
}
-void Rec2DTwoTri2Quad::getNeighbourElements(std::vector<Rec2DElement*> &elem) const
+void Rec2DTwoTri2Quad::getNeighbourElements(
+ std::vector<Rec2DElement *> &elem) const
{
elem.clear();
_triangles[0]->getMoreNeighbours(elem);
_triangles[1]->getMoreNeighbours(elem);
unsigned int i = 0;
- while (i < elem.size()) {
- if (elem[i] == _triangles[0] || elem[i] == _triangles[1]) {
+ while(i < elem.size()) {
+ if(elem[i] == _triangles[0] || elem[i] == _triangles[1]) {
elem[i] = elem.back();
elem.pop_back();
}
- else ++i;
+ else
+ ++i;
}
}
-void Rec2DTwoTri2Quad::getNeighbElemWithActions(std::vector<Rec2DElement*> &elem) const
+void Rec2DTwoTri2Quad::getNeighbElemWithActions(
+ std::vector<Rec2DElement *> &elem) const
{
getNeighbourElements(elem);
unsigned int i = 0;
- while (i < elem.size()) {
- if (!elem[i]->getNumActions()) {
+ while(i < elem.size()) {
+ if(!elem[i]->getNumActions()) {
elem[i] = elem.back();
elem.pop_back();
}
- else ++i;
+ else
+ ++i;
}
}
-void Rec2DTwoTri2Quad::getTouchedActions(std::vector<Rec2DAction*> &actions) const
+void Rec2DTwoTri2Quad::getTouchedActions(
+ std::vector<Rec2DAction *> &actions) const
{
- std::vector<Rec2DElement*> elem;
+ std::vector<Rec2DElement *> elem;
getNeighbourElements(elem);
- for (unsigned int i = 0; i < elem.size(); ++i) {
+ for(unsigned int i = 0; i < elem.size(); ++i) {
elem[i]->getMoreUniqueActions(actions);
}
}
@@ -2884,49 +2787,52 @@ void Rec2DTwoTri2Quad::getTouchedActions(std::vector<Rec2DAction*> &actions) con
bool Rec2DTwoTri2Quad::checkCoherence(const Rec2DAction *action) const
{
Rec2DEdge *edge4 = Rec2DElement::getCommonEdge(_triangles[0], _triangles[1]);
- if (!edge4) {
- if (!_triangles[0]->has(_edges[4]) || !_triangles[1]->has(_edges[4])) {
- Msg::Error("inco action [-1], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ if(!edge4) {
+ if(!_triangles[0]->has(_edges[4]) || !_triangles[1]->has(_edges[4])) {
+ Msg::Error("inco action [-1], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
return false;
}
}
- else if (_edges[4] != edge4) {
- Msg::Error("inco action [0], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
- if (_edges[4])
+ else if(_edges[4] != edge4) {
+ Msg::Error("inco action [0], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
+ if(_edges[4])
_edges[4]->print();
- else Msg::Info("no edge");
- if (Rec2DElement::getCommonEdge(_triangles[0], _triangles[1]))
+ else
+ Msg::Info("no edge");
+ if(Rec2DElement::getCommonEdge(_triangles[0], _triangles[1]))
Rec2DElement::getCommonEdge(_triangles[0], _triangles[1])->print();
- else Msg::Info("no edge");
+ else
+ Msg::Info("no edge");
return false;
}
- std::vector<Rec2DEdge*> edges;
+ std::vector<Rec2DEdge *> edges;
Rec2DEdge *re[4];
_triangles[0]->getMoreEdges(edges);
_triangles[1]->getMoreEdges(edges);
int k = -1;
- for (unsigned int i = 0; i < edges.size(); ++i) {
- if (edges[i] != _edges[4])
- re[++k] = edges[i];
+ for(unsigned int i = 0; i < edges.size(); ++i) {
+ if(edges[i] != _edges[4]) re[++k] = edges[i];
}
- if (k > 3)
- Msg::Error("[Rec2DTwoTri2Quad] too much edges");
+ if(k > 3) Msg::Error("[Rec2DTwoTri2Quad] too much edges");
// reoder edges if needed
- if (edges[1] == _edges[4]) {
+ if(edges[1] == _edges[4]) {
Rec2DEdge *e = re[0];
re[0] = re[1];
re[1] = e;
}
- if (edges[4] == _edges[4]) {
+ if(edges[4] == _edges[4]) {
Rec2DEdge *e = re[2];
re[2] = re[3];
re[3] = e;
}
- for (int i = 0; i < 4; ++i) {
- if (re[i] != _edges[i]) {
- Msg::Error("inco action [1], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
- for (int i = 0; i < 4; ++i) {
+ for(int i = 0; i < 4; ++i) {
+ if(re[i] != _edges[i]) {
+ Msg::Error("inco action [1], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
+ for(int i = 0; i < 4; ++i) {
_edges[i]->print();
re[i]->print();
Msg::Info(" ");
@@ -2935,43 +2841,56 @@ bool Rec2DTwoTri2Quad::checkCoherence(const Rec2DAction *action) const
}
}
- if (_edges[0]->getOtherVertex(_vertices[2]) == _edges[4]->getVertex(0)) {
- if (_vertices[0] != _edges[4]->getVertex(0) || _vertices[1] != _edges[4]->getVertex(1)) {
- Msg::Error("inco action [2], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ if(_edges[0]->getOtherVertex(_vertices[2]) == _edges[4]->getVertex(0)) {
+ if(_vertices[0] != _edges[4]->getVertex(0) ||
+ _vertices[1] != _edges[4]->getVertex(1)) {
+ Msg::Error("inco action [2], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
return false;
}
}
else {
- if (_vertices[0] != _edges[4]->getVertex(1) || _vertices[1] != _edges[4]->getVertex(0)) {
- Msg::Error("inco action [3], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ if(_vertices[0] != _edges[4]->getVertex(1) ||
+ _vertices[1] != _edges[4]->getVertex(0)) {
+ Msg::Error("inco action [3], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
return false;
}
}
- if (_vertices[2] != _triangles[0]->getOtherVertex(_vertices[0], _vertices[1])) {
- Msg::Error("inco action [4], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ if(_vertices[2] !=
+ _triangles[0]->getOtherVertex(_vertices[0], _vertices[1])) {
+ Msg::Error("inco action [4], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
return false;
}
- if (_vertices[3] != _triangles[1]->getOtherVertex(_vertices[0], _vertices[1])) {
- Msg::Error("inco action [5], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ if(_vertices[3] !=
+ _triangles[1]->getOtherVertex(_vertices[0], _vertices[1])) {
+ Msg::Error("inco action [5], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
return false;
}
const Rec2DAction *ra;
- if (action) ra = action;
- else ra = this;
- if (!_triangles[0]->has(ra) || !_triangles[1]->has(ra) || _triangles[0] == _triangles[1]) {
- Msg::Error("inco action [6], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ if(action)
+ ra = action;
+ else
+ ra = this;
+ if(!_triangles[0]->has(ra) || !_triangles[1]->has(ra) ||
+ _triangles[0] == _triangles[1]) {
+ Msg::Error("inco action [6], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
return false;
}
- if (isObsolete()) {
+ if(isObsolete()) {
int p[4];
p[0] = _vertices[0]->getParity();
p[1] = _vertices[1]->getParity();
p[2] = _vertices[2]->getParity();
p[3] = _vertices[3]->getParity();
Msg::Info("%d %d %d %d", p[0], p[1], p[2], p[3]);
- Msg::Error("inco action [7], |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ Msg::Error("inco action [7], |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
return false;
}
@@ -2980,33 +2899,37 @@ bool Rec2DTwoTri2Quad::checkCoherence(const Rec2DAction *action) const
void Rec2DTwoTri2Quad::printReward() const
{
- if (Recombine2D::blossomQual()) {
+ if(Recombine2D::blossomQual()) {
Msg::Error("[Rec2DTwoTri2Quad] Don't know");
//?return (double)_cur->_blossomQuality;
return;
}
- if (Recombine2D::verticesQual()) {
+ if(Recombine2D::verticesQual()) {
Msg::Info("reward rec : %g %g %g %g",
- _vertices[0]->getGainRecomb(_triangles[0], _triangles[1], _edges[4], _edges[0], _edges[3]),
- _vertices[1]->getGainRecomb(_triangles[0], _triangles[1], _edges[4], _edges[1], _edges[2]),
+ _vertices[0]->getGainRecomb(_triangles[0], _triangles[1],
+ _edges[4], _edges[0], _edges[3]),
+ _vertices[1]->getGainRecomb(_triangles[0], _triangles[1],
+ _edges[4], _edges[1], _edges[2]),
_vertices[2]->getGainQuad(_triangles[0], _edges[0], _edges[1]),
_vertices[3]->getGainQuad(_triangles[1], _edges[2], _edges[3]));
return;
}
- if (Recombine2D::vertAndEdgesQual()) {
+ if(Recombine2D::vertAndEdgesQual()) {
double valEdge1 = _edges[4]->getQual();
double valEdge2 = 0;
- for (int i = 0; i < 4; ++i)
- valEdge2 += _edges[i]->getQual();
+ for(int i = 0; i < 4; ++i) valEdge2 += _edges[i]->getQual();
double valVert;
valVert = _vertices[0]->getGainRecomb(_triangles[0], _triangles[1]);
valVert += _vertices[1]->getGainRecomb(_triangles[0], _triangles[1]);
- Msg::Info("-%de%g +%de%g +0v%g -> %g", Recombine2D::getWeightEdgeBase(), valEdge1, 4 * Recombine2D::getWeightEdgeQuad(),
- valEdge2/4, valVert/2,
- Rec2DData::getGlobalQuality(0, valVert,
- 4*Recombine2D::getWeightEdgeQuad() - Recombine2D::getWeightEdgeBase(),
- -Recombine2D::getWeightEdgeBase()*valEdge1+Recombine2D::getWeightEdgeQuad()*valEdge2));
+ Msg::Info(
+ "-%de%g +%de%g +0v%g -> %g", Recombine2D::getWeightEdgeBase(), valEdge1,
+ 4 * Recombine2D::getWeightEdgeQuad(), valEdge2 / 4, valVert / 2,
+ Rec2DData::getGlobalQuality(
+ 0, valVert,
+ 4 * Recombine2D::getWeightEdgeQuad() - Recombine2D::getWeightEdgeBase(),
+ -Recombine2D::getWeightEdgeBase() * valEdge1 +
+ Recombine2D::getWeightEdgeQuad() * valEdge2));
return;
}
Msg::Error("[Rec2DTwoTri2Quad] Unknown quality criterion");
@@ -3014,7 +2937,7 @@ void Rec2DTwoTri2Quad::printReward() const
void Rec2DTwoTri2Quad::printVertices() const
{
- for (int i = 0; i < 4; ++i) {
+ for(int i = 0; i < 4; ++i) {
Msg::Info("vert %d : %g", _vertices[i]->getNum(), _vertices[i]->getQual());
//_vertices[i]->printQual();
}
@@ -3022,30 +2945,30 @@ void Rec2DTwoTri2Quad::printVertices() const
void Rec2DTwoTri2Quad::printIdentity() const
{
- Msg::Info("Recombine |%d|%d|", _triangles[0]->getNum(), _triangles[1]->getNum());
+ Msg::Info("Recombine |%d|%d|", _triangles[0]->getNum(),
+ _triangles[1]->getNum());
}
-MElement* Rec2DTwoTri2Quad::createMElement(double shiftx, double shifty)
+MElement *Rec2DTwoTri2Quad::createMElement(double shiftx, double shifty)
{
MQuadrangle *quad;
- if (shiftx == .0 && shifty == .0)
- quad = new MQuadrangle(_vertices[0]->getMVertex(),
- _vertices[2]->getMVertex(),
- _vertices[1]->getMVertex(),
- _vertices[3]->getMVertex());
+ if(shiftx == .0 && shifty == .0)
+ quad =
+ new MQuadrangle(_vertices[0]->getMVertex(), _vertices[2]->getMVertex(),
+ _vertices[1]->getMVertex(), _vertices[3]->getMVertex());
else {
MVertex *v0 = new MVertex(_vertices[0]->getMVertex()->x() + shiftx,
_vertices[0]->getMVertex()->y() + shifty,
- _vertices[0]->getMVertex()->z() );
+ _vertices[0]->getMVertex()->z());
MVertex *v1 = new MVertex(_vertices[1]->getMVertex()->x() + shiftx,
_vertices[1]->getMVertex()->y() + shifty,
- _vertices[1]->getMVertex()->z() );
+ _vertices[1]->getMVertex()->z());
MVertex *v2 = new MVertex(_vertices[2]->getMVertex()->x() + shiftx,
_vertices[2]->getMVertex()->y() + shifty,
- _vertices[2]->getMVertex()->z() );
+ _vertices[2]->getMVertex()->z());
MVertex *v3 = new MVertex(_vertices[3]->getMVertex()->x() + shiftx,
_vertices[3]->getMVertex()->y() + shifty,
- _vertices[3]->getMVertex()->z() );
+ _vertices[3]->getMVertex()->z());
quad = new MQuadrangle(v0, v2, v1, v3);
}
Recombine2D::add(quad);
@@ -3056,20 +2979,21 @@ void Rec2DTwoTri2Quad::color(int a, int b, int c) const
{
#ifdef REC2D_DRAW
unsigned int col = CTX::instance()->packColor(a, b, c, 255);
- //_triangles[0]->getMElement()->setCol(col);// no more in the code (see Amaury)
- //_triangles[1]->getMElement()->setCol(col);// no more in the code (see Amaury)
+ //_triangles[0]->getMElement()->setCol(col);// no more in the code (see
+ //Amaury) _triangles[1]->getMElement()->setCol(col);// no more in the code
+ //(see Amaury)
#endif
}
-void Rec2DTwoTri2Quad::getIncompatible(std::vector<Rec2DAction*> &vect)
+void Rec2DTwoTri2Quad::getIncompatible(std::vector<Rec2DAction *> &vect)
{
vect.clear();
Rec2DDataChange *rdc = new Rec2DDataChange();
- std::vector<Rec2DAction*> *v = NULL;
+ std::vector<Rec2DAction *> *v = NULL;
apply(rdc, v);
vect = rdc->hiddenActions;
- for (unsigned int i = 0; i < vect.size(); ++i) {
- if (vect[i] == this) {
+ for(unsigned int i = 0; i < vect.size(); ++i) {
+ if(vect[i] == this) {
vect[i] = vect.back();
vect.pop_back();
rdc->revert();
@@ -3079,15 +3003,15 @@ void Rec2DTwoTri2Quad::getIncompatible(std::vector<Rec2DAction*> &vect)
}
}
-
void Rec2DTwoTri2Quad::_computeGlobQual()
{
- if (Recombine2D::blossomQual()) {
+ if(Recombine2D::blossomQual()) {
_globQualIfExecuted = -99;
- //_globQualIfExecuted = Rec2DData::getGlobalQuality() + (int)_rt->total_gain;// no more in the code (see Amaury)
+ //_globQualIfExecuted = Rec2DData::getGlobalQuality() +
+ //(int)_rt->total_gain;// no more in the code (see Amaury)
return;
}
- if (Recombine2D::verticesQual()) {
+ if(Recombine2D::verticesQual()) {
_valVert = .0;
_valVert += _vertices[0]->getGainRecomb(_triangles[0], _triangles[1],
_edges[4], _edges[0], _edges[3]);
@@ -3100,19 +3024,19 @@ void Rec2DTwoTri2Quad::_computeGlobQual()
_lastUpdate = Recombine2D::getNumChange();
return;
}
- if (Recombine2D::vertAndEdgesQual()) {
+ if(Recombine2D::vertAndEdgesQual()) {
double valEdge = -Recombine2D::getWeightEdgeBase() * _edges[4]->getQual();
- for (int i = 0; i < 4; ++i)
+ for(int i = 0; i < 4; ++i)
valEdge += Recombine2D::getWeightEdgeQuad() * _edges[i]->getQual();
- if (_vertices[0]->getLastUpdate() > _lastUpdate ||
- _vertices[1]->getLastUpdate() > _lastUpdate ) {
+ if(_vertices[0]->getLastUpdate() > _lastUpdate ||
+ _vertices[1]->getLastUpdate() > _lastUpdate) {
_valVert = _vertices[0]->getGainRecomb(_triangles[0], _triangles[1]);
_valVert += _vertices[1]->getGainRecomb(_triangles[0], _triangles[1]);
}
- double w = 4*Recombine2D::getWeightEdgeQuad()
- - Recombine2D::getWeightEdgeBase();
+ double w =
+ 4 * Recombine2D::getWeightEdgeQuad() - Recombine2D::getWeightEdgeBase();
_globQualIfExecuted = Rec2DData::getGlobalQuality(0, _valVert, w, valEdge);
_lastUpdate = Recombine2D::getNumChange();
return;
@@ -3122,86 +3046,86 @@ void Rec2DTwoTri2Quad::_computeGlobQual()
void Rec2DTwoTri2Quad::_computeReward()
{
- Rec2DQualCrit crit = Recombine2D::getQualCrit();
+ Rec2DQualCrit crit = Recombine2D::getQualCrit();
- switch (crit) {
- case BlossomQuality :
- _reward = -99;
- //_reward = (int)_rt->total_gain;// no more in the code (see Amaury)
- return;
+ switch(crit) {
+ case BlossomQuality:
+ _reward = -99;
+ //_reward = (int)_rt->total_gain;// no more in the code (see Amaury)
+ return;
- case VertQuality :
- _valVert = .0;
- _valVert += _vertices[0]->getGainRecomb(_triangles[0], _triangles[1],
- _edges[4], _edges[0], _edges[3]);
- _valVert += _vertices[1]->getGainRecomb(_triangles[0], _triangles[1],
- _edges[4], _edges[1], _edges[2]);
- _valVert += _vertices[2]->getGainQuad(_triangles[0], _edges[0], _edges[1]);
- _valVert += _vertices[3]->getGainQuad(_triangles[1], _edges[2], _edges[3]);
-
- _reward = Rec2DData::getGlobalQuality(0, _valVert)
- - Rec2DData::getGlobalQuality();
- _lastUpdate = Recombine2D::getNumChange();
- return;
+ case VertQuality:
+ _valVert = .0;
+ _valVert += _vertices[0]->getGainRecomb(_triangles[0], _triangles[1],
+ _edges[4], _edges[0], _edges[3]);
+ _valVert += _vertices[1]->getGainRecomb(_triangles[0], _triangles[1],
+ _edges[4], _edges[1], _edges[2]);
+ _valVert += _vertices[2]->getGainQuad(_triangles[0], _edges[0], _edges[1]);
+ _valVert += _vertices[3]->getGainQuad(_triangles[1], _edges[2], _edges[3]);
- case VertEdgeQuality :
- {
- double valEdge = -Recombine2D::getWeightEdgeBase() * _edges[4]->getQual();
- for (int i = 0; i < 4; ++i)
- valEdge += Recombine2D::getWeightEdgeQuad() * _edges[i]->getQual();
-
- if (_vertices[0]->getLastUpdate() > _lastUpdate ||
- _vertices[1]->getLastUpdate() > _lastUpdate ) {
- _valVert = _vertices[0]->getGainRecomb(_triangles[0], _triangles[1]);
- _valVert += _vertices[1]->getGainRecomb(_triangles[0], _triangles[1]);
- }
+ _reward =
+ Rec2DData::getGlobalQuality(0, _valVert) - Rec2DData::getGlobalQuality();
+ _lastUpdate = Recombine2D::getNumChange();
+ return;
- double w = 4*Recombine2D::getWeightEdgeQuad()
- - Recombine2D::getWeightEdgeBase();
- _reward = Rec2DData::getGlobalQuality(0, _valVert, w, valEdge)
- - Rec2DData::getGlobalQuality();
+ case VertEdgeQuality: {
+ double valEdge = -Recombine2D::getWeightEdgeBase() * _edges[4]->getQual();
+ for(int i = 0; i < 4; ++i)
+ valEdge += Recombine2D::getWeightEdgeQuad() * _edges[i]->getQual();
- _lastUpdate = Recombine2D::getNumChange();
- return;
+ if(_vertices[0]->getLastUpdate() > _lastUpdate ||
+ _vertices[1]->getLastUpdate() > _lastUpdate) {
+ _valVert = _vertices[0]->getGainRecomb(_triangles[0], _triangles[1]);
+ _valVert += _vertices[1]->getGainRecomb(_triangles[0], _triangles[1]);
}
- default :
- Msg::Error("[Rec2DTwoTri2Quad:_computeReward] Unknown quality criterion %d", crit);
+ double w =
+ 4 * Recombine2D::getWeightEdgeQuad() - Recombine2D::getWeightEdgeBase();
+ _reward = Rec2DData::getGlobalQuality(0, _valVert, w, valEdge) -
+ Rec2DData::getGlobalQuality();
+
+ _lastUpdate = Recombine2D::getNumChange();
+ return;
+ }
+
+ default:
+ Msg::Error("[Rec2DTwoTri2Quad:_computeReward] Unknown quality criterion %d",
+ crit);
}
}
void Rec2DTwoTri2Quad::_doWhatYouHaveToDoWithParity(Rec2DDataChange *rdc) const
{
int parMin = Rec2DData::getNewParity(), index = -1;
- for (int i = 0; i < 4; ++i) {
- if (_vertices[i]->getParity() && parMin > _vertices[i]->getParity()) {
+ for(int i = 0; i < 4; ++i) {
+ if(_vertices[i]->getParity() && parMin > _vertices[i]->getParity()) {
parMin = _vertices[i]->getParity();
index = i;
}
}
- if (index == -1) {
+ if(index == -1) {
rdc->changeParity(_vertices[0], parMin);
rdc->changeParity(_vertices[1], parMin);
- rdc->changeParity(_vertices[2], parMin+1);
- rdc->changeParity(_vertices[3], parMin+1);
+ rdc->changeParity(_vertices[2], parMin + 1);
+ rdc->changeParity(_vertices[3], parMin + 1);
}
- else for (int i = 0; i < 4; i += 2) {
- int par;
- if ((index/2) * 2 == i)
- par = parMin;
- else
- par = otherParity(parMin);
- for (int j = 0; j < 2; ++j) {
- if (!_vertices[i+j]->getParity())
- rdc->changeParity(_vertices[i+j], par);
- else if (_vertices[i+j]->getParity() != par)
- Rec2DData::associateParity(_vertices[i+j]->getParity(), par, rdc);
+ else
+ for(int i = 0; i < 4; i += 2) {
+ int par;
+ if((index / 2) * 2 == i)
+ par = parMin;
+ else
+ par = otherParity(parMin);
+ for(int j = 0; j < 2; ++j) {
+ if(!_vertices[i + j]->getParity())
+ rdc->changeParity(_vertices[i + j], par);
+ else if(_vertices[i + j]->getParity() != par)
+ Rec2DData::associateParity(_vertices[i + j]->getParity(), par, rdc);
+ }
}
- }
rdc->checkObsoleteActions(_vertices, 4);
}
-
/** Rec2DCollapse **/
/*********************/
Rec2DCollapse::Rec2DCollapse(Rec2DTwoTri2Quad *rec) : _rec(rec)
@@ -3214,15 +3138,15 @@ Rec2DCollapse::Rec2DCollapse(Rec2DTwoTri2Quad *rec) : _rec(rec)
void Rec2DCollapse::operator delete(void *p)
{
- if (!p) return;
- Rec2DCollapse *ra = (Rec2DCollapse*)p;
- if (ra->_dataAction) { // ra->hide()
+ if(!p) return;
+ Rec2DCollapse *ra = (Rec2DCollapse *)p;
+ if(ra->_dataAction) { // ra->hide()
ra->_rec->_triangles[0]->rmv(ra);
ra->_rec->_triangles[1]->rmv(ra);
Rec2DData::rmv(ra);
}
- if (!ra->_numPointing) {
- //Msg::Info("del ac %d", p);
+ if(!ra->_numPointing) {
+ // Msg::Info("del ac %d", p);
ra->_rec->_col = NULL;
free(p);
}
@@ -3230,19 +3154,15 @@ void Rec2DCollapse::operator delete(void *p)
void Rec2DCollapse::hide()
{
- if (_rec->_triangles[0])
- _rec->_triangles[0]->rmv(this);
- if (_rec->_triangles[1])
- _rec->_triangles[1]->rmv(this);
+ if(_rec->_triangles[0]) _rec->_triangles[0]->rmv(this);
+ if(_rec->_triangles[1]) _rec->_triangles[1]->rmv(this);
Rec2DData::rmv(this);
}
void Rec2DCollapse::reveal()
{
- if (_rec->_triangles[0])
- _rec->_triangles[0]->add(this);
- if (_rec->_triangles[1])
- _rec->_triangles[1]->add(this);
+ if(_rec->_triangles[0]) _rec->_triangles[0]->add(this);
+ if(_rec->_triangles[1]) _rec->_triangles[1]->add(this);
Rec2DData::add(this);
}
@@ -3251,36 +3171,42 @@ bool Rec2DCollapse::isObsolete() const
int p[2];
p[0] = _rec->_vertices[0]->getParity();
p[1] = _rec->_vertices[1]->getParity();
- return (p[0]/2 == p[1]/2 && p[0] != p[1]) ||
+ return (p[0] / 2 == p[1] / 2 && p[0] != p[1]) ||
(_rec->_vertices[0]->getOnBoundary() &&
- _rec->_vertices[1]->getOnBoundary()) ||
+ _rec->_vertices[1]->getOnBoundary()) ||
(!_rec->_vertices[2]->getOnBoundary() &&
_rec->_vertices[2]->getNumElements() < 4) ||
(!_rec->_vertices[3]->getOnBoundary() &&
- _rec->_vertices[3]->getNumElements() < 4) ;
+ _rec->_vertices[3]->getNumElements() < 4);
}
-void Rec2DCollapse::apply(std::vector<Rec2DVertex*> &newPar)
+void Rec2DCollapse::apply(std::vector<Rec2DVertex *> &newPar)
{
static int a = 0;
- if (++a == 1) Msg::Error("FIXME Need definition Rec2DCollapse::apply(newPar)");
+ if(++a == 1) Msg::Error("FIXME Need definition Rec2DCollapse::apply(newPar)");
}
void Rec2DCollapse::apply(Rec2DDataChange *rdc,
- std::vector<Rec2DAction*> *&createdActions,
+ std::vector<Rec2DAction *> *&createdActions,
bool color) const
{
- //Msg::Info("applying Collapse |%d|%d|", _rec->_triangles[0]->getNum(), _rec->_triangles[1]->getNum());
- if (isObsolete()) {
+ // Msg::Info("applying Collapse |%d|%d|", _rec->_triangles[0]->getNum(),
+ // _rec->_triangles[1]->getNum());
+ if(isObsolete()) {
printIdentity();
int p[2];
p[0] = _rec->_vertices[0]->getParity();
p[1] = _rec->_vertices[1]->getParity();
- Msg::Info("%d %d %d %d", _rec->_vertices[0]->getNum(), _rec->_vertices[1]->getNum(), _rec->_vertices[2]->getNum(), _rec->_vertices[3]->getNum());
+ Msg::Info("%d %d %d %d", _rec->_vertices[0]->getNum(),
+ _rec->_vertices[1]->getNum(), _rec->_vertices[2]->getNum(),
+ _rec->_vertices[3]->getNum());
Msg::Info("%d %d - %d %d %d", p[0], p[1],
- _rec->_vertices[0]->getOnBoundary() && _rec->_vertices[1]->getOnBoundary(),
- !_rec->_vertices[2]->getOnBoundary() && _rec->_vertices[2]->getNumElements() < 4,
- !_rec->_vertices[3]->getOnBoundary() && _rec->_vertices[3]->getNumElements() < 4);
+ _rec->_vertices[0]->getOnBoundary() &&
+ _rec->_vertices[1]->getOnBoundary(),
+ !_rec->_vertices[2]->getOnBoundary() &&
+ _rec->_vertices[2]->getNumElements() < 4,
+ !_rec->_vertices[3]->getOnBoundary() &&
+ _rec->_vertices[3]->getNumElements() < 4);
_rec->_vertices[2]->printElem();
_rec->_vertices[3]->printElem();
Msg::Error("[Rec2DTwoTri2Quad] I was obsolete !");
@@ -3289,7 +3215,7 @@ void Rec2DCollapse::apply(Rec2DDataChange *rdc,
#ifdef REC2D_DRAW
rdc->setAction(this);
#endif
- std::vector<Rec2DAction*> actions;
+ std::vector<Rec2DAction *> actions;
_rec->_triangles[0]->getMoreUniqueActions(actions);
_rec->_triangles[1]->getMoreUniqueActions(actions);
rdc->hide(actions);
@@ -3297,13 +3223,13 @@ void Rec2DCollapse::apply(Rec2DDataChange *rdc,
rdc->hide(_rec->_triangles[1]);
rdc->hide(_rec->_edges[4]);
Rec2DVertex *vOK, *vKO;
- if (_rec->_vertices[0]->getOnBoundary()) {
+ if(_rec->_vertices[0]->getOnBoundary()) {
SPoint2 p(_rec->_vertices[0]->u(), _rec->_vertices[0]->v());
rdc->relocate(_rec->_vertices[1], p);
vOK = _rec->_vertices[0];
vKO = _rec->_vertices[1];
}
- else if (_rec->_vertices[1]->getOnBoundary()) {
+ else if(_rec->_vertices[1]->getOnBoundary()) {
SPoint2 p(_rec->_vertices[1]->u(), _rec->_vertices[1]->v());
rdc->relocate(_rec->_vertices[0], p);
vOK = _rec->_vertices[1];
@@ -3318,49 +3244,53 @@ void Rec2DCollapse::apply(Rec2DDataChange *rdc,
vKO = _rec->_vertices[1];
}
bool edge12KO = _rec->_edges[1]->getVertex(0) == vKO ||
- _rec->_edges[1]->getVertex(1) == vKO ;
+ _rec->_edges[1]->getVertex(1) == vKO;
rdc->swapFor(vKO, vOK);
rdc->hide(vKO);
int i0, i1, i2, i3;
- if (edge12KO) {
- i0 = 1; i1 = 2;
- i2 = 0; i3 = 3;
+ if(edge12KO) {
+ i0 = 1;
+ i1 = 2;
+ i2 = 0;
+ i3 = 3;
}
else {
- i0 = 0; i1 = 3;
- i2 = 1; i3 = 2;
+ i0 = 0;
+ i1 = 3;
+ i2 = 1;
+ i3 = 2;
}
{
rdc->swapFor(_rec->_edges[i0], _rec->_edges[i2]);
rdc->swapFor(_rec->_edges[i1], _rec->_edges[i3]);
rdc->hide(_rec->_edges[i0]);
rdc->hide(_rec->_edges[i1]);
- if (createdActions) {
- for (unsigned int i = 0; i < createdActions->size(); ++i) {
+ if(createdActions) {
+ for(unsigned int i = 0; i < createdActions->size(); ++i) {
(*createdActions)[i]->reveal();
rdc->append((*createdActions)[i]);
}
}
else {
- createdActions = new std::vector<Rec2DAction*>;
+ createdActions = new std::vector<Rec2DAction *>;
Rec2DElement *elem[2];
Rec2DAction *newAction;
Rec2DEdge::getElements(_rec->_edges[i2], elem);
- if (elem[1] && elem[0]->isTri() && elem[1]->isTri()) {
+ if(elem[1] && elem[0]->isTri() && elem[1]->isTri()) {
newAction = new Rec2DTwoTri2Quad(elem[0], elem[1]);
rdc->append(newAction);
createdActions->push_back(newAction);
- newAction = new Rec2DCollapse((Rec2DTwoTri2Quad*)newAction);
+ newAction = new Rec2DCollapse((Rec2DTwoTri2Quad *)newAction);
rdc->append(newAction);
createdActions->push_back(newAction);
}
Rec2DEdge::getElements(_rec->_edges[i3], elem);
- if (elem[1] && elem[0]->isTri() && elem[1]->isTri()) {
+ if(elem[1] && elem[0]->isTri() && elem[1]->isTri()) {
newAction = new Rec2DTwoTri2Quad(elem[0], elem[1]);
rdc->append(newAction);
createdActions->push_back(newAction);
- newAction = new Rec2DCollapse((Rec2DTwoTri2Quad*)newAction);
+ newAction = new Rec2DCollapse((Rec2DTwoTri2Quad *)newAction);
rdc->append(newAction);
createdActions->push_back(newAction);
}
@@ -3368,34 +3298,37 @@ void Rec2DCollapse::apply(Rec2DDataChange *rdc,
}
int parKO, parOK;
- if ((parKO = vKO->getParity())) {
- if (!(parOK = vOK->getParity()))
+ if((parKO = vKO->getParity())) {
+ if(!(parOK = vOK->getParity()))
rdc->changeParity(vOK, parKO);
- else if (parOK/2 != parKO/2)
- Rec2DData::associateParity(std::max(parOK, parKO), std::min(parOK, parKO), rdc);
+ else if(parOK / 2 != parKO / 2)
+ Rec2DData::associateParity(std::max(parOK, parKO), std::min(parOK, parKO),
+ rdc);
}
rdc->checkObsoleteActions(_rec->_vertices, 4);
}
-void Rec2DCollapse::getNeighbourElements(std::vector<Rec2DElement*> &elem) const
+void Rec2DCollapse::getNeighbourElements(
+ std::vector<Rec2DElement *> &elem) const
{
_rec->getNeighbourElements(elem);
}
-void Rec2DCollapse::getNeighbElemWithActions(std::vector<Rec2DElement*> &elem) const
+void Rec2DCollapse::getNeighbElemWithActions(
+ std::vector<Rec2DElement *> &elem) const
{
_rec->getNeighbElemWithActions(elem);
}
void Rec2DCollapse::printReward() const
{
- if (Recombine2D::blossomQual()) {
+ if(Recombine2D::blossomQual()) {
Msg::Error("[Rec2DCollapse] Don't know");
//?return (double)_cur->_blossomQuality;
return;
}
- if (Recombine2D::verticesQual()) {
+ if(Recombine2D::verticesQual()) {
SPoint2 p[2];
_rec->_vertices[0]->getParam(&p[0]);
_rec->_vertices[1]->getParam(&p[1]);
@@ -3403,9 +3336,9 @@ void Rec2DCollapse::printReward() const
int b1 = _rec->_vertices[1]->getOnBoundary();
double valVert = .0;
- if (b0 || b1) {
+ if(b0 || b1) {
int iOK = 1, iKO = 0;
- if (b0) {
+ if(b0) {
iOK = 0;
iKO = 1;
}
@@ -3414,19 +3347,20 @@ void Rec2DCollapse::printReward() const
double qualRelocation = Rec2DData::getSumVert() - oldValVert;
valVert += _rec->_vertices[iOK]->getGainMerge(_rec->_vertices[iKO],
- &_rec->_edges[1], 2 );
+ &_rec->_edges[1], 2);
valVert += _rec->_vertices[2]->getGainTriLess(_rec->_edges[1]);
valVert += _rec->_vertices[3]->getGainTriLess(_rec->_edges[2]);
- for (int i = 0; i < 4; ++i) {
- Msg::Info("vert %d : %g", _rec->_vertices[i]->getNum(), _rec->_vertices[i]->getQual());
+ for(int i = 0; i < 4; ++i) {
+ Msg::Info("vert %d : %g", _rec->_vertices[i]->getNum(),
+ _rec->_vertices[i]->getQual());
}
Msg::Info("qual col %g %g %g %g", qualRelocation,
- _rec->_vertices[iOK]->getGainMerge(_rec->_vertices[iKO], &_rec->_edges[1], 2),
+ _rec->_vertices[iOK]->getGainMerge(_rec->_vertices[iKO],
+ &_rec->_edges[1], 2),
_rec->_vertices[2]->getGainTriLess(_rec->_edges[1]),
- _rec->_vertices[3]->getGainTriLess(_rec->_edges[2])
- );
+ _rec->_vertices[3]->getGainTriLess(_rec->_edges[2]));
_rec->_vertices[iKO]->relocate(p[iKO]);
}
@@ -3441,57 +3375,59 @@ void Rec2DCollapse::printReward() const
valVert += _rec->_vertices[0]->getGainMerge(_rec->_vertices[1],
&_rec->_edges[1], 2);
- valVert += _rec->_vertices[2]->getGainTriLess(_rec->_edges[0]); //FIX normal ?
+ valVert +=
+ _rec->_vertices[2]->getGainTriLess(_rec->_edges[0]); // FIX normal ?
valVert += _rec->_vertices[3]->getGainTriLess(_rec->_edges[2]);
- for (int i = 0; i < 4; ++i) {
- Msg::Info("vert %d : %g", _rec->_vertices[i]->getNum(), _rec->_vertices[i]->getQual());
+ for(int i = 0; i < 4; ++i) {
+ Msg::Info("vert %d : %g", _rec->_vertices[i]->getNum(),
+ _rec->_vertices[i]->getQual());
}
Msg::Info("qual col %g %g %g %g", qualRelocation,
- _rec->_vertices[0]->getGainMerge(_rec->_vertices[1], &_rec->_edges[1], 2),
+ _rec->_vertices[0]->getGainMerge(_rec->_vertices[1],
+ &_rec->_edges[1], 2),
_rec->_vertices[2]->getGainTriLess(_rec->_edges[1]),
- _rec->_vertices[3]->getGainTriLess(_rec->_edges[2])
- );
+ _rec->_vertices[3]->getGainTriLess(_rec->_edges[2]));
_rec->_vertices[0]->relocate(p[0]);
_rec->_vertices[1]->relocate(p[1]);
}
return;
}
- if (Recombine2D::vertAndEdgesQual()) {
- std::vector<Rec2DVertex*> verts;
- std::vector<Rec2DEdge*> edges;
+ if(Recombine2D::vertAndEdgesQual()) {
+ std::vector<Rec2DVertex *> verts;
+ std::vector<Rec2DEdge *> edges;
_rec->_vertices[0]->getEdges(edges);
- for (unsigned int i = 0; i < edges.size(); ++i) {
+ for(unsigned int i = 0; i < edges.size(); ++i) {
Rec2DVertex *v = edges[i]->getOtherVertex(_rec->_vertices[0]);
bool toAdd = true;
- for (int j = 0; j < 4; ++j) {
- if (v == _rec->_vertices[j]) {
+ for(int j = 0; j < 4; ++j) {
+ if(v == _rec->_vertices[j]) {
toAdd = false;
break;
}
}
- if (toAdd) verts.push_back(v);
+ if(toAdd) verts.push_back(v);
}
_rec->_vertices[1]->getEdges(edges);
- for (unsigned int i = 0; i < edges.size(); ++i) {
+ for(unsigned int i = 0; i < edges.size(); ++i) {
Rec2DVertex *v = edges[i]->getOtherVertex(_rec->_vertices[1]);
bool toAdd = true;
- for (int j = 0; j < 4; ++j) {
- if (v == _rec->_vertices[j]) {
+ for(int j = 0; j < 4; ++j) {
+ if(v == _rec->_vertices[j]) {
toAdd = false;
break;
}
}
- if (toAdd) verts.push_back(v);
+ if(toAdd) verts.push_back(v);
}
_rec->_vertices[0]->getMoreUniqueEdges(edges);
_rec->_vertices[1]->getMoreUniqueEdges(edges);
int numEdgeBef = edges.size(), weightEdgeBef = 0;
double valEdgeBef = 0;
- for (unsigned int i = 0; i < edges.size(); ++i) {
+ for(unsigned int i = 0; i < edges.size(); ++i) {
valEdgeBef += edges[i]->getWeightedQual();
weightEdgeBef += edges[i]->getWeight();
}
@@ -3502,11 +3438,11 @@ void Rec2DCollapse::printReward() const
vert01Bef += _rec->_vertices[1]->getQual();
vert23Bef += _rec->_vertices[2]->getQual();
vert23Bef += _rec->_vertices[3]->getQual();
- for (unsigned int i = 0; i < verts.size(); ++i) {
+ for(unsigned int i = 0; i < verts.size(); ++i) {
vertOtherBef += verts[i]->getQual();
}
- Rec2DNode *n = new Rec2DNode(NULL, (Rec2DAction*)this, 0);
+ Rec2DNode *n = new Rec2DNode(NULL, (Rec2DAction *)this, 0);
n->makeChanges();
edges.clear();
@@ -3514,19 +3450,19 @@ void Rec2DCollapse::printReward() const
_rec->_vertices[1]->getMoreUniqueEdges(edges);
int numEdgeAft = edges.size(), weightEdgeAft = 0;
double valEdgeAft = 0;
- for (unsigned int i = 0; i < edges.size(); ++i) {
+ for(unsigned int i = 0; i < edges.size(); ++i) {
valEdgeAft += edges[i]->getWeightedQual();
weightEdgeAft += edges[i]->getWeight();
}
double vert01Aft = 0, vert23Aft = 0, vertOtherAft = 0;
- if (_rec->_vertices[0]->getNumElements())
+ if(_rec->_vertices[0]->getNumElements())
vert01Aft += _rec->_vertices[0]->getQual();
- if (_rec->_vertices[1]->getNumElements())
+ if(_rec->_vertices[1]->getNumElements())
vert01Aft += _rec->_vertices[1]->getQual();
vert23Aft += _rec->_vertices[2]->getQual();
vert23Aft += _rec->_vertices[3]->getQual();
- for (unsigned int i = 0; i < verts.size(); ++i) {
+ for(unsigned int i = 0; i < verts.size(); ++i) {
vertOtherAft += verts[i]->getQual();
}
@@ -3535,10 +3471,10 @@ void Rec2DCollapse::printReward() const
Msg::Info("-(%d)%de%g +(%d)%de%g "
"-4v%g +2v%g +0v%g +(%d)0v%g",
- numEdgeBef, weightEdgeBef, valEdgeBef/weightEdgeBef,
- numEdgeAft, weightEdgeAft, valEdgeAft/weightEdgeAft,
- vert01Bef/4, vert01Aft/2, (vert23Aft-vert23Bef)/2,
- numVertOther, vertOtherAft-vertOtherBef);
+ numEdgeBef, weightEdgeBef, valEdgeBef / weightEdgeBef, numEdgeAft,
+ weightEdgeAft, valEdgeAft / weightEdgeAft, vert01Bef / 4,
+ vert01Aft / 2, (vert23Aft - vert23Bef) / 2, numVertOther,
+ vertOtherAft - vertOtherBef);
return;
}
Msg::Error("[Rec2DCollapse] Unknown quality criterion");
@@ -3546,17 +3482,18 @@ void Rec2DCollapse::printReward() const
void Rec2DCollapse::printIdentity() const
{
- Msg::Info("Collapse |%d|%d|", _rec->_triangles[0]->getNum(), _rec->_triangles[1]->getNum());
+ Msg::Info("Collapse |%d|%d|", _rec->_triangles[0]->getNum(),
+ _rec->_triangles[1]->getNum());
}
void Rec2DCollapse::_computeGlobQual()
{
- std::vector<Rec2DVertex*> verts;
+ std::vector<Rec2DVertex *> verts;
_rec->_vertices[0]->getMoreNeighbourVertices(verts);
_rec->_vertices[1]->getMoreNeighbourVertices(verts);
unsigned int i = 0;
- while (i < verts.size() && verts[i]->getLastUpdate() <= _lastUpdate) ++i;
- if (i >= verts.size()) {
+ while(i < verts.size() && verts[i]->getLastUpdate() <= _lastUpdate) ++i;
+ if(i >= verts.size()) {
_lastUpdate = Recombine2D::getNumChange();
return;
}
@@ -3567,23 +3504,23 @@ void Rec2DCollapse::_computeGlobQual()
int b0 = _rec->_vertices[0]->getOnBoundary();
int b1 = _rec->_vertices[1]->getOnBoundary();
- if (Recombine2D::blossomQual()) {
+ if(Recombine2D::blossomQual()) {
Msg::Error("[Rec2DCollapse] Don't know");
//?return (double)_cur->_blossomQuality;
return;
}
- if (Recombine2D::verticesQual()) {
+ if(Recombine2D::verticesQual()) {
double valVert = .0;
- if (b0 || b1) {
+ if(b0 || b1) {
int iOK = 1, iKO = 0;
- if (b0) {
+ if(b0) {
iOK = 0;
iKO = 1;
}
_rec->_vertices[iKO]->relocate(p[iOK]);
valVert += _rec->_vertices[iOK]->getGainMerge(_rec->_vertices[iKO],
- &_rec->_edges[1], 2 );
+ &_rec->_edges[1], 2);
valVert += _rec->_vertices[2]->getGainTriLess(_rec->_edges[1]);
valVert += _rec->_vertices[3]->getGainTriLess(_rec->_edges[2]);
_globQualIfExecuted = Rec2DData::getGlobalQuality(-1, valVert);
@@ -3609,12 +3546,12 @@ void Rec2DCollapse::_computeGlobQual()
_lastUpdate = Recombine2D::getNumChange();
return;
}
- if (Recombine2D::vertAndEdgesQual()) {
+ if(Recombine2D::vertAndEdgesQual()) {
int numEdge = 0;
double valEdge = .0, valVert = .0;
- if (b0 || b1) {
+ if(b0 || b1) {
int iOK = 1, iKO = 0;
- if (b0) {
+ if(b0) {
iOK = 0;
iKO = 1;
}
@@ -3629,8 +3566,8 @@ void Rec2DCollapse::_computeGlobQual()
valEdge -= _rec->_edges[4]->getWeightedQual();
numEdge -= _rec->_edges[4]->getWeight();
- _globQualIfExecuted = Rec2DData::getGlobalQuality(-1, valVert,
- numEdge, valEdge);
+ _globQualIfExecuted =
+ Rec2DData::getGlobalQuality(-1, valVert, numEdge, valEdge);
_rec->_vertices[iKO]->relocate(p[iKO]);
}
@@ -3650,8 +3587,8 @@ void Rec2DCollapse::_computeGlobQual()
valEdge -= _rec->_edges[4]->getWeightedQual();
numEdge -= _rec->_edges[4]->getWeight();
- _globQualIfExecuted = Rec2DData::getGlobalQuality(-1, valVert,
- numEdge, valEdge);
+ _globQualIfExecuted =
+ Rec2DData::getGlobalQuality(-1, valVert, numEdge, valEdge);
_rec->_vertices[0]->relocate(p[0]);
_rec->_vertices[1]->relocate(p[1]);
@@ -3670,16 +3607,15 @@ void Rec2DCollapse::_computeReward()
bool Rec2DCollapse::_hasIdenticalElement() const
{
return _rec->_triangles[0]->hasIdenticalNeighbour() ||
- _rec->_triangles[1]->hasIdenticalNeighbour() ;
+ _rec->_triangles[1]->hasIdenticalNeighbour();
}
-
/** Rec2DEdge **/
/*****************/
Rec2DEdge::Rec2DEdge(Rec2DVertex *rv0, Rec2DVertex *rv1)
-: _rv0(rv0), _rv1(rv1), _weight(Recombine2D::getWeightEdgeBase()
- + 2*Recombine2D::getWeightEdgeQuad()),
- _lastUpdate(-1), _pos(-1)
+ : _rv0(rv0), _rv1(rv1), _weight(Recombine2D::getWeightEdgeBase() +
+ 2 * Recombine2D::getWeightEdgeQuad()),
+ _lastUpdate(-1), _pos(-1)
{
_qual = -999999999; // FIXME // _computeQual();
reveal();
@@ -3699,34 +3635,33 @@ void Rec2DEdge::reveal()
Rec2DData::add(this);
}
-Rec2DVertex* Rec2DEdge::getOtherVertex(const Rec2DVertex *rv) const
+Rec2DVertex *Rec2DEdge::getOtherVertex(const Rec2DVertex *rv) const
{
- if (rv == _rv0)
- return _rv1;
- if (rv == _rv1)
- return _rv0;
+ if(rv == _rv0) return _rv1;
+ if(rv == _rv1) return _rv0;
Msg::Error("[Rec2DEdge] You are wrong, I don't have this vertex !");
return NULL;
}
-Rec2DElement* Rec2DEdge::getTheOnlyElement(const Rec2DEdge *re)
+Rec2DElement *Rec2DEdge::getTheOnlyElement(const Rec2DEdge *re)
{
- std::vector<Rec2DElement*> elem;
+ std::vector<Rec2DElement *> elem;
Rec2DVertex::getCommonElements(re->getVertex(0), re->getVertex(1), elem);
unsigned int i = 0;
- while (i < elem.size()) {
- if (!elem[i]->has(re)) {
+ while(i < elem.size()) {
+ if(!elem[i]->has(re)) {
elem[i] = elem.back();
elem.pop_back();
}
else
++i;
}
- if (elem.size() == 1)
- return elem[0];
- if (elem.size() != 0) {
- Msg::Info("size(%d) %d %d", elem.size(), elem[0]->getNum(), elem[1]->getNum());
- Msg::Error("[Rec2DEdge] Edge bound %d elements, returning NULL", elem.size());
+ if(elem.size() == 1) return elem[0];
+ if(elem.size() != 0) {
+ Msg::Info("size(%d) %d %d", elem.size(), elem[0]->getNum(),
+ elem[1]->getNum());
+ Msg::Error("[Rec2DEdge] Edge bound %d elements, returning NULL",
+ elem.size());
}
return NULL;
}
@@ -3735,30 +3670,26 @@ void Rec2DEdge::getElements(const Rec2DEdge *re, Rec2DElement **elem)
{
elem[0] = NULL;
elem[1] = NULL;
- std::vector<Rec2DElement*> vectElem;
+ std::vector<Rec2DElement *> vectElem;
Rec2DVertex::getCommonElements(re->getVertex(0), re->getVertex(1), vectElem);
unsigned int i = 0;
- while (i < vectElem.size()) {
- if (!vectElem[i]->has(re)) {
+ while(i < vectElem.size()) {
+ if(!vectElem[i]->has(re)) {
vectElem[i] = vectElem.back();
vectElem.pop_back();
}
else
++i;
}
- switch (vectElem.size()) {
- case 2 :
- elem[1] = vectElem[1];
- case 1 :
- elem[0] = vectElem[0];
- case 0 :
- return;
- default :
- Msg::Error("[Rec2DEdge] my integrity is not respected :'(");
+ switch(vectElem.size()) {
+ case 2: elem[1] = vectElem[1];
+ case 1: elem[0] = vectElem[0];
+ case 0: return;
+ default: Msg::Error("[Rec2DEdge] my integrity is not respected :'(");
}
}
-//void Rec2DEdge::getUniqueActions(std::vector<Rec2DAction*> &actions) const
+// void Rec2DEdge::getUniqueActions(std::vector<Rec2DAction*> &actions) const
//{
// actions.clear();
// Rec2DElement *elem[2];
@@ -3771,7 +3702,7 @@ void Rec2DEdge::updateQual()
{
double diffQual = _qual;
_computeQual();
- diffQual = _weight*(_qual-diffQual);
+ diffQual = _weight * (_qual - diffQual);
_rv0->updateWAQualEdges(diffQual);
_rv1->updateWAQualEdges(diffQual);
@@ -3787,15 +3718,15 @@ bool Rec2DEdge::isOnBoundary() const
void Rec2DEdge::swap(Rec2DVertex *oldRV, Rec2DVertex *newRV, bool upVert)
{
- if (upVert) {
+ if(upVert) {
oldRV->rmv(this);
newRV->add(this);
}
- if (_rv0 == oldRV) {
+ if(_rv0 == oldRV) {
_rv0 = newRV;
return;
}
- if (_rv1 == oldRV) {
+ if(_rv1 == oldRV) {
_rv1 = newRV;
return;
}
@@ -3804,19 +3735,20 @@ void Rec2DEdge::swap(Rec2DVertex *oldRV, Rec2DVertex *newRV, bool upVert)
bool Rec2DEdge::checkCoherence() const
{
- if (_rv0 == _rv1) return false;
- if (!_rv0->has(this) || !_rv1->has(this)) return false;
+ if(_rv0 == _rv1) return false;
+ if(!_rv0->has(this) || !_rv1->has(this)) return false;
Rec2DElement *elem[2];
Rec2DEdge::getElements(this, elem);
- if (elem[1]) {
- if (!elem[0]->has(this) || !elem[1]->has(this)) return false;
- if (!elem[0]->isNeighbour(this, elem[1]) ||
- !elem[1]->isNeighbour(this, elem[0]) ) return false;
+ if(elem[1]) {
+ if(!elem[0]->has(this) || !elem[1]->has(this)) return false;
+ if(!elem[0]->isNeighbour(this, elem[1]) ||
+ !elem[1]->isNeighbour(this, elem[0]))
+ return false;
}
else {
- if (!elem[0]->has(this)) return false;
- if (!elem[0]->isNeighbour(this, NULL)) return false;
+ if(!elem[0]->has(this)) return false;
+ if(!elem[0]->isNeighbour(this, NULL)) return false;
}
return true;
}
@@ -3826,10 +3758,8 @@ void Rec2DEdge::print() const
Rec2DElement *elem[2];
Rec2DEdge::getElements(this, elem);
int a, b = a = 0;
- if (elem[0])
- a = elem[0]->getNum();
- if (elem[1])
- b = elem[1]->getNum();
+ if(elem[0]) a = elem[0]->getNum();
+ if(elem[1]) b = elem[1]->getNum();
Msg::Info(" edge , %d--%d , %d/%d", _rv0->getNum(), _rv1->getNum(), a, b);
}
@@ -3838,27 +3768,27 @@ void Rec2DEdge::_computeQual()
{
double alignment = _straightAlignment();
double adimLength = _straightAdimLength();
- if (adimLength > 1)
- adimLength = 1./adimLength;
+ if(adimLength > 1) adimLength = 1. / adimLength;
- _qual = (Recombine2D::getCoefLengOrientQual() * alignment
- + Recombine2D::getCoefLengthQual() ) * adimLength
- + Recombine2D::getCoefOrientQual() * alignment;
+ _qual = (Recombine2D::getCoefLengOrientQual() * alignment +
+ Recombine2D::getCoefLengthQual()) *
+ adimLength +
+ Recombine2D::getCoefOrientQual() * alignment;
_lastUpdate = Recombine2D::getNumChange();
}
void Rec2DEdge::_addWeight(int w)
{
_weight += w;
- if (_weight > Recombine2D::getWeightEdgeBase()
- + 2*Recombine2D::getWeightEdgeQuad()) {
+ if(_weight >
+ Recombine2D::getWeightEdgeBase() + 2 * Recombine2D::getWeightEdgeQuad()) {
Msg::Error("[Rec2DEdge] Weight too high");
}
- if (_weight < Recombine2D::getWeightEdgeBase()) {
+ if(_weight < Recombine2D::getWeightEdgeBase()) {
Msg::Error("[Rec2DEdge] Weight too low");
}
- double diffQual = w*getQual();
+ double diffQual = w * getQual();
_rv0->updateWAQualEdges(diffQual, w);
_rv1->updateWAQualEdges(diffQual, w);
Rec2DData::updateEdgeQual(diffQual, w);
@@ -3879,14 +3809,14 @@ double Rec2DEdge::_straightAdimLength() const
double lc0 = (*Recombine2D::bgm())(_rv0->u(), _rv0->v(), .0);
double lc1 = (*Recombine2D::bgm())(_rv1->u(), _rv1->v(), .0);
- return length * (1./lc0 + 1./lc1) / 2.;
+ return length * (1. / lc0 + 1. / lc1) / 2.;
}
double Rec2DEdge::_straightAlignment() const
{
double angle0 = Recombine2D::bgm()->getAngle(_rv0->u(), _rv0->v(), .0);
double angle1 = Recombine2D::bgm()->getAngle(_rv1->u(), _rv1->v(), .0);
- double angleEdge = atan2(_rv0->v()-_rv1->v(), _rv0->u()-_rv1->u());
+ double angleEdge = atan2(_rv0->v() - _rv1->v(), _rv0->u() - _rv1->u());
double alpha0 = angleEdge - angle0;
double alpha1 = angleEdge - angle1;
@@ -3898,48 +3828,46 @@ double Rec2DEdge::_straightAlignment() const
double lc0 = (*Recombine2D::bgm())(_rv0->u(), _rv0->v(), .0);
double lc1 = (*Recombine2D::bgm())(_rv1->u(), _rv1->v(), .0);
- return (alpha0/lc0 + alpha1/lc1) / (1./lc0 + 1./lc1);
+ return (alpha0 / lc0 + alpha1 / lc1) / (1. / lc0 + 1. / lc1);
}
-
/** Rec2DVertex **/
/*******************/
Rec2DVertex::Rec2DVertex(MVertex *v)
-: _v(v), _angle(4.*M_PI), _onWhat(1), _parity(0),
- _lastUpdate(-1), _sumWQualAngle(.0), _sumWQualEdge(.0),
- _sumWeightAngle(0), _sumWeightEdge(0), _pos(-1)
+ : _v(v), _angle(4. * M_PI), _onWhat(1), _parity(0), _lastUpdate(-1),
+ _sumWQualAngle(.0), _sumWQualEdge(.0), _sumWeightAngle(0),
+ _sumWeightEdge(0), _pos(-1)
{
reparamMeshVertexOnFace(_v, Recombine2D::getGFace(), _param);
reveal();
#ifdef REC2D_DRAW
- if (_v)
- _v->setIndex(_parity);
+ if(_v) _v->setIndex(_parity);
//_v->setIndex(_onWhat);
#endif
}
Rec2DVertex::Rec2DVertex(Rec2DVertex *rv, double ang)
-: _v(rv->_v), _angle(ang), _onWhat(-1), _parity(rv->_parity),
- _lastUpdate(rv->_lastUpdate),
- _sumWQualAngle(rv->_sumWQualAngle), _sumWQualEdge(rv->_sumWQualEdge),
- _sumWeightAngle(rv->_sumWeightAngle), _sumWeightEdge(rv->_sumWeightEdge), _edges(rv->_edges),
- _elements(rv->_elements), _param(rv->_param), _pos(-1)
+ : _v(rv->_v), _angle(ang), _onWhat(-1), _parity(rv->_parity),
+ _lastUpdate(rv->_lastUpdate), _sumWQualAngle(rv->_sumWQualAngle),
+ _sumWQualEdge(rv->_sumWQualEdge), _sumWeightAngle(rv->_sumWeightAngle),
+ _sumWeightEdge(rv->_sumWeightEdge), _edges(rv->_edges),
+ _elements(rv->_elements), _param(rv->_param), _pos(-1)
{
rv->hide(false);
// swap the two vertices in edges
- for (unsigned int i = 0; i < _edges.size(); ++i) {
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
_edges[i]->swap(rv, this, false);
}
rv->_edges.clear();
// swap the two vertices in actions
- std::vector<Rec2DAction*> actions;
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ std::vector<Rec2DAction *> actions;
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
_elements[i]->getMoreUniqueActions(actions);
}
- for (unsigned int i = 0; i < actions.size(); ++i) {
- if (actions[i]->isRecomb()) actions[i]->swap(rv, this);
+ for(unsigned int i = 0; i < actions.size(); ++i) {
+ if(actions[i]->isRecomb()) actions[i]->swap(rv, this);
}
rv->_elements.clear();
@@ -3947,8 +3875,7 @@ Rec2DVertex::Rec2DVertex(Rec2DVertex *rv, double ang)
reveal();
delete rv;
#ifdef REC2D_DRAW
- if (_v)
- _v->setIndex(_parity);
+ if(_v) _v->setIndex(_parity);
//_v->setIndex(_onWhat);
#endif
_lastUpdate = Recombine2D::getNumChange();
@@ -3956,18 +3883,17 @@ Rec2DVertex::Rec2DVertex(Rec2DVertex *rv, double ang)
void Rec2DVertex::hide(bool check)
{
- if (check && _elements.size() && _edges.size())
- Msg::Error("[Rec2DVertex] I have %d elements and %d edges", _elements.size(), _edges.size());
- if (_parity)
- Rec2DData::removeParity(this, _parity);
+ if(check && _elements.size() && _edges.size())
+ Msg::Error("[Rec2DVertex] I have %d elements and %d edges",
+ _elements.size(), _edges.size());
+ if(_parity) Rec2DData::removeParity(this, _parity);
Rec2DData::rmv(this);
}
void Rec2DVertex::reveal()
{
- if (_parity)
- Rec2DData::addParity(this, _parity);
+ if(_parity) Rec2DData::addParity(this, _parity);
Rec2DData::add(this);
}
@@ -3975,34 +3901,34 @@ void Rec2DVertex::reveal()
void Rec2DVertex::initStaticTable()
{
// _qualVSnum[onWhat][numEl]; onWhat={0:edge,1:face}
- // _gains[onWhat][numEl]; onWhat={0:edge,1:face} (earning of adding an element)
- if (_qualVSnum == NULL) {
- int nE = 10, nF = 20; //edge, face
+ // _gains[onWhat][numEl]; onWhat={0:edge,1:face} (earning of adding an
+ // element)
+ if(_qualVSnum == NULL) {
+ int nE = 10, nF = 20; // edge, face
- _qualVSnum = new double*[2];
+ _qualVSnum = new double *[2];
_qualVSnum[0] = new double[nE];
_qualVSnum[1] = new double[nF];
_qualVSnum[0][0] = -REC2D_BIG_NUMB;
_qualVSnum[1][0] = -REC2D_BIG_NUMB;
- for (int i = 1; i < nE; ++i)
- _qualVSnum[0][i] = 1. - fabs(2./i - 1.);
- for (int i = 1; i < nF; ++i)
- _qualVSnum[1][i] = std::max(1. - fabs(4./i - 1.), .0);
+ for(int i = 1; i < nE; ++i) _qualVSnum[0][i] = 1. - fabs(2. / i - 1.);
+ for(int i = 1; i < nF; ++i)
+ _qualVSnum[1][i] = std::max(1. - fabs(4. / i - 1.), .0);
- _gains = new double*[2];
- _gains[0] = new double[nE-1];
- _gains[1] = new double[nF-1];
- for (int i = 0; i < nE-1; ++i)
- _gains[0][i] = _qualVSnum[0][i+1] - _qualVSnum[0][i];
- for (int i = 0; i < nF-1; ++i)
- _gains[1][i] = _qualVSnum[1][i+1] - _qualVSnum[1][i];
+ _gains = new double *[2];
+ _gains[0] = new double[nE - 1];
+ _gains[1] = new double[nF - 1];
+ for(int i = 0; i < nE - 1; ++i)
+ _gains[0][i] = _qualVSnum[0][i + 1] - _qualVSnum[0][i];
+ for(int i = 0; i < nF - 1; ++i)
+ _gains[1][i] = _qualVSnum[1][i + 1] - _qualVSnum[1][i];
}
}
void Rec2DVertex::add(const Rec2DEdge *re)
{
- for (unsigned int i = 0; i < _edges.size(); ++i) {
- if (_edges[i] == re) {
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
+ if(_edges[i] == re) {
Msg::Error("[Rec2DVertex] Edge was already there");
return;
}
@@ -4010,18 +3936,18 @@ void Rec2DVertex::add(const Rec2DEdge *re)
double oldQual = getQual(VertQuality);
- _edges.push_back(const_cast<Rec2DEdge*>(re));
+ _edges.push_back(const_cast<Rec2DEdge *>(re));
_sumWQualEdge += re->getWeightedQual();
_sumWeightEdge += re->getWeight();
_lastUpdate = Recombine2D::getNumChange();
- Rec2DData::updateVertQual(getQual(VertQuality)-oldQual, VertQuality);
+ Rec2DData::updateVertQual(getQual(VertQuality) - oldQual, VertQuality);
}
bool Rec2DVertex::has(const Rec2DEdge *re) const
{
- for (unsigned int i = 0; i < _edges.size(); ++i) {
- if (_edges[i] == re) return true;
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
+ if(_edges[i] == re) return true;
}
return false;
}
@@ -4029,20 +3955,20 @@ bool Rec2DVertex::has(const Rec2DEdge *re) const
void Rec2DVertex::rmv(const Rec2DEdge *re)
{
unsigned int i = 0;
- while (i < _edges.size()) {
- if (_edges[i] == re) {
-
+ while(i < _edges.size()) {
+ if(_edges[i] == re) {
double oldQual = getQual(VertQuality);
_edges[i] = _edges.back();
_edges.pop_back();
_sumWQualEdge -= re->getWeightedQual();
_sumWeightEdge -= re->getWeight();
- if (_sumWeightEdge < 0 || _sumWQualEdge < -1e12)
- Msg::Error("[Rec2DVertex] Negative sum edge %d %g", _sumWeightEdge, _sumWQualEdge);
+ if(_sumWeightEdge < 0 || _sumWQualEdge < -1e12)
+ Msg::Error("[Rec2DVertex] Negative sum edge %d %g", _sumWeightEdge,
+ _sumWQualEdge);
_lastUpdate = Recombine2D::getNumChange();
- Rec2DData::updateVertQual(getQual(VertQuality)-oldQual, VertQuality);
+ Rec2DData::updateVertQual(getQual(VertQuality) - oldQual, VertQuality);
return;
}
++i;
@@ -4052,8 +3978,8 @@ void Rec2DVertex::rmv(const Rec2DEdge *re)
void Rec2DVertex::add(const Rec2DElement *rel)
{
- for (unsigned int i = 0; i < _elements.size(); ++i) {
- if (_elements[i] == rel) {
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
+ if(_elements[i] == rel) {
Msg::Error("[Rec2DVertex] Element was already there");
return;
}
@@ -4062,20 +3988,20 @@ void Rec2DVertex::add(const Rec2DElement *rel)
double oldQual1 = getQual(VertQuality);
double oldQual2 = getQual(VertEdgeQuality);
- _elements.push_back(const_cast<Rec2DElement*>(rel));
+ _elements.push_back(const_cast<Rec2DElement *>(rel));
_sumWeightAngle += rel->getAngleWeight();
_sumWQualAngle += rel->getWeightedAngleQual(this);
_lastUpdate = Recombine2D::getNumChange();
- Rec2DData::updateVertQual(getQual(VertQuality)-oldQual1, VertQuality);
- Rec2DData::updateVertQual(getQual(VertEdgeQuality)-oldQual2, VertEdgeQuality);
+ Rec2DData::updateVertQual(getQual(VertQuality) - oldQual1, VertQuality);
+ Rec2DData::updateVertQual(getQual(VertEdgeQuality) - oldQual2,
+ VertEdgeQuality);
}
bool Rec2DVertex::has(const Rec2DElement *rel) const
{
- for (unsigned int i = 0; i < _elements.size(); ++i) {
- if (_elements[i] == rel)
- return true;
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
+ if(_elements[i] == rel) return true;
}
return false;
}
@@ -4083,9 +4009,8 @@ bool Rec2DVertex::has(const Rec2DElement *rel) const
void Rec2DVertex::rmv(const Rec2DElement *rel)
{
unsigned int i = 0;
- while (i < _elements.size()) {
- if (_elements[i] == rel) {
-
+ while(i < _elements.size()) {
+ if(_elements[i] == rel) {
double oldQual1 = getQual(VertQuality);
double oldQual2 = getQual(VertEdgeQuality);
@@ -4095,8 +4020,9 @@ void Rec2DVertex::rmv(const Rec2DElement *rel)
_elements.pop_back();
_lastUpdate = Recombine2D::getNumChange();
- Rec2DData::updateVertQual(getQual(VertQuality)-oldQual1, VertQuality);
- Rec2DData::updateVertQual(getQual(VertEdgeQuality)-oldQual2, VertEdgeQuality);
+ Rec2DData::updateVertQual(getQual(VertQuality) - oldQual1, VertQuality);
+ Rec2DData::updateVertQual(getQual(VertEdgeQuality) - oldQual2,
+ VertEdgeQuality);
return;
}
++i;
@@ -4104,83 +4030,82 @@ void Rec2DVertex::rmv(const Rec2DElement *rel)
Msg::Error("[Rec2DVertex] Didn't removed element, didn't have it");
}
-void Rec2DVertex::getMoreUniqueEdges(std::vector<Rec2DEdge*> &edges) const
+void Rec2DVertex::getMoreUniqueEdges(std::vector<Rec2DEdge *> &edges) const
{
unsigned int size = edges.size();
- for (unsigned int i = 0; i < _edges.size(); ++i) {
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
unsigned int j = -1;
- while (++j < size && edges[j] != _edges[i]);
- if (j == size)
- edges.push_back(_edges[i]);
+ while(++j < size && edges[j] != _edges[i])
+ ;
+ if(j == size) edges.push_back(_edges[i]);
}
}
-Rec2DEdge* Rec2DVertex::getCommonEdge(const Rec2DVertex *rv0,
- const Rec2DVertex *rv1 )
+Rec2DEdge *Rec2DVertex::getCommonEdge(const Rec2DVertex *rv0,
+ const Rec2DVertex *rv1)
{
- for (unsigned int i = 0; i < rv0->_edges.size(); ++i) {
- if (rv1->has(rv0->_edges[i]))
- return rv0->_edges[i];
+ for(unsigned int i = 0; i < rv0->_edges.size(); ++i) {
+ if(rv1->has(rv0->_edges[i])) return rv0->_edges[i];
}
- //Msg::Warning("[Rec2DVertex] didn't find edge, returning NULL");
+ // Msg::Warning("[Rec2DVertex] didn't find edge, returning NULL");
return NULL;
}
-void Rec2DVertex::getMoreNeighbourVertices(std::vector<Rec2DVertex*> &verts) const
+void Rec2DVertex::getMoreNeighbourVertices(
+ std::vector<Rec2DVertex *> &verts) const
{
- for (unsigned int i = 0; i < _edges.size(); ++i)
+ for(unsigned int i = 0; i < _edges.size(); ++i)
verts.push_back(_edges[i]->getOtherVertex(this));
}
void Rec2DVertex::getCommonElements(const Rec2DVertex *rv0,
const Rec2DVertex *rv1,
- std::vector<Rec2DElement*> &elem)
+ std::vector<Rec2DElement *> &elem)
{
- for (unsigned int i = 0; i < rv0->_elements.size(); ++i) {
- if (rv1->has(rv0->_elements[i]))
- elem.push_back(rv0->_elements[i]);
+ for(unsigned int i = 0; i < rv0->_elements.size(); ++i) {
+ if(rv1->has(rv0->_elements[i])) elem.push_back(rv0->_elements[i]);
}
}
-void Rec2DVertex::getMoreUniqueActions(std::vector<Rec2DAction*> &actions) const
+void Rec2DVertex::getMoreUniqueActions(
+ std::vector<Rec2DAction *> &actions) const
{
- std::vector<Rec2DAction*> actions2;
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ std::vector<Rec2DAction *> actions2;
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
_elements[i]->getMoreUniqueActions(actions2);
}
int size = (int)actions.size();
- for (unsigned int i = 0; i < actions2.size(); ++i) {
+ for(unsigned int i = 0; i < actions2.size(); ++i) {
int j = -1;
- while (++j < size && actions2[i] != actions[j]);
- if (j == size) actions.push_back(actions2[i]);
+ while(++j < size && actions2[i] != actions[j])
+ ;
+ if(j == size) actions.push_back(actions2[i]);
}
}
void Rec2DVertex::setOnBoundary()
{
- if (_onWhat > 0) {
+ if(_onWhat > 0) {
double oldQual1 = getQual(VertQuality);
double oldQual2 = getQual(VertEdgeQuality);
_onWhat = 0;
- Rec2DData::updateVertQual(getQual(VertQuality)-oldQual1, VertQuality);
- Rec2DData::updateVertQual(getQual(VertEdgeQuality)-oldQual2, VertEdgeQuality);
+ Rec2DData::updateVertQual(getQual(VertQuality) - oldQual1, VertQuality);
+ Rec2DData::updateVertQual(getQual(VertEdgeQuality) - oldQual2,
+ VertEdgeQuality);
_lastUpdate = Recombine2D::getNumChange();
}
-
}
void Rec2DVertex::setParity(int p, bool tree)
{
- if (_parity && !tree) {
- //Msg::Warning("[Rec2DVertex] I don't like to do it. Think about that !");
+ if(_parity && !tree) {
+ // Msg::Warning("[Rec2DVertex] I don't like to do it. Think about that !");
Rec2DData::removeParity(this, _parity);
}
- if ((_parity = p))
- Rec2DData::addParity(this, _parity);
+ if((_parity = p)) Rec2DData::addParity(this, _parity);
#ifdef REC2D_DRAW
- if (_v)
- _v->setIndex(_parity);
+ if(_v) _v->setIndex(_parity);
//_v->setIndex(_onWhat);
#endif
}
@@ -4188,102 +4113,98 @@ void Rec2DVertex::setParity(int p, bool tree)
void Rec2DVertex::setParityWD(int pOld, int pNew)
{
static int a = 0;
- if (++a == 1)
- Msg::Warning("FIXME puis-je rendre fonction utilisable uniquement par recdata ?");
- if (pOld != _parity)
- Msg::Error("[Rec2DVertex] Old parity was not correct");
+ if(++a == 1)
+ Msg::Warning(
+ "FIXME puis-je rendre fonction utilisable uniquement par recdata ?");
+ if(pOld != _parity) Msg::Error("[Rec2DVertex] Old parity was not correct");
_parity = pNew;
#ifdef REC2D_DRAW
- if (_v)
- _v->setIndex(_parity);
+ if(_v) _v->setIndex(_parity);
//_v->setIndex(_onWhat);
#endif
}
bool Rec2DVertex::setBoundaryParity(int p0, int p1)
{
- if (_parity) {
+ if(_parity) {
Msg::Error("[Rec2DVertex] Are you kidding me ? Already have a parity !");
return false;
}
setParity(p0);
int num = 0;
Rec2DVertex *nextRV = NULL;
- for (unsigned int i = 0; i < _edges.size(); ++i) {
- if (_edges[i]->isOnBoundary()) {
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
+ if(_edges[i]->isOnBoundary()) {
nextRV = _edges[i]->getOtherVertex(this);
++num;
}
}
- if (num != 2)
- Msg::Error("[Rec2DVertex] What's happening ? Am I on boundary or not ? TELL ME ! (%d)", num);
- if (nextRV)
+ if(num != 2)
+ Msg::Error("[Rec2DVertex] What's happening ? Am I on boundary or not ? "
+ "TELL ME ! (%d)",
+ num);
+ if(nextRV)
return nextRV->_recursiveBoundParity(this, p1, p0); // alternate parity
- Msg::Error("[Rec2DVertex] Have I really to say that I didn't find neighbouring vertex ?");
+ Msg::Error("[Rec2DVertex] Have I really to say that I didn't find "
+ "neighbouring vertex ?");
return false;
}
double Rec2DVertex::getQualDegree(int numEl) const
{
int nEl = numEl > -1 ? numEl : _elements.size();
- if (nEl == 0) return -REC2D_BIG_NUMB;
- if (_onWhat > -1) return _qualVSnum[_onWhat][nEl];
- return std::max(1. - fabs(2./M_PI * _angle/nEl - 1.), .0);
+ if(nEl == 0) return -REC2D_BIG_NUMB;
+ if(_onWhat > -1) return _qualVSnum[_onWhat][nEl];
+ return std::max(1. - fabs(2. / M_PI * _angle / nEl - 1.), .0);
}
double Rec2DVertex::getGainDegree(int n) const
{
- if (!n)
- return .0;
+ if(!n) return .0;
int numElem = (int)_elements.size();
- if (numElem + n < 0) {
- Msg::Error("[Rec2DVertex] gain for %d elements not available",
- numElem + n );
+ if(numElem + n < 0) {
+ Msg::Error("[Rec2DVertex] gain for %d elements not available", numElem + n);
return .0;
}
- if (_onWhat > -1) {
- switch (n) {
- case 1 :
- return _gains[_onWhat][numElem];
- case -1 :
- return - _gains[_onWhat][numElem-1];
- default :
- return _qualVSnum[_onWhat][numElem+n]
- - _qualVSnum[_onWhat][numElem-1];
+ if(_onWhat > -1) {
+ switch(n) {
+ case 1: return _gains[_onWhat][numElem];
+ case -1: return -_gains[_onWhat][numElem - 1];
+ default:
+ return _qualVSnum[_onWhat][numElem + n] -
+ _qualVSnum[_onWhat][numElem - 1];
}
}
- if (numElem == 0) {
+ if(numElem == 0) {
Msg::Error("[Rec2DVertex] I don't want this anymore !");
- return 11. - fabs(2./M_PI * _angle/(double)(numElem + n) - 1.);
+ return 11. - fabs(2. / M_PI * _angle / (double)(numElem + n) - 1.);
}
- if (numElem + n == 0) {
+ if(numElem + n == 0) {
Msg::Error("[Rec2DVertex] I don't want this anymore !");
- return fabs(2./M_PI * _angle/(double)numElem - 1.) - 11.;
+ return fabs(2. / M_PI * _angle / (double)numElem - 1.) - 11.;
}
- return fabs(2./M_PI * _angle/(double)numElem - 1.)
- - fabs(2./M_PI * _angle/(double)(numElem + n) - 1.);
+ return fabs(2. / M_PI * _angle / (double)numElem - 1.) -
+ fabs(2. / M_PI * _angle / (double)(numElem + n) - 1.);
}
double Rec2DVertex::getQual(Rec2DQualCrit crit) const
{
- if (crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
+ if(crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
- switch (crit) {
- case VertQuality :
- return _vertQual() * _WAQualEdges();
+ switch(crit) {
+ case VertQuality: return _vertQual() * _WAQualEdges();
- case VertEdgeQuality :
- return _vertQual();
+ case VertEdgeQuality: return _vertQual();
- default :
- Msg::Error("[Rec2DVertex:getQual-1] Unknown quality criterion %d", crit);
- Msg::Error("");
- __crash();
+ default:
+ Msg::Error("[Rec2DVertex:getQual-1] Unknown quality criterion %d", crit);
+ Msg::Error("");
+ __crash();
}
return -1.;
}
@@ -4292,66 +4213,67 @@ double Rec2DVertex::getQual(Rec2DQualCrit crit) const
double Rec2DVertex::getQual(double waQualAngles, double waQualEdges,
int numElem, Rec2DQualCrit crit) const
{
- if (crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
+ if(crit == ChoosedCrit) crit = Recombine2D::getQualCrit();
static int a = 0;
- if (++a == 1) Msg::Warning("FIXME NoCrit==-2, ChoosedCrit==-1");
+ if(++a == 1) Msg::Warning("FIXME NoCrit==-2, ChoosedCrit==-1");
- switch (crit) {
- case VertQuality :
- return _vertQual(_qualDegree(numElem), waQualAngles) * waQualEdges;
+ switch(crit) {
+ case VertQuality:
+ return _vertQual(_qualDegree(numElem), waQualAngles) * waQualEdges;
- case VertEdgeQuality :
- return _vertQual(_qualDegree(numElem), waQualAngles);
+ case VertEdgeQuality: return _vertQual(_qualDegree(numElem), waQualAngles);
- default :
- Msg::Error("[Rec2DVertex:getQual-2] Unknown quality criterion %d", crit);
+ default:
+ Msg::Error("[Rec2DVertex:getQual-2] Unknown quality criterion %d", crit);
}
return -1.;
}
-double Rec2DVertex::/*vertQual_*/getGainQuad(const Rec2DElement *rel,
- const Rec2DEdge *re0,
- const Rec2DEdge *re1 ) const
+double Rec2DVertex::/*vertQual_*/ getGainQuad(const Rec2DElement *rel,
+ const Rec2DEdge *re0,
+ const Rec2DEdge *re1) const
{
- double wa = Recombine2D::getWeightAngleQuad()
- - Recombine2D::getWeightAngleTri();
+ double wa =
+ Recombine2D::getWeightAngleQuad() - Recombine2D::getWeightAngleTri();
double wq = Recombine2D::getWeightEdgeQuad();
- double qualAngle = _sumWQualAngle + wa * rel->getAngleQual(this) ;
+ double qualAngle = _sumWQualAngle + wa * rel->getAngleQual(this);
int sumAngle = _sumWeightAngle + wa;
double qualEdge = _sumWQualEdge + wq * re0->getQual() + wq * re1->getQual();
- int sumEdge = _sumWeightEdge + 2*wq;
+ int sumEdge = _sumWeightEdge + 2 * wq;
- return getQual(qualAngle/sumAngle, qualEdge/sumEdge,
- (int)_elements.size() ) - getQual();
+ return getQual(qualAngle / sumAngle, qualEdge / sumEdge,
+ (int)_elements.size()) -
+ getQual();
}
-double Rec2DVertex::/*vertQual_*/getGainTriLess(const Rec2DEdge *re) const
+double Rec2DVertex::/*vertQual_*/ getGainTriLess(const Rec2DEdge *re) const
{
- return getQual(_sumWQualAngle /*!!!!*/ / (_sumWeightAngle - Recombine2D::getWeightAngleTri()),
- (_sumWQualEdge - re->getQual())
- / (_sumWeightEdge - Recombine2D::getWeightEdgeBase()),
- (int)_elements.size() - 1)
- - getQual();
+ return getQual(_sumWQualAngle /*!!!!*/ /
+ (_sumWeightAngle - Recombine2D::getWeightAngleTri()),
+ (_sumWQualEdge - re->getQual()) /
+ (_sumWeightEdge - Recombine2D::getWeightEdgeBase()),
+ (int)_elements.size() - 1) -
+ getQual();
}
double Rec2DVertex::getGainRecomb(/*Rec2DQualCrit crit,*/
const Rec2DElement *rel1,
const Rec2DElement *rel2,
- const Rec2DEdge *re0,
- const Rec2DEdge *re1,
- const Rec2DEdge *re2 ) const
+ const Rec2DEdge *re0, const Rec2DEdge *re1,
+ const Rec2DEdge *re2) const
{
- if (rel1->isQuad() || rel2->isQuad()) {
- Msg::Error("[Rec2DVertex] Cannot compute gain of recombination if elements aren't triangles");
+ if(rel1->isQuad() || rel2->isQuad()) {
+ Msg::Error("[Rec2DVertex] Cannot compute gain of recombination if elements "
+ "aren't triangles");
return -1.;
}
- //if (crit == BlossomQuality) return .0;
- //if (crit < 0) {
- Msg::Warning("[Rec2DVertex] Give me another criterion please.");
+ // if (crit == BlossomQuality) return .0;
+ // if (crit < 0) {
+ Msg::Warning("[Rec2DVertex] Give me another criterion please.");
// }
double swQualAngle = _sumWQualAngle, swQualEdge = _sumWQualEdge;
@@ -4364,11 +4286,11 @@ double Rec2DVertex::getGainRecomb(/*Rec2DQualCrit crit,*/
swQualAngle -= wat * rel1->getAngleQual(this);
swQualAngle -= wat * rel2->getAngleQual(this);
- swQualAngle += waq * Recombine2D::angle2qual(rel1->getAngle(this)
- + rel2->getAngle(this));
+ swQualAngle +=
+ waq * Recombine2D::angle2qual(rel1->getAngle(this) + rel2->getAngle(this));
swAngle += waq - 2 * wat;
- if (re2) {
+ if(re2) {
swQualEdge -= web * re0->getQual();
swQualEdge += weq * re1->getQual();
swQualEdge += weq * re2->getQual();
@@ -4376,13 +4298,14 @@ double Rec2DVertex::getGainRecomb(/*Rec2DQualCrit crit,*/
}
return getQual(swQualAngle / swAngle, swQualEdge / swEdge,
- static_cast<int>(_elements.size())-1/*, crit*/)
- - getQual(/*crit*/);
+ static_cast<int>(_elements.size()) - 1 /*, crit*/) -
+ getQual(/*crit*/);
- //FIX verifier que c'est bien ce qui est demande ! (renvoie bien ce que veux apply, compute reward, ...)
+ // FIX verifier que c'est bien ce qui est demande ! (renvoie bien ce que veux
+ // apply, compute reward, ...)
}
-void Rec2DVertex::/*vertQual_*/addEdgeQual(double val, int num)
+void Rec2DVertex::/*vertQual_*/ addEdgeQual(double val, int num)
{
Msg::Error("old function, need redefinition");
__crash();
@@ -4391,30 +4314,31 @@ void Rec2DVertex::/*vertQual_*/addEdgeQual(double val, int num)
oldQual = getQual();*/
_sumWQualEdge += val;
_sumWeightEdge += num;
- if (_sumWeightEdge < 0 || _sumWQualEdge < -1e12)
+ if(_sumWeightEdge < 0 || _sumWQualEdge < -1e12)
Msg::Error("[Rec2DVertex] Negative sum edge");
- if (_elements.size()) {
+ if(_elements.size()) {
Msg::Fatal("[Rec2DVertex:addEdgeQual] Need redefinition");
- //Rec2DData::addSumVert(getQual()-oldQual);
+ // Rec2DData::addSumVert(getQual()-oldQual);
}
_lastUpdate = Recombine2D::getNumChange();
}
-double Rec2DVertex::/*vertQual_*/getGainMerge(const Rec2DVertex *rv,
- const Rec2DEdge *const*edges, int nEdges) const
+double Rec2DVertex::/*vertQual_*/ getGainMerge(const Rec2DVertex *rv,
+ const Rec2DEdge *const *edges,
+ int nEdges) const
{
int sumAngle = 0;
double sumQualAngle = .0;
int *numAngle = new int[_elements.size()];
double *qualAngle = new double[_elements.size()];
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
numAngle[i] = _elements[i]->getAngleWeight();
qualAngle[i] = _elements[i]->getWeightedAngleQual(this);
}
- for (unsigned int i = 0; i < rv->_elements.size(); ++i) {
+ for(unsigned int i = 0; i < rv->_elements.size(); ++i) {
unsigned int j = 0;
- while (j < _elements.size() && _elements[j] != rv->_elements[i]) ++j;
- if (j >= _elements.size()) {
+ while(j < _elements.size() && _elements[j] != rv->_elements[i]) ++j;
+ if(j >= _elements.size()) {
sumAngle += rv->_elements[i]->getAngleWeight();
sumQualAngle += rv->_elements[i]->getWeightedAngleQual(rv);
}
@@ -4423,7 +4347,7 @@ double Rec2DVertex::/*vertQual_*/getGainMerge(const Rec2DVertex *rv,
qualAngle[j] = .0;
}
}
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
sumAngle += numAngle[i];
sumQualAngle += qualAngle[i];
}
@@ -4431,32 +4355,33 @@ double Rec2DVertex::/*vertQual_*/getGainMerge(const Rec2DVertex *rv,
int sumEdge = 0;
double sumQualEdge = .0;
- for (unsigned int i = 0; i < _edges.size(); ++i) {
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
sumEdge += _edges[i]->getWeight();
sumQualEdge += _edges[i]->getWeightedQual();
}
- for (unsigned int i = 0; i < rv->_edges.size(); ++i) {
+ for(unsigned int i = 0; i < rv->_edges.size(); ++i) {
sumEdge += rv->_edges[i]->getWeight();
sumQualEdge += rv->_edges[i]->getWeightedQual();
}
- for (int i = 0; i < nEdges; ++i) {
+ for(int i = 0; i < nEdges; ++i) {
sumEdge -= Recombine2D::getWeightEdgeBase();
sumQualEdge -= Recombine2D::getWeightEdgeBase() * edges[i]->getQual();
}
delete[] numAngle;
delete[] qualAngle;
- return Rec2DVertex::getQual(sumQualAngle/sumAngle,
- sumQualEdge/sumEdge, numElem)
- - getQual() - rv->getQual() ;
+ return Rec2DVertex::getQual(sumQualAngle / sumAngle, sumQualEdge / sumEdge,
+ numElem) -
+ getQual() - rv->getQual();
}
//#else
-double Rec2DVertex::/*vertEdgeQual_*/getGainOneElemLess() const
-{//FIX here element size instead of weight
- return getGainDegree(-1) + _sumWQualAngle / (_elements.size()-1) - _WAQualAngles();
+double Rec2DVertex::/*vertEdgeQual_*/ getGainOneElemLess() const
+{ // FIX here element size instead of weight
+ return getGainDegree(-1) + _sumWQualAngle / (_elements.size() - 1) -
+ _WAQualAngles();
}
-double Rec2DVertex::/*vertEdgeQual_*/getGainMerge(const Rec2DVertex *rv) const
+double Rec2DVertex::/*vertEdgeQual_*/ getGainMerge(const Rec2DVertex *rv) const
{
double ans = .0, sumQualAngle = .0;
int sumAngle = 0;
@@ -4464,14 +4389,14 @@ double Rec2DVertex::/*vertEdgeQual_*/getGainMerge(const Rec2DVertex *rv) const
ans -= rv->getQual();
double *qualAngle = new double[_elements.size()];
int *angleWeight = new int[_elements.size()];
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
qualAngle[i] = _elements[i]->getWeightedAngleQual(this);
angleWeight[i] = _elements[i]->getAngleWeight();
}
- for (unsigned int i = 0; i < rv->_elements.size(); ++i) {
+ for(unsigned int i = 0; i < rv->_elements.size(); ++i) {
unsigned int j = 0;
- while (j < _elements.size() && _elements[j] != rv->_elements[i]) ++j;
- if (j >= _elements.size()) {
+ while(j < _elements.size() && _elements[j] != rv->_elements[i]) ++j;
+ if(j >= _elements.size()) {
sumQualAngle += rv->_elements[i]->getWeightedAngleQual(rv);
sumAngle += rv->_elements[i]->getAngleWeight();
}
@@ -4480,7 +4405,7 @@ double Rec2DVertex::/*vertEdgeQual_*/getGainMerge(const Rec2DVertex *rv) const
angleWeight[j] = 0;
}
}
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
sumQualAngle += qualAngle[i];
sumAngle += angleWeight[i];
}
@@ -4501,18 +4426,19 @@ void Rec2DVertex::updateWAQualEdges(double d, int a)
_sumWeightEdge += a;
_lastUpdate = Recombine2D::getNumChange();
- Rec2DData::updateVertQual(getQual(VertQuality)-oldQual, VertQuality);
+ Rec2DData::updateVertQual(getQual(VertQuality) - oldQual, VertQuality);
}
void Rec2DVertex::relocate(SPoint2 p)
{
- //Msg::Fatal("relocate is disabled because of param on discrete face, see constructor to enable param");
+ // Msg::Fatal("relocate is disabled because of param on discrete face, see
+ // constructor to enable param");
_param = p;
GPoint gpt = Recombine2D::getGFace()->point(p);
_v->x() = gpt.x();
_v->y() = gpt.y();
_v->z() = gpt.z();
- for (unsigned int i = 0; i < _edges.size(); ++i) {
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
_edges[i]->updateQual();
_edges[i]->getOtherVertex(this)->_updateQualAngle();
}
@@ -4521,16 +4447,16 @@ void Rec2DVertex::relocate(SPoint2 p)
bool Rec2DVertex::checkCoherence() const
{
- for (unsigned int i = 0; i < _edges.size(); ++i) {
- if (!_edges[i]->has(this)) return false;
- for (unsigned int j = 0; j < i; ++j) {
- if (_edges[i] == _edges[j]) return false;
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
+ if(!_edges[i]->has(this)) return false;
+ for(unsigned int j = 0; j < i; ++j) {
+ if(_edges[i] == _edges[j]) return false;
}
}
- for (unsigned int i = 0; i < _elements.size(); ++i) {
- if (!_elements[i]->has(this)) return false;
- for (unsigned int j = 0; j < i; ++j) {
- if (_elements[i] == _elements[j]) return false;
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
+ if(!_elements[i]->has(this)) return false;
+ for(unsigned int j = 0; j < i; ++j) {
+ if(_elements[i] == _elements[j]) return false;
}
}
return true;
@@ -4541,27 +4467,25 @@ bool Rec2DVertex::checkQuality() const
double wQualAngle = .0, wQualEdge = .0;
int weightAngle = 0, weightEdge = 0;
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
wQualAngle += _elements[i]->getWeightedAngleQual(this);
weightAngle += _elements[i]->getAngleWeight();
}
- for (unsigned int i = 0; i < _edges.size(); ++i) {
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
wQualEdge += _edges[i]->getWeightedQual();
weightEdge += _edges[i]->getWeight();
}
- if (wQualAngle < _sumWQualAngle - 1e12 ||
- wQualAngle > _sumWQualAngle + 1e12 ||
- weightAngle != _sumWeightAngle) {
- Msg::Error("wrong angle qual, stored %g/%d, computed %g/%d",
- _sumWQualAngle, _sumWeightAngle, wQualAngle, weightAngle);
+ if(wQualAngle < _sumWQualAngle - 1e12 || wQualAngle > _sumWQualAngle + 1e12 ||
+ weightAngle != _sumWeightAngle) {
+ Msg::Error("wrong angle qual, stored %g/%d, computed %g/%d", _sumWQualAngle,
+ _sumWeightAngle, wQualAngle, weightAngle);
return false;
}
- if (wQualEdge < _sumWQualEdge - 1e12 ||
- wQualEdge > _sumWQualEdge + 1e12 ||
- weightEdge != _sumWeightEdge) {
- Msg::Error("wrong edge qual, stored %g/%d, computed %g/%d",
- _sumWQualEdge, _sumWeightEdge, wQualEdge, weightEdge);
+ if(wQualEdge < _sumWQualEdge - 1e12 || wQualEdge > _sumWQualEdge + 1e12 ||
+ weightEdge != _sumWeightEdge) {
+ Msg::Error("wrong edge qual, stored %g/%d, computed %g/%d", _sumWQualEdge,
+ _sumWeightEdge, wQualEdge, weightEdge);
return false;
}
@@ -4570,41 +4494,42 @@ bool Rec2DVertex::checkQuality() const
void Rec2DVertex::printElem() const
{
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
Msg::Info("%d - %d", i, _elements[i]->getNum());
}
}
void Rec2DVertex::printQual() const
{
- Msg::Info("d:%g, a:%g, e:%g (sa:%d, se:%d)",
- getQualDegree(), _sumWQualAngle/_sumWeightAngle, _sumWQualEdge / _sumWeightEdge,
+ Msg::Info("d:%g, a:%g, e:%g (sa:%d, se:%d)", getQualDegree(),
+ _sumWQualAngle / _sumWeightAngle, _sumWQualEdge / _sumWeightEdge,
_sumWeightAngle, _sumWeightEdge);
}
-bool Rec2DVertex::_recursiveBoundParity(const Rec2DVertex *prevRV, int p0, int p1)
+bool Rec2DVertex::_recursiveBoundParity(const Rec2DVertex *prevRV, int p0,
+ int p1)
{
- if (_parity == p0)
- return true;
- if (_parity) {
+ if(_parity == p0) return true;
+ if(_parity) {
Msg::Error("[Rec2DVertex] Sorry, have parity %d, can't set it to %d... "
- "You failed ! Try again !", _parity, p0);
+ "You failed ! Try again !",
+ _parity, p0);
return false;
}
setParity(p0);
int num = 0;
Rec2DVertex *nextRV = NULL;
- for (unsigned int i = 0; i < _edges.size(); ++i) {
- if (_edges[i]->isOnBoundary() && _edges[i]->getOtherVertex(this) != prevRV) {
+ for(unsigned int i = 0; i < _edges.size(); ++i) {
+ if(_edges[i]->isOnBoundary() && _edges[i]->getOtherVertex(this) != prevRV) {
nextRV = _edges[i]->getOtherVertex(this);
++num;
}
}
- if (num != 1)
- Msg::Error("[Rec2DVertex] Holy shit !");
- if (nextRV)
+ if(num != 1) Msg::Error("[Rec2DVertex] Holy shit !");
+ if(nextRV)
return nextRV->_recursiveBoundParity(this, p1, p0); // alternate parity
- Msg::Error("[Rec2DVertex] Have I really to say that I didn't find next vertex ?");
+ Msg::Error(
+ "[Rec2DVertex] Have I really to say that I didn't find next vertex ?");
return false;
}
@@ -4615,149 +4540,138 @@ void Rec2DVertex::_updateQualAngle()
_sumWQualAngle = .0;
_sumWeightAngle = 0;
- for (unsigned int i = 0; i < _elements.size(); ++i) {
+ for(unsigned int i = 0; i < _elements.size(); ++i) {
_sumWeightAngle += _elements[i]->getAngleWeight();
_sumWQualAngle += _elements[i]->getWeightedAngleQual(this);
}
_lastUpdate = Recombine2D::getNumChange();
- Rec2DData::updateVertQual(getQual(VertQuality)-oldQual1, VertQuality);
- Rec2DData::updateVertQual(getQual(VertEdgeQuality)-oldQual2, VertEdgeQuality);
+ Rec2DData::updateVertQual(getQual(VertQuality) - oldQual1, VertQuality);
+ Rec2DData::updateVertQual(getQual(VertEdgeQuality) - oldQual2,
+ VertEdgeQuality);
}
-
double Rec2DVertex::_qualDegree(int numEl) const
{
int nEl = numEl > -1 ? numEl : _elements.size();
- if (nEl == 0) return -REC2D_BIG_NUMB;
- if (_onWhat > -1) return _qualVSnum[_onWhat][nEl];
- return std::max(1. - fabs(2./M_PI * _angle/nEl - 1.), .0);
+ if(nEl == 0) return -REC2D_BIG_NUMB;
+ if(_onWhat > -1) return _qualVSnum[_onWhat][nEl];
+ return std::max(1. - fabs(2. / M_PI * _angle / nEl - 1.), .0);
}
/** Rec2DElement **/
/********************/
Rec2DElement::Rec2DElement(MTriangle *t, const Rec2DEdge **re, Rec2DVertex **rv)
-: _mEl((MElement *)t), _numEdge(3), _pos(-1)
+ : _mEl((MElement *)t), _numEdge(3), _pos(-1)
{
- for (int i = 0; i < 3; ++i)
- _edges[i] = (Rec2DEdge*)re[i];
- for (int i = 0; i < 3; ++i)
+ for(int i = 0; i < 3; ++i) _edges[i] = (Rec2DEdge *)re[i];
+ for(int i = 0; i < 3; ++i)
_elements[i] = Rec2DEdge::getTheOnlyElement(_edges[i]);
_edges[3] = NULL;
_elements[3] = NULL;
reveal(rv);
- if (!edgesAreInOrder(_edges, 3)) Msg::Error("tri |%d|", getNum());
+ if(!edgesAreInOrder(_edges, 3)) Msg::Error("tri |%d|", getNum());
}
-Rec2DElement::Rec2DElement(MQuadrangle *q, const Rec2DEdge **re, Rec2DVertex **rv)
-: _mEl((MElement *)q), _numEdge(4), _pos(-1)
+Rec2DElement::Rec2DElement(MQuadrangle *q, const Rec2DEdge **re,
+ Rec2DVertex **rv)
+ : _mEl((MElement *)q), _numEdge(4), _pos(-1)
{
- for (int i = 0; i < 4; ++i)
- _edges[i] = (Rec2DEdge*)re[i];
- for (int i = 0; i < 4; ++i)
+ for(int i = 0; i < 4; ++i) _edges[i] = (Rec2DEdge *)re[i];
+ for(int i = 0; i < 4; ++i)
_elements[i] = Rec2DEdge::getTheOnlyElement(_edges[i]);
reveal(rv);
- if (!edgesAreInOrder(_edges, 4)) Msg::Error("quad |%d|", getNum());
+ if(!edgesAreInOrder(_edges, 4)) Msg::Error("quad |%d|", getNum());
}
void Rec2DElement::hide()
{
- if (_actions.size())
+ if(_actions.size())
Msg::Error("[Rec2DElement] I don't want to be hidden :'(");
- for (int i = 0; i < _numEdge; ++i) {
- if (_numEdge == 3)
- _edges[i]->remHasTri();
- if (_elements[i])
- _elements[i]->rmvNeighbour(_edges[i], this);
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_numEdge == 3) _edges[i]->remHasTri();
+ if(_elements[i]) _elements[i]->rmvNeighbour(_edges[i], this);
}
- std::vector<Rec2DVertex*> vertices(_numEdge);
+ std::vector<Rec2DVertex *> vertices(_numEdge);
getVertices(vertices);
- for (int i = 0; i < _numEdge; ++i) {
+ for(int i = 0; i < _numEdge; ++i) {
vertices[i]->rmv(this);
}
- if (_numEdge == 3)
- Rec2DData::rmvHasZeroAction(this);
+ if(_numEdge == 3) Rec2DData::rmvHasZeroAction(this);
Rec2DData::rmv(this);
}
void Rec2DElement::reveal(Rec2DVertex **rv)
{
- for (int i = 0; i < _numEdge; ++i) {
- if (_numEdge == 3)
- _edges[i]->addHasTri();
- if (_elements[i])
- _elements[i]->addNeighbour(_edges[i], this);
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_numEdge == 3) _edges[i]->addHasTri();
+ if(_elements[i]) _elements[i]->addNeighbour(_edges[i], this);
}
- if (rv) {
- for (int i = 0; i < _numEdge; ++i)
- rv[i]->add(this);
+ if(rv) {
+ for(int i = 0; i < _numEdge; ++i) rv[i]->add(this);
}
else {
- std::vector<Rec2DVertex*> vert;
+ std::vector<Rec2DVertex *> vert;
getVertices(vert);
- for (int i = 0; i < _numEdge; ++i)
- vert[i]->add(this);
+ for(int i = 0; i < _numEdge; ++i) vert[i]->add(this);
}
- if (_numEdge == 3)
- Rec2DData::addHasZeroAction(this);
+ if(_numEdge == 3) Rec2DData::addHasZeroAction(this);
Rec2DData::add(this);
}
void Rec2DElement::add(Rec2DEdge *re)
{
int i;
- for (i = 0; i < _numEdge; ++i) {
- if (_edges[i] == re) {
+ for(i = 0; i < _numEdge; ++i) {
+ if(_edges[i] == re) {
Msg::Error("[Rec2DElement] Edge was already there");
return;
}
- if (_edges[i] == NULL) {
+ if(_edges[i] == NULL) {
_edges[i] = re;
break;
}
}
- if (i == _numEdge)
+ if(i == _numEdge)
Msg::Error("[Rec2DElement] Already %d edges, can't add anymore", _numEdge);
- if (_numEdge == 3)
- re->addHasTri();
+ if(_numEdge == 3) re->addHasTri();
}
bool Rec2DElement::has(const Rec2DEdge *re) const
{
- for (int i = 0; i < _numEdge; ++i) {
- if (_edges[i] == re)
- return true;
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_edges[i] == re) return true;
}
return false;
}
bool Rec2DElement::has(const Rec2DVertex *rv) const
{
- std::vector<Rec2DVertex*> verts;
+ std::vector<Rec2DVertex *> verts;
getVertices(verts);
- for (unsigned int i = 0; i < verts.size(); ++i)
- if (verts[i] == rv) return true;
+ for(unsigned int i = 0; i < verts.size(); ++i)
+ if(verts[i] == rv) return true;
return false;
}
bool Rec2DElement::has(const Rec2DElement *rel) const
{
- for (int i = 0; i < _numEdge; ++i)
- if (_elements[i] == rel) return true;
+ for(int i = 0; i < _numEdge; ++i)
+ if(_elements[i] == rel) return true;
return false;
}
void Rec2DElement::addNeighbour(const Rec2DEdge *re, const Rec2DElement *rel)
{
- for (int i = 0; i < _numEdge; ++i) {
- if (_edges[i] == re) {
- if (_elements[i] != NULL && _elements[i] != rel)
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_edges[i] == re) {
+ if(_elements[i] != NULL && _elements[i] != rel)
Msg::Error("[Rec2DElement] Have already a neighbour element");
- _elements[i] = (Rec2DElement*)rel;
+ _elements[i] = (Rec2DElement *)rel;
return;
}
}
@@ -4765,33 +4679,33 @@ void Rec2DElement::addNeighbour(const Rec2DEdge *re, const Rec2DElement *rel)
Rec2DElement *elem[2];
Rec2DEdge::getElements(re, elem);
int a, b = a = 0;
- if (elem[0])
- a = elem[0]->getNum();
- if (elem[1])
- b = elem[1]->getNum();
- Msg::Error("[Rec2DElement] Edge not found (add) (im %d, edge %d %d)", getNum(), a, b);
+ if(elem[0]) a = elem[0]->getNum();
+ if(elem[1]) b = elem[1]->getNum();
+ Msg::Error("[Rec2DElement] Edge not found (add) (im %d, edge %d %d)",
+ getNum(), a, b);
}
void Rec2DElement::rmvNeighbour(const Rec2DEdge *re, const Rec2DElement *rel)
{
- for (int i = 0; i < _numEdge; ++i) {
- if (_edges[i] == re) {
- if (_elements[i] == rel)
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_edges[i] == re) {
+ if(_elements[i] == rel)
_elements[i] = NULL;
else
- Msg::Error("[Rec2DElement] I didn't know this element was my neighbour...");
+ Msg::Error(
+ "[Rec2DElement] I didn't know this element was my neighbour...");
return;
}
}
Msg::Error("[Rec2DElement] Edge not found (rmv) (im %d)", getNum());
}
-bool Rec2DElement::isNeighbour(const Rec2DEdge *re, const Rec2DElement *rel) const
+bool Rec2DElement::isNeighbour(const Rec2DEdge *re,
+ const Rec2DElement *rel) const
{
- for (int i = 0; i < _numEdge; ++i) {
- if (_edges[i] == re) {
- if (_elements[i] == rel)
- return true;
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_edges[i] == re) {
+ if(_elements[i] == rel) return true;
return false;
}
}
@@ -4800,51 +4714,48 @@ bool Rec2DElement::isNeighbour(const Rec2DEdge *re, const Rec2DElement *rel) con
void Rec2DElement::add(const Rec2DAction *ra)
{
- for (unsigned int i = 0; i < _actions.size(); ++i) {
- if (_actions[i] == ra) {
+ for(unsigned int i = 0; i < _actions.size(); ++i) {
+ if(_actions[i] == ra) {
Msg::Error("[Rec2DElement] Action was already there");
return;
}
}
- if (Recombine2D::onlyRecombinations()) {
- switch (_actions.size()) {
- case 0 :
- Rec2DData::addHasOneAction(this, (Rec2DAction*)ra);
- Rec2DData::rmvHasZeroAction(this);
- Rec2DData::elementChgAction(this, 0, 1);
- break;
- case 1 :
- Rec2DData::rmvHasOneAction(this, _actions[0]);
- Rec2DData::elementChgAction(this, 1, 2);
- break;
- case 2 :
- break;
- default :
- Msg::Error("Should not have more than 3 actions");
+ if(Recombine2D::onlyRecombinations()) {
+ switch(_actions.size()) {
+ case 0:
+ Rec2DData::addHasOneAction(this, (Rec2DAction *)ra);
+ Rec2DData::rmvHasZeroAction(this);
+ Rec2DData::elementChgAction(this, 0, 1);
+ break;
+ case 1:
+ Rec2DData::rmvHasOneAction(this, _actions[0]);
+ Rec2DData::elementChgAction(this, 1, 2);
+ break;
+ case 2: break;
+ default: Msg::Error("Should not have more than 3 actions");
}
}
- _actions.push_back((Rec2DAction*)ra);
+ _actions.push_back((Rec2DAction *)ra);
}
void Rec2DElement::rmv(const Rec2DAction *ra)
{
unsigned int i = 0;
- while (i < _actions.size()) {
- if (_actions[i] == ra) {
- if (Recombine2D::onlyRecombinations()) {
- switch (_actions.size()) {
- case 1 :
- Rec2DData::rmvHasOneAction(this, (Rec2DAction*)ra);
- Rec2DData::addHasZeroAction(this);
- Rec2DData::elementChgAction(this, 1, 0);
- break;
- case 2 :
- Rec2DData::addHasOneAction(this, _actions[i == 0 ? 1 : 0]);
- Rec2DData::elementChgAction(this, 2, 1);
- break;
- case 3 :
- Rec2DData::elementChgAction(this, 3, 2);
- default :;
+ while(i < _actions.size()) {
+ if(_actions[i] == ra) {
+ if(Recombine2D::onlyRecombinations()) {
+ switch(_actions.size()) {
+ case 1:
+ Rec2DData::rmvHasOneAction(this, (Rec2DAction *)ra);
+ Rec2DData::addHasZeroAction(this);
+ Rec2DData::elementChgAction(this, 1, 0);
+ break;
+ case 2:
+ Rec2DData::addHasOneAction(this, _actions[i == 0 ? 1 : 0]);
+ Rec2DData::elementChgAction(this, 2, 1);
+ break;
+ case 3: Rec2DData::elementChgAction(this, 3, 2);
+ default:;
}
}
_actions[i] = _actions.back();
@@ -4858,20 +4769,19 @@ void Rec2DElement::rmv(const Rec2DAction *ra)
bool Rec2DElement::has(const Rec2DAction *ra) const
{
- for (unsigned int i = 0; i < _actions.size(); ++i) {
- if (_actions[i] == ra)
- return true;
+ for(unsigned int i = 0; i < _actions.size(); ++i) {
+ if(_actions[i] == ra) return true;
}
return false;
}
-Rec2DEdge* Rec2DElement::getCommonEdge(const Rec2DElement *rel0,
- const Rec2DElement *rel1 )
+Rec2DEdge *Rec2DElement::getCommonEdge(const Rec2DElement *rel0,
+ const Rec2DElement *rel1)
{
bool foundOne = false;
- for (int i = 0; i < rel0->_numEdge; ++i) {
- if (rel1->has(rel0->_edges[i])) {
- if (!foundOne) {
+ for(int i = 0; i < rel0->_numEdge; ++i) {
+ if(rel1->has(rel0->_edges[i])) {
+ if(!foundOne) {
return rel0->_edges[i];
foundOne = true;
}
@@ -4885,20 +4795,19 @@ Rec2DEdge* Rec2DElement::getCommonEdge(const Rec2DElement *rel0,
return NULL;
}
-void Rec2DElement::getVertices(std::vector<Rec2DVertex*> &verts) const
+void Rec2DElement::getVertices(std::vector<Rec2DVertex *> &verts) const
{
verts.resize(_numEdge);
int i = 0, k = 0;
- while (k < _numEdge) {
- verts[k] = _edges[i/2]->getVertex(i%2);
+ while(k < _numEdge) {
+ verts[k] = _edges[i / 2]->getVertex(i % 2);
bool itsOK = true;
- for (int j = 0; j < k; ++j) {
- if (verts[k] == verts[j])
- itsOK = false;
+ for(int j = 0; j < k; ++j) {
+ if(verts[k] == verts[j]) itsOK = false;
}
- if (itsOK) {
+ if(itsOK) {
// make sure they are well ordered (edges are ordered)
- if (k == 2 && _edges[i/2]->getVertex((i+1)%2) == verts[0]) {
+ if(k == 2 && _edges[i / 2]->getVertex((i + 1) % 2) == verts[0]) {
Rec2DVertex *rv = verts[0];
verts[0] = verts[1];
verts[1] = rv;
@@ -4909,67 +4818,64 @@ void Rec2DElement::getVertices(std::vector<Rec2DVertex*> &verts) const
}
}
-Rec2DVertex* Rec2DElement::getOtherVertex(const Rec2DVertex *rv1,
- const Rec2DVertex *rv2 ) const
+Rec2DVertex *Rec2DElement::getOtherVertex(const Rec2DVertex *rv1,
+ const Rec2DVertex *rv2) const
{
- if (_numEdge == 4) {
+ if(_numEdge == 4) {
Msg::Error("[Rec2DElement] I'm not a triangle");
return NULL;
}
- for (int i = 0; i < 2; ++i) {
+ for(int i = 0; i < 2; ++i) {
Rec2DVertex *rv = _edges[i]->getVertex(0);
- if (rv != rv1 && rv != rv2)
- return rv;
+ if(rv != rv1 && rv != rv2) return rv;
rv = _edges[i]->getVertex(1);
- if (rv != rv1 && rv != rv2)
- return rv;
+ if(rv != rv1 && rv != rv2) return rv;
}
Msg::Error("[Rec2DElement] I should not be here... Why this happen to me ?");
return NULL;
}
-void Rec2DElement::getMoreNeighbours(std::vector<Rec2DElement*> &elem) const
+void Rec2DElement::getMoreNeighbours(std::vector<Rec2DElement *> &elem) const
{
- for (int i = 0; i < _numEdge; ++i) {
- if (_elements[i]) elem.push_back(_elements[i]);
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_elements[i]) elem.push_back(_elements[i]);
}
}
-void Rec2DElement::getMoreUniqueActions(std::vector<Rec2DAction*> &vectRA) const
+void Rec2DElement::getMoreUniqueActions(
+ std::vector<Rec2DAction *> &vectRA) const
{
unsigned int size = vectRA.size();
- for (unsigned int i = 0; i < _actions.size(); ++i) {
+ for(unsigned int i = 0; i < _actions.size(); ++i) {
unsigned int j = -1;
- while (++j < size && vectRA[j] != _actions[i]);
- if (j == size)
- vectRA.push_back(_actions[i]);
+ while(++j < size && vectRA[j] != _actions[i])
+ ;
+ if(j == size) vectRA.push_back(_actions[i]);
}
}
void Rec2DElement::getMoreUniqueActions(
- std::set<Rec2DAction*, gterRec2DAction> &setRA) const
+ std::set<Rec2DAction *, gterRec2DAction> &setRA) const
{
- for (unsigned int i = 0; i < _actions.size(); ++i) {
+ for(unsigned int i = 0; i < _actions.size(); ++i) {
setRA.insert(_actions[i]);
}
}
void Rec2DElement::swap(Rec2DEdge *re1, Rec2DEdge *re2)
{
- for (int i = 0; i < _numEdge; ++i) {
- if (_edges[i] == re1) {
- if (_numEdge == 3)
- re1->remHasTri();
- if (_elements[i])
- _elements[i]->rmvNeighbour(_edges[i], this);
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_edges[i] == re1) {
+ if(_numEdge == 3) re1->remHasTri();
+ if(_elements[i]) _elements[i]->rmvNeighbour(_edges[i], this);
Rec2DElement *elem[2];
Rec2DEdge::getElements(re2, elem);
- _edges[i] = (Rec2DEdge*)re2;
- if (_numEdge == 3)
- re2->addHasTri();
- if (elem[1])
- Msg::Error("[Rec2DElement] Invalid swapping (there are %d and %d)", elem[0]->getNum(), elem[1]->getNum());
- else if (elem[0]) {
+ _edges[i] = (Rec2DEdge *)re2;
+ if(_numEdge == 3) re2->addHasTri();
+ if(elem[1])
+ Msg::Error("[Rec2DElement] Invalid swapping (there are %d and %d)",
+ elem[0]->getNum(), elem[1]->getNum());
+ else if(elem[0]) {
_elements[i] = elem[0];
elem[0]->addNeighbour(re2, this);
}
@@ -4983,8 +4889,8 @@ void Rec2DElement::swap(Rec2DEdge *re1, Rec2DEdge *re2)
void Rec2DElement::swapMVertex(Rec2DVertex *rv0, Rec2DVertex *rv1)
{
- for (int i = 0; i < _numEdge; ++i) {
- if (_mEl->getVertex(i) == rv0->getMVertex()) {
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_mEl->getVertex(i) == rv0->getMVertex()) {
_mEl->setVertex(i, rv1->getMVertex());
return;
}
@@ -4994,42 +4900,40 @@ void Rec2DElement::swapMVertex(Rec2DVertex *rv0, Rec2DVertex *rv1)
double Rec2DElement::getAngle(const Rec2DVertex *rv) const
{
- std::vector<Rec2DVertex*> vert;
+ std::vector<Rec2DVertex *> vert;
getVertices(vert);
int index = -1;
- for (int i = 0; i < _numEdge; ++i) {
- if (vert[i] == rv) {
+ for(int i = 0; i < _numEdge; ++i) {
+ if(vert[i] == rv) {
index = i;
break;
}
}
- if (index == -1) {
+ if(index == -1) {
Msg::Error("[Rec2DElement] I don't have your vertex...");
Msg::Info("im %d, the vertex is %d", getNum(), rv->getNum());
return -1.;
}
- int i1 = (index+_numEdge-1)%_numEdge;
- int i0 = (index+1)%_numEdge;
- double ang = atan2(vert[i0]->v() - rv->v(), vert[i0]->u() - rv->u())
- - atan2(vert[i1]->v() - rv->v(), vert[i1]->u() - rv->u());
+ int i1 = (index + _numEdge - 1) % _numEdge;
+ int i0 = (index + 1) % _numEdge;
+ double ang = atan2(vert[i0]->v() - rv->v(), vert[i0]->u() - rv->u()) -
+ atan2(vert[i1]->v() - rv->v(), vert[i1]->u() - rv->u());
static unsigned int a = 0;
- if (++a < 2) Msg::Warning("FIXME use real angle instead of parametric angle");
+ if(++a < 2) Msg::Warning("FIXME use real angle instead of parametric angle");
- if (ang < .0)
- return ang + 2.*M_PI;
+ if(ang < .0) return ang + 2. * M_PI;
return ang;
}
bool Rec2DElement::hasIdenticalNeighbour() const
{
- for (int i = 1; i < _numEdge; ++i) {
- if (_elements[i]) {
- for (int j = 0; j < i; ++j) {
- if (_elements[i] == _elements[j])
- return true;
+ for(int i = 1; i < _numEdge; ++i) {
+ if(_elements[i]) {
+ for(int j = 0; j < i; ++j) {
+ if(_elements[i] == _elements[j]) return true;
}
}
}
@@ -5041,85 +4945,87 @@ bool Rec2DElement::checkCoherence() const
Rec2DVertex *v[4], *v0, *v1;
v0 = _edges[0]->getVertex(0);
v1 = _edges[0]->getVertex(1);
- if (_edges[1]->getVertex(0) == v0 || _edges[1]->getVertex(1) == v0) {
+ if(_edges[1]->getVertex(0) == v0 || _edges[1]->getVertex(1) == v0) {
v[0] = v0;
- if (_edges[1]->getVertex(0) == v0)
+ if(_edges[1]->getVertex(0) == v0)
v[1] = _edges[1]->getVertex(1);
else
v[1] = _edges[1]->getVertex(0);
}
- else if (_edges[1]->getVertex(0) == v1 || _edges[1]->getVertex(1) == v1) {
+ else if(_edges[1]->getVertex(0) == v1 || _edges[1]->getVertex(1) == v1) {
v[0] = v1;
- if (_edges[1]->getVertex(0) == v1)
+ if(_edges[1]->getVertex(0) == v1)
v[1] = _edges[1]->getVertex(1);
else
v[1] = _edges[1]->getVertex(0);
}
else {
- Msg::Error("not only %d vertices or edge not in order [1] (im %d)", _numEdge, getNum());
- for (int i = 0; i < _numEdge; ++i) {
+ Msg::Error("not only %d vertices or edge not in order [1] (im %d)",
+ _numEdge, getNum());
+ for(int i = 0; i < _numEdge; ++i) {
_edges[i]->print();
}
return false;
}
- for (int i = 2; i < _numEdge; ++i) {
- if (_edges[i]->getVertex(0) == v[i-1])
+ for(int i = 2; i < _numEdge; ++i) {
+ if(_edges[i]->getVertex(0) == v[i - 1])
v[i] = _edges[i]->getVertex(1);
- else if (_edges[i]->getVertex(1) == v[i-1])
+ else if(_edges[i]->getVertex(1) == v[i - 1])
v[i] = _edges[i]->getVertex(0);
else {
- Msg::Error("not only %d vertices or edge not in order [2] (im %d)", _numEdge, getNum());
- for (int i = 0; i < _numEdge; ++i) {
+ Msg::Error("not only %d vertices or edge not in order [2] (im %d)",
+ _numEdge, getNum());
+ for(int i = 0; i < _numEdge; ++i) {
_edges[i]->print();
}
return false;
}
}
- if ((v[0] == v1 && v[_numEdge-1] != v0) ||
- (v[0] == v0 && v[_numEdge-1] != v1) ) {
- Msg::Error("not only %d vertices or edge not in order [3] (im %d)", _numEdge, getNum());
- for (int i = 0; i < _numEdge; ++i) {
+ if((v[0] == v1 && v[_numEdge - 1] != v0) ||
+ (v[0] == v0 && v[_numEdge - 1] != v1)) {
+ Msg::Error("not only %d vertices or edge not in order [3] (im %d)",
+ _numEdge, getNum());
+ for(int i = 0; i < _numEdge; ++i) {
_edges[i]->print();
}
return false;
}
- for (int i = 1; i < _numEdge; ++i) {
- for (int j = 0; j < i; ++j) {
- if (_edges[i] == _edges[j]) return false;
- if (v[i] == v[j]) return false;
+ for(int i = 1; i < _numEdge; ++i) {
+ for(int j = 0; j < i; ++j) {
+ if(_edges[i] == _edges[j]) return false;
+ if(v[i] == v[j]) return false;
}
}
- for (int i = 0; i < _numEdge; ++i) {
- if (!v[i]->has(this)) {
+ for(int i = 0; i < _numEdge; ++i) {
+ if(!v[i]->has(this)) {
Msg::Error("vertex don't have me (im %d)", getNum());
return false;
}
- if (_elements[i] && (!_elements[i]->has(this) || !_elements[i]->has(_edges[i]))) {
+ if(_elements[i] &&
+ (!_elements[i]->has(this) || !_elements[i]->has(_edges[i]))) {
Msg::Error("does %d know me ? %d / does it know edge ? %d (im %d)",
- _elements[i]->getNum(),
- _elements[i]->has(this),
- _elements[i]->has(_edges[i]),
- getNum() );
+ _elements[i]->getNum(), _elements[i]->has(this),
+ _elements[i]->has(_edges[i]), getNum());
return false;
}
}
- if (Recombine2D::onlyRecombinations()) {
- if (_numEdge == 3) {
- if (_actions.size() == 1 && !Rec2DData::hasHasOneAction(this)) {
+ if(Recombine2D::onlyRecombinations()) {
+ if(_numEdge == 3) {
+ if(_actions.size() == 1 && !Rec2DData::hasHasOneAction(this)) {
Msg::Error("Data doesn't know I've only 1 action(im %d)", getNum());
return false;
}
- if (_actions.size() == 0 && !Rec2DData::hasHasZeroAction(this)) {
+ if(_actions.size() == 0 && !Rec2DData::hasHasZeroAction(this)) {
Msg::Error("Data doesn't know I've only 0 action(im %d)", getNum());
return false;
}
}
}
- for (unsigned int i = 0; i < _actions.size(); ++i) {
- if (!_actions[i]->has(this)) {
+ for(unsigned int i = 0; i < _actions.size(); ++i) {
+ if(!_actions[i]->has(this)) {
Msg::Error("action doesn't have me (im %d)", getNum());
return false;
}
@@ -5130,31 +5036,33 @@ bool Rec2DElement::checkCoherence() const
void Rec2DElement::print() const
{
int num[4];
- for (int i = 0; i < _numEdge; ++i) {
- if (_elements[i])
+ for(int i = 0; i < _numEdge; ++i) {
+ if(_elements[i])
num[i] = _elements[i]->getNum();
else
num[i] = 0;
}
- if (_numEdge == 3)
- Msg::Info("tri %d - %d %d %d - nRA %d", getNum(), num[0], num[1], num[2], _actions.size());
- if (_numEdge == 4)
- Msg::Info("quad %d - %d %d %d %d - nRA %d", getNum(), num[0], num[1], num[2], num[3], _actions.size());
+ if(_numEdge == 3)
+ Msg::Info("tri %d - %d %d %d - nRA %d", getNum(), num[0], num[1], num[2],
+ _actions.size());
+ if(_numEdge == 4)
+ Msg::Info("quad %d - %d %d %d %d - nRA %d", getNum(), num[0], num[1],
+ num[2], num[3], _actions.size());
}
void Rec2DElement::createElement(double shiftx, double shifty) const
{
MVertex *mv[4];
- std::vector<Rec2DVertex*> v;
+ std::vector<Rec2DVertex *> v;
getVertices(v);
- for (unsigned int i = 0; i < v.size(); ++i) {
- mv[i] = new MVertex(v[i]->getMVertex()->x() + shiftx,
- v[i]->getMVertex()->y() + shifty,
- v[i]->getMVertex()->z() );
+ for(unsigned int i = 0; i < v.size(); ++i) {
+ mv[i] =
+ new MVertex(v[i]->getMVertex()->x() + shiftx,
+ v[i]->getMVertex()->y() + shifty, v[i]->getMVertex()->z());
}
- if (v.size() == 3) {
+ if(v.size() == 3) {
MTriangle *tri = new MTriangle(mv[0], mv[1], mv[2]);
Recombine2D::add(tri);
}
@@ -5164,39 +5072,40 @@ void Rec2DElement::createElement(double shiftx, double shifty) const
}
}
-MQuadrangle* Rec2DElement::_createQuad() const
+MQuadrangle *Rec2DElement::_createQuad() const
{
- if (_numEdge != 4) {
- Msg::Error("[Rec2DElement] Why do you ask me to do this ? You know I can't do it ! COULD YOU LEAVE ME KNOW ?");
+ if(_numEdge != 4) {
+ Msg::Error("[Rec2DElement] Why do you ask me to do this ? You know I can't "
+ "do it ! COULD YOU LEAVE ME KNOW ?");
return new MQuadrangle(NULL, NULL, NULL, NULL);
}
MVertex *v1, *v2, *v3 = NULL, *v4 = NULL;
v1 = _edges[0]->getVertex(0)->getMVertex();
v2 = _edges[0]->getVertex(1)->getMVertex();
int I = -1;
- for (int i = 1; i < 4; ++i) {
- if (v2 == _edges[i]->getVertex(0)->getMVertex()) {
+ for(int i = 1; i < 4; ++i) {
+ if(v2 == _edges[i]->getVertex(0)->getMVertex()) {
v3 = _edges[i]->getVertex(1)->getMVertex();
I = i;
break;
}
- if (v2 == _edges[i]->getVertex(1)->getMVertex()) {
+ if(v2 == _edges[i]->getVertex(1)->getMVertex()) {
v3 = _edges[i]->getVertex(0)->getMVertex();
I = i;
break;
}
}
- if (I == -1) {
+ if(I == -1) {
Msg::Error("[Rec2DElement] Edges not connected");
return NULL;
}
- for (int i = 1; i < 4; ++i) {
- if (i == I) continue;
- if (v3 == _edges[i]->getVertex(0)->getMVertex()) {
+ for(int i = 1; i < 4; ++i) {
+ if(i == I) continue;
+ if(v3 == _edges[i]->getVertex(0)->getMVertex()) {
v4 = _edges[i]->getVertex(1)->getMVertex();
break;
}
- if (v3 == _edges[i]->getVertex(1)->getMVertex()) {
+ if(v3 == _edges[i]->getVertex(1)->getMVertex()) {
v4 = _edges[i]->getVertex(0)->getMVertex();
break;
}
@@ -5207,1085 +5116,1069 @@ MQuadrangle* Rec2DElement::_createQuad() const
/** Rec2DAlgo **/
/*****************/
namespace Rec2DAlgo {
-void execute(bool complete)
-{
- using namespace data;
+ void execute(bool complete)
+ {
+ using namespace data;
- if (initial || current) {
- Msg::Error("[Rec2DAlgo] Already have a sequence, cannot execute");
- return;
- }
- initial = new Node();
- current = initial;
- quadOk = initial;
- //Msg::Warning("root is %d", initial);
+ if(initial || current) {
+ Msg::Error("[Rec2DAlgo] Already have a sequence, cannot execute");
+ return;
+ }
+ initial = new Node();
+ current = initial;
+ quadOk = initial;
+ // Msg::Warning("root is %d", initial);
#ifdef REC2D_DRAW
- __draw(.0);
+ __draw(.0);
#endif
- while (func::lookAhead(complete)) {
- func::chooseBestSequence();
+ while(func::lookAhead(complete)) {
+ func::chooseBestSequence();
#ifdef DRAW_WHEN_SELECTED
- __draw(REC2D_WAIT_SELECTED);
+ __draw(REC2D_WAIT_SELECTED);
#endif
+ }
}
-}
-
-void clear()
-{
- Rec2DData::_cur->_NActions.clear();
- Rec2DData::_cur->_sortedNActions.clear();
+ void clear()
+ {
+ Rec2DData::_cur->_NActions.clear();
+ Rec2DData::_cur->_sortedNActions.clear();
- Rec2DData::_cur->_OActions.clear();
- Rec2DData::_cur->_sortedOActions.clear();
+ Rec2DData::_cur->_OActions.clear();
+ Rec2DData::_cur->_sortedOActions.clear();
- using namespace data;
+ using namespace data;
- delete initial;
- initial = current = quadOk = NULL;
- if (sequence.size()) {
- Msg::Error("Don't think sequence can be of size %d", sequence.size());
+ delete initial;
+ initial = current = quadOk = NULL;
+ if(sequence.size()) {
+ Msg::Error("Don't think sequence can be of size %d", sequence.size());
+ }
+ sequence.clear();
}
- sequence.clear();
-}
-bool paramOK()
-{
- using namespace data;
- bool ans = true;
- if (root_std_srch > 4 || root_std_srch < 1) {
- Msg::Error("Wrong root std search: %d (not in {1,..,4})", root_std_srch);
- ans = false;
- }
- if (plus_std_srch > 6 || plus_std_srch < 1) {
- Msg::Error("Wrong plus std search: %d (not in {1,..,6})", root_std_srch);
- ans = false;
- }
- if (plus_tree_srch && !root_tree_srch) {
- Msg::Error("Cannot plus tree-search if no root tree-searching");
- ans = false;
+ bool paramOK()
+ {
+ using namespace data;
+ bool ans = true;
+ if(root_std_srch > 4 || root_std_srch < 1) {
+ Msg::Error("Wrong root std search: %d (not in {1,..,4})", root_std_srch);
+ ans = false;
+ }
+ if(plus_std_srch > 6 || plus_std_srch < 1) {
+ Msg::Error("Wrong plus std search: %d (not in {1,..,6})", root_std_srch);
+ ans = false;
+ }
+ if(plus_tree_srch && !root_tree_srch) {
+ Msg::Error("Cannot plus tree-search if no root tree-searching");
+ ans = false;
+ }
+ return ans;
}
- return ans;
-}
-bool paramOKSimpleAlgo()
-{
- using namespace data;
- bool ans = true;
- if (root_std_srch != 0) {
- Msg::Error("Wrong root std search: %d (not 0)", root_std_srch);
- ans = false;
- }
- if (plus_std_srch != 0) {
- Msg::Error("Wrong plus std search: %d (not 0)", plus_std_srch);
- ans = false;
+ bool paramOKSimpleAlgo()
+ {
+ using namespace data;
+ bool ans = true;
+ if(root_std_srch != 0) {
+ Msg::Error("Wrong root std search: %d (not 0)", root_std_srch);
+ ans = false;
+ }
+ if(plus_std_srch != 0) {
+ Msg::Error("Wrong plus std search: %d (not 0)", plus_std_srch);
+ ans = false;
+ }
+ return ans;
}
- return ans;
-}
-bool setParam(int horiz, int code)
-{
- using namespace data;
+ bool setParam(int horiz, int code)
+ {
+ using namespace data;
- horizon = horiz;
- codeParam = code;
+ horizon = horiz;
+ codeParam = code;
- unsigned char code_root = static_cast<unsigned char>(code);
- unsigned char code_tree = static_cast<unsigned char>(code >> 8);
+ unsigned char code_root = static_cast<unsigned char>(code);
+ unsigned char code_tree = static_cast<unsigned char>(code >> 8);
- root_tree_srch = code_root % 2;
- root_one_srch = (code_root >> 1) % 2;
- root_take_best = (code_root >> 2) % 2;
- root_std_srch = code_root >> 3;
- plus_tree_srch = code_tree % 2;
- plus_one_srch = (code_tree >> 1) % 2;
- plus_take_best = (code_tree >> 2) % 2;
- // plus_std_srch = code_tree>>3;
- // for try_Clique
- plus_std_srch = (code_tree>>3) % 7;
- try_clique = code_tree>>3 > 6;
+ root_tree_srch = code_root % 2;
+ root_one_srch = (code_root >> 1) % 2;
+ root_take_best = (code_root >> 2) % 2;
+ root_std_srch = code_root >> 3;
+ plus_tree_srch = code_tree % 2;
+ plus_one_srch = (code_tree >> 1) % 2;
+ plus_take_best = (code_tree >> 2) % 2;
+ // plus_std_srch = code_tree>>3;
+ // for try_Clique
+ plus_std_srch = (code_tree >> 3) % 7;
+ try_clique = code_tree >> 3 > 6;
- return (root_std_srch == 0 && plus_std_srch == 0) || paramOK();
-}
+ return (root_std_srch == 0 && plus_std_srch == 0) || paramOK();
+ }
-void getParam(int &horiz, int &code)
-{
- using namespace data;
- horiz = horizon;
- code = codeParam;
-}
+ void getParam(int &horiz, int &code)
+ {
+ using namespace data;
+ horiz = horizon;
+ code = codeParam;
+ }
-void computeAllParam(std::vector<int> &v, bool restricted)
-{
- std::set<int> set;
- for (int code_root = 8*1; code_root < 8*5; ++code_root) {
- for (int code_tree = 8*1; code_tree < 8*7; ++code_tree) {
- if (restricted &&
- (code_root >> 3 > 2 || code_tree >> 3 == 3 || code_root % 2)) {
- continue;
- }
- bool b = (code_tree >> 1) % 4 == (code_root >> 1) % 4;
- switch (code_tree >> 3) {
- case 1: b = b && code_root >> 3 == 1; break;
- case 2: b = b && code_root >> 3 == 2; break;
- case 3: b = b && code_root >> 3 == 3; break;
- case 4: b = b && code_root >> 3 == 2; break;
- case 5: b = b && code_root >> 3 == 4; break;
- case 6: b = b && code_root >> 3 == 4; break;
- }
- if ((code_root % 2 && b)
- || (!(code_root % 2) && !(code_tree % 2))) {
- set.insert((code_tree << 8) + code_root);
- //if ((code_root >> 1) % 2) {
+ void computeAllParam(std::vector<int> &v, bool restricted)
+ {
+ std::set<int> set;
+ for(int code_root = 8 * 1; code_root < 8 * 5; ++code_root) {
+ for(int code_tree = 8 * 1; code_tree < 8 * 7; ++code_tree) {
+ if(restricted &&
+ (code_root >> 3 > 2 || code_tree >> 3 == 3 || code_root % 2)) {
+ continue;
+ }
+ bool b = (code_tree >> 1) % 4 == (code_root >> 1) % 4;
+ switch(code_tree >> 3) {
+ case 1: b = b && code_root >> 3 == 1; break;
+ case 2: b = b && code_root >> 3 == 2; break;
+ case 3: b = b && code_root >> 3 == 3; break;
+ case 4: b = b && code_root >> 3 == 2; break;
+ case 5: b = b && code_root >> 3 == 4; break;
+ case 6: b = b && code_root >> 3 == 4; break;
+ }
+ if((code_root % 2 && b) || (!(code_root % 2) && !(code_tree % 2))) {
+ set.insert((code_tree << 8) + code_root);
+ // if ((code_root >> 1) % 2) {
// for try_Clique
- set.insert((code_tree << 8) + code_root + (8*6 << 8));
- //}
- //Msg::Info("%d %d", code_tree, code_root);
+ set.insert((code_tree << 8) + code_root + (8 * 6 << 8));
+ //}
+ // Msg::Info("%d %d", code_tree, code_root);
+ }
}
}
+ v.assign(set.begin(), set.end());
}
- v.assign(set.begin(), set.end());
-}
-namespace data {
- bool root_tree_srch = false;
- bool root_one_srch = false;
- bool root_take_best = false;
- int root_std_srch = 0;
- bool plus_tree_srch = false;
- bool plus_one_srch = false;
- bool plus_take_best = false;
- int plus_std_srch = 0;
- int horizon = 0;
- int codeParam = 0;
- Node *current = NULL;
- Node *initial = NULL;
- Node *quadOk = NULL;
- std::vector<Node*> sequence;
+ namespace data {
+ bool root_tree_srch = false;
+ bool root_one_srch = false;
+ bool root_take_best = false;
+ int root_std_srch = 0;
+ bool plus_tree_srch = false;
+ bool plus_one_srch = false;
+ bool plus_take_best = false;
+ int plus_std_srch = 0;
+ int horizon = 0;
+ int codeParam = 0;
+ Node *current = NULL;
+ Node *initial = NULL;
+ Node *quadOk = NULL;
+ std::vector<Node *> sequence;
- bool try_clique = false;
-}
+ bool try_clique = false;
+ } // namespace data
-namespace func {
- using namespace data;
+ namespace func {
+ using namespace data;
- bool lookAhead(bool complete)
- {
- current->goAhead(0, complete);
- return current->numChildren();
- }
+ bool lookAhead(bool complete)
+ {
+ current->goAhead(0, complete);
+ return current->numChildren();
+ }
- void chooseBestSequence()
- {
- Node *next = current->getNodeBestSequence();
+ void chooseBestSequence()
+ {
+ Node *next = current->getNodeBestSequence();
#ifdef DRAW_BEST_SEQ
- if (next) next->colourBestSequence(1);
+ if(next) next->colourBestSequence(1);
#endif
- if (current->choose(next))
- current = next;
- else
- Msg::Fatal("Wrong child node in lookahead tree");
- }
+ if(current->choose(next))
+ current = next;
+ else
+ Msg::Fatal("Wrong child node in lookahead tree");
+ }
- Rec2DElement* best(std::vector<Rec2DElement*> &available)
- {
- std::set<Rec2DAction*, gterRec2DAction> actions;
- for (unsigned int i = 0; i < available.size(); ++i)
- available[i]->getMoreUniqueActions(actions);
-
- std::vector<Rec2DElement*> candidate;
- (*actions.begin())->getElements(candidate);
-
- std::vector<Rec2DElement*> unionBest;
- for (unsigned int i = 0; i < candidate.size(); ++i) {
- for (unsigned int j = 0; j < available.size(); ++j) {
- if (candidate[i] == available[j]) {
- unionBest.push_back(candidate[i]);
+ Rec2DElement *best(std::vector<Rec2DElement *> &available)
+ {
+ std::set<Rec2DAction *, gterRec2DAction> actions;
+ for(unsigned int i = 0; i < available.size(); ++i)
+ available[i]->getMoreUniqueActions(actions);
+
+ std::vector<Rec2DElement *> candidate;
+ (*actions.begin())->getElements(candidate);
+
+ std::vector<Rec2DElement *> unionBest;
+ for(unsigned int i = 0; i < candidate.size(); ++i) {
+ for(unsigned int j = 0; j < available.size(); ++j) {
+ if(candidate[i] == available[j]) {
+ unionBest.push_back(candidate[i]);
+ }
}
}
+ return unionBest[rand() % unionBest.size()];
}
- return unionBest[rand() % unionBest.size()];
- }
- Rec2DElement* random(std::vector<Rec2DElement*> &v)
- {
- return v[rand() % v.size()];
- }
+ Rec2DElement *random(std::vector<Rec2DElement *> &v)
+ {
+ return v[rand() % v.size()];
+ }
- void searchForOne(std::vector<Rec2DElement*> &triangles, bool takeBest)
- {
- Rec2DAction *ra;
- if (takeBest)
- ra = getBestOAction();
- else
- ra = getRandomOAction();
+ void searchForOne(std::vector<Rec2DElement *> &triangles, bool takeBest)
+ {
+ Rec2DAction *ra;
+ if(takeBest)
+ ra = getBestOAction();
+ else
+ ra = getRandomOAction();
- if (ra) {
- if (ra->getElement(0)->getNumActions() == 1) {
- triangles.push_back(ra->getElement(0));
- }
- else if (ra->getElement(1)->getNumActions() == 1) {
- triangles.push_back(ra->getElement(1));
- }
- else {
- Msg::Error(" it was not a one action :( %d %d",
- ra->getElement(0)->getNumActions(),
- ra->getElement(1)->getNumActions());
+ if(ra) {
+ if(ra->getElement(0)->getNumActions() == 1) {
+ triangles.push_back(ra->getElement(0));
+ }
+ else if(ra->getElement(1)->getNumActions() == 1) {
+ triangles.push_back(ra->getElement(1));
+ }
+ else {
+ Msg::Error(" it was not a one action :( %d %d",
+ ra->getElement(0)->getNumActions(),
+ ra->getElement(1)->getNumActions());
+ }
}
}
- }
- void searchForRootStd(std::vector<Rec2DElement*> &triangles)
- {
- switch (root_std_srch) {
- case 0: // Simple algo
- searchForLessAction(triangles);
- return;
- case 1:
- searchForAll(triangles, root_take_best);
- return;
- case 2:
- searchForQAll(triangles, root_take_best);
- return;
- case 3:
- searchForQFirst(triangles);
- return;
- case 4:
- searchForQLast(triangles);
- return;
- default:
- Msg::Error("Wrong root standard search");
+ void searchForRootStd(std::vector<Rec2DElement *> &triangles)
+ {
+ switch(root_std_srch) {
+ case 0: // Simple algo
+ searchForLessAction(triangles);
+ return;
+ case 1: searchForAll(triangles, root_take_best); return;
+ case 2: searchForQAll(triangles, root_take_best); return;
+ case 3: searchForQFirst(triangles); return;
+ case 4: searchForQLast(triangles); return;
+ default: Msg::Error("Wrong root standard search");
+ }
}
- }
- void searchForPlusStd(std::vector<Rec2DElement*> &triangles, int depth)
- {
- switch (plus_std_srch) {
- case 0: // Simple algo
- searchForTreeLessAction(triangles);
- return;
- case 1:
+ void searchForPlusStd(std::vector<Rec2DElement *> &triangles, int depth)
{
- searchForAll(triangles, plus_take_best);
- return;
+ switch(plus_std_srch) {
+ case 0: // Simple algo
+ searchForTreeLessAction(triangles);
+ return;
+ case 1: {
+ searchForAll(triangles, plus_take_best);
+ return;
+ }
+ case 2: {
+ if(depth > Rec2DData::getNumNActions() / 3)
+ searchForTAll(triangles);
+ else
+ searchForQAll(triangles, plus_take_best);
+ return;
+ }
+ case 3: searchForQFirst(triangles); return;
+ case 4: searchForTAll(triangles); return;
+ case 5: searchForTFirst(triangles); return;
+ case 6: searchForTLast(triangles); return;
+ default: Msg::Error("Wrong plus standard search");
+ }
}
- case 2:
+
+ void searchForLessAction(std::vector<Rec2DElement *> &triangles)
{
- if (depth > Rec2DData::getNumNActions()/3)
- searchForTAll(triangles);
- else
- searchForQAll(triangles, plus_take_best);
- return;
+ Rec2DElement *re;
+ re = Rec2DData::getRandomLessAction();
+ if(re) triangles.push_back(re);
}
- case 3:
- searchForQFirst(triangles);
- return;
- case 4:
- searchForTAll(triangles);
- return;
- case 5:
- searchForTFirst(triangles);
- return;
- case 6:
- searchForTLast(triangles);
- return;
- default:
- Msg::Error("Wrong plus standard search");
- }
- }
-
- void searchForLessAction(std::vector<Rec2DElement*> &triangles)
- {
- Rec2DElement *re;
- re = Rec2DData::getRandomLessAction();
- if (re) triangles.push_back(re);
- }
- void searchForTreeLessAction(std::vector<Rec2DElement*> &triangles)
- {
- searchForTAll(triangles);
- if (triangles.empty()) return;
-
- int minAction = 3;
- std::vector<Rec2DElement*> candidates;
- for (unsigned int i = 0; i < triangles.size(); ++i) {
- if (triangles[i]->getNumActions() < minAction) {
- minAction = triangles[i]->getNumActions();
- candidates.clear();
- candidates.push_back(triangles[i]);
+ void searchForTreeLessAction(std::vector<Rec2DElement *> &triangles)
+ {
+ searchForTAll(triangles);
+ if(triangles.empty()) return;
+
+ int minAction = 3;
+ std::vector<Rec2DElement *> candidates;
+ for(unsigned int i = 0; i < triangles.size(); ++i) {
+ if(triangles[i]->getNumActions() < minAction) {
+ minAction = triangles[i]->getNumActions();
+ candidates.clear();
+ candidates.push_back(triangles[i]);
+ }
+ else if(triangles[i]->getNumActions() == minAction) {
+ candidates.push_back(triangles[i]);
+ }
}
- else if (triangles[i]->getNumActions() == minAction) {
- candidates.push_back(triangles[i]);
+ if(minAction < 1) {
+ Msg::Fatal("[searchForTreeLessAction] min action is %d", minAction);
}
- }
- if (minAction < 1) {
- Msg::Fatal("[searchForTreeLessAction] min action is %d", minAction);
- }
- triangles.clear();
- triangles.push_back(candidates[rand() % candidates.size()]);
- }
+ triangles.clear();
+ triangles.push_back(candidates[rand() % candidates.size()]);
+ }
- void searchForAll(std::vector<Rec2DElement*> &triangles, bool takeBest)
- {
- Rec2DAction *ra;
- if (takeBest)
- ra = (Rec2DAction*)Rec2DData::getBestAction();
- else
- ra = (Rec2DAction*)Rec2DData::getRandomAction();
+ void searchForAll(std::vector<Rec2DElement *> &triangles, bool takeBest)
+ {
+ Rec2DAction *ra;
+ if(takeBest)
+ ra = (Rec2DAction *)Rec2DData::getBestAction();
+ else
+ ra = (Rec2DAction *)Rec2DData::getRandomAction();
- if (ra) triangles.push_back(ra->getElement(rand() % 2));
- }
+ if(ra) triangles.push_back(ra->getElement(rand() % 2));
+ }
- void searchForQAll(std::vector<Rec2DElement*> &triangles, bool takeBest)
- {
- Rec2DAction *ra;
- if (takeBest)
- ra = getBestNAction();
- else
- ra = getRandomNAction();
+ void searchForQAll(std::vector<Rec2DElement *> &triangles, bool takeBest)
+ {
+ Rec2DAction *ra;
+ if(takeBest)
+ ra = getBestNAction();
+ else
+ ra = getRandomNAction();
- if (!ra) return;
+ if(!ra) return;
- for (int i = 0; i < 2; ++i) {
- std::vector<Rec2DElement*> elem;
- ra->getElement(i)->getMoreNeighbours(elem);
- for (unsigned int j = 0; j < elem.size(); ++j) {
- if (elem[j]->isQuad()) {
- triangles.push_back(ra->getElement(i));
- return;
+ for(int i = 0; i < 2; ++i) {
+ std::vector<Rec2DElement *> elem;
+ ra->getElement(i)->getMoreNeighbours(elem);
+ for(unsigned int j = 0; j < elem.size(); ++j) {
+ if(elem[j]->isQuad()) {
+ triangles.push_back(ra->getElement(i));
+ return;
+ }
}
}
+ Msg::Fatal("Didn't get a action neighbour to a quad");
}
- Msg::Fatal("Didn't get a action neighbour to a quad");
- }
- void searchForQFirst(std::vector<Rec2DElement*> &triangles)
- {
- triangles.clear();
- Node *n = data::quadOk;
- while (n != data::current) {
- n = n->getChild();
- n->getAction()->getNeighbElemWithActions(triangles);
- if (triangles.size()) return;
- }
-
- searchForTFirst(triangles);
- }
+ void searchForQFirst(std::vector<Rec2DElement *> &triangles)
+ {
+ triangles.clear();
+ Node *n = data::quadOk;
+ while(n != data::current) {
+ n = n->getChild();
+ n->getAction()->getNeighbElemWithActions(triangles);
+ if(triangles.size()) return;
+ }
- void searchForQLast(std::vector<Rec2DElement*> &triangles)
- {
- if (current != initial)
- current->getAction()->getNeighbElemWithActions(triangles);
- }
+ searchForTFirst(triangles);
+ }
- void searchForTAll(std::vector<Rec2DElement*> &triangles)
- {
- triangles.clear();
- std::set<Rec2DElement*> set;
- for (unsigned int i = 0; i < data::sequence.size(); ++i) {
- std::vector<Rec2DElement*> elem;
- data::sequence[i]->getAction()->getNeighbElemWithActions(elem);
- set.insert(elem.begin(), elem.end());
+ void searchForQLast(std::vector<Rec2DElement *> &triangles)
+ {
+ if(current != initial)
+ current->getAction()->getNeighbElemWithActions(triangles);
}
- triangles.assign(set.begin(),set.end());
- }
- void searchForTFirst(std::vector<Rec2DElement*> &triangles)
- {
- triangles.clear();
- unsigned int i = 0;
- while (triangles.empty() && i < data::sequence.size()) {
- data::sequence[i]->getAction()->getNeighbElemWithActions(triangles);
- ++i;
+ void searchForTAll(std::vector<Rec2DElement *> &triangles)
+ {
+ triangles.clear();
+ std::set<Rec2DElement *> set;
+ for(unsigned int i = 0; i < data::sequence.size(); ++i) {
+ std::vector<Rec2DElement *> elem;
+ data::sequence[i]->getAction()->getNeighbElemWithActions(elem);
+ set.insert(elem.begin(), elem.end());
+ }
+ triangles.assign(set.begin(), set.end());
}
- }
- void searchForTLast(std::vector<Rec2DElement*> &triangles)
- {
- data::sequence.back()->getAction()->getNeighbElemWithActions(triangles);
- }
+ void searchForTFirst(std::vector<Rec2DElement *> &triangles)
+ {
+ triangles.clear();
+ unsigned int i = 0;
+ while(triangles.empty() && i < data::sequence.size()) {
+ data::sequence[i]->getAction()->getNeighbElemWithActions(triangles);
+ ++i;
+ }
+ }
- Rec2DAction* getBestNAction()
- {
- std::set<Rec2DAction*, gterRec2DAction>::iterator it;
- it = Rec2DData::_cur->_sortedNActions.begin();
+ void searchForTLast(std::vector<Rec2DElement *> &triangles)
+ {
+ data::sequence.back()->getAction()->getNeighbElemWithActions(triangles);
+ }
- while (it != Rec2DData::_cur->_sortedNActions.end()
- && !Rec2DData::has(*it)) ++it;
+ Rec2DAction *getBestNAction()
+ {
+ std::set<Rec2DAction *, gterRec2DAction>::iterator it;
+ it = Rec2DData::_cur->_sortedNActions.begin();
- return it != Rec2DData::_cur->_sortedNActions.end() ? *it : NULL;
- }
+ while(it != Rec2DData::_cur->_sortedNActions.end() &&
+ !Rec2DData::has(*it))
+ ++it;
- Rec2DAction* getRandomNAction()
- {
- if (Rec2DData::_cur->_sortedNActions.empty()) {
- Rec2DData::_cur->_NActions.clear();
- return NULL;
+ return it != Rec2DData::_cur->_sortedNActions.end() ? *it : NULL;
}
- unsigned int count = 0; // limit number of search
- while (count < Rec2DData::_cur->_sortedNActions.size()) {
- int index = rand() % Rec2DData::_cur->_NActions.size();
- Rec2DAction *ra = Rec2DData::_cur->_NActions[index];
- if (Rec2DData::_cur->_sortedNActions.find(ra) ==
- Rec2DData::_cur->_sortedNActions.end()) {
- Rec2DData::_cur->_NActions[index] = Rec2DData::_cur->_NActions.back();
- Rec2DData::_cur->_NActions.pop_back();
+ Rec2DAction *getRandomNAction()
+ {
+ if(Rec2DData::_cur->_sortedNActions.empty()) {
+ Rec2DData::_cur->_NActions.clear();
+ return NULL;
}
- else if(Rec2DData::has(ra)) {
- return ra;
+
+ unsigned int count = 0; // limit number of search
+ while(count < Rec2DData::_cur->_sortedNActions.size()) {
+ int index = rand() % Rec2DData::_cur->_NActions.size();
+ Rec2DAction *ra = Rec2DData::_cur->_NActions[index];
+ if(Rec2DData::_cur->_sortedNActions.find(ra) ==
+ Rec2DData::_cur->_sortedNActions.end()) {
+ Rec2DData::_cur->_NActions[index] = Rec2DData::_cur->_NActions.back();
+ Rec2DData::_cur->_NActions.pop_back();
+ }
+ else if(Rec2DData::has(ra)) {
+ return ra;
+ }
+ ++count;
}
- ++count;
+ return NULL;
}
- return NULL;
- }
-
- Rec2DAction* getBestOAction()
- {
- if (Rec2DData::_cur->_sortedOActions.empty()) return NULL;
- return *Rec2DData::_cur->_sortedOActions.begin();
- }
- Rec2DAction* getRandomOAction()
- {
- if (Rec2DData::_cur->_sortedOActions.empty()) {
- Rec2DData::_cur->_OActions.clear();
- return NULL;
+ Rec2DAction *getBestOAction()
+ {
+ if(Rec2DData::_cur->_sortedOActions.empty()) return NULL;
+ return *Rec2DData::_cur->_sortedOActions.begin();
}
- while (Rec2DData::_cur->_OActions.size()) {
- int index = rand() % Rec2DData::_cur->_OActions.size();
- Rec2DAction *ra = Rec2DData::_cur->_OActions[index];
- if (Rec2DData::_cur->_sortedOActions.find(ra) ==
- Rec2DData::_cur->_sortedOActions.end()) {
- Rec2DData::_cur->_OActions[index] = Rec2DData::_cur->_OActions.back();
- Rec2DData::_cur->_OActions.pop_back();
+ Rec2DAction *getRandomOAction()
+ {
+ if(Rec2DData::_cur->_sortedOActions.empty()) {
+ Rec2DData::_cur->_OActions.clear();
+ return NULL;
}
- else {
- return ra;
+
+ while(Rec2DData::_cur->_OActions.size()) {
+ int index = rand() % Rec2DData::_cur->_OActions.size();
+ Rec2DAction *ra = Rec2DData::_cur->_OActions[index];
+ if(Rec2DData::_cur->_sortedOActions.find(ra) ==
+ Rec2DData::_cur->_sortedOActions.end()) {
+ Rec2DData::_cur->_OActions[index] = Rec2DData::_cur->_OActions.back();
+ Rec2DData::_cur->_OActions.pop_back();
+ }
+ else {
+ return ra;
+ }
}
+ return NULL;
}
- return NULL;
- }
- void findMaximalClique(std::vector<Rec2DAction*> &actions)
- { // vector 'actions' should be a clique of incompatible actions
+ void findMaximalClique(std::vector<Rec2DAction *> &actions)
+ { // vector 'actions' should be a clique of incompatible actions
- // find other actions incompatible with input actions
- std::vector<Rec2DAction*> otherIncompatible;
- for (unsigned int i = 0; i < actions.size(); ++i) {
- std::vector<Rec2DAction*> incompI;
- actions[i]->getIncompatible(incompI);
- relativeComplement(actions, incompI);
- if (i == 0)
- otherIncompatible = incompI;
- else
- intersection(incompI, otherIncompatible);
- }
-
- if (otherIncompatible.empty()) return;
+ // find other actions incompatible with input actions
+ std::vector<Rec2DAction *> otherIncompatible;
+ for(unsigned int i = 0; i < actions.size(); ++i) {
+ std::vector<Rec2DAction *> incompI;
+ actions[i]->getIncompatible(incompI);
+ relativeComplement(actions, incompI);
+ if(i == 0)
+ otherIncompatible = incompI;
+ else
+ intersection(incompI, otherIncompatible);
+ }
- // Compute incompatibilities & Search a maximum
- // clique among those other actions:
- std::vector<Ra2Incomp*> incompatibilities;
- for (unsigned int i = 0; i < otherIncompatible.size(); ++i) {
- std::vector<Rec2DAction*> incompI;
- otherIncompatible[i]->getIncompatible(incompI);
- intersection(otherIncompatible, incompI);
- Ra2Incomp *ra2i = new Ra2Incomp(otherIncompatible[i], incompI);
- incompatibilities.push_back(ra2i);
- }
+ if(otherIncompatible.empty()) return;
+
+ // Compute incompatibilities & Search a maximum
+ // clique among those other actions:
+ std::vector<Ra2Incomp *> incompatibilities;
+ for(unsigned int i = 0; i < otherIncompatible.size(); ++i) {
+ std::vector<Rec2DAction *> incompI;
+ otherIncompatible[i]->getIncompatible(incompI);
+ intersection(otherIncompatible, incompI);
+ Ra2Incomp *ra2i = new Ra2Incomp(otherIncompatible[i], incompI);
+ incompatibilities.push_back(ra2i);
+ }
- findMaximumClique(incompatibilities);
+ findMaximumClique(incompatibilities);
- for (unsigned int i = 0; i < incompatibilities.size(); ++i) {
- actions.push_back(incompatibilities[i]->first);
- delete incompatibilities[i];
+ for(unsigned int i = 0; i < incompatibilities.size(); ++i) {
+ actions.push_back(incompatibilities[i]->first);
+ delete incompatibilities[i];
+ }
}
- }
- void findMaximumClique(std::vector<Ra2Incomp*> &truc)
- {
- if (truc.empty()) {
- Msg::Error("error2 here");
- return;
- }
+ void findMaximumClique(std::vector<Ra2Incomp *> &truc)
+ {
+ if(truc.empty()) {
+ Msg::Error("error2 here");
+ return;
+ }
+
+ std::vector<Ra2Incomp *> candidate, ans;
+ Ra2Incomp *remember;
- std::vector<Ra2Incomp*> candidate, ans;
- Ra2Incomp *remember;
+ std::make_heap(truc.begin(), truc.end(), CompareIncomp());
- std::make_heap(truc.begin(), truc.end(), CompareIncomp());
+ while(truc.size()) {
+ // remove all actions that can not lead to better clique than ans
+ while(truc.size() && truc.front()->second.size() < ans.size()) {
+ while(truc.front()->second.size()) {
+ removeLinkIncompatibilities(truc, truc.front()->first,
+ truc.front()->second.front());
+ }
+ std::pop_heap(truc.begin(), truc.end(), CompareIncomp());
+ delete truc.back();
+ truc.pop_back();
+ std::make_heap(truc.begin(), truc.end(), CompareIncomp());
+ }
+ if(truc.empty()) break;
- while (truc.size()) {
+ if(truc[0]->second.empty()) {
+ std::vector<Rec2DAction *> actions(1, truc.front()->first);
+ subsetIncompatibilities(truc, actions, ans);
+ }
+ else {
+ // take action A which has the least incompatible
+ // and action B which is the first incompatible with A.
+ // Then find common incompatibles
+ std::vector<Rec2DAction *> actions = truc.front()->second; // A
+ unsigned i = 0;
+ while(i < truc.size()) {
+ if(truc[i]->first == truc.front()->second.front()) {
+ remember = truc[i];
+ intersection(truc[i]->second, actions); // B
+ break;
+ }
+ ++i;
+ }
+ if(i == truc.size()) Msg::Error("error3 here");
+
+ // create incompatibilities vector & findMaximumClique
+ subsetIncompatibilities(truc, actions, candidate);
+ if(candidate.size()) findMaximumClique(candidate);
+
+ // copy candidate if better
+ if(candidate.size() + 2 > ans.size()) {
+ actions.clear();
+ actions.push_back(truc.front()->first); // A
+ actions.push_back(truc.front()->second.front()); // B
+ for(unsigned int i = 0; i < candidate.size(); ++i) {
+ actions.push_back(candidate[i]->first);
+ }
+ subsetIncompatibilities(truc, actions, ans);
+ }
- // remove all actions that can not lead to better clique than ans
- while (truc.size() && truc.front()->second.size() < ans.size()) {
- while (truc.front()->second.size()) {
+ // remove incomp link between A & B and start again
removeLinkIncompatibilities(truc, truc.front()->first,
- truc.front()->second.front());
+ truc.front()->second.front());
+ std::make_heap(truc.begin(), truc.end(), CompareIncomp());
}
- std::pop_heap(truc.begin(), truc.end(), CompareIncomp());
- delete truc.back();
- truc.pop_back();
- std::make_heap(truc.begin(), truc.end(), CompareIncomp());
}
- if (truc.empty()) break;
- if (truc[0]->second.empty()) {
- std::vector<Rec2DAction*> actions(1, truc.front()->first);
- subsetIncompatibilities(truc, actions, ans);
+ for(unsigned int i = 0; i < candidate.size(); ++i) delete candidate[i];
+ for(unsigned int i = 0; i < truc.size(); ++i) delete truc[i];
+ truc = ans;
+ }
+
+ void subsetIncompatibilities(const std::vector<Ra2Incomp *> &complete,
+ const std::vector<Rec2DAction *> &subAction,
+ std::vector<Ra2Incomp *> &subset)
+ {
+ for(unsigned int i = 0; i < subset.size(); ++i) {
+ delete subset[i];
}
- else {
- // take action A which has the least incompatible
- // and action B which is the first incompatible with A.
- // Then find common incompatibles
- std::vector<Rec2DAction*> actions = truc.front()->second; // A
- unsigned i = 0;
- while (i < truc.size()) {
- if (truc[i]->first == truc.front()->second.front()) {
- remember = truc[i];
- intersection(truc[i]->second, actions); // B
+ subset.clear();
+ for(unsigned int i = 0; i < subAction.size(); ++i) {
+ unsigned int j = 0;
+ while(j < complete.size()) {
+ if(complete[j]->first == subAction[i]) {
+ std::vector<Rec2DAction *> tmp1 = complete[j]->second;
+ intersection(subAction, tmp1);
+ Ra2Incomp *tmp2 = new Ra2Incomp(complete[j]->first, tmp1);
+ subset.push_back(tmp2);
break;
}
- ++i;
- }
- if (i == truc.size()) Msg::Error("error3 here");
-
- // create incompatibilities vector & findMaximumClique
- subsetIncompatibilities(truc, actions, candidate);
- if (candidate.size()) findMaximumClique(candidate);
-
- // copy candidate if better
- if (candidate.size() + 2 > ans.size()) {
- actions.clear();
- actions.push_back(truc.front()->first); // A
- actions.push_back(truc.front()->second.front()); // B
- for (unsigned int i = 0; i < candidate.size(); ++i) {
- actions.push_back(candidate[i]->first);
- }
- subsetIncompatibilities(truc, actions, ans);
+ ++j;
}
-
- // remove incomp link between A & B and start again
- removeLinkIncompatibilities(truc, truc.front()->first,
- truc.front()->second.front());
- std::make_heap(truc.begin(), truc.end(), CompareIncomp());
+ if(j == complete.size()) Msg::Error("error4 here");
}
}
- for (unsigned int i = 0; i < candidate.size(); ++i) delete candidate[i];
- for (unsigned int i = 0; i < truc.size(); ++i) delete truc[i];
- truc = ans;
- }
-
- void subsetIncompatibilities(const std::vector<Ra2Incomp*> &complete,
- const std::vector<Rec2DAction*> &subAction,
- std::vector<Ra2Incomp*> &subset)
- {
- for (unsigned int i = 0; i < subset.size(); ++i) {
- delete subset[i];
- }
- subset.clear();
- for (unsigned int i = 0; i < subAction.size(); ++i) {
- unsigned int j = 0;
- while (j < complete.size()) {
- if (complete[j]->first == subAction[i]) {
- std::vector<Rec2DAction*> tmp1 = complete[j]->second;
- intersection(subAction, tmp1);
- Ra2Incomp *tmp2 = new Ra2Incomp(complete[j]->first, tmp1);
- subset.push_back(tmp2);
- break;
+ void removeLinkIncompatibilities(std::vector<Ra2Incomp *> &set,
+ const Rec2DAction *a, const Rec2DAction *b)
+ {
+ if(a == NULL || b == NULL) Msg::Error("gneeeeeeeeeeeee");
+ bool aOK = false, bOK = false;
+ unsigned int i = 0;
+ while(i < set.size()) {
+ const Rec2DAction *other = NULL;
+ if(set[i]->first == a) {
+ aOK = true;
+ other = b;
}
- ++j;
+ else if(set[i]->first == b) {
+ bOK = true;
+ other = a;
+ }
+ if(other) {
+ unsigned int j = 0;
+ while(j < set[i]->second.size()) {
+ if(set[i]->second[j] == other) {
+ set[i]->second[j] = set[i]->second.back();
+ set[i]->second.pop_back();
+ --j;
+ break;
+ }
+ ++j;
+ }
+ if(j == set[i]->second.size()) Msg::Error("error7 here");
+ }
+ if(aOK && bOK) return;
+ ++i;
}
- if (j == complete.size()) Msg::Error("error4 here");
+ Msg::Error("error6 here");
}
- }
- void removeLinkIncompatibilities(std::vector<Ra2Incomp*> &set,
- const Rec2DAction *a, const Rec2DAction *b)
- {
- if (a == NULL || b == NULL) Msg::Error("gneeeeeeeeeeeee");
- bool aOK = false, bOK = false;
- unsigned int i = 0;
- while (i < set.size()) {
- const Rec2DAction *other = NULL;
- if (set[i]->first == a) {
- aOK = true;
- other = b;
- }
- else if (set[i]->first == b) {
- bOK = true;
- other = a;
- }
- if (other) {
- unsigned int j = 0;
- while (j < set[i]->second.size()) {
- if (set[i]->second[j] == other) {
- set[i]->second[j] = set[i]->second.back();
- set[i]->second.pop_back();
- --j;
+ void relativeComplement(const std::vector<Rec2DAction *> &vA,
+ std::vector<Rec2DAction *> &vB)
+ {
+ unsigned int i = 0;
+ while(i < vB.size()) {
+ for(unsigned int j = 0; j < vA.size(); ++j) {
+ if(vB[i] == vA[j]) {
+ vB[i] = vB.back();
+ vB.pop_back();
+ --i;
break;
}
- ++j;
}
- if (j == set[i]->second.size()) Msg::Error("error7 here");
+ ++i;
}
- if (aOK && bOK) return;
- ++i;
}
- Msg::Error("error6 here");
- }
- void relativeComplement(const std::vector<Rec2DAction*> &vA,
- std::vector<Rec2DAction*> &vB)
- {
- unsigned int i = 0;
- while (i < vB.size()) {
- for (unsigned int j = 0; j < vA.size(); ++j) {
- if (vB[i] == vA[j]) {
+ void intersection(const std::vector<Rec2DAction *> &vA,
+ std::vector<Rec2DAction *> &vB)
+ {
+ unsigned int i = 0;
+ while(i < vB.size()) {
+ unsigned int j = 0;
+ while(j < vA.size()) {
+ if(vB[i] == vA[j]) break;
+ ++j;
+ }
+ if(j == vA.size()) {
vB[i] = vB.back();
vB.pop_back();
- --i;
- break;
}
+ else
+ ++i;
}
- ++i;
}
+ } // namespace func
+
+ Node::Node() : _ra(NULL), _dataChange(NULL), _createdActions(NULL)
+ {
+ _quality = Rec2DData::getGlobalQuality();
}
- void intersection(const std::vector<Rec2DAction*> &vA,
- std::vector<Rec2DAction*> &vB)
+ Node::Node(Rec2DAction *action)
+ : _ra(action), _dataChange(NULL), _createdActions(NULL)
{
- unsigned int i = 0;
- while (i < vB.size()) {
- unsigned int j = 0;
- while (j < vA.size()) {
- if (vB[i] == vA[j]) break;
- ++j;
- }
- if (j == vA.size()) {
- vB[i] = vB.back();
- vB.pop_back();
+ _quality = Rec2DData::getGlobalQuality() + _ra->getRealReward();
+ }
+
+ Node::~Node()
+ {
+ for(unsigned int j = 0; j < _children.size(); ++j) {
+ delete _children[j];
+ }
+ if(_createdActions) {
+ Msg::Warning("What should I do ?");
+ for(unsigned int i = 0; i < _createdActions->size(); ++i) {
+ (*_createdActions)[i]->rmvPointing();
+ delete(*_createdActions)[i];
}
- else ++i;
+ delete _createdActions;
+ }
+ if(_ra) {
+ _ra->rmvPointing();
}
}
-}
-
-Node::Node() : _ra(NULL), _dataChange(NULL), _createdActions(NULL)
-{
- _quality = Rec2DData::getGlobalQuality();
-}
-
-Node::Node(Rec2DAction *action) : _ra(action), _dataChange(NULL),
- _createdActions(NULL)
-{
- _quality = Rec2DData::getGlobalQuality() + _ra->getRealReward();
-}
-Node::~Node()
-{
- for (unsigned int j = 0; j < _children.size(); ++j) {
- delete _children[j];
- }
- if (_createdActions) {
- Msg::Warning("What should I do ?");
- for (unsigned int i = 0; i < _createdActions->size(); ++i) {
- (*_createdActions)[i]->rmvPointing();
- delete (*_createdActions)[i];
+ Node *Node::getNodeBestSequence()
+ {
+ // return NULL if no children;
+ Node *bestNode = NULL;
+ int maxLeafQual = 0; // /!\ ok if quality criterion is >= 0
+
+ for(unsigned int i = 0; i < _children.size(); ++i) {
+ int qual = _children[i]->getMaxLeafQual();
+ if(qual > maxLeafQual) {
+ bestNode = _children[i];
+ maxLeafQual = qual;
+ }
+ // Msg::Info("for child %d, I get %d -> max=%d", _children[i], qual,
+ // maxLeafQual);
}
- delete _createdActions;
+ return bestNode;
}
- if (_ra) {
- _ra->rmvPointing();
- }
-}
-Node* Node::getNodeBestSequence()
-{
- // return NULL if no children;
- Node *bestNode = NULL;
- int maxLeafQual = 0; // /!\ ok if quality criterion is >= 0
+ int Node::getMaxLeafQual() const
+ {
+ if(_children.empty()) return _quality;
- for (unsigned int i = 0; i < _children.size(); ++i) {
- int qual = _children[i]->getMaxLeafQual();
- if (qual > maxLeafQual) {
- bestNode = _children[i];
- maxLeafQual = qual;
+ int maxLeafQual = 0; // /!\ ok if quality criterion is >= 0
+ for(unsigned int i = 0; i < _children.size(); ++i) {
+ maxLeafQual = std::max(maxLeafQual, _children[i]->getMaxLeafQual());
}
- //Msg::Info("for child %d, I get %d -> max=%d", _children[i], qual, maxLeafQual);
+ return maxLeafQual;
}
- return bestNode;
-}
-int Node::getMaxLeafQual() const
-{
- if (_children.empty()) return _quality;
+ bool Node::choose(Node *node)
+ {
+ if(!node) return false;
- int maxLeafQual = 0; // /!\ ok if quality criterion is >= 0
- for (unsigned int i = 0; i < _children.size(); ++i) {
- maxLeafQual = std::max(maxLeafQual, _children[i]->getMaxLeafQual());
+ for(unsigned int i = 0; i < _children.size(); ++i) {
+ if(_children[i] == node) {
+ if(!node->makeChanges()) {
+ Msg::Error("No changes");
+ return false;
+ }
+ updateNActions(node);
+ _children[i] = NULL;
+ for(unsigned int j = 0; j < _children.size(); ++j) {
+ delete _children[j]; // sufficient ?
+ }
+ _children.clear();
+ _children.push_back(node);
+ return true;
+ }
+ }
+ return false;
}
- return maxLeafQual;
-}
-bool Node::choose(Node *node)
-{
- if (!node) return false;
+ void Node::updateNActions(Node *node)
+ {
+ // - remove obsolete actions from the set
+ // (for performance, actions in the vector will be removed later)
+ // - add new actions which are neighbour of quadrangle in set and vector
- for (unsigned int i = 0; i < _children.size(); ++i) {
- if (_children[i] == node) {
- if (!node->makeChanges()) {
- Msg::Error("No changes");
- return false;
- }
- updateNActions(node);
- _children[i] = NULL;
- for (unsigned int j = 0; j < _children.size(); ++j) {
- delete _children[j]; // sufficient ?
- }
- _children.clear();
- _children.push_back(node);
- return true;
+ if(!node->_dataChange) {
+ Msg::Fatal("no changes");
+ return;
}
- }
- return false;
-}
-void Node::updateNActions(Node *node)
-{
- // - remove obsolete actions from the set
- // (for performance, actions in the vector will be removed later)
- // - add new actions which are neighbour of quadrangle in set and vector
+ std::set<Rec2DAction *> hiddenRA;
+ node->_dataChange->getHiddenActions(hiddenRA);
+ std::set<Rec2DAction *>::iterator it = hiddenRA.begin();
+ while(it != hiddenRA.end()) {
+ Rec2DData::_cur->_sortedNActions.erase(*it);
+ ++it;
+ }
- if (!node->_dataChange) {
- Msg::Fatal("no changes");
- return;
- }
+ std::vector<Rec2DAction *> neighbourActions;
+ node->_ra->getTouchedActions(neighbourActions);
+ // since changes are made, we do not get obsolete actions
- std::set<Rec2DAction*> hiddenRA;
- node->_dataChange->getHiddenActions(hiddenRA);
- std::set<Rec2DAction*>::iterator it = hiddenRA.begin();
- while (it != hiddenRA.end()) {
- Rec2DData::_cur->_sortedNActions.erase(*it);
- ++it;
+ for(unsigned int i = 0; i < neighbourActions.size(); ++i) {
+ std::pair<std::set<Rec2DAction *, gterRec2DAction>::iterator, bool> p;
+ p = Rec2DData::_cur->_sortedNActions.insert(neighbourActions[i]);
+ if(p.second) Rec2DData::_cur->_NActions.push_back(neighbourActions[i]);
+ }
}
- std::vector<Rec2DAction*> neighbourActions;
- node->_ra->getTouchedActions(neighbourActions);
- // since changes are made, we do not get obsolete actions
+ void Node::goAhead(int depth, bool complete)
+ {
+ if(depth > data::horizon - 1 || depth < 0) {
+ Msg::Fatal("the fuck..");
+ }
- for (unsigned int i = 0; i < neighbourActions.size(); ++i) {
- std::pair<std::set<Rec2DAction*, gterRec2DAction>::iterator, bool> p;
- p = Rec2DData::_cur->_sortedNActions.insert(neighbourActions[i]);
- if (p.second) Rec2DData::_cur->_NActions.push_back(neighbourActions[i]);
- }
-}
+ if(depth == 0) {
+ if(complete)
+ branchComplete(depth);
+ else
+ branch_root();
+ return;
+ }
-void Node::goAhead(int depth, bool complete)
-{
- if (depth > data::horizon - 1 || depth < 0) {
- Msg::Fatal("the fuck..");
- }
+ // 1) Make changes
+ _dataChange = Rec2DData::getNewDataChange();
+ _ra->apply(_dataChange, _createdActions);
+ if(_createdActions) {
+ for(unsigned int i = 0; i < _createdActions->size(); ++i)
+ (*_createdActions)[i]->addPointing();
+ }
- if (depth == 0) {
- if (complete) branchComplete(depth);
- else branch_root();
- return;
- }
+ // 2) branch on children
+ if(complete)
+ branchComplete(depth);
+ else
+ branch(depth);
- // 1) Make changes
- _dataChange = Rec2DData::getNewDataChange();
- _ra->apply(_dataChange, _createdActions);
- if (_createdActions) {
- for (unsigned int i = 0; i < _createdActions->size(); ++i)
- (*_createdActions)[i]->addPointing();
+ // 3) revert changes
+ if(!Rec2DData::revertDataChange(_dataChange))
+ Msg::Error("Unreverted changes");
+ else
+ Recombine2D::incNumChange();
+ _dataChange = NULL;
}
- // 2) branch on children
- if (complete) branchComplete(depth);
- else branch(depth);
+ void Node::branch_root()
+ {
+ using namespace data;
+ using namespace func;
+
+ // 1) search a set of triangles
+ int searchType = 0;
+ std::vector<Rec2DElement *> candidateTriangle;
+
+ while(candidateTriangle.empty()) {
+ switch(searchType) {
+ case 0:
+ if(horizon > 1 && root_tree_srch && current != initial) {
+ for(unsigned int i = 0; i < _children.size(); ++i)
+ _children[i]->goAhead(1);
+ return;
+ }
+ else {
+ for(unsigned int i = 0; i < _children.size(); ++i)
+ delete _children[i]; // is it sufficient ?
+ _children.clear();
+ }
+ break;
- // 3) revert changes
- if (!Rec2DData::revertDataChange(_dataChange))
- Msg::Error("Unreverted changes");
- else
- Recombine2D::incNumChange();
- _dataChange = NULL;
-}
+ case 1:
+ if(root_one_srch) searchForOne(candidateTriangle, root_take_best);
+ break;
-void Node::branch_root()
-{
- using namespace data;
- using namespace func;
+ case 2: searchForRootStd(candidateTriangle); break;
- // 1) search a set of triangles
- int searchType = 0;
- std::vector<Rec2DElement*> candidateTriangle;
+ case 3: searchForAll(candidateTriangle, root_take_best); break;
- while (candidateTriangle.empty()) {
- switch (searchType) {
- case 0:
- if (horizon > 1 && root_tree_srch && current != initial) {
- for (unsigned int i = 0; i < _children.size(); ++i)
- _children[i]->goAhead(1);
+ case 4:
+ // end of algorithm
return;
- }
- else {
- for (unsigned int i = 0; i < _children.size(); ++i)
- delete _children[i]; //is it sufficient ?
- _children.clear();
- }
- break;
- case 1:
- if (root_one_srch) searchForOne(candidateTriangle, root_take_best);
- break;
-
- case 2:
- searchForRootStd(candidateTriangle);
- break;
-
- case 3:
- searchForAll(candidateTriangle, root_take_best);
- break;
-
- case 4:
- // end of algorithm
- return;
-
- default:
- Msg::Fatal("No reason to be here");
+ default: Msg::Fatal("No reason to be here");
+ }
+ ++searchType;
}
- ++searchType;
- }
- // 2) take actions of the best or a random
- Rec2DElement *rt;
- if (root_take_best)
- rt = best(candidateTriangle);
- else
- rt = random(candidateTriangle);
- std::vector<Rec2DAction*> actions;
- rt->getActions(actions);
-
- // 2b) Find maximum clique if asked
- if (try_clique) {
- unsigned int num = actions.size();
- findMaximalClique(actions);
- static int more = 0, same = 0;
- if (actions.size() > num) ++more;
- else if (actions.size() == num) ++same;
- else Msg::Fatal("You've got to be kidding me. -_-");
- Msg::Info("same - more : %d - %d", same, more);
- }
-
- // 3) branch on the actions
- if (_children.size()) {
- Msg::Fatal("ARGREAGAEGERGA");
- }
- for (unsigned int i = 0; i < actions.size(); ++i)
- _children.push_back(new Node(actions[i]));
-
- // Optimization 2 : do not branch if just one child and
- // if no influence of subchildren...
- if (horizon > 1 && (_children.size() != 1 || root_tree_srch)) {
- for (unsigned int i = 0; i < _children.size(); ++i) {
- //Msg::Info("child %d -> q%d(%d)", _children[i], _children[i]->getQual(), _children[i]->getReward());
- _children[i]->goAhead(1);
- }
- }
- /*else {
- for (unsigned int i = 0; i < _children.size(); ++i) {
- Msg::Info("child %d -> q%d(%d)", _children[i], _children[i]->getQual(), _children[i]->getReward());
+ // 2) take actions of the best or a random
+ Rec2DElement *rt;
+ if(root_take_best)
+ rt = best(candidateTriangle);
+ else
+ rt = random(candidateTriangle);
+ std::vector<Rec2DAction *> actions;
+ rt->getActions(actions);
+
+ // 2b) Find maximum clique if asked
+ if(try_clique) {
+ unsigned int num = actions.size();
+ findMaximalClique(actions);
+ static int more = 0, same = 0;
+ if(actions.size() > num)
+ ++more;
+ else if(actions.size() == num)
+ ++same;
+ else
+ Msg::Fatal("You've got to be kidding me. -_-");
+ Msg::Info("same - more : %d - %d", same, more);
}
- }*/
-}
+ // 3) branch on the actions
+ if(_children.size()) {
+ Msg::Fatal("ARGREAGAEGERGA");
+ }
+ for(unsigned int i = 0; i < actions.size(); ++i)
+ _children.push_back(new Node(actions[i]));
-void Node::branch(int depth)
-{
- if (depth > data::horizon || depth < 1) {
- if (depth == 0) {
- Msg::Error("branch() cannot be called for root, use branch_root()");
- return;
+ // Optimization 2 : do not branch if just one child and
+ // if no influence of subchildren...
+ if(horizon > 1 && (_children.size() != 1 || root_tree_srch)) {
+ for(unsigned int i = 0; i < _children.size(); ++i) {
+ // Msg::Info("child %d -> q%d(%d)", _children[i],
+ // _children[i]->getQual(), _children[i]->getReward());
+ _children[i]->goAhead(1);
+ }
}
- Msg::Fatal("the fuck !");
+ /*else {
+ for (unsigned int i = 0; i < _children.size(); ++i) {
+ Msg::Info("child %d -> q%d(%d)", _children[i], _children[i]->getQual(),
+ _children[i]->getReward());
+ }
+ }*/
}
- using namespace data;
- using namespace func;
- sequence.push_back(this);
-
- // 1) search a set of triangles
- int searchType = 0;
- std::vector<Rec2DElement*> candidateTriangle;
-
- while (candidateTriangle.empty()) {
- switch (searchType) {
- case 0:
- if (depth < horizon - 1 && plus_tree_srch && current != initial) {
- if (_children.size()) {
- for (unsigned int i = 0; i < _children.size(); ++i)
- _children[i]->goAhead(depth + 1);
- }
- if (sequence.back() != this) Msg::Fatal("Aaargh 1");
- sequence.pop_back();
+ void Node::branch(int depth)
+ {
+ if(depth > data::horizon || depth < 1) {
+ if(depth == 0) {
+ Msg::Error("branch() cannot be called for root, use branch_root()");
return;
}
- else {
- for (unsigned int i = 0; i < _children.size(); ++i)
- delete _children[i]; //is it sufficient ?
- _children.clear();
- }
- break;
+ Msg::Fatal("the fuck !");
+ }
+ using namespace data;
+ using namespace func;
+ sequence.push_back(this);
+
+ // 1) search a set of triangles
+ int searchType = 0;
+ std::vector<Rec2DElement *> candidateTriangle;
+
+ while(candidateTriangle.empty()) {
+ switch(searchType) {
+ case 0:
+ if(depth < horizon - 1 && plus_tree_srch && current != initial) {
+ if(_children.size()) {
+ for(unsigned int i = 0; i < _children.size(); ++i)
+ _children[i]->goAhead(depth + 1);
+ }
+ if(sequence.back() != this) Msg::Fatal("Aaargh 1");
+ sequence.pop_back();
- case 1:
- if (plus_one_srch) searchForOne(candidateTriangle, plus_take_best);
- break;
+ return;
+ }
+ else {
+ for(unsigned int i = 0; i < _children.size(); ++i)
+ delete _children[i]; // is it sufficient ?
+ _children.clear();
+ }
+ break;
- case 2:
- searchForPlusStd(candidateTriangle, depth);
- break;
+ case 1:
+ if(plus_one_srch) searchForOne(candidateTriangle, plus_take_best);
+ break;
- case 3:
- searchForAll(candidateTriangle, plus_take_best);
- break;
+ case 2: searchForPlusStd(candidateTriangle, depth); break;
- case 4:
- if (sequence.back() != this) Msg::Fatal("Aaargh 2");
- sequence.pop_back();
- return;
+ case 3: searchForAll(candidateTriangle, plus_take_best); break;
- default:
- Msg::Fatal("No reason to be here");
- }
- ++searchType;
- }
+ case 4:
+ if(sequence.back() != this) Msg::Fatal("Aaargh 2");
+ sequence.pop_back();
+ return;
- // 2) take actions of the best or a random
- Rec2DElement *rt;
- if (plus_take_best)
- rt = best(candidateTriangle);
- else
- rt = random(candidateTriangle);
- std::vector<Rec2DAction*> actions;
- rt->getActions(actions);
+ default: Msg::Fatal("No reason to be here");
+ }
+ ++searchType;
+ }
- // 2b) Find maximum clique if asked
- if (try_clique) {
- unsigned int num = actions.size();
- findMaximalClique(actions);
- static int more = 0, same = 0;
- if (actions.size() > num) ++more;
- else if (actions.size() == num) ++same;
- else Msg::Fatal("You've got to be kidding me. -_-");
- //Msg::Info("same - more : %d - %d", same, more);
- }
+ // 2) take actions of the best or a random
+ Rec2DElement *rt;
+ if(plus_take_best)
+ rt = best(candidateTriangle);
+ else
+ rt = random(candidateTriangle);
+ std::vector<Rec2DAction *> actions;
+ rt->getActions(actions);
+
+ // 2b) Find maximum clique if asked
+ if(try_clique) {
+ unsigned int num = actions.size();
+ findMaximalClique(actions);
+ static int more = 0, same = 0;
+ if(actions.size() > num)
+ ++more;
+ else if(actions.size() == num)
+ ++same;
+ else
+ Msg::Fatal("You've got to be kidding me. -_-");
+ // Msg::Info("same - more : %d - %d", same, more);
+ }
+
+ // 3) branch on the actions
+ if(_children.size()) {
+ Msg::Fatal("ARGREAGAEGERGA");
+ }
+ for(unsigned int i = 0; i < actions.size(); ++i)
+ _children.push_back(new Node(actions[i]));
+
+ if(depth + 1 < horizon) {
+ for(unsigned int i = 0; i < _children.size(); ++i) {
+ /*std::ostringstream oss;
+ for (int j = 0; j < depth; ++j)
+ oss << " ";
+ oss << "child %d -> q(%d)%d";
+ Msg::Info("_____%d_%d", _children[i]->getQual(),
+ _children[i]->getReward()); Msg::Info(oss.str().c_str(), _children[i],
+ _children[i]->getReward(), _children[i]->getQual());*/
+ _children[i]->goAhead(depth + 1);
+ }
+ }
+ /*else {
+ for (unsigned int i = 0; i < _children.size(); ++i) {
+ std::ostringstream oss;
+ for (int j = 0; j < depth; ++j)
+ oss << " ";
+ oss << "child %d -> q(%d)%d";
+ Msg::Info(oss.str().c_str(), _children[i], _children[i]->getReward(),
+ _children[i]->getQual());
+ }
+ }*/
- // 3) branch on the actions
- if (_children.size()) {
- Msg::Fatal("ARGREAGAEGERGA");
+ if(sequence.back() != this) Msg::Fatal("Aaargh 3");
+ sequence.pop_back();
}
- for (unsigned int i = 0; i < actions.size(); ++i)
- _children.push_back(new Node(actions[i]));
- if (depth + 1 < horizon) {
- for (unsigned int i = 0; i < _children.size(); ++i) {
- /*std::ostringstream oss;
- for (int j = 0; j < depth; ++j)
- oss << " ";
- oss << "child %d -> q(%d)%d";
- Msg::Info("_____%d_%d", _children[i]->getQual(), _children[i]->getReward());
- Msg::Info(oss.str().c_str(), _children[i], _children[i]->getReward(), _children[i]->getQual());*/
- _children[i]->goAhead(depth + 1);
- }
- }
- /*else {
- for (unsigned int i = 0; i < _children.size(); ++i) {
- std::ostringstream oss;
- for (int j = 0; j < depth; ++j)
- oss << " ";
- oss << "child %d -> q(%d)%d";
- Msg::Info(oss.str().c_str(), _children[i], _children[i]->getReward(), _children[i]->getQual());
+ void Node::branchComplete(int depth)
+ {
+ if(depth > data::horizon || depth < 0) {
+ Msg::Fatal("the fuck !");
}
- }*/
+ using namespace data;
+ using namespace func;
+ sequence.push_back(this);
- if (sequence.back() != this) Msg::Fatal("Aaargh 3");
- sequence.pop_back();
-}
+ for(unsigned int i = 0; i < _children.size(); ++i)
+ delete _children[i]; // is it sufficient ?
+ _children.clear();
-void Node::branchComplete(int depth)
-{
- if (depth > data::horizon || depth < 0) {
- Msg::Fatal("the fuck !");
- }
- using namespace data;
- using namespace func;
- sequence.push_back(this);
-
- for (unsigned int i = 0; i < _children.size(); ++i)
- delete _children[i]; //is it sufficient ?
- _children.clear();
-
- // Branch on all actions
- for (int i = 0; i < Rec2DData::getNumAction(); ++i)
- _children.push_back(new Node(Rec2DData::getAction(i)));
+ // Branch on all actions
+ for(int i = 0; i < Rec2DData::getNumAction(); ++i)
+ _children.push_back(new Node(Rec2DData::getAction(i)));
- if (depth + 1 < horizon &&
- (depth > 0 || (depth == 0 && _children.size() > 1))) {
- for (unsigned int i = 0; i < _children.size(); ++i) {
- _children[i]->goAhead(depth + 1, true);
+ if(depth + 1 < horizon &&
+ (depth > 0 || (depth == 0 && _children.size() > 1))) {
+ for(unsigned int i = 0; i < _children.size(); ++i) {
+ _children[i]->goAhead(depth + 1, true);
+ }
}
+
+ if(sequence.back() != this) Msg::Fatal("Aaargh 3");
+ sequence.pop_back();
}
- if (sequence.back() != this) Msg::Fatal("Aaargh 3");
- sequence.pop_back();
-}
+ bool Node::makeChanges()
+ {
+ if(_dataChange || !_ra) return false;
-bool Node::makeChanges()
-{
- if (_dataChange || !_ra)
- return false;
+ _dataChange = Rec2DData::getNewDataChange();
+ _ra->apply(_dataChange, _createdActions, Recombine2D::blossomRec());
+ Recombine2D::incNumChange();
- _dataChange = Rec2DData::getNewDataChange();
- _ra->apply(_dataChange, _createdActions, Recombine2D::blossomRec());
- Recombine2D::incNumChange();
+ std::vector<Rec2DElement *> tri;
+ Node *n = data::quadOk;
+ while(n != data::current) {
+ n = n->getChild();
+ n->getAction()->getNeighbElemWithActions(tri);
+ if(tri.empty())
+ data::quadOk = n;
+ else
+ break;
+ }
- std::vector<Rec2DElement*> tri;
- Node *n = data::quadOk;
- while (n != data::current) {
- n = n->getChild();
- n->getAction()->getNeighbElemWithActions(tri);
- if (tri.empty()) data::quadOk = n;
- else break;
+ return true;
}
- return true;
-}
-
-void Node::colourBestSequence(int depth) {
- _ra->color(255,
- 255*(double) (depth-1)/(data::horizon-1),
- 128*(double) (depth-1)/(data::horizon-1) );
+ void Node::colourBestSequence(int depth)
+ {
+ _ra->color(255, 255 * (double)(depth - 1) / (data::horizon - 1),
+ 128 * (double)(depth - 1) / (data::horizon - 1));
- Node *next = getNodeBestSequence();
- if (next) {
- next->colourBestSequence(depth + 1);
- }
- else {
+ Node *next = getNodeBestSequence();
+ if(next) {
+ next->colourBestSequence(depth + 1);
+ }
+ else {
#ifdef REC2D_DRAW
- __draw(REC2D_WAIT_BEST_SEQ);
+ __draw(REC2D_WAIT_BEST_SEQ);
#endif
+ }
+ _ra->color(183, 255, 169);
}
- _ra->color(183, 255, 169);
-}
-}
+} // namespace Rec2DAlgo
/** Rec2DNode **/
/*****************/
@@ -6300,64 +6193,62 @@ bool gterRec2DNode::operator()(Rec2DNode *rn1, Rec2DNode *rn2) const
}
Rec2DNode::Rec2DNode(Rec2DNode *father, Rec2DAction *ra, int depth)
-: _father(father), _ra(ra), _dataChange(NULL), _depth(depth),
- _reward(.0),
- _globalQuality(Rec2DData::getGlobalQuality()), _bestSeqReward(.0),
- _expectedSeqReward(.0), _createdActions(NULL), _notAllQuad(false)
+ : _father(father), _ra(ra), _dataChange(NULL), _depth(depth), _reward(.0),
+ _globalQuality(Rec2DData::getGlobalQuality()), _bestSeqReward(.0),
+ _expectedSeqReward(.0), _createdActions(NULL), _notAllQuad(false)
{
- //printIdentity();
- if (!depth && !ra) {
+ // printIdentity();
+ if(!depth && !ra) {
Msg::Error("[Rec2DNode:constructor] Nothing to do");
return;
}
- if (!father) Recombine2D::setNewTreeNode(this);
+ if(!father) Recombine2D::setNewTreeNode(this);
- for (int i = 0; i < REC2D_NUMB_SONS; ++i)
- _son[i] = NULL;
- if (_ra) _ra->addPointing();
+ for(int i = 0; i < REC2D_NUMB_SONS; ++i) _son[i] = NULL;
+ if(_ra) _ra->addPointing();
- if (!depth) {
+ if(!depth) {
_reward = _ra->getRealReward();
- if (Recombine2D::checkIfNotAllQuad()) {
+ if(Recombine2D::checkIfNotAllQuad()) {
int initialNum = Rec2DData::getNumZeroAction();
Rec2DDataChange *dataChg = Rec2DData::getNewDataChange();
- std::vector<Rec2DAction*> *vActions;
+ std::vector<Rec2DAction *> *vActions;
_ra->apply(dataChg, vActions);
- while (Rec2DData::getNumZeroAction() == initialNum &&
- Rec2DData::getNumOneAction() ) {
+ while(Rec2DData::getNumZeroAction() == initialNum &&
+ Rec2DData::getNumOneAction()) {
Rec2DAction *ra = Rec2DData::getOneAction();
ra->apply(dataChg, vActions);
}
- if (Rec2DData::getNumZeroAction() > initialNum) _notAllQuad = true;
+ if(Rec2DData::getNumZeroAction() > initialNum) _notAllQuad = true;
Rec2DData::revertDataChange(dataChg);
}
return;
}
// Apply changes
- std::vector<Rec2DElement*> savedNeighbours; // for Collapses
- if (_ra) {
+ std::vector<Rec2DElement *> savedNeighbours; // for Collapses
+ if(_ra) {
_ra->getNeighbElemWithActions(savedNeighbours);
_dataChange = Rec2DData::getNewDataChange();
_ra->apply(_dataChange, _createdActions);
- if (_createdActions) {
- for (unsigned int i = 0; i < _createdActions->size(); ++i)
+ if(_createdActions) {
+ for(unsigned int i = 0; i < _createdActions->size(); ++i)
(*_createdActions)[i]->addPointing();
}
_reward = Rec2DData::getGlobalQuality() - _globalQuality;
}
// Create branches
- std::vector<Rec2DAction*> actions;
+ std::vector<Rec2DAction *> actions;
Recombine2D::incNumChange();
Recombine2D::nextTreeActions(actions, savedNeighbours, this);
- if (actions.empty() && depth < 0) Rec2DData::addEndNode(this);
- if (actions.size()) _createSons(actions, depth);
+ if(actions.empty() && depth < 0) Rec2DData::addEndNode(this);
+ if(actions.size()) _createSons(actions, depth);
// Revert changes
- if (_dataChange) {
- if (!Rec2DData::revertDataChange(_dataChange))
+ if(_dataChange) {
+ if(!Rec2DData::revertDataChange(_dataChange))
Msg::Error(" 1 - don't reverted changes");
else
Recombine2D::incNumChange();
@@ -6368,35 +6259,34 @@ Rec2DNode::Rec2DNode(Rec2DNode *father, Rec2DAction *ra, int depth)
Rec2DNode::~Rec2DNode()
{
int i = -1;
- while (++i < REC2D_NUMB_SONS && _son[i]) {
+ while(++i < REC2D_NUMB_SONS && _son[i]) {
_son[i]->_rmvFather(this);
delete _son[i];
}
- if (_createdActions) {
- for (unsigned int i = 0; i < _createdActions->size(); ++i) {
+ if(_createdActions) {
+ for(unsigned int i = 0; i < _createdActions->size(); ++i) {
(*_createdActions)[i]->rmvPointing();
- delete (*_createdActions)[i];
+ delete(*_createdActions)[i];
}
delete _createdActions;
}
- if (_ra) {
+ if(_ra) {
_ra->rmvPointing();
_ra = NULL;
}
- if (_father) {
+ if(_father) {
_father->_rmvSon(this);
- if (!_father->_hasSons() && _father->canBeDeleted())
- delete _father;
+ if(!_father->_hasSons() && _father->canBeDeleted()) delete _father;
}
}
void Rec2DNode::lookahead(int depth)
{
- if (!_ra || depth < 1 || !_dataChange) {
+ if(!_ra || depth < 1 || !_dataChange) {
Msg::Error("[Rec2DNode] should not be here (lookahead)");
return;
}
- if (Recombine2D::revertIfNotAllQuad() && _notAllQuad) {
+ if(Recombine2D::revertIfNotAllQuad() && _notAllQuad) {
Msg::Error("[Rec2DNode] not sure if it is normal... Take a look !");
// should check if normal that 'new Node()' or 'selectbest()'
// return a notAllQuad node
@@ -6406,32 +6296,32 @@ void Rec2DNode::lookahead(int depth)
_bestSeqReward = .0;
_expectedSeqReward = .0;
- if (_son[0]) {
+ if(_son[0]) {
_depth = depth;
_makeDevelopments(depth);
}
- else {//if (depth == 1) {
+ else { // if (depth == 1) {
_depth = depth;
- std::vector<Rec2DElement*> savedNeighbours;
+ std::vector<Rec2DElement *> savedNeighbours;
_ra->getNeighbElemWithActions(savedNeighbours);
- std::vector<Rec2DAction*> actions;
+ std::vector<Rec2DAction *> actions;
Recombine2D::incNumChange();
Recombine2D::nextTreeActions(actions, savedNeighbours, this);
- if (actions.size()) _createSons(actions, depth);
+ if(actions.size()) _createSons(actions, depth);
}
- //else {Msg::Warning("Why am I here ?");
- //I(( "father%d ra%d son[0]%d", _father, _ra, _son[0] ));}
+ // else {Msg::Warning("Why am I here ?");
+ // I(( "father%d ra%d son[0]%d", _father, _ra, _son[0] ));}
}
-Rec2DNode* Rec2DNode::selectBestNode(Rec2DNode *rn)
+Rec2DNode *Rec2DNode::selectBestNode(Rec2DNode *rn)
{
- if (Recombine2D::revertIfNotAllQuad() && rn->_notAllQuad) {
+ if(Recombine2D::revertIfNotAllQuad() && rn->_notAllQuad) {
#ifdef DRAW_WHEN_SELECTED
__draw(.1);
#endif
Rec2DNode *father = rn->_father;
- while (father) {
- if (!Rec2DData::revertDataChange(rn->_dataChange))
+ while(father) {
+ if(!Rec2DData::revertDataChange(rn->_dataChange))
Msg::Error(" 4 - don't reverted changes");
rn->_rmvFather(father);
@@ -6440,7 +6330,8 @@ Rec2DNode* Rec2DNode::selectBestNode(Rec2DNode *rn)
rn = father;
father = rn->_father;
- if (!rn->_getNumSon()) rn->_notAllQuad = true;
+ if(!rn->_getNumSon())
+ rn->_notAllQuad = true;
else {
#ifdef DRAW_WHEN_SELECTED
__draw(.1);
@@ -6451,40 +6342,40 @@ Rec2DNode* Rec2DNode::selectBestNode(Rec2DNode *rn)
return NULL;
}
- if (!rn->_son[0])
- return NULL;
+ if(!rn->_son[0]) return NULL;
#ifdef DRAW_BEST_SEQ
rn->_son[0]->printSequence();
#endif
- for (int i = 1; i < REC2D_NUMB_SONS; ++i) {
+ for(int i = 1; i < REC2D_NUMB_SONS; ++i) {
rn->_delSons(false);
}
- if (Recombine2D::dynamicTree()) {
+ if(Recombine2D::dynamicTree()) {
rn->_son[0]->_delSons(true);
}
- if (!rn->_son[0]->makeChanges()) Msg::Error("[Rec2DNode] No changes");
+ if(!rn->_son[0]->makeChanges()) Msg::Error("[Rec2DNode] No changes");
#ifndef DRAW_BEST_SEQ
#ifdef DRAW_WHEN_SELECTED // draw state at origin
- __draw(REC2D_WAIT_SELECTED);
+ __draw(REC2D_WAIT_SELECTED);
#endif
#endif
static int a = 0;
- if (++a == 1) Msg::Warning("FIXME : if only recombines : can do all alone recombinations at beginning");
+ if(++a == 1)
+ Msg::Warning("FIXME : if only recombines : can do all alone recombinations "
+ "at beginning");
return rn->_son[0];
}
bool Rec2DNode::makeChanges()
{
- if (_dataChange || !_ra)
- return false;
+ if(_dataChange || !_ra) return false;
_dataChange = Rec2DData::getNewDataChange();
-#if 0//def REC2D_DRAW // draw state at origin
+#if 0 // def REC2D_DRAW // draw state at origin
double time = Cpu();
_ra->color(0, 0, 200);
//_ra->printTypeRew();
@@ -6493,7 +6384,7 @@ bool Rec2DNode::makeChanges()
while (Cpu()-time < REC2D_WAIT_TIME)
FlGui::instance()->check();
#endif
- if (Recombine2D::blossomRec())
+ if(Recombine2D::blossomRec())
_ra->apply(_dataChange, _createdActions, true);
else
_ra->apply(_dataChange, _createdActions);
@@ -6503,9 +6394,8 @@ bool Rec2DNode::makeChanges()
bool Rec2DNode::revertChanges()
{
- if (!_dataChange)
- return false;
- if (!Rec2DData::revertDataChange(_dataChange))
+ if(!_dataChange) return false;
+ if(!Rec2DData::revertDataChange(_dataChange))
Msg::Error(" 3 - don't reverted changes");
else
Recombine2D::incNumChange();
@@ -6518,19 +6408,15 @@ bool Rec2DNode::operator<(Rec2DNode &other)
return _globalQuality + _reward < other._globalQuality + other._reward;
}
-bool Rec2DNode::canBeDeleted() const
-{
- return _father && _father->_father;
-}
+bool Rec2DNode::canBeDeleted() const { return _father && _father->_father; }
void Rec2DNode::printIdentity() const
{
Msg::Info("---- I am a node (n%d)", this);
- if (_father)
- Msg::Info(" I have a father (n%d)", _father);
+ if(_father) Msg::Info(" I have a father (n%d)", _father);
- if (_ra) {
+ if(_ra) {
Msg::Info(" My action is (ac%d)", _ra);
_ra->printIdentity();
}
@@ -6541,9 +6427,12 @@ void Rec2DNode::printIdentity() const
void Rec2DNode::printSequence() const
{
static int denom = 5;
- //_ra->color(183+72*(double)(_depth+2)/denom, 255*(1-(double)(_depth+2)/denom), 169*(1-(double)(_depth+2)/denom));
- _ra->color(255, 255*(1-(double)_depth/denom), 128*(1-(double)_depth/denom));
- if (_son[0]) _son[0]->printSequence();
+ //_ra->color(183+72*(double)(_depth+2)/denom,
+ //255*(1-(double)(_depth+2)/denom), 169*(1-(double)(_depth+2)/denom));
+ _ra->color(255, 255 * (1 - (double)_depth / denom),
+ 128 * (1 - (double)_depth / denom));
+ if(_son[0])
+ _son[0]->printSequence();
else {
#ifdef REC2D_DRAW
__draw(REC2D_WAIT_BEST_SEQ);
@@ -6554,18 +6443,18 @@ void Rec2DNode::printSequence() const
void Rec2DNode::_makeDevelopments(int depth)
{
- if (Recombine2D::revertIfNotAllQuad() && _notAllQuad)
+ if(Recombine2D::revertIfNotAllQuad() && _notAllQuad)
Msg::Error("[Rec2DNode] Mais !");
int numSon = 0;
- while (numSon < REC2D_NUMB_SONS && _son[numSon]) ++numSon;
+ while(numSon < REC2D_NUMB_SONS && _son[numSon]) ++numSon;
int i = 0, k2 = REC2D_NUMB_SONS;
- while (i < numSon) {
- _son[i]->_develop(depth-1);
+ while(i < numSon) {
+ _son[i]->_develop(depth - 1);
- if (Recombine2D::avoidIfNotAllQuad() && _son[i]->_isNotAllQuad()) {
- if (_son[--k2]) {
+ if(Recombine2D::avoidIfNotAllQuad() && _son[i]->_isNotAllQuad()) {
+ if(_son[--k2]) {
Rec2DNode *tmp = _son[k2];
_son[k2] = _son[i];
_son[i] = tmp;
@@ -6578,8 +6467,9 @@ void Rec2DNode::_makeDevelopments(int depth)
}
}
else {
- if (i == 0) _bestSeqReward = _son[i]->_getBestSequenceReward();
- else if (_bestSeqReward < _son[i]->_getBestSequenceReward()) {
+ if(i == 0)
+ _bestSeqReward = _son[i]->_getBestSequenceReward();
+ else if(_bestSeqReward < _son[i]->_getBestSequenceReward()) {
_bestSeqReward = _son[i]->_getBestSequenceReward();
Rec2DNode *tmp = _son[0];
_son[0] = _son[i];
@@ -6589,9 +6479,9 @@ void Rec2DNode::_makeDevelopments(int depth)
}
}
- if (numSon == 0) {
+ if(numSon == 0) {
_notAllQuad = true;
- if (!Recombine2D::revertIfNotAllQuad()) {
+ if(!Recombine2D::revertIfNotAllQuad()) {
// If not all quad, I can't tell which son is the best...
Msg::Warning("I'm crazy and I don't know what I am doing Oo");
Rec2DNode *tmpNode = _son[0];
@@ -6602,31 +6492,33 @@ void Rec2DNode::_makeDevelopments(int depth)
}
}
- for (int j = k2; j < REC2D_NUMB_SONS; ++j) {
+ for(int j = k2; j < REC2D_NUMB_SONS; ++j) {
_son[j]->_rmvFather(this);
delete _son[j];
_son[j] = NULL;
}
}
-void Rec2DNode::_createSons(const std::vector<Rec2DAction*> &actions, int depth)
+void Rec2DNode::_createSons(const std::vector<Rec2DAction *> &actions,
+ int depth)
{
- if (actions.empty() || _son[0]) {
+ if(actions.empty() || _son[0]) {
Msg::Error("[Rec2DNode:_createSons] Nothing to do");
return;
}
Rec2DNode *tmpNode;
int k1 = -1, k2 = REC2D_NUMB_SONS;
- for (unsigned int i = 0; i < actions.size(); ++i) {
- Rec2DNode *rn = new Rec2DNode(this, actions[i], depth-1);
- if (Recombine2D::avoidIfNotAllQuad() && rn->_isNotAllQuad()) {
+ for(unsigned int i = 0; i < actions.size(); ++i) {
+ Rec2DNode *rn = new Rec2DNode(this, actions[i], depth - 1);
+ if(Recombine2D::avoidIfNotAllQuad() && rn->_isNotAllQuad()) {
_son[--k2] = rn;
}
else {
_son[++k1] = rn;
- if (k1 == 0) _bestSeqReward = _son[k1]->_getBestSequenceReward();
- else if (_bestSeqReward < _son[k1]->_getBestSequenceReward()) {
+ if(k1 == 0)
+ _bestSeqReward = _son[k1]->_getBestSequenceReward();
+ else if(_bestSeqReward < _son[k1]->_getBestSequenceReward()) {
_bestSeqReward = _son[k1]->_getBestSequenceReward();
tmpNode = _son[0];
_son[0] = _son[k1];
@@ -6635,9 +6527,9 @@ void Rec2DNode::_createSons(const std::vector<Rec2DAction*> &actions, int depth)
}
}
- if (k1 < 0) {
+ if(k1 < 0) {
_notAllQuad = true;
- if (!Recombine2D::revertIfNotAllQuad()) {
+ if(!Recombine2D::revertIfNotAllQuad()) {
// If not all quad, I can't tell which son is the best...
++k1;
tmpNode = _son[k1];
@@ -6648,7 +6540,7 @@ void Rec2DNode::_createSons(const std::vector<Rec2DAction*> &actions, int depth)
}
}
- for (int i = k2; i < REC2D_NUMB_SONS; ++i) {
+ for(int i = k2; i < REC2D_NUMB_SONS; ++i) {
_son[i]->_rmvFather(this);
delete _son[i];
_son[i] = NULL;
@@ -6657,11 +6549,11 @@ void Rec2DNode::_createSons(const std::vector<Rec2DAction*> &actions, int depth)
void Rec2DNode::_develop(int depth)
{
- if (!depth || !_ra) {
- if (!_ra) Msg::Error("[Rec2DNode] should not be here (develop)");
+ if(!depth || !_ra) {
+ if(!_ra) Msg::Error("[Rec2DNode] should not be here (develop)");
return;
}
- if (Recombine2D::revertIfNotAllQuad() && _notAllQuad) {
+ if(Recombine2D::revertIfNotAllQuad() && _notAllQuad) {
Msg::Error("[Rec2DNode] No, no, no, it is not normal !");
// see lookahead
return;
@@ -6671,28 +6563,28 @@ void Rec2DNode::_develop(int depth)
_bestSeqReward = .0;
_expectedSeqReward = .0;
- std::vector<Rec2DElement*> neighbours;
- if (!_son[0])
- _ra->getNeighbElemWithActions(neighbours);
+ std::vector<Rec2DElement *> neighbours;
+ if(!_son[0]) _ra->getNeighbElemWithActions(neighbours);
bool hadAction = _createdActions;
_dataChange = Rec2DData::getNewDataChange();
_ra->apply(_dataChange, _createdActions);
- if (_createdActions && !hadAction) {
- for (unsigned int i = 0; i < _createdActions->size(); ++i)
+ if(_createdActions && !hadAction) {
+ for(unsigned int i = 0; i < _createdActions->size(); ++i)
(*_createdActions)[i]->addPointing();
}
_reward = Rec2DData::getGlobalQuality() - _globalQuality;
- if (_son[0]) _makeDevelopments(depth);
+ if(_son[0])
+ _makeDevelopments(depth);
else {
- std::vector<Rec2DAction*> actions;
+ std::vector<Rec2DAction *> actions;
Recombine2D::incNumChange();
Recombine2D::nextTreeActions(actions, neighbours, this);
- if (actions.size()) _createSons(actions, depth);
+ if(actions.size()) _createSons(actions, depth);
}
- if (!Rec2DData::revertDataChange(_dataChange))
+ if(!Rec2DData::revertDataChange(_dataChange))
Msg::Error(" 2 - don't reverted changes");
else
Recombine2D::incNumChange();
@@ -6702,8 +6594,8 @@ void Rec2DNode::_develop(int depth)
int Rec2DNode::_getNumSon() const
{
int num = 0;
- for (int i = 0; i < REC2D_NUMB_SONS; ++i) {
- if (_son[i]) ++num;
+ for(int i = 0; i < REC2D_NUMB_SONS; ++i) {
+ if(_son[i]) ++num;
}
return num;
}
@@ -6711,16 +6603,16 @@ int Rec2DNode::_getNumSon() const
void Rec2DNode::_delSons(bool alsoFirst)
{
int beg = 1;
- if (alsoFirst) beg = 0;
- for (int i = beg; i < REC2D_NUMB_SONS; ++i) {
- if (_son[i]) _son[i]->_rmvFather(this);
+ if(alsoFirst) beg = 0;
+ for(int i = beg; i < REC2D_NUMB_SONS; ++i) {
+ if(_son[i]) _son[i]->_rmvFather(this);
delete _son[i];
_son[i] = NULL;
}
- if (_createdActions) {
- for (unsigned int i = 0; i < _createdActions->size(); ++i) {
+ if(_createdActions) {
+ for(unsigned int i = 0; i < _createdActions->size(); ++i) {
(*_createdActions)[i]->rmvPointing();
- delete (*_createdActions)[i];
+ delete(*_createdActions)[i];
}
delete _createdActions;
}
@@ -6731,15 +6623,15 @@ void Rec2DNode::_orderSons()
bool one = false;
double bestReward = .0;
int k = -1;
- for (int i = 0; i < REC2D_NUMB_SONS; ++i) {
- if (_son[i]) {
+ for(int i = 0; i < REC2D_NUMB_SONS; ++i) {
+ if(_son[i]) {
_son[++k] = _son[i];
_son[i] = NULL;
- if (!one) {
+ if(!one) {
bestReward = _son[k]->_getBestSequenceReward();
one = true;
}
- if (bestReward < _son[k]->_getBestSequenceReward()) {
+ if(bestReward < _son[k]->_getBestSequenceReward()) {
bestReward = _son[k]->_getBestSequenceReward();
Rec2DNode *tmp = _son[0];
_son[0] = _son[k];
@@ -6752,11 +6644,12 @@ void Rec2DNode::_orderSons()
bool Rec2DNode::_rmvSon(Rec2DNode *n)
{
int i = -1;
- while (++i < REC2D_NUMB_SONS && _son[i] != n);
+ while(++i < REC2D_NUMB_SONS && _son[i] != n)
+ ;
- if (i == REC2D_NUMB_SONS) {
+ if(i == REC2D_NUMB_SONS) {
Msg::Info("im %d", this);
- for (int i = 0; i < REC2D_NUMB_SONS; ++i) {
+ for(int i = 0; i < REC2D_NUMB_SONS; ++i) {
Msg::Info("son%d %d", i, _son[i]);
}
Msg::Error("son %d not found", n);
@@ -6772,7 +6665,7 @@ bool Rec2DNode::_rmvSon(Rec2DNode *n)
void Rec2DNode::_rmvFather(Rec2DNode *n)
{
- if (_father != n) {
+ if(_father != n) {
Msg::Error("is not my father");
return;
}
diff --git a/Mesh/meshGFaceRecombine.h b/Mesh/meshGFaceRecombine.h
index 988bbaa236545c76ecfbbdcc1d9374258746a5a9..b5946496272a80c9eed5ac04caaa84993c030cbb 100644
--- a/Mesh/meshGFaceRecombine.h
+++ b/Mesh/meshGFaceRecombine.h
@@ -12,21 +12,21 @@
#define REC2D_NUMB_SONS 20
#ifdef REC2D_ONLY_RECO
- #define REC2D_VERT_ONLY
- #define REC2D_COEF_ANGL 1.
- #define REC2D_COEF_DEGR .0
- #define REC2D_COEF_ANDE .0
- #define REC2D_COEF_ORIE .5
- #define REC2D_COEF_LENG .5
- #define REC2D_COEF_ORLE .0
+#define REC2D_VERT_ONLY
+#define REC2D_COEF_ANGL 1.
+#define REC2D_COEF_DEGR .0
+#define REC2D_COEF_ANDE .0
+#define REC2D_COEF_ORIE .5
+#define REC2D_COEF_LENG .5
+#define REC2D_COEF_ORLE .0
#else
- #define REC2D_VERT_ONLY
- #define REC2D_COEF_ANGL .0
- #define REC2D_COEF_DEGR .5
- #define REC2D_COEF_ANDE (1. - REC2D_COEF_ANGL - REC2D_COEF_DEGR)
- #define REC2D_COEF_ORIE .0
- #define REC2D_COEF_LENG .5
- #define REC2D_COEF_ORLE .5 //(1. - REC2D_COEF_ORIE - REC2D_COEF_LENG)
+#define REC2D_VERT_ONLY
+#define REC2D_COEF_ANGL .0
+#define REC2D_COEF_DEGR .5
+#define REC2D_COEF_ANDE (1. - REC2D_COEF_ANGL - REC2D_COEF_DEGR)
+#define REC2D_COEF_ORIE .0
+#define REC2D_COEF_LENG .5
+#define REC2D_COEF_ORLE .5 //(1. - REC2D_COEF_ORIE - REC2D_COEF_LENG)
#endif
#define REC2D_BIG_NUMB 1e10
@@ -37,12 +37,11 @@
//#include "MEdge.h"
//#include "MQuadrangle.h"
#ifdef REC2D_RECO_BLOS
- #include "meshGFaceOptimize.h"
+#include "meshGFaceOptimize.h"
#endif
#include <fstream>
#include <vector>
-
class Rec2DNode;
class Rec2DVertex;
class Rec2DEdge;
@@ -53,8 +52,7 @@ class Rec2DCollapse;
class Rec2DData;
class Rec2DDataChange;
-template<typename T>
-class Rec2DContainer {
+template <typename T> class Rec2DContainer {
private:
std::vector<T> _vec;
std::set<T> _set;
@@ -69,26 +67,26 @@ namespace Rec2DAlgo {
bool setParam(int horizon, int code);
void clear();
namespace func {
- Rec2DAction* getBestNAction();
- Rec2DAction* getRandomNAction();
- Rec2DAction* getBestOAction();
- Rec2DAction* getRandomOAction();
- }
+ Rec2DAction *getBestNAction();
+ Rec2DAction *getRandomNAction();
+ Rec2DAction *getBestOAction();
+ Rec2DAction *getRandomOAction();
+ } // namespace func
class Node;
-}
+} // namespace Rec2DAlgo
struct lessRec2DAction {
- bool operator()(const Rec2DAction*, const Rec2DAction*) const;
+ bool operator()(const Rec2DAction *, const Rec2DAction *) const;
};
struct gterRec2DAction {
- bool operator()(const Rec2DAction*, const Rec2DAction*) const;
+ bool operator()(const Rec2DAction *, const Rec2DAction *) const;
};
struct lessRec2DNode {
- bool operator()(Rec2DNode*, Rec2DNode*) const;
+ bool operator()(Rec2DNode *, Rec2DNode *) const;
};
struct gterRec2DNode {
- bool operator()(Rec2DNode*, Rec2DNode*) const;
+ bool operator()(Rec2DNode *, Rec2DNode *) const;
};
enum Rec2DQualCrit {
@@ -101,1026 +99,1152 @@ enum Rec2DQualCrit {
//
class Recombine2D {
- private :
- GFace *_gf;
- Rec2DData *_data;
- backgroundMesh *_bgm;
- static Recombine2D *_cur;
- int _numChange;
- double _lastRunTime;
- Rec2DNode *_curNode;
-
- // Parameter :
- const bool _collapses;
- int _strategy, _horizon;
- Rec2DQualCrit _qualCriterion;
-
- bool _checkIfNotAllQuad; // Check if action implies triangle isolation
- bool _avoidIfNotAllQuad; // Don't apply action if it implies triangle isolation
- bool _revertIfNotAllQuad; // Be all quad at any price (can it be not totally unefficient ?)
- bool _oneActionHavePriority; // Tracks and prioritises elements with 1 action
- bool _noProblemIfObsolete; // For recombineSameAsHeuristic
-
- int _weightEdgeBase;
- int _weightEdgeQuad;
- int _weightAngleTri;
- int _weightAngleQuad;
- float _coefAngleQual;
- float _coefDegreeQual;
- float _coefLengthQual;
- float _coefOrientQual;
+private:
+ GFace *_gf;
+ Rec2DData *_data;
+ backgroundMesh *_bgm;
+ static Recombine2D *_cur;
+ int _numChange;
+ double _lastRunTime;
+ Rec2DNode *_curNode;
+
+ // Parameter :
+ const bool _collapses;
+ int _strategy, _horizon;
+ Rec2DQualCrit _qualCriterion;
+
+ bool _checkIfNotAllQuad; // Check if action implies triangle isolation
+ bool
+ _avoidIfNotAllQuad; // Don't apply action if it implies triangle isolation
+ bool _revertIfNotAllQuad; // Be all quad at any price (can it be not totally
+ // unefficient ?)
+ bool _oneActionHavePriority; // Tracks and prioritises elements with 1 action
+ bool _noProblemIfObsolete; // For recombineSameAsHeuristic
+
+ int _weightEdgeBase;
+ int _weightEdgeQuad;
+ int _weightAngleTri;
+ int _weightAngleQuad;
+ float _coefAngleQual;
+ float _coefDegreeQual;
+ float _coefLengthQual;
+ float _coefOrientQual;
#ifdef REC2D_RECO_BLOS
- bool _recombineWithBlossom;
- int _blossomTime;
- bool _saveBlossomMesh;
- int *elist;
- std::map<MElement*, int> t2n;
+ bool _recombineWithBlossom;
+ int _blossomTime;
+ bool _saveBlossomMesh;
+ int *elist;
+ std::map<MElement *, int> t2n;
#endif
- public :
-
- static double t0, t1, t2, t3, t4, t5, t6, t7, t8, t9;
-
- Recombine2D(GFace*, bool collapses);
- ~Recombine2D();
-
- // Construct data
- bool construct();
-
- // Recombination methods
- bool recombine();
- bool recombineNewAlgo(int horiz = -1, int code = -1);
- bool recombineSimpleAlgo(int horiz = -1);
- bool recombineComplete(int horiz = -1);
- double recombine(int depth);
- void recombineSameAsBlossom(); // just to check blossomQual
- void recombineSameAsHeuristic();
- void recombineGreedy(bool constrained = false);
- //bool developTree();
- static void nextTreeActions(std::vector<Rec2DAction*>&,
- const std::vector<Rec2DElement*> &neighbours,
- const Rec2DNode *node = NULL);
-
- // Revert recombinations
- void clearChanges();
-
- // Save mesh & stats
- void updateMesh();
- void saveMesh(std::string);
- void saveStats(std::fstream*);
-
- // Get/Set methods
- inline void setParamNewAlgo(int horiz, int code) {
- Rec2DAlgo::setParam(horiz, code);
- }
- inline void setHorizon(int h) {_horizon = h;} //1
- inline void setStrategy(int s) {_strategy = s;} //0->6
- inline void setQualCriterion(Rec2DQualCrit c) {_qualCriterion = c;}
- inline void setQualCriterion(int a) {_qualCriterion = (Rec2DQualCrit)a;} //0
- static inline GFace const *const getGFace() {return _cur->_gf;}
- static inline backgroundMesh const *const bgm() {return _cur->_bgm;}
- static inline int getNumChange() {return _cur->_numChange;}
- static inline void incNumChange() {++_cur->_numChange;}
- static inline Rec2DQualCrit getQualCrit() {return _cur->_qualCriterion;}
- static inline void setNewTreeNode(Rec2DNode *rn) {_cur->_curNode = rn;}
- static inline double getTimeLastRun() {return _cur->_lastRunTime;}
- static inline double getTimeBlossom() {return _cur->_blossomTime;}
-
- // What is asked ?
- static inline bool dynamicTree() {return _cur->_strategy == 6;}
- static inline bool blossomRec() {return _cur->_recombineWithBlossom;}
- static inline bool blossomQual() {return _cur->_qualCriterion == 0;}
- static inline bool verticesQual() {return _cur->_qualCriterion == 1;}
- static inline bool vertAndEdgesQual() {return _cur->_qualCriterion == 2;}
- static inline bool onlyRecombinations() {return !_cur->_collapses;}
- static inline bool checkIfNotAllQuad() {return _cur->_checkIfNotAllQuad;}
- static inline bool avoidIfNotAllQuad() {return _cur->_avoidIfNotAllQuad;}
- static inline bool revertIfNotAllQuad() {return _cur->_revertIfNotAllQuad;}
- static inline bool priorityOfOneAction() {return _cur->_oneActionHavePriority;}
- static inline bool canIsolateTriangle() {return _cur->_noProblemIfObsolete;}
-
- // Get/Set Weights
- static inline int getWeightEdgeBase() {return _cur->_weightEdgeBase;}
- static inline int getWeightEdgeQuad() {return _cur->_weightEdgeQuad;}
- static inline int getWeightAngleTri() {return _cur->_weightAngleTri;}
- static inline int getWeightAngleQuad() {return _cur->_weightAngleQuad;}
- static inline void setWeightEdgeBase(int a) {_cur->_weightEdgeBase = a;}
- static inline void setWeightEdgeQuad(int a) {_cur->_weightEdgeQuad = a;}
- static inline void setWeightAngleTri(int a) {_cur->_weightAngleTri = a;}
- static inline void setWeightAngleQuad(int a) {_cur->_weightAngleQuad = a;}
-
- // Get/Set Coefficients
- static inline float getCoefAngleQual() {return _cur->_coefAngleQual;}
- static inline float getCoefDegreeQual() {return _cur->_coefDegreeQual;}
- static inline float getCoefAnglDegQual() {
- return 1. - _cur->_coefAngleQual - _cur->_coefDegreeQual;
- }
- static inline float getCoefLengthQual() {return _cur->_coefLengthQual;}
- static inline float getCoefOrientQual() {return _cur->_coefOrientQual;}
- static inline float getCoefLengOrientQual() {
- return 1. - _cur->_coefLengthQual - _cur->_coefOrientQual;
- }
- static inline void setCoefAngleQual(float f) {_cur->_coefAngleQual = f;}
- static inline void setCoefDegreeQual(float f) {_cur->_coefDegreeQual = f;}
- static inline void setCoefLengthQual(float f) {_cur->_coefLengthQual = f;}
- static inline void setCoefOrientQual(float f) {_cur->_coefOrientQual = f;}
-
- // Miscellaneous
- void compareWithBlossom();
- int computeQualBlossom() const;
- inline int getNumElemBlossom() const {return elist[0];}
- static void add(MQuadrangle *q);
- static void add(MTriangle *t);
- static void colorFromBlossom(const Rec2DElement *tri1,
- const Rec2DElement *tri2,
- const Rec2DElement *quad );
- static void colorFromBlossom(const Rec2DElement *tri1,
- const Rec2DElement *tri2,
- const MElement *quad );
- //
- static inline double angle2qual(double ang) {
- return std::max(1. - fabs(ang*2./M_PI - 1.), .0);
- }
+public:
+ static double t0, t1, t2, t3, t4, t5, t6, t7, t8, t9;
+
+ Recombine2D(GFace *, bool collapses);
+ ~Recombine2D();
+
+ // Construct data
+ bool construct();
+
+ // Recombination methods
+ bool recombine();
+ bool recombineNewAlgo(int horiz = -1, int code = -1);
+ bool recombineSimpleAlgo(int horiz = -1);
+ bool recombineComplete(int horiz = -1);
+ double recombine(int depth);
+ void recombineSameAsBlossom(); // just to check blossomQual
+ void recombineSameAsHeuristic();
+ void recombineGreedy(bool constrained = false);
+ // bool developTree();
+ static void nextTreeActions(std::vector<Rec2DAction *> &,
+ const std::vector<Rec2DElement *> &neighbours,
+ const Rec2DNode *node = NULL);
+
+ // Revert recombinations
+ void clearChanges();
+
+ // Save mesh & stats
+ void updateMesh();
+ void saveMesh(std::string);
+ void saveStats(std::fstream *);
+
+ // Get/Set methods
+ inline void setParamNewAlgo(int horiz, int code)
+ {
+ Rec2DAlgo::setParam(horiz, code);
+ }
+ inline void setHorizon(int h) { _horizon = h; } // 1
+ inline void setStrategy(int s) { _strategy = s; } // 0->6
+ inline void setQualCriterion(Rec2DQualCrit c) { _qualCriterion = c; }
+ inline void setQualCriterion(int a) { _qualCriterion = (Rec2DQualCrit)a; } // 0
+ static inline GFace const *const getGFace() { return _cur->_gf; }
+ static inline backgroundMesh const *const bgm() { return _cur->_bgm; }
+ static inline int getNumChange() { return _cur->_numChange; }
+ static inline void incNumChange() { ++_cur->_numChange; }
+ static inline Rec2DQualCrit getQualCrit() { return _cur->_qualCriterion; }
+ static inline void setNewTreeNode(Rec2DNode *rn) { _cur->_curNode = rn; }
+ static inline double getTimeLastRun() { return _cur->_lastRunTime; }
+ static inline double getTimeBlossom() { return _cur->_blossomTime; }
+
+ // What is asked ?
+ static inline bool dynamicTree() { return _cur->_strategy == 6; }
+ static inline bool blossomRec() { return _cur->_recombineWithBlossom; }
+ static inline bool blossomQual() { return _cur->_qualCriterion == 0; }
+ static inline bool verticesQual() { return _cur->_qualCriterion == 1; }
+ static inline bool vertAndEdgesQual() { return _cur->_qualCriterion == 2; }
+ static inline bool onlyRecombinations() { return !_cur->_collapses; }
+ static inline bool checkIfNotAllQuad() { return _cur->_checkIfNotAllQuad; }
+ static inline bool avoidIfNotAllQuad() { return _cur->_avoidIfNotAllQuad; }
+ static inline bool revertIfNotAllQuad() { return _cur->_revertIfNotAllQuad; }
+ static inline bool priorityOfOneAction()
+ {
+ return _cur->_oneActionHavePriority;
+ }
+ static inline bool canIsolateTriangle() { return _cur->_noProblemIfObsolete; }
+
+ // Get/Set Weights
+ static inline int getWeightEdgeBase() { return _cur->_weightEdgeBase; }
+ static inline int getWeightEdgeQuad() { return _cur->_weightEdgeQuad; }
+ static inline int getWeightAngleTri() { return _cur->_weightAngleTri; }
+ static inline int getWeightAngleQuad() { return _cur->_weightAngleQuad; }
+ static inline void setWeightEdgeBase(int a) { _cur->_weightEdgeBase = a; }
+ static inline void setWeightEdgeQuad(int a) { _cur->_weightEdgeQuad = a; }
+ static inline void setWeightAngleTri(int a) { _cur->_weightAngleTri = a; }
+ static inline void setWeightAngleQuad(int a) { _cur->_weightAngleQuad = a; }
+
+ // Get/Set Coefficients
+ static inline float getCoefAngleQual() { return _cur->_coefAngleQual; }
+ static inline float getCoefDegreeQual() { return _cur->_coefDegreeQual; }
+ static inline float getCoefAnglDegQual()
+ {
+ return 1. - _cur->_coefAngleQual - _cur->_coefDegreeQual;
+ }
+ static inline float getCoefLengthQual() { return _cur->_coefLengthQual; }
+ static inline float getCoefOrientQual() { return _cur->_coefOrientQual; }
+ static inline float getCoefLengOrientQual()
+ {
+ return 1. - _cur->_coefLengthQual - _cur->_coefOrientQual;
+ }
+ static inline void setCoefAngleQual(float f) { _cur->_coefAngleQual = f; }
+ static inline void setCoefDegreeQual(float f) { _cur->_coefDegreeQual = f; }
+ static inline void setCoefLengthQual(float f) { _cur->_coefLengthQual = f; }
+ static inline void setCoefOrientQual(float f) { _cur->_coefOrientQual = f; }
+
+ // Miscellaneous
+ void compareWithBlossom();
+ int computeQualBlossom() const;
+ inline int getNumElemBlossom() const { return elist[0]; }
+ static void add(MQuadrangle *q);
+ static void add(MTriangle *t);
+ static void colorFromBlossom(const Rec2DElement *tri1,
+ const Rec2DElement *tri2,
+ const Rec2DElement *quad);
+ static void colorFromBlossom(const Rec2DElement *tri1,
+ const Rec2DElement *tri2, const MElement *quad);
+ //
+ static inline double angle2qual(double ang)
+ {
+ return std::max(1. - fabs(ang * 2. / M_PI - 1.), .0);
+ }
+
+ // Debug
+ void printState() const;
+ void drawState(double shiftx, double shifty, bool color = false) const;
+ static void drawStateCur(double dx, double dy) { _cur->drawState(dx, dy); }
+ static void drawStateOrigin();
- // Debug
- void printState() const;
- void drawState(double shiftx, double shifty, bool color = false) const;
- static void drawStateCur(double dx, double dy) {_cur->drawState(dx, dy);}
- static void drawStateOrigin();
-
- private :
- double _geomAngle(const MVertex*,
- const std::vector<GEdge*>&,
- const std::vector<MElement*>&) const;
- bool _iamCurrent() const {return this == Recombine2D::_cur;}
+private:
+ double _geomAngle(const MVertex *, const std::vector<GEdge *> &,
+ const std::vector<MElement *> &) const;
+ bool _iamCurrent() const { return this == Recombine2D::_cur; }
};
//
class Rec2DData {
- public :
- class Action {
- public :
- const Rec2DAction *action;
- unsigned int position;
- Action(const Rec2DAction *ra, unsigned int pos)
- : action(ra), position(pos) {
- static int a = 0;
- if (++a == 1) Msg::Warning("FIXME: position is supefluous in this case (iterators are sufficient)");
- }
- void update();
- };
- //template<class T> friend void std::swap(T&, T&);
- struct gterAction {
- bool operator()(const Action*, const Action*) const;
- };
- struct lessAction {
- bool operator()(const Action*, const Action*) const;
- };
+public:
+ class Action {
+ public:
+ const Rec2DAction *action;
+ unsigned int position;
+ Action(const Rec2DAction *ra, unsigned int pos) : action(ra), position(pos)
+ {
+ static int a = 0;
+ if(++a == 1)
+ Msg::Warning("FIXME: position is supefluous in this case (iterators "
+ "are sufficient)");
+ }
+ void update();
+ };
+ // template<class T> friend void std::swap(T&, T&);
+ struct gterAction {
+ bool operator()(const Action *, const Action *) const;
+ };
+ struct lessAction {
+ bool operator()(const Action *, const Action *) const;
+ };
- private :
- static Rec2DData *_cur;
+private:
+ static Rec2DData *_cur;
- long double _1valVert, _2valEdge, _2valVert;
- int _numVert, _numEdge;
+ long double _1valVert, _2valEdge, _2valVert;
+ int _numVert, _numEdge;
#ifdef REC2D_RECO_BLOS
- int _0blossomQuality;
+ int _0blossomQuality;
#endif
- // Store entities
- std::vector<Rec2DEdge*> _edges;
- std::vector<Rec2DVertex*> _vertices;
- std::vector<Rec2DElement*> _elements;
- std::vector<Action*> _actions;
-
- // Addition for new algo
- std::set<Rec2DAction*, gterRec2DAction> _sortedActions; // if blossom !
- friend class Rec2DAlgo::Node;
- friend void Rec2DAlgo::clear();
- friend Rec2DAction* Rec2DAlgo::func::getBestNAction();
- friend Rec2DAction* Rec2DAlgo::func::getRandomNAction();
- // TODO: presently managed by Rec2DAlgo... should be managed by Rec2DAction::apply()
- std::vector<Rec2DAction*> _NActions;
- std::set<Rec2DAction*, gterRec2DAction> _sortedNActions; // if blossom !
- friend Rec2DAction* Rec2DAlgo::func::getBestOAction();
- friend Rec2DAction* Rec2DAlgo::func::getRandomOAction();
- std::vector<Rec2DAction*> _OActions;
- std::set<Rec2DAction*, gterRec2DAction> _sortedOActions; // if blossom !
-
- // Addition for simple algo
- Rec2DContainer<Rec2DElement*> _el_1Actions;
- Rec2DContainer<Rec2DElement*> _el_2Actions;
- Rec2DContainer<Rec2DElement*> _el_3Actions;
-
- // Store changes (so can revert)
- std::vector<Rec2DDataChange*> _changes;
-
- // Store parities
- std::map<int, std::vector<Rec2DVertex*> > _parities;
- std::map<Rec2DVertex*, int> _oldParity;
-
- // for Recombine2D::developTree(..)
- std::vector<Rec2DNode*> _endNodes;
-
- // Useless Rec2DTwoTri2Quad are not deleted because Rec2DCollapse need them
- std::vector<Rec2DAction*> _hiddenActions;
-
- // Track elements with one or zero actions
- std::set<Rec2DElement*> _elementWithOneAction;
- std::set<Rec2DElement*> _elementWithZeroAction;
+ // Store entities
+ std::vector<Rec2DEdge *> _edges;
+ std::vector<Rec2DVertex *> _vertices;
+ std::vector<Rec2DElement *> _elements;
+ std::vector<Action *> _actions;
+
+ // Addition for new algo
+ std::set<Rec2DAction *, gterRec2DAction> _sortedActions; // if blossom !
+ friend class Rec2DAlgo::Node;
+ friend void Rec2DAlgo::clear();
+ friend Rec2DAction *Rec2DAlgo::func::getBestNAction();
+ friend Rec2DAction *Rec2DAlgo::func::getRandomNAction();
+ // TODO: presently managed by Rec2DAlgo... should be managed by
+ // Rec2DAction::apply()
+ std::vector<Rec2DAction *> _NActions;
+ std::set<Rec2DAction *, gterRec2DAction> _sortedNActions; // if blossom !
+ friend Rec2DAction *Rec2DAlgo::func::getBestOAction();
+ friend Rec2DAction *Rec2DAlgo::func::getRandomOAction();
+ std::vector<Rec2DAction *> _OActions;
+ std::set<Rec2DAction *, gterRec2DAction> _sortedOActions; // if blossom !
+
+ // Addition for simple algo
+ Rec2DContainer<Rec2DElement *> _el_1Actions;
+ Rec2DContainer<Rec2DElement *> _el_2Actions;
+ Rec2DContainer<Rec2DElement *> _el_3Actions;
+
+ // Store changes (so can revert)
+ std::vector<Rec2DDataChange *> _changes;
+
+ // Store parities
+ std::map<int, std::vector<Rec2DVertex *> > _parities;
+ std::map<Rec2DVertex *, int> _oldParity;
+
+ // for Recombine2D::developTree(..)
+ std::vector<Rec2DNode *> _endNodes;
+
+ // Useless Rec2DTwoTri2Quad are not deleted because Rec2DCollapse need them
+ std::vector<Rec2DAction *> _hiddenActions;
+
+ // Track elements with one or zero actions
+ std::set<Rec2DElement *> _elementWithOneAction;
+ std::set<Rec2DElement *> _elementWithZeroAction;
#ifdef REC2D_RECO_BLOS
- std::map<MElement*, Rec2DElement*> _mel2rel;
+ std::map<MElement *, Rec2DElement *> _mel2rel;
#endif
- public :
-#if 1//def REC2D_DRAW
- std::vector<MTriangle*> _tri;
- std::vector<MQuadrangle*> _quad;
+public:
+#if 1 // def REC2D_DRAW
+ std::vector<MTriangle *> _tri;
+ std::vector<MQuadrangle *> _quad;
#endif
- public :
- Rec2DData();
- ~Rec2DData();
- static inline bool hasInstance() {return _cur;}
-
- // Get/Set methods
- //static inline int getNumVert() {return _cur->_numVert;}
- //static inline int getNumEdge() {return _cur->_numEdge;}
- //static inline double getValVert() {return static_cast<double>(_cur->_2valVert);}
- static inline double getSumVert() {return static_cast<double>(_cur->_1valVert);}
- //static inline double getValEdge() {return static_cast<double>(_cur->_2valEdge);}
- static double getValVert(Rec2DQualCrit c = ChoosedCrit);
+public:
+ Rec2DData();
+ ~Rec2DData();
+ static inline bool hasInstance() { return _cur; }
+
+ // Get/Set methods
+ // static inline int getNumVert() {return _cur->_numVert;}
+ // static inline int getNumEdge() {return _cur->_numEdge;}
+ // static inline double getValVert() {return
+ // static_cast<double>(_cur->_2valVert);}
+ static inline double getSumVert()
+ {
+ return static_cast<double>(_cur->_1valVert);
+ }
+ // static inline double getValEdge() {return
+ // static_cast<double>(_cur->_2valEdge);}
+ static double getValVert(Rec2DQualCrit c = ChoosedCrit);
#ifdef REC2D_RECO_BLOS
- static inline int getBlosQual() {return _cur->_0blossomQuality;}
+ static inline int getBlosQual() { return _cur->_0blossomQuality; }
#endif
- static inline unsigned int getNumElements() {return _cur->_elements.size();}
- static void elementChgAction(Rec2DElement*, int from, int to);
-
- // Add/Remove Entities
- static void add(const Rec2DEdge*);
- static void add(const Rec2DVertex*);
- static void add(const Rec2DElement*);
- static void rmv(const Rec2DEdge*);
- static void rmv(const Rec2DVertex*);
- static void rmv(const Rec2DElement*);
-
- // Entities iterators
- typedef std::vector<Rec2DEdge*>::iterator iter_re;
- typedef std::vector<Rec2DVertex*>::iterator iter_rv;
- typedef std::vector<Rec2DElement*>::iterator iter_rel;
- static inline iter_re firstEdge() {return _cur->_edges.begin();}
- static inline iter_rv firstVertex() {return _cur->_vertices.begin();}
- static inline iter_rel firstElement() {return _cur->_elements.begin();}
- static inline iter_re lastEdge() {return _cur->_edges.end();}
- static inline iter_rv lastVertex() {return _cur->_vertices.end();}
- static inline iter_rel lastElement() {return _cur->_elements.end();}
-
- // Operators on Actions
- static void add(const Rec2DAction*);
- static void rmv(const Rec2DAction*);
- static bool has(const Rec2DAction*);
- static inline void addHidden(const Rec2DAction *ra) {
- _cur->_hiddenActions.push_back((Rec2DAction*)ra);
- }
- static inline bool hasAction() {return _cur->_actions.size();}
- static inline int getNumAction() {return _cur->_actions.size();}
- static inline Rec2DAction* getAction(int i) {
- return const_cast<Rec2DAction*>(_cur->_actions[i]->action);
- }
- //
- static Rec2DAction* getBestAction();
- static Rec2DAction* getRandomAction();
- //inline void sortActions() {sort(_actions.begin(), _actions.end(), gterAction());}
- //
- static void checkObsolete();
-
- // Operators on Elements
- static Rec2DElement* getBestLessAction();
- static Rec2DElement* getRandomLessAction();
-
- // Operators on One & Zero Actions
- static void addHasZeroAction(const Rec2DElement*);
- static void rmvHasZeroAction(const Rec2DElement*);
- static bool hasHasZeroAction(const Rec2DElement*);
- static int getNumZeroAction();
- static void addHasOneAction(const Rec2DElement*, Rec2DAction*);
- static void rmvHasOneAction(const Rec2DElement*, Rec2DAction*);
- static bool hasHasOneAction(const Rec2DElement*);
- static int getNumOneAction();
- static void getElementsOneAction(std::vector<Rec2DElement*> &vec);
- static Rec2DAction* getOneAction();
- static void getUniqueOneActions(std::vector<Rec2DAction*>&);
-
- // Process parities
- static int getNewParity();
- static void removeParity(const Rec2DVertex*, int);
- static inline void addParity(const Rec2DVertex *rv, int p) {
- _cur->_parities[p].push_back((Rec2DVertex*)rv);
- }
- static void associateParity(int pOld, int pNew, Rec2DDataChange *rdc = NULL);
-
- // Process DataChange objects
- static Rec2DDataChange* getNewDataChange();
- static bool revertDataChange(Rec2DDataChange*);
- static void clearChanges();
- static inline int getNumChanges() {return _cur->_changes.size();}
-
- // Quality
- static double getGlobalQuality(Rec2DQualCrit c = ChoosedCrit);
- static double getGlobalQuality(int numVert, double valVert,
- int numEdge = 0, double valEdge = .0,
- Rec2DQualCrit c = ChoosedCrit);
- static void updateVertQual(double, Rec2DQualCrit);
- static void updateEdgeQual(double d, int a = 0) {
- _cur->_2valEdge += d;
- _cur->_numEdge += a;
- }
+ static inline unsigned int getNumElements() { return _cur->_elements.size(); }
+ static void elementChgAction(Rec2DElement *, int from, int to);
+
+ // Add/Remove Entities
+ static void add(const Rec2DEdge *);
+ static void add(const Rec2DVertex *);
+ static void add(const Rec2DElement *);
+ static void rmv(const Rec2DEdge *);
+ static void rmv(const Rec2DVertex *);
+ static void rmv(const Rec2DElement *);
+
+ // Entities iterators
+ typedef std::vector<Rec2DEdge *>::iterator iter_re;
+ typedef std::vector<Rec2DVertex *>::iterator iter_rv;
+ typedef std::vector<Rec2DElement *>::iterator iter_rel;
+ static inline iter_re firstEdge() { return _cur->_edges.begin(); }
+ static inline iter_rv firstVertex() { return _cur->_vertices.begin(); }
+ static inline iter_rel firstElement() { return _cur->_elements.begin(); }
+ static inline iter_re lastEdge() { return _cur->_edges.end(); }
+ static inline iter_rv lastVertex() { return _cur->_vertices.end(); }
+ static inline iter_rel lastElement() { return _cur->_elements.end(); }
+
+ // Operators on Actions
+ static void add(const Rec2DAction *);
+ static void rmv(const Rec2DAction *);
+ static bool has(const Rec2DAction *);
+ static inline void addHidden(const Rec2DAction *ra)
+ {
+ _cur->_hiddenActions.push_back((Rec2DAction *)ra);
+ }
+ static inline bool hasAction() { return _cur->_actions.size(); }
+ static inline int getNumAction() { return _cur->_actions.size(); }
+ static inline Rec2DAction *getAction(int i)
+ {
+ return const_cast<Rec2DAction *>(_cur->_actions[i]->action);
+ }
+ //
+ static Rec2DAction *getBestAction();
+ static Rec2DAction *getRandomAction();
+ // inline void sortActions() {sort(_actions.begin(), _actions.end(),
+ // gterAction());}
+ //
+ static void checkObsolete();
+
+ // Operators on Elements
+ static Rec2DElement *getBestLessAction();
+ static Rec2DElement *getRandomLessAction();
+
+ // Operators on One & Zero Actions
+ static void addHasZeroAction(const Rec2DElement *);
+ static void rmvHasZeroAction(const Rec2DElement *);
+ static bool hasHasZeroAction(const Rec2DElement *);
+ static int getNumZeroAction();
+ static void addHasOneAction(const Rec2DElement *, Rec2DAction *);
+ static void rmvHasOneAction(const Rec2DElement *, Rec2DAction *);
+ static bool hasHasOneAction(const Rec2DElement *);
+ static int getNumOneAction();
+ static void getElementsOneAction(std::vector<Rec2DElement *> &vec);
+ static Rec2DAction *getOneAction();
+ static void getUniqueOneActions(std::vector<Rec2DAction *> &);
+
+ // Process parities
+ static int getNewParity();
+ static void removeParity(const Rec2DVertex *, int);
+ static inline void addParity(const Rec2DVertex *rv, int p)
+ {
+ _cur->_parities[p].push_back((Rec2DVertex *)rv);
+ }
+ static void associateParity(int pOld, int pNew, Rec2DDataChange *rdc = NULL);
+
+ // Process DataChange objects
+ static Rec2DDataChange *getNewDataChange();
+ static bool revertDataChange(Rec2DDataChange *);
+ static void clearChanges();
+ static inline int getNumChanges() { return _cur->_changes.size(); }
+
+ // Quality
+ static double getGlobalQuality(Rec2DQualCrit c = ChoosedCrit);
+ static double getGlobalQuality(int numVert, double valVert, int numEdge = 0,
+ double valEdge = .0,
+ Rec2DQualCrit c = ChoosedCrit);
+ static void updateVertQual(double, Rec2DQualCrit);
+ static void updateEdgeQual(double d, int a = 0)
+ {
+ _cur->_2valEdge += d;
+ _cur->_numEdge += a;
+ }
#ifdef REC2D_RECO_BLOS
- static inline void addBlosQual(int val) {_cur->_0blossomQuality += val;}
+ static inline void addBlosQual(int val) { _cur->_0blossomQuality += val; }
#endif
- // Check errors
- static bool checkEntities();
- void checkQuality() const;
-
- // Print state / Draw actions
- void printState() const;
- void printActions() const;
- static void printAction() {_cur->printAction();}
-
- // Draw methods
- void drawTriangles(double shiftx, double shifty) const;
- void drawElements(double shiftx, double shifty) const;
- void drawChanges(double shiftx, double shifty, bool color) const;
-
- // Operators on End Nodes
- static void addEndNode(const Rec2DNode*);
- static void sortEndNode();
- static inline void drawEndNode(int num);
- static inline int getNumEndNode() {return _cur->_endNodes.size();}
- static inline int getNumElement() {return _cur->_elements.size();}
-
- // Miscellaneous
- static void copyElements(std::vector<Rec2DElement*> &v) {
- v = _cur->_elements;
- }
- static void copyActions(std::vector<Rec2DAction*> &v) {
- v.resize(_cur->_actions.size());
- for (unsigned int i = 0; i < v.size(); ++i) {
- v[i] = const_cast<Rec2DAction*>(_cur->_actions[i]->action);
- }
+ // Check errors
+ static bool checkEntities();
+ void checkQuality() const;
+
+ // Print state / Draw actions
+ void printState() const;
+ void printActions() const;
+ static void printAction() { _cur->printAction(); }
+
+ // Draw methods
+ void drawTriangles(double shiftx, double shifty) const;
+ void drawElements(double shiftx, double shifty) const;
+ void drawChanges(double shiftx, double shifty, bool color) const;
+
+ // Operators on End Nodes
+ static void addEndNode(const Rec2DNode *);
+ static void sortEndNode();
+ static inline void drawEndNode(int num);
+ static inline int getNumEndNode() { return _cur->_endNodes.size(); }
+ static inline int getNumElement() { return _cur->_elements.size(); }
+
+ // Miscellaneous
+ static void copyElements(std::vector<Rec2DElement *> &v)
+ {
+ v = _cur->_elements;
+ }
+ static void copyActions(std::vector<Rec2DAction *> &v)
+ {
+ v.resize(_cur->_actions.size());
+ for(unsigned int i = 0; i < v.size(); ++i) {
+ v[i] = const_cast<Rec2DAction *>(_cur->_actions[i]->action);
}
- static int getNumNActions() {return _cur->_sortedNActions.size();}
+ }
+ static int getNumNActions() { return _cur->_sortedNActions.size(); }
#ifdef REC2D_RECO_BLOS
- static Rec2DElement* getRElement(MElement*);
+ static Rec2DElement *getRElement(MElement *);
#endif
};
enum Rec2DChangeType {
- HideEdge, HideVertex, HideElement, //0-2
- CreatedEdge, CreatedVertex, CreatedElement, //3-5
- HideAction, HideActions, //6-7
- CreatedAction, CreatedActions, //8-9
- SwapVertInAction, SwapVertInEdge, //10-11
- SwapEdgeInAction, SwapEdgeInElem, //12-13
- RemoveElem, AddElem, Relocate, ChangePar, SavePar, //14-18
- SwapMVertInElement, ValQuad,
- Error, Reverted
+ HideEdge,
+ HideVertex,
+ HideElement, // 0-2
+ CreatedEdge,
+ CreatedVertex,
+ CreatedElement, // 3-5
+ HideAction,
+ HideActions, // 6-7
+ CreatedAction,
+ CreatedActions, // 8-9
+ SwapVertInAction,
+ SwapVertInEdge, // 10-11
+ SwapEdgeInAction,
+ SwapEdgeInElem, // 12-13
+ RemoveElem,
+ AddElem,
+ Relocate,
+ ChangePar,
+ SavePar, // 14-18
+ SwapMVertInElement,
+ ValQuad,
+ Error,
+ Reverted
};
class Rec2DChange {
- private :
- Rec2DChangeType _type;
- void *_entity;
- void *_info;
-
- public :
- Rec2DChange() {Msg::Fatal("[Rec2DChange] I should not be created in this manner");}
- Rec2DChange(int);
- Rec2DChange(Rec2DEdge*, bool toHide = false);
- Rec2DChange(Rec2DVertex*, bool toHide = false);
- Rec2DChange(Rec2DElement*, bool toHide = false);
- Rec2DChange(Rec2DAction*, bool toHide = false);
- Rec2DChange(const std::vector<Rec2DAction*>&, bool toHide = false);
- Rec2DChange(Rec2DVertex*, int newParity, Rec2DChangeType);
- Rec2DChange(Rec2DVertex*, SPoint2 newCoord);
- Rec2DChange(const std::vector<Rec2DVertex*>&, Rec2DChangeType); // save Parity
- Rec2DChange(Rec2DVertex*, const std::vector<Rec2DElement*>&,
- Rec2DChangeType ); // add or remove element in vertex
- Rec2DChange(Rec2DVertex*, Rec2DVertex*,
- const std::vector<Rec2DEdge*>&,
- Rec2DChangeType ); // swap vertex1 to vertex2 (edge)
- Rec2DChange(Rec2DVertex*, Rec2DVertex*,
- const std::vector<Rec2DAction*>&,
- Rec2DChangeType ); // swap vertex1 to vertex2 (action)
- Rec2DChange(Rec2DVertex*, Rec2DVertex*,
- const std::vector<Rec2DElement*>&,
- Rec2DChangeType ); // swap mvertex1 to mvertex2 (element)
- Rec2DChange(Rec2DEdge*, Rec2DEdge*, Rec2DChangeType); // swap edge1 to edge2 (element)
- Rec2DChange(Rec2DEdge*, Rec2DEdge*,
- const std::vector<Rec2DAction*>&,
- Rec2DChangeType ); // swap edge1 to edge2 (action)
-
- void getHiddenActions(std::set<Rec2DAction*>&);
-
- void revert();
+private:
+ Rec2DChangeType _type;
+ void *_entity;
+ void *_info;
+
+public:
+ Rec2DChange()
+ {
+ Msg::Fatal("[Rec2DChange] I should not be created in this manner");
+ }
+ Rec2DChange(int);
+ Rec2DChange(Rec2DEdge *, bool toHide = false);
+ Rec2DChange(Rec2DVertex *, bool toHide = false);
+ Rec2DChange(Rec2DElement *, bool toHide = false);
+ Rec2DChange(Rec2DAction *, bool toHide = false);
+ Rec2DChange(const std::vector<Rec2DAction *> &, bool toHide = false);
+ Rec2DChange(Rec2DVertex *, int newParity, Rec2DChangeType);
+ Rec2DChange(Rec2DVertex *, SPoint2 newCoord);
+ Rec2DChange(const std::vector<Rec2DVertex *> &,
+ Rec2DChangeType); // save Parity
+ Rec2DChange(Rec2DVertex *, const std::vector<Rec2DElement *> &,
+ Rec2DChangeType); // add or remove element in vertex
+ Rec2DChange(Rec2DVertex *, Rec2DVertex *, const std::vector<Rec2DEdge *> &,
+ Rec2DChangeType); // swap vertex1 to vertex2 (edge)
+ Rec2DChange(Rec2DVertex *, Rec2DVertex *, const std::vector<Rec2DAction *> &,
+ Rec2DChangeType); // swap vertex1 to vertex2 (action)
+ Rec2DChange(Rec2DVertex *, Rec2DVertex *, const std::vector<Rec2DElement *> &,
+ Rec2DChangeType); // swap mvertex1 to mvertex2 (element)
+ Rec2DChange(Rec2DEdge *, Rec2DEdge *,
+ Rec2DChangeType); // swap edge1 to edge2 (element)
+ Rec2DChange(Rec2DEdge *, Rec2DEdge *, const std::vector<Rec2DAction *> &,
+ Rec2DChangeType); // swap edge1 to edge2 (action)
+
+ void getHiddenActions(std::set<Rec2DAction *> &);
+
+ void revert();
};
class Rec2DDataChange {
- private :
- std::vector<Rec2DChange*> _changes;
- Rec2DAction *_ra;
+private:
+ std::vector<Rec2DChange *> _changes;
+ Rec2DAction *_ra;
- public :
- ~Rec2DDataChange();
+public:
+ ~Rec2DDataChange();
- inline void add(int a) {_changes.push_back(new Rec2DChange(a));}
+ inline void add(int a) { _changes.push_back(new Rec2DChange(a)); }
- inline void hide(Rec2DEdge *re) {_changes.push_back(new Rec2DChange(re, 1));}
- inline void hide(Rec2DVertex *rv) {_changes.push_back(new Rec2DChange(rv, 1));}
- inline void hide(Rec2DElement *rel) {_changes.push_back(new Rec2DChange(rel, 1));}
- std::vector<Rec2DAction*> hiddenActions;
- inline void hide(Rec2DAction *ra) {
- _changes.push_back(new Rec2DChange(ra, 1));
- hiddenActions.push_back(ra);
- }
- inline void hide(std::vector<Rec2DAction*> &vect) {
- _changes.push_back(new Rec2DChange(vect, 1));
- hiddenActions.insert(hiddenActions.end(), vect.begin(), vect.end());
- }
+ inline void hide(Rec2DEdge *re)
+ {
+ _changes.push_back(new Rec2DChange(re, 1));
+ }
+ inline void hide(Rec2DVertex *rv)
+ {
+ _changes.push_back(new Rec2DChange(rv, 1));
+ }
+ inline void hide(Rec2DElement *rel)
+ {
+ _changes.push_back(new Rec2DChange(rel, 1));
+ }
+ std::vector<Rec2DAction *> hiddenActions;
+ inline void hide(Rec2DAction *ra)
+ {
+ _changes.push_back(new Rec2DChange(ra, 1));
+ hiddenActions.push_back(ra);
+ }
+ inline void hide(std::vector<Rec2DAction *> &vect)
+ {
+ _changes.push_back(new Rec2DChange(vect, 1));
+ hiddenActions.insert(hiddenActions.end(), vect.begin(), vect.end());
+ }
- inline void append(Rec2DElement *rel) {_changes.push_back(new Rec2DChange(rel));}
- inline void append(Rec2DAction *ra) {_changes.push_back(new Rec2DChange(ra));}
+ inline void append(Rec2DElement *rel)
+ {
+ _changes.push_back(new Rec2DChange(rel));
+ }
+ inline void append(Rec2DAction *ra)
+ {
+ _changes.push_back(new Rec2DChange(ra));
+ }
- void swapFor(Rec2DEdge*, Rec2DEdge*);
- void swapFor(Rec2DVertex*, Rec2DVertex*);
+ void swapFor(Rec2DEdge *, Rec2DEdge *);
+ void swapFor(Rec2DVertex *, Rec2DVertex *);
- inline void relocate(Rec2DVertex *rv, const SPoint2 &p) {
- _changes.push_back(new Rec2DChange(rv, p));
- }
- inline void changeParity(Rec2DVertex *rv, int p) {
- _changes.push_back(new Rec2DChange(rv, p, ChangePar));
- }
- inline void saveParity(const std::vector<Rec2DVertex*> &verts) {
- _changes.push_back(new Rec2DChange(verts, SavePar));
- }
+ inline void relocate(Rec2DVertex *rv, const SPoint2 &p)
+ {
+ _changes.push_back(new Rec2DChange(rv, p));
+ }
+ inline void changeParity(Rec2DVertex *rv, int p)
+ {
+ _changes.push_back(new Rec2DChange(rv, p, ChangePar));
+ }
+ inline void saveParity(const std::vector<Rec2DVertex *> &verts)
+ {
+ _changes.push_back(new Rec2DChange(verts, SavePar));
+ }
- void checkObsoleteActions(Rec2DVertex*const*, int size);
+ void checkObsoleteActions(Rec2DVertex *const *, int size);
- void getHiddenActions(std::set<Rec2DAction*>&);
+ void getHiddenActions(std::set<Rec2DAction *> &);
- void revert();
+ void revert();
- void setAction(const Rec2DAction *action) {_ra = (Rec2DAction*)action;}
- Rec2DAction* getAction() const {return _ra;}
+ void setAction(const Rec2DAction *action) { _ra = (Rec2DAction *)action; }
+ Rec2DAction *getAction() const { return _ra; }
};
//
class Rec2DAction {
- protected :
- double _globQualIfExecuted, _reward;
- int _lastUpdate, _numPointing;
- void *_dataAction; // Rec2DData::Action*
-
- friend void Rec2DData::add(const Rec2DAction*);
- friend void Rec2DData::rmv(const Rec2DAction*);
- friend bool Rec2DData::has(const Rec2DAction *ra);
- friend void Rec2DData::Action::update();
-
- public :
- Rec2DAction();
- virtual ~Rec2DAction() {}
- virtual void hide() = 0;
- virtual void reveal() = 0;
-
- // Get methods
- virtual bool isRecomb() const = 0;
-
- // Quality
- double getReward() const;
- double getRealReward() const;
- bool operator<(const Rec2DAction&) const;
-
- // Application
- virtual bool isObsolete() const = 0;
- virtual void apply(std::vector<Rec2DVertex*> &newPar) = 0;
- virtual void apply(Rec2DDataChange*, std::vector<Rec2DAction*>*&,
- bool color = false) const = 0;
-
- // Swap
- virtual void swap(Rec2DVertex*, Rec2DVertex*) = 0;
- virtual void swap(Rec2DEdge*, Rec2DEdge*) = 0;
-
- // Pointing
- inline void addPointing() {++_numPointing;}
- inline void rmvPointing() {--_numPointing;}
-
- // Get Element methods
- virtual bool has(const Rec2DElement*) const = 0;
- virtual bool haveElem() const = 0;
- virtual int getNumElement() const = 0;
- virtual Rec2DElement* getElement(int) const = 0;
- virtual Rec2DElement* getRandomElement() const = 0;
- virtual void getElements(std::vector<Rec2DElement*>&) const = 0;
- virtual void getNeighbourElements(std::vector<Rec2DElement*>&) const = 0;
- virtual void getNeighbElemWithActions(std::vector<Rec2DElement*>&) const = 0;
- virtual void getTouchedActions(std::vector<Rec2DAction*>&) const = 0;
-
- // Get Vertex methods
- virtual Rec2DVertex* getVertex(int) const = 0;
-
- // Check errors
- virtual bool checkCoherence(const Rec2DAction *ra = NULL) const = 0;
- inline void *getDataAction() const {return _dataAction;}
-
- // Debug
- virtual void printAdress() = 0;
- virtual void printReward() const = 0;
- virtual void printTypeRew() const = 0;
- virtual void printVertices() const = 0;
- virtual void printIdentity() const = 0;
-
- // Miscellaneous
- virtual Rec2DAction* getBase() const = 0;
- virtual Rec2DAction* getInfant() const = 0;
- virtual MElement* createMElement(double shiftx, double shifty) = 0;
- virtual void color(int, int, int) const = 0;
- virtual void getIncompatible(std::vector<Rec2DAction*>&) = 0;
- //
- static void removeDuplicate(std::vector<Rec2DAction*>&);
-
- private :
- virtual void _computeGlobQual() = 0;
- virtual void _computeReward() = 0;
+protected:
+ double _globQualIfExecuted, _reward;
+ int _lastUpdate, _numPointing;
+ void *_dataAction; // Rec2DData::Action*
+
+ friend void Rec2DData::add(const Rec2DAction *);
+ friend void Rec2DData::rmv(const Rec2DAction *);
+ friend bool Rec2DData::has(const Rec2DAction *ra);
+ friend void Rec2DData::Action::update();
+
+public:
+ Rec2DAction();
+ virtual ~Rec2DAction() {}
+ virtual void hide() = 0;
+ virtual void reveal() = 0;
+
+ // Get methods
+ virtual bool isRecomb() const = 0;
+
+ // Quality
+ double getReward() const;
+ double getRealReward() const;
+ bool operator<(const Rec2DAction &) const;
+
+ // Application
+ virtual bool isObsolete() const = 0;
+ virtual void apply(std::vector<Rec2DVertex *> &newPar) = 0;
+ virtual void apply(Rec2DDataChange *, std::vector<Rec2DAction *> *&,
+ bool color = false) const = 0;
+
+ // Swap
+ virtual void swap(Rec2DVertex *, Rec2DVertex *) = 0;
+ virtual void swap(Rec2DEdge *, Rec2DEdge *) = 0;
+
+ // Pointing
+ inline void addPointing() { ++_numPointing; }
+ inline void rmvPointing() { --_numPointing; }
+
+ // Get Element methods
+ virtual bool has(const Rec2DElement *) const = 0;
+ virtual bool haveElem() const = 0;
+ virtual int getNumElement() const = 0;
+ virtual Rec2DElement *getElement(int) const = 0;
+ virtual Rec2DElement *getRandomElement() const = 0;
+ virtual void getElements(std::vector<Rec2DElement *> &) const = 0;
+ virtual void getNeighbourElements(std::vector<Rec2DElement *> &) const = 0;
+ virtual void
+ getNeighbElemWithActions(std::vector<Rec2DElement *> &) const = 0;
+ virtual void getTouchedActions(std::vector<Rec2DAction *> &) const = 0;
+
+ // Get Vertex methods
+ virtual Rec2DVertex *getVertex(int) const = 0;
+
+ // Check errors
+ virtual bool checkCoherence(const Rec2DAction *ra = NULL) const = 0;
+ inline void *getDataAction() const { return _dataAction; }
+
+ // Debug
+ virtual void printAdress() = 0;
+ virtual void printReward() const = 0;
+ virtual void printTypeRew() const = 0;
+ virtual void printVertices() const = 0;
+ virtual void printIdentity() const = 0;
+
+ // Miscellaneous
+ virtual Rec2DAction *getBase() const = 0;
+ virtual Rec2DAction *getInfant() const = 0;
+ virtual MElement *createMElement(double shiftx, double shifty) = 0;
+ virtual void color(int, int, int) const = 0;
+ virtual void getIncompatible(std::vector<Rec2DAction *> &) = 0;
+ //
+ static void removeDuplicate(std::vector<Rec2DAction *> &);
+
+private:
+ virtual void _computeGlobQual() = 0;
+ virtual void _computeReward() = 0;
};
class Rec2DTwoTri2Quad : public Rec2DAction {
- private :
- Rec2DElement *_triangles[2];
- Rec2DEdge *_edges[5]; // 4 boundary, 1 embedded
- Rec2DVertex *_vertices[4]; // 4 boundary (2 on embedded edge + 2)
- Rec2DCollapse *_col;
- double _valVert;
+private:
+ Rec2DElement *_triangles[2];
+ Rec2DEdge *_edges[5]; // 4 boundary, 1 embedded
+ Rec2DVertex *_vertices[4]; // 4 boundary (2 on embedded edge + 2)
+ Rec2DCollapse *_col;
+ double _valVert;
#ifdef REC2D_RECO_BLOS
- RecombineTriangle *_rt;
+ RecombineTriangle *_rt;
#endif
- friend class Rec2DCollapse;
-
- public :
- Rec2DTwoTri2Quad(Rec2DElement*, Rec2DElement*);
- ~Rec2DTwoTri2Quad() {}
- void operator delete(void*);
- virtual void hide();
- virtual void reveal();
-
- // Get methods
- inline bool isRecomb() const {return true;}
-
- // Application
- virtual bool isObsolete() const;
- virtual void apply(std::vector<Rec2DVertex*> &newPar);
- virtual void apply(Rec2DDataChange*, std::vector<Rec2DAction*>*&,
- bool color = false) const;
-
- // Swap
- virtual void swap(Rec2DVertex*, Rec2DVertex*);
- virtual void swap(Rec2DEdge*, Rec2DEdge*);
-
- // Get Element methods
- virtual bool has(const Rec2DElement*) const;
- virtual inline bool haveElem() const {return true;}
- virtual inline int getNumElement() const {return 2;}
- virtual inline Rec2DElement* getElement(int i) const {return _triangles[i];}
- virtual Rec2DElement* getRandomElement() const;
- virtual void getElements(std::vector<Rec2DElement*>&) const;
- virtual void getNeighbourElements(std::vector<Rec2DElement*>&) const;
- virtual void getNeighbElemWithActions(std::vector<Rec2DElement*>&) const;
- virtual void getTouchedActions(std::vector<Rec2DAction*>&) const;
-
- // Get Vertex methods
- virtual inline Rec2DVertex* getVertex(int i) const {return _vertices[i];} //-
-
- // Check errors
- virtual bool checkCoherence(const Rec2DAction *ra = NULL) const;
-
- // Debug
- virtual inline void printAdress() {Msg::Info(" %d", this);}
- virtual void printReward() const;
- virtual inline void printTypeRew() const {Msg::Info("Recombine %g", _globQualIfExecuted);}
- virtual void printVertices() const;
- virtual void printIdentity() const;
-
- // Miscellaneous
- virtual inline Rec2DAction* getBase() const {return NULL;}
- virtual inline Rec2DAction* getInfant() const {return (Rec2DAction*)_col;}
- virtual MElement* createMElement(double shiftx, double shifty);
- virtual void color(int, int, int) const;
- virtual void getIncompatible(std::vector<Rec2DAction*>&);
-
- private :
- virtual void _computeGlobQual();
- virtual void _computeReward();
- void _doWhatYouHaveToDoWithParity(Rec2DDataChange*) const;
+ friend class Rec2DCollapse;
+
+public:
+ Rec2DTwoTri2Quad(Rec2DElement *, Rec2DElement *);
+ ~Rec2DTwoTri2Quad() {}
+ void operator delete(void *);
+ virtual void hide();
+ virtual void reveal();
+
+ // Get methods
+ inline bool isRecomb() const { return true; }
+
+ // Application
+ virtual bool isObsolete() const;
+ virtual void apply(std::vector<Rec2DVertex *> &newPar);
+ virtual void apply(Rec2DDataChange *, std::vector<Rec2DAction *> *&,
+ bool color = false) const;
+
+ // Swap
+ virtual void swap(Rec2DVertex *, Rec2DVertex *);
+ virtual void swap(Rec2DEdge *, Rec2DEdge *);
+
+ // Get Element methods
+ virtual bool has(const Rec2DElement *) const;
+ virtual inline bool haveElem() const { return true; }
+ virtual inline int getNumElement() const { return 2; }
+ virtual inline Rec2DElement *getElement(int i) const { return _triangles[i]; }
+ virtual Rec2DElement *getRandomElement() const;
+ virtual void getElements(std::vector<Rec2DElement *> &) const;
+ virtual void getNeighbourElements(std::vector<Rec2DElement *> &) const;
+ virtual void getNeighbElemWithActions(std::vector<Rec2DElement *> &) const;
+ virtual void getTouchedActions(std::vector<Rec2DAction *> &) const;
+
+ // Get Vertex methods
+ virtual inline Rec2DVertex *getVertex(int i) const
+ {
+ return _vertices[i];
+ } //-
+
+ // Check errors
+ virtual bool checkCoherence(const Rec2DAction *ra = NULL) const;
+
+ // Debug
+ virtual inline void printAdress() { Msg::Info(" %d", this); }
+ virtual void printReward() const;
+ virtual inline void printTypeRew() const
+ {
+ Msg::Info("Recombine %g", _globQualIfExecuted);
+ }
+ virtual void printVertices() const;
+ virtual void printIdentity() const;
+
+ // Miscellaneous
+ virtual inline Rec2DAction *getBase() const { return NULL; }
+ virtual inline Rec2DAction *getInfant() const { return (Rec2DAction *)_col; }
+ virtual MElement *createMElement(double shiftx, double shifty);
+ virtual void color(int, int, int) const;
+ virtual void getIncompatible(std::vector<Rec2DAction *> &);
+
+private:
+ virtual void _computeGlobQual();
+ virtual void _computeReward();
+ void _doWhatYouHaveToDoWithParity(Rec2DDataChange *) const;
};
class Rec2DCollapse : public Rec2DAction {
- private :
- Rec2DTwoTri2Quad *_rec;
-
- public :
- Rec2DCollapse(Rec2DTwoTri2Quad*);
- ~Rec2DCollapse() {}
- void operator delete(void*);
- virtual void hide();
- virtual void reveal();
-
- // Get methods
- inline bool isRecomb() const {return false;}
-
- // Application
- virtual bool isObsolete() const;
- virtual void apply(std::vector<Rec2DVertex*> &newPar);
- virtual void apply(Rec2DDataChange*, std::vector<Rec2DAction*>*&,
- bool color = false) const;
-
- // Swap
- virtual inline void swap(Rec2DVertex *rv0, Rec2DVertex *rv1) {_rec->swap(rv0, rv1);}
- virtual inline void swap(Rec2DEdge *re0, Rec2DEdge *re1) {_rec->swap(re0, re1);}
-
- // Get Element methods
- virtual inline bool has(const Rec2DElement *rel) const {return _rec->has(rel);}
- virtual inline bool haveElem() const {return false;}
- virtual inline int getNumElement() const {return 2;}
- virtual inline Rec2DElement* getElement(int i) const {return _rec->_triangles[i];}
- virtual inline Rec2DElement* getRandomElement() const {
- return _rec->getRandomElement();
- }
- virtual inline void getElements(std::vector<Rec2DElement*> &vec) const {
- _rec->getElements(vec);
- }
- virtual void getNeighbourElements(std::vector<Rec2DElement*> &) const;
- virtual void getNeighbElemWithActions(std::vector<Rec2DElement*> &) const;
- virtual void getTouchedActions(std::vector<Rec2DAction*>&) const {}
+private:
+ Rec2DTwoTri2Quad *_rec;
- // Get Vertex methods
- virtual inline Rec2DVertex* getVertex(int i) const {
- return _rec->getVertex(i);
- }
+public:
+ Rec2DCollapse(Rec2DTwoTri2Quad *);
+ ~Rec2DCollapse() {}
+ void operator delete(void *);
+ virtual void hide();
+ virtual void reveal();
+
+ // Get methods
+ inline bool isRecomb() const { return false; }
+
+ // Application
+ virtual bool isObsolete() const;
+ virtual void apply(std::vector<Rec2DVertex *> &newPar);
+ virtual void apply(Rec2DDataChange *, std::vector<Rec2DAction *> *&,
+ bool color = false) const;
+
+ // Swap
+ virtual inline void swap(Rec2DVertex *rv0, Rec2DVertex *rv1)
+ {
+ _rec->swap(rv0, rv1);
+ }
+ virtual inline void swap(Rec2DEdge *re0, Rec2DEdge *re1)
+ {
+ _rec->swap(re0, re1);
+ }
- // Check errors
- virtual inline bool checkCoherence(const Rec2DAction *ra = NULL) const {
- return _rec->checkCoherence(this);
- }
+ // Get Element methods
+ virtual inline bool has(const Rec2DElement *rel) const
+ {
+ return _rec->has(rel);
+ }
+ virtual inline bool haveElem() const { return false; }
+ virtual inline int getNumElement() const { return 2; }
+ virtual inline Rec2DElement *getElement(int i) const
+ {
+ return _rec->_triangles[i];
+ }
+ virtual inline Rec2DElement *getRandomElement() const
+ {
+ return _rec->getRandomElement();
+ }
+ virtual inline void getElements(std::vector<Rec2DElement *> &vec) const
+ {
+ _rec->getElements(vec);
+ }
+ virtual void getNeighbourElements(std::vector<Rec2DElement *> &) const;
+ virtual void getNeighbElemWithActions(std::vector<Rec2DElement *> &) const;
+ virtual void getTouchedActions(std::vector<Rec2DAction *> &) const {}
+
+ // Get Vertex methods
+ virtual inline Rec2DVertex *getVertex(int i) const
+ {
+ return _rec->getVertex(i);
+ }
- // Debug
- virtual inline void printAdress() {_rec->printAdress();}
- virtual void printReward() const;
- virtual inline void printTypeRew() const {Msg::Info("Collapse %g", _globQualIfExecuted);}
- virtual inline void printVertices() const {_rec->printVertices();}
- virtual void printIdentity() const;
-
- // Miscellaneous
- virtual inline Rec2DAction* getBase() const {return _rec;}
- virtual inline Rec2DAction* getInfant() const {return NULL;}
- virtual inline MElement* createMElement(double shiftx, double shifty) {return NULL;}
- virtual inline void color(int c1, int c2, int c3) const {_rec->color(c1, c2, c3);}
- virtual void getIncompatible(std::vector<Rec2DAction*>&) {Msg::Fatal("not implemented");};
-
- private :
- virtual void _computeGlobQual();
- virtual void _computeReward();
- bool _hasIdenticalElement() const;
+ // Check errors
+ virtual inline bool checkCoherence(const Rec2DAction *ra = NULL) const
+ {
+ return _rec->checkCoherence(this);
+ }
+
+ // Debug
+ virtual inline void printAdress() { _rec->printAdress(); }
+ virtual void printReward() const;
+ virtual inline void printTypeRew() const
+ {
+ Msg::Info("Collapse %g", _globQualIfExecuted);
+ }
+ virtual inline void printVertices() const { _rec->printVertices(); }
+ virtual void printIdentity() const;
+
+ // Miscellaneous
+ virtual inline Rec2DAction *getBase() const { return _rec; }
+ virtual inline Rec2DAction *getInfant() const { return NULL; }
+ virtual inline MElement *createMElement(double shiftx, double shifty)
+ {
+ return NULL;
+ }
+ virtual inline void color(int c1, int c2, int c3) const
+ {
+ _rec->color(c1, c2, c3);
+ }
+ virtual void getIncompatible(std::vector<Rec2DAction *> &)
+ {
+ Msg::Fatal("not implemented");
+ };
+
+private:
+ virtual void _computeGlobQual();
+ virtual void _computeReward();
+ bool _hasIdenticalElement() const;
};
//
class Rec2DEdge {
- private :
- Rec2DVertex *_rv0, *_rv1;
- double _qual;
- int _weight;
- int _lastUpdate;
-
- int _pos; // For quick add and remove in Rec2DData
- friend void Rec2DData::add(const Rec2DEdge*);
- friend void Rec2DData::rmv(const Rec2DEdge*);
-
- public :
- Rec2DEdge(Rec2DVertex*, Rec2DVertex*);
- ~Rec2DEdge() {if (_pos > -1) hide();}
- void hide();
- void reveal();
-
- // Get Vertex methods
- inline bool has(const Rec2DVertex *v) const {return v == _rv0 || v == _rv1;}
- inline Rec2DVertex* getVertex(int i) const {if (i) return _rv1; return _rv0;}
- Rec2DVertex* getOtherVertex(const Rec2DVertex*) const;
-
- // Get Element methods
- static Rec2DElement* getTheOnlyElement(const Rec2DEdge*);
- static void getElements(const Rec2DEdge*, Rec2DElement**);
-
- // Get Action methods
- //void getUniqueActions(std::vector<Rec2DAction*>&) const;
-
- // Quality
- inline double getQual() const {return _qual;}
- inline int getWeight() const {return _weight;}
- inline double getWeightedQual() const {return _weight * _qual;}
- void updateQual();
-
- // Miscellaneous
- inline bool isOnBoundary() const;
- inline void addHasTri() {_addWeight(-Recombine2D::getWeightEdgeQuad());}
- inline void remHasTri() {_addWeight(Recombine2D::getWeightEdgeQuad());}
- void swap(Rec2DVertex *oldRV, Rec2DVertex *newRV, bool upVert = true);
-
- // Check errors
- bool checkCoherence() const;
-
- // Debug
- void print() const;
-
- private :
- void _computeQual();
- void _addWeight(int);
- double _straightAdimLength() const;
- double _straightAlignment() const;
+private:
+ Rec2DVertex *_rv0, *_rv1;
+ double _qual;
+ int _weight;
+ int _lastUpdate;
+
+ int _pos; // For quick add and remove in Rec2DData
+ friend void Rec2DData::add(const Rec2DEdge *);
+ friend void Rec2DData::rmv(const Rec2DEdge *);
+
+public:
+ Rec2DEdge(Rec2DVertex *, Rec2DVertex *);
+ ~Rec2DEdge()
+ {
+ if(_pos > -1) hide();
+ }
+ void hide();
+ void reveal();
+
+ // Get Vertex methods
+ inline bool has(const Rec2DVertex *v) const { return v == _rv0 || v == _rv1; }
+ inline Rec2DVertex *getVertex(int i) const
+ {
+ if(i) return _rv1;
+ return _rv0;
+ }
+ Rec2DVertex *getOtherVertex(const Rec2DVertex *) const;
+
+ // Get Element methods
+ static Rec2DElement *getTheOnlyElement(const Rec2DEdge *);
+ static void getElements(const Rec2DEdge *, Rec2DElement **);
+
+ // Get Action methods
+ // void getUniqueActions(std::vector<Rec2DAction*>&) const;
+
+ // Quality
+ inline double getQual() const { return _qual; }
+ inline int getWeight() const { return _weight; }
+ inline double getWeightedQual() const { return _weight * _qual; }
+ void updateQual();
+
+ // Miscellaneous
+ inline bool isOnBoundary() const;
+ inline void addHasTri() { _addWeight(-Recombine2D::getWeightEdgeQuad()); }
+ inline void remHasTri() { _addWeight(Recombine2D::getWeightEdgeQuad()); }
+ void swap(Rec2DVertex *oldRV, Rec2DVertex *newRV, bool upVert = true);
+
+ // Check errors
+ bool checkCoherence() const;
+
+ // Debug
+ void print() const;
+
+private:
+ void _computeQual();
+ void _addWeight(int);
+ double _straightAdimLength() const;
+ double _straightAlignment() const;
};
struct AngleData {
- std::vector<GEdge*> _gEdges;
- std::vector<MElement*> _mElements;
+ std::vector<GEdge *> _gEdges;
+ std::vector<MElement *> _mElements;
Rec2DVertex *_rv;
AngleData() : _rv(NULL) {}
};
class Rec2DVertex {
- private :
- MVertex *_v;
- const double _angle;
- int _onWhat; // _onWhat={-1:corner,0:edge,1:face}
- int _parity, _lastUpdate;
-
- double _sumWQualAngle, _sumWQualEdge;
- int _sumWeightAngle, _sumWeightEdge;
-
- std::vector<Rec2DEdge*> _edges;
- std::vector<Rec2DElement*> _elements;
- SPoint2 _param;
-
- int _pos; // For quick add and remove in Rec2DData
- friend void Rec2DData::add(const Rec2DVertex*);
- friend void Rec2DData::rmv(const Rec2DVertex*);
-
- static double **_qualVSnum;
- static double **_gains;
-
- public :
- Rec2DVertex(MVertex*);
- Rec2DVertex(Rec2DVertex*, double angle);
- ~Rec2DVertex() {if (_pos > -1) hide();}
- void hide(bool check = true);
- void reveal();
-
- // Initialize topo qual table
- static void initStaticTable();
-
- // Get methods
- inline double u() const {return _param[0];}
- inline double v() const {return _param[1];}
- inline void getParam(SPoint2 *p) {*p = _param;}
- inline void getxyz(double *xyz) const {
- xyz[0] = _v->x();
- xyz[1] = _v->y();
- xyz[2] = _v->z();
- }
- inline double getGeomAngle() const {return _angle;}
- inline int getLastUpdate() const {return _lastUpdate;}
- inline MVertex* getMVertex() const {return _v;}
-
- // Add/Remove Edges
- void add(const Rec2DEdge*);
- bool has(const Rec2DEdge*) const;
- void rmv(const Rec2DEdge*);
-
- // Add/Remove Elements
- void add(const Rec2DElement*);
- bool has(const Rec2DElement*) const;
- void rmv(const Rec2DElement*);
-
- // Get Edge methods
- inline void getEdges(std::vector<Rec2DEdge*> &v) const {v = _edges;}
- void getMoreUniqueEdges(std::vector<Rec2DEdge*>&) const;
- static Rec2DEdge* getCommonEdge(const Rec2DVertex*, const Rec2DVertex*);
-
- // Get Vertex methods
- void getMoreNeighbourVertices(std::vector<Rec2DVertex*>&) const;
-
- // Get Element methods
- inline int getNumElements() const {return _elements.size();}
- inline void getElements(std::vector<Rec2DElement*> &v) const {v = _elements;}
- static void getCommonElements(const Rec2DVertex*, const Rec2DVertex*,
- std::vector<Rec2DElement*>& );
-
- // Get Action methods
- void getMoreUniqueActions(std::vector<Rec2DAction*>&) const;
-
- // Get/Set on boundary
- inline void setOnBoundary();
- inline bool getOnBoundary() const {return _onWhat < 1;}
-
- // Get/Set parity
- inline int getParity() const {return _parity;}
- void setParity(int, bool tree = false);
- void setParityWD(int pOld, int pNew);
- bool setBoundaryParity(int p0, int p1);
-
- // Quality
- double getQualDegree(int numEl = -1) const;
- double getGainDegree(int) const;
+private:
+ MVertex *_v;
+ const double _angle;
+ int _onWhat; // _onWhat={-1:corner,0:edge,1:face}
+ int _parity, _lastUpdate;
+
+ double _sumWQualAngle, _sumWQualEdge;
+ int _sumWeightAngle, _sumWeightEdge;
+
+ std::vector<Rec2DEdge *> _edges;
+ std::vector<Rec2DElement *> _elements;
+ SPoint2 _param;
+
+ int _pos; // For quick add and remove in Rec2DData
+ friend void Rec2DData::add(const Rec2DVertex *);
+ friend void Rec2DData::rmv(const Rec2DVertex *);
+
+ static double **_qualVSnum;
+ static double **_gains;
+
+public:
+ Rec2DVertex(MVertex *);
+ Rec2DVertex(Rec2DVertex *, double angle);
+ ~Rec2DVertex()
+ {
+ if(_pos > -1) hide();
+ }
+ void hide(bool check = true);
+ void reveal();
+
+ // Initialize topo qual table
+ static void initStaticTable();
+
+ // Get methods
+ inline double u() const { return _param[0]; }
+ inline double v() const { return _param[1]; }
+ inline void getParam(SPoint2 *p) { *p = _param; }
+ inline void getxyz(double *xyz) const
+ {
+ xyz[0] = _v->x();
+ xyz[1] = _v->y();
+ xyz[2] = _v->z();
+ }
+ inline double getGeomAngle() const { return _angle; }
+ inline int getLastUpdate() const { return _lastUpdate; }
+ inline MVertex *getMVertex() const { return _v; }
+
+ // Add/Remove Edges
+ void add(const Rec2DEdge *);
+ bool has(const Rec2DEdge *) const;
+ void rmv(const Rec2DEdge *);
+
+ // Add/Remove Elements
+ void add(const Rec2DElement *);
+ bool has(const Rec2DElement *) const;
+ void rmv(const Rec2DElement *);
+
+ // Get Edge methods
+ inline void getEdges(std::vector<Rec2DEdge *> &v) const { v = _edges; }
+ void getMoreUniqueEdges(std::vector<Rec2DEdge *> &) const;
+ static Rec2DEdge *getCommonEdge(const Rec2DVertex *, const Rec2DVertex *);
+
+ // Get Vertex methods
+ void getMoreNeighbourVertices(std::vector<Rec2DVertex *> &) const;
+
+ // Get Element methods
+ inline int getNumElements() const { return _elements.size(); }
+ inline void getElements(std::vector<Rec2DElement *> &v) const
+ {
+ v = _elements;
+ }
+ static void getCommonElements(const Rec2DVertex *, const Rec2DVertex *,
+ std::vector<Rec2DElement *> &);
+
+ // Get Action methods
+ void getMoreUniqueActions(std::vector<Rec2DAction *> &) const;
+
+ // Get/Set on boundary
+ inline void setOnBoundary();
+ inline bool getOnBoundary() const { return _onWhat < 1; }
+
+ // Get/Set parity
+ inline int getParity() const { return _parity; }
+ void setParity(int, bool tree = false);
+ void setParityWD(int pOld, int pNew);
+ bool setBoundaryParity(int p0, int p1);
+
+ // Quality
+ double getQualDegree(int numEl = -1) const;
+ double getGainDegree(int) const;
#ifndef REC2D_VERT_ONLY
- inline double getQualAngle() const {return _sumQualAngle/_elements.size();}
+ inline double getQualAngle() const
+ {
+ return _sumQualAngle / _elements.size();
+ }
#endif
#ifdef REC2D_VERT_ONLY
- /*double vertQual_getGainQuad(const Rec2DElement*,
- const Rec2DEdge*, const Rec2DEdge*) const;
- double vertQual_getGainTriLess(const Rec2DEdge*) const;
- void vertQual_addEdgeQual(double val, int num = 0);
- double vertQual_getGainMerge(const Rec2DVertex*, const Rec2DEdge*const*, int) const;
- double vertEdgeQual_getGainOneElemLess() const;
- double vertEdgeQual_getGainMerge(const Rec2DVertex*) const;
- */
- double getGainQuad(const Rec2DElement*,
- const Rec2DEdge*, const Rec2DEdge*) const;
- double getGainTriLess(const Rec2DEdge*) const;
- void addEdgeQual(double val, int num = 0);
- double getGainMerge(const Rec2DVertex*, const Rec2DEdge*const*, int) const;
- double getGainOneElemLess() const;
- double getGainMerge(const Rec2DVertex*) const;
-
- double getQual(Rec2DQualCrit crit = ChoosedCrit) const;
- double getQual(double waQualAngles, double waQualEdges, int numElem,
- Rec2DQualCrit c = ChoosedCrit) const;
- double getGainRecomb(/*Rec2DQualCrit c,*/
- const Rec2DElement *rel1, const Rec2DElement *rel2,
- const Rec2DEdge *common = NULL,
- const Rec2DEdge *adjacent1 = NULL,
- const Rec2DEdge *adjacent2 = NULL) const;
+ /*double vertQual_getGainQuad(const Rec2DElement*,
+ const Rec2DEdge*, const Rec2DEdge*) const;
+ double vertQual_getGainTriLess(const Rec2DEdge*) const;
+ void vertQual_addEdgeQual(double val, int num = 0);
+ double vertQual_getGainMerge(const Rec2DVertex*, const Rec2DEdge*const*, int)
+ const; double vertEdgeQual_getGainOneElemLess() const; double
+ vertEdgeQual_getGainMerge(const Rec2DVertex*) const;
+ */
+ double getGainQuad(const Rec2DElement *, const Rec2DEdge *,
+ const Rec2DEdge *) const;
+ double getGainTriLess(const Rec2DEdge *) const;
+ void addEdgeQual(double val, int num = 0);
+ double getGainMerge(const Rec2DVertex *, const Rec2DEdge *const *, int) const;
+ double getGainOneElemLess() const;
+ double getGainMerge(const Rec2DVertex *) const;
+
+ double getQual(Rec2DQualCrit crit = ChoosedCrit) const;
+ double getQual(double waQualAngles, double waQualEdges, int numElem,
+ Rec2DQualCrit c = ChoosedCrit) const;
+ double getGainRecomb(/*Rec2DQualCrit c,*/
+ const Rec2DElement *rel1, const Rec2DElement *rel2,
+ const Rec2DEdge *common = NULL,
+ const Rec2DEdge *adjacent1 = NULL,
+ const Rec2DEdge *adjacent2 = NULL) const;
#endif
- void updateWAQualEdges(double d, int a = 0);
-
- // Miscellaneous
- void relocate(SPoint2 p);
- inline int getNum() const {return _v->getNum();}
-
- // Check errors
- bool checkCoherence() const;
- bool checkQuality() const;
-
- // Debug
- void printElem() const;
- void printQual() const;
-
- private :
- //inline double _getQualAngle() const {return _sumQualAngle/_elements.size();}
- bool _recursiveBoundParity(const Rec2DVertex *prev, int p0, int p1);
- void _updateQualAngle();
- //inline double _angle2Qual(double ang) const {
- // return std::max(1. - fabs(ang*2./M_PI - 1.), .0);
- // }
- double _qualDegree(int numEl = -1) const;
- inline double _WAQualAngles() const {return _sumWQualAngle / _sumWeightAngle;}
- inline double _WAQualEdges() const {return _sumWQualEdge / _sumWeightEdge;}
- inline double _vertQual() const {
- double vertQual = _qualDegree();
- vertQual = (Recombine2D::getCoefAnglDegQual() * vertQual
- + Recombine2D::getCoefAngleQual() ) * _WAQualAngles()
- + Recombine2D::getCoefDegreeQual() * vertQual;
- return vertQual;
- }
- inline double _vertQual(double qualDegree, double qualAngle) const {
- double vertQual = qualDegree;
- vertQual = (Recombine2D::getCoefAnglDegQual() * vertQual
- + Recombine2D::getCoefAngleQual() ) * qualAngle
- + Recombine2D::getCoefDegreeQual() * vertQual;
- return vertQual;
- }
+ void updateWAQualEdges(double d, int a = 0);
+
+ // Miscellaneous
+ void relocate(SPoint2 p);
+ inline int getNum() const { return _v->getNum(); }
+
+ // Check errors
+ bool checkCoherence() const;
+ bool checkQuality() const;
+
+ // Debug
+ void printElem() const;
+ void printQual() const;
+
+private:
+ // inline double _getQualAngle() const {return
+ // _sumQualAngle/_elements.size();}
+ bool _recursiveBoundParity(const Rec2DVertex *prev, int p0, int p1);
+ void _updateQualAngle();
+ // inline double _angle2Qual(double ang) const {
+ // return std::max(1. - fabs(ang*2./M_PI - 1.), .0);
+ // }
+ double _qualDegree(int numEl = -1) const;
+ inline double _WAQualAngles() const
+ {
+ return _sumWQualAngle / _sumWeightAngle;
+ }
+ inline double _WAQualEdges() const { return _sumWQualEdge / _sumWeightEdge; }
+ inline double _vertQual() const
+ {
+ double vertQual = _qualDegree();
+ vertQual = (Recombine2D::getCoefAnglDegQual() * vertQual +
+ Recombine2D::getCoefAngleQual()) *
+ _WAQualAngles() +
+ Recombine2D::getCoefDegreeQual() * vertQual;
+ return vertQual;
+ }
+ inline double _vertQual(double qualDegree, double qualAngle) const
+ {
+ double vertQual = qualDegree;
+ vertQual = (Recombine2D::getCoefAnglDegQual() * vertQual +
+ Recombine2D::getCoefAngleQual()) *
+ qualAngle +
+ Recombine2D::getCoefDegreeQual() * vertQual;
+ return vertQual;
+ }
};
class Rec2DElement {
- private :
- MElement *_mEl; // can be NULL
- int _numEdge;
- Rec2DEdge *_edges[4];
- Rec2DElement *_elements[4]; // NULL if no neighbour
- std::vector<Rec2DAction*> _actions;
-
- int _pos; // For quick add and remove in Rec2DData
- friend void Rec2DData::add(const Rec2DElement*);
- friend void Rec2DData::rmv(const Rec2DElement*);
-
- public :
- Rec2DElement(MTriangle*, const Rec2DEdge**, Rec2DVertex **rv = NULL);
- Rec2DElement(MQuadrangle*, const Rec2DEdge**, Rec2DVertex **rv = NULL);
- ~Rec2DElement() {if (_pos > -1) hide();}
- void hide();
- void reveal(Rec2DVertex **rv = NULL);
-
- // Add/Remove Edges
- void add(Rec2DEdge*);
- bool has(const Rec2DEdge*) const;
-
- // Has Vertex/Element
- bool has(const Rec2DVertex*) const;
- bool has(const Rec2DElement*) const;
-
- // Add/Remove neighbour Elements
- void addNeighbour(const Rec2DEdge*, const Rec2DElement*);
- void rmvNeighbour(const Rec2DEdge*, const Rec2DElement*);
- bool isNeighbour(const Rec2DEdge*, const Rec2DElement*) const;
-
- // Add/Remove Actions
- void add(const Rec2DAction*);
- void rmv(const Rec2DAction*);
- bool has(const Rec2DAction*) const;
-
- // Get Edge methods
- inline void getMoreEdges(std::vector<Rec2DEdge*> &v) const {
- v.insert(v.end(), _edges, _edges + _numEdge);
- }
- static Rec2DEdge* getCommonEdge(const Rec2DElement*, const Rec2DElement*);
-
- // Get Vertex methods
- void getVertices(std::vector<Rec2DVertex*>&) const;
- Rec2DVertex* getOtherVertex(const Rec2DVertex*, const Rec2DVertex*) const;
-
- // Get Element methods
- void getMoreNeighbours(std::vector<Rec2DElement*>&) const;
- //static void getElements(const Rec2DEdge*, Rec2DElement**);
-
- // Get Action methods
- inline int getNumActions() const {return _actions.size();}
- inline Rec2DAction* getAction(int i) const {return _actions[i];}
- inline void getActions(std::vector<Rec2DAction*> &v) const {v = _actions;};
- void getMoreUniqueActions(std::vector<Rec2DAction*>&) const;
- void getMoreUniqueActions(std::set<Rec2DAction*, gterRec2DAction>&) const;
-
- // Swap
- void swap(Rec2DEdge*, Rec2DEdge*);
- void swapMVertex(Rec2DVertex*, Rec2DVertex*);
-
- // Quality
- inline int getAngleWeight() const {
- return _numEdge > 3 ? Recombine2D::getWeightAngleQuad() : Recombine2D::getWeightAngleTri();
- }
- double getAngle(const Rec2DVertex*) const;
- inline double getAngleQual(const Rec2DVertex *v) const {
- return Recombine2D::angle2qual(getAngle(v));
- }
- inline double getWeightedAngleQual(const Rec2DVertex *v) const {
- return getAngleWeight() * getAngleQual(v);
- }
+private:
+ MElement *_mEl; // can be NULL
+ int _numEdge;
+ Rec2DEdge *_edges[4];
+ Rec2DElement *_elements[4]; // NULL if no neighbour
+ std::vector<Rec2DAction *> _actions;
- // Miscellaneous
- inline int getNum() const {return _mEl->getNum();}
- inline bool isTri() const {return _numEdge == 3;}
- inline bool isQuad() const {return _numEdge == 4;}
- inline MElement* getMElement() const {return _mEl;}
- bool hasIdenticalNeighbour() const;
-#if 1//def REC2D_DRAW
- MTriangle* getMTriangle() const {
- if (_numEdge == 3) {
- if (_mEl)
- return (MTriangle*) _mEl;
- else
- Msg::Error("[Rec2DElement] Do you thing I'll create a triangle for you ?");
- }
- return NULL;
+ int _pos; // For quick add and remove in Rec2DData
+ friend void Rec2DData::add(const Rec2DElement *);
+ friend void Rec2DData::rmv(const Rec2DElement *);
+
+public:
+ Rec2DElement(MTriangle *, const Rec2DEdge **, Rec2DVertex **rv = NULL);
+ Rec2DElement(MQuadrangle *, const Rec2DEdge **, Rec2DVertex **rv = NULL);
+ ~Rec2DElement()
+ {
+ if(_pos > -1) hide();
+ }
+ void hide();
+ void reveal(Rec2DVertex **rv = NULL);
+
+ // Add/Remove Edges
+ void add(Rec2DEdge *);
+ bool has(const Rec2DEdge *) const;
+
+ // Has Vertex/Element
+ bool has(const Rec2DVertex *) const;
+ bool has(const Rec2DElement *) const;
+
+ // Add/Remove neighbour Elements
+ void addNeighbour(const Rec2DEdge *, const Rec2DElement *);
+ void rmvNeighbour(const Rec2DEdge *, const Rec2DElement *);
+ bool isNeighbour(const Rec2DEdge *, const Rec2DElement *) const;
+
+ // Add/Remove Actions
+ void add(const Rec2DAction *);
+ void rmv(const Rec2DAction *);
+ bool has(const Rec2DAction *) const;
+
+ // Get Edge methods
+ inline void getMoreEdges(std::vector<Rec2DEdge *> &v) const
+ {
+ v.insert(v.end(), _edges, _edges + _numEdge);
+ }
+ static Rec2DEdge *getCommonEdge(const Rec2DElement *, const Rec2DElement *);
+
+ // Get Vertex methods
+ void getVertices(std::vector<Rec2DVertex *> &) const;
+ Rec2DVertex *getOtherVertex(const Rec2DVertex *, const Rec2DVertex *) const;
+
+ // Get Element methods
+ void getMoreNeighbours(std::vector<Rec2DElement *> &) const;
+ // static void getElements(const Rec2DEdge*, Rec2DElement**);
+
+ // Get Action methods
+ inline int getNumActions() const { return _actions.size(); }
+ inline Rec2DAction *getAction(int i) const { return _actions[i]; }
+ inline void getActions(std::vector<Rec2DAction *> &v) const { v = _actions; };
+ void getMoreUniqueActions(std::vector<Rec2DAction *> &) const;
+ void getMoreUniqueActions(std::set<Rec2DAction *, gterRec2DAction> &) const;
+
+ // Swap
+ void swap(Rec2DEdge *, Rec2DEdge *);
+ void swapMVertex(Rec2DVertex *, Rec2DVertex *);
+
+ // Quality
+ inline int getAngleWeight() const
+ {
+ return _numEdge > 3 ? Recombine2D::getWeightAngleQuad() :
+ Recombine2D::getWeightAngleTri();
+ }
+ double getAngle(const Rec2DVertex *) const;
+ inline double getAngleQual(const Rec2DVertex *v) const
+ {
+ return Recombine2D::angle2qual(getAngle(v));
+ }
+ inline double getWeightedAngleQual(const Rec2DVertex *v) const
+ {
+ return getAngleWeight() * getAngleQual(v);
+ }
+
+ // Miscellaneous
+ inline int getNum() const { return _mEl->getNum(); }
+ inline bool isTri() const { return _numEdge == 3; }
+ inline bool isQuad() const { return _numEdge == 4; }
+ inline MElement *getMElement() const { return _mEl; }
+ bool hasIdenticalNeighbour() const;
+#if 1 // def REC2D_DRAW
+ MTriangle *getMTriangle() const
+ {
+ if(_numEdge == 3) {
+ if(_mEl)
+ return (MTriangle *)_mEl;
+ else
+ Msg::Error(
+ "[Rec2DElement] Do you thing I'll create a triangle for you ?");
}
- MQuadrangle* getMQuadrangle() const {
- if (_numEdge == 4) {
- if (!_mEl)
- ((Rec2DElement*)this)->_mEl = (MElement*) _createQuad();
- return (MQuadrangle*) _mEl;
- }
- return NULL;
+ return NULL;
+ }
+ MQuadrangle *getMQuadrangle() const
+ {
+ if(_numEdge == 4) {
+ if(!_mEl) ((Rec2DElement *)this)->_mEl = (MElement *)_createQuad();
+ return (MQuadrangle *)_mEl;
}
+ return NULL;
+ }
#endif
- // Check errors
- bool checkCoherence() const;
+ // Check errors
+ bool checkCoherence() const;
- // Debug
- void print() const;
- void createElement(double shiftx, double shifty) const;
+ // Debug
+ void print() const;
+ void createElement(double shiftx, double shifty) const;
- private :
- MQuadrangle* _createQuad() const;
+private:
+ MQuadrangle *_createQuad() const;
};
//
@@ -1164,95 +1288,95 @@ namespace Rec2DAlgo {
extern Node *initial;
extern Node *current;
extern Node *quadOk;
- extern std::vector<Node*> sequence;
+ extern std::vector<Node *> sequence;
extern bool try_clique;
- }
+ } // namespace data
namespace func {
bool lookAhead(bool complete); // false if no lookahead tree
void chooseBestSequence();
// functions search
- void searchForOne(std::vector<Rec2DElement*>&, bool takeBest);
- void searchForRootStd(std::vector<Rec2DElement*>&);
- void searchForPlusStd(std::vector<Rec2DElement*>&, int depth);
- void searchForAll(std::vector<Rec2DElement*>&, bool takeBest);
- void searchForQAll(std::vector<Rec2DElement*>&, bool takeBest);
- void searchForQFirst(std::vector<Rec2DElement*>&);
- void searchForQLast(std::vector<Rec2DElement*>&);
- void searchForTAll(std::vector<Rec2DElement*>&);
- void searchForTFirst(std::vector<Rec2DElement*>&);
- void searchForTLast(std::vector<Rec2DElement*>&);
-
- void searchForLessAction(std::vector<Rec2DElement*>&);
- void searchForTreeLessAction(std::vector<Rec2DElement*>&);
-
- Rec2DElement* random(std::vector<Rec2DElement*> &v);
- Rec2DElement* best(std::vector<Rec2DElement*>&);
+ void searchForOne(std::vector<Rec2DElement *> &, bool takeBest);
+ void searchForRootStd(std::vector<Rec2DElement *> &);
+ void searchForPlusStd(std::vector<Rec2DElement *> &, int depth);
+ void searchForAll(std::vector<Rec2DElement *> &, bool takeBest);
+ void searchForQAll(std::vector<Rec2DElement *> &, bool takeBest);
+ void searchForQFirst(std::vector<Rec2DElement *> &);
+ void searchForQLast(std::vector<Rec2DElement *> &);
+ void searchForTAll(std::vector<Rec2DElement *> &);
+ void searchForTFirst(std::vector<Rec2DElement *> &);
+ void searchForTLast(std::vector<Rec2DElement *> &);
+
+ void searchForLessAction(std::vector<Rec2DElement *> &);
+ void searchForTreeLessAction(std::vector<Rec2DElement *> &);
+
+ Rec2DElement *random(std::vector<Rec2DElement *> &v);
+ Rec2DElement *best(std::vector<Rec2DElement *> &);
/*void insertUnique(std::vector<Rec2DElement*> &from,
std::vector<Rec2DElement*> &to);
void removeCommon(std::vector<Rec2DElement*> &from,
std::vector<Rec2DElement*> &to);*/
- Rec2DAction* getBestNAction();
- Rec2DAction* getRandomNAction();
- Rec2DAction* getBestOAction();
- Rec2DAction* getRandomOAction();
+ Rec2DAction *getBestNAction();
+ Rec2DAction *getRandomNAction();
+ Rec2DAction *getBestOAction();
+ Rec2DAction *getRandomOAction();
// For cliques
- typedef std::pair< Rec2DAction*, std::vector<Rec2DAction*> > Ra2Incomp;
- class CompareIncomp
- {
- public:
+ typedef std::pair<Rec2DAction *, std::vector<Rec2DAction *> > Ra2Incomp;
+ class CompareIncomp {
+ public:
bool operator()(const Ra2Incomp *x, const Ra2Incomp *y) const
{
return x->second.size() > y->second.size();
// action with less incompatible action on top of the heap
}
};
- void subsetIncompatibilities(const std::vector<Ra2Incomp*> &complete,
- const std::vector<Rec2DAction*> &subAction,
- std::vector<Ra2Incomp*> &subset);
- void removeLinkIncompatibilities(std::vector<Ra2Incomp*>&,
- const Rec2DAction*, const Rec2DAction*);
- void findMaximalClique(std::vector<Rec2DAction*>&);
- void findMaximumClique(std::vector<Ra2Incomp*>&);
- void relativeComplement(const std::vector<Rec2DAction*>&,
- std::vector<Rec2DAction*>&);
- void intersection(const std::vector<Rec2DAction*>&,
- std::vector<Rec2DAction*>&);
- }
+ void subsetIncompatibilities(const std::vector<Ra2Incomp *> &complete,
+ const std::vector<Rec2DAction *> &subAction,
+ std::vector<Ra2Incomp *> &subset);
+ void removeLinkIncompatibilities(std::vector<Ra2Incomp *> &,
+ const Rec2DAction *, const Rec2DAction *);
+ void findMaximalClique(std::vector<Rec2DAction *> &);
+ void findMaximumClique(std::vector<Ra2Incomp *> &);
+ void relativeComplement(const std::vector<Rec2DAction *> &,
+ std::vector<Rec2DAction *> &);
+ void intersection(const std::vector<Rec2DAction *> &,
+ std::vector<Rec2DAction *> &);
+ } // namespace func
class Node {
- private :
+ private:
int _quality;
Rec2DAction *_ra;
Rec2DDataChange *_dataChange;
- std::vector<Rec2DAction*> *_createdActions;
- std::vector<Node*> _children;
+ std::vector<Rec2DAction *> *_createdActions;
+ std::vector<Node *> _children;
- public :
+ public:
Node();
- Node(Rec2DAction*);
+ Node(Rec2DAction *);
~Node();
- Node* getChild() const {
- if (_children.size() != 1) {
+ Node *getChild() const
+ {
+ if(_children.size() != 1) {
Msg::Fatal("Have %d child(ren), not exactly one", _children.size());
return NULL;
}
return _children[0];
}
- Rec2DAction* getAction() const {return _ra;}
- int numChildren() const {return _children.size();}
- Node* getNodeBestSequence();
- bool choose(Node*);
- void updateNActions(Node*);
+ Rec2DAction *getAction() const { return _ra; }
+ int numChildren() const { return _children.size(); }
+ Node *getNodeBestSequence();
+ bool choose(Node *);
+ void updateNActions(Node *);
int getMaxLeafQual() const;
- inline int getQual() const {return _quality;} //ft
- inline int getReward() const {return _ra->getRealReward();} //ft
+ inline int getQual() const { return _quality; } // ft
+ inline int getReward() const { return _ra->getRealReward(); } // ft
bool makeChanges();
void colourBestSequence(int depth);
@@ -1262,99 +1386,107 @@ namespace Rec2DAlgo {
void branchComplete(int depth);
void goAhead(int depth, bool complete = false);
};
-}
+} // namespace Rec2DAlgo
class Rec2DNode {
- private :
- Rec2DNode *_father;
- Rec2DNode *_son[REC2D_NUMB_SONS];
- Rec2DAction *_ra;
- Rec2DDataChange *_dataChange;
- int _depth;
- // seq = from son to end of horizon/tree
- double _reward, _globalQuality, _bestSeqReward, _expectedSeqReward;
- std::vector<Rec2DAction*> *_createdActions;
-
- bool _notAllQuad; // For only recombinations
-
- public :
- Rec2DNode(Rec2DNode *father, Rec2DAction*, int depth = -1);
- ~Rec2DNode();
-
- // Get methods
- inline double getReward() const {return _reward;}
- inline Rec2DAction* getAction() const {return _ra;}
- inline Rec2DNode* getFather() const {return _father;}
+private:
+ Rec2DNode *_father;
+ Rec2DNode *_son[REC2D_NUMB_SONS];
+ Rec2DAction *_ra;
+ Rec2DDataChange *_dataChange;
+ int _depth;
+ // seq = from son to end of horizon/tree
+ double _reward, _globalQuality, _bestSeqReward, _expectedSeqReward;
+ std::vector<Rec2DAction *> *_createdActions;
- // Process the tree
- void lookahead(int depth);
- static Rec2DNode* selectBestNode(Rec2DNode*);
+ bool _notAllQuad; // For only recombinations
- // Make/Revert changes
- bool makeChanges();
- bool revertChanges();
-
- // Miscellaneous
- bool operator<(Rec2DNode&);
- bool canBeDeleted() const;
- inline bool isInSequence() const {return _father && _father->_depth != _depth;}
- inline bool notInSubTree() const {return hasOneSon() && _son[0]->_depth == _depth;}
- inline bool hasOneSon() const {return _son[0] && !_son[1];}
- inline Rec2DNode* getSon() const {return _son[0];}
-
- // Debug
- void draw(double dx, double dy) {
- if (_father)
- _father->_mkChgSinceBeginning();
- if (_dataChange) Msg::Error("_Ber_");
- _dataChange = Rec2DData::getNewDataChange();
- _ra->apply(_dataChange, _createdActions);
- _dataChange = NULL;
- Recombine2D::drawStateCur(dx, dy);
- }
- void printIdentity() const;
- void printSequence() const;
+public:
+ Rec2DNode(Rec2DNode *father, Rec2DAction *, int depth = -1);
+ ~Rec2DNode();
+
+ // Get methods
+ inline double getReward() const { return _reward; }
+ inline Rec2DAction *getAction() const { return _ra; }
+ inline Rec2DNode *getFather() const { return _father; }
+
+ // Process the tree
+ void lookahead(int depth);
+ static Rec2DNode *selectBestNode(Rec2DNode *);
+
+ // Make/Revert changes
+ bool makeChanges();
+ bool revertChanges();
+
+ // Miscellaneous
+ bool operator<(Rec2DNode &);
+ bool canBeDeleted() const;
+ inline bool isInSequence() const
+ {
+ return _father && _father->_depth != _depth;
+ }
+ inline bool notInSubTree() const
+ {
+ return hasOneSon() && _son[0]->_depth == _depth;
+ }
+ inline bool hasOneSon() const { return _son[0] && !_son[1]; }
+ inline Rec2DNode *getSon() const { return _son[0]; }
+
+ // Debug
+ void draw(double dx, double dy)
+ {
+ if(_father) _father->_mkChgSinceBeginning();
+ if(_dataChange) Msg::Error("_Ber_");
+ _dataChange = Rec2DData::getNewDataChange();
+ _ra->apply(_dataChange, _createdActions);
+ _dataChange = NULL;
+ Recombine2D::drawStateCur(dx, dy);
+ }
+ void printIdentity() const;
+ void printSequence() const;
- private:
- // Process the tree
- void _makeDevelopments(int depth);
- void _createSons(const std::vector<Rec2DAction*>&, int depth);
- void _develop(int depth);
-
- // Operators on Sons
- inline bool _hasSons() const {return _son[0];}
- /*bool _hasSon(Rec2DNode *n) {
- if (!n) return false;
- int i = -1;
- while (++i < REC2D_NUMB_SONS && _son[i] != n);
- return i < REC2D_NUMB_SONS;
- }*/
- inline int _getNumSon() const;
- void _delSons(bool alsoFirst);
- void _orderSons();
- bool _rmvSon(Rec2DNode *n);
-
- // Operators on Father
- void _rmvFather(Rec2DNode *n);
-
- // Reward
- inline double _getExpectedSeqReward() {return _reward + _expectedSeqReward;}
- inline double _getBestSequenceReward() {return _reward + _bestSeqReward;}
- inline double _getGlobQual() const {return _globalQuality + _reward;}
-
- // Miscellaneous
- void _mkChgSinceBeginning() {
- if (_father)
- _father->_mkChgSinceBeginning();
- else if (!_ra) return;
- if (_dataChange) Msg::Error("_Ber_");
- _dataChange = Rec2DData::getNewDataChange();
- _ra->apply(_dataChange, _createdActions);
- _dataChange = NULL;
- static int a = 0;
- if (++a == 1) Msg::Warning("FIXME pas propre du tout");
- }
- inline bool _isNotAllQuad() const {return _notAllQuad;}
+private:
+ // Process the tree
+ void _makeDevelopments(int depth);
+ void _createSons(const std::vector<Rec2DAction *> &, int depth);
+ void _develop(int depth);
+
+ // Operators on Sons
+ inline bool _hasSons() const { return _son[0]; }
+ /*bool _hasSon(Rec2DNode *n) {
+ if (!n) return false;
+ int i = -1;
+ while (++i < REC2D_NUMB_SONS && _son[i] != n);
+ return i < REC2D_NUMB_SONS;
+ }*/
+ inline int _getNumSon() const;
+ void _delSons(bool alsoFirst);
+ void _orderSons();
+ bool _rmvSon(Rec2DNode *n);
+
+ // Operators on Father
+ void _rmvFather(Rec2DNode *n);
+
+ // Reward
+ inline double _getExpectedSeqReward() { return _reward + _expectedSeqReward; }
+ inline double _getBestSequenceReward() { return _reward + _bestSeqReward; }
+ inline double _getGlobQual() const { return _globalQuality + _reward; }
+
+ // Miscellaneous
+ void _mkChgSinceBeginning()
+ {
+ if(_father)
+ _father->_mkChgSinceBeginning();
+ else if(!_ra)
+ return;
+ if(_dataChange) Msg::Error("_Ber_");
+ _dataChange = Rec2DData::getNewDataChange();
+ _ra->apply(_dataChange, _createdActions);
+ _dataChange = NULL;
+ static int a = 0;
+ if(++a == 1) Msg::Warning("FIXME pas propre du tout");
+ }
+ inline bool _isNotAllQuad() const { return _notAllQuad; }
};
#endif
diff --git a/Mesh/meshGRegion.cpp b/Mesh/meshGRegion.cpp
index 2583cb7ed001dde8363d2ea48914f7994a11f462..5a9eb534e93e5cae94beaf20dfabe7cbf39874ca 100644
--- a/Mesh/meshGRegion.cpp
+++ b/Mesh/meshGRegion.cpp
@@ -45,99 +45,109 @@
// hybrid mesh recovery structure
class splitQuadRecovery {
- std::multimap<GEntity*, std::pair<MVertex*,MFace> >_data;
+ std::multimap<GEntity *, std::pair<MVertex *, MFace> > _data;
bool _empty;
- public :
- std::map<MFace, MVertex*, Less_Face>_invmap;
- std::set<MFace, Less_Face>_toDelete;
+
+public:
+ std::map<MFace, MVertex *, Less_Face> _invmap;
+ std::set<MFace, Less_Face> _toDelete;
splitQuadRecovery() : _empty(true) {}
- bool empty(){ return _empty; }
- void setEmpty(bool val){ _empty = val; }
- void add (const MFace &f, MVertex *v, GEntity*ge)
+ bool empty() { return _empty; }
+ void setEmpty(bool val) { _empty = val; }
+ void add(const MFace &f, MVertex *v, GEntity *ge)
{
- _data.insert(std::make_pair(ge, std::make_pair(v,f)));
+ _data.insert(std::make_pair(ge, std::make_pair(v, f)));
}
- void relocateVertices(GRegion *region, int niter) {
- if(empty()) return ;
+ void relocateVertices(GRegion *region, int niter)
+ {
+ if(empty()) return;
v2t_cont adj;
buildVertexToElement(region->tetrahedra, adj);
buildVertexToElement(region->pyramids, adj);
buildVertexToElement(region->prisms, adj);
buildVertexToElement(region->hexahedra, adj);
- double minQual = 1;
+ double minQual = 1;
double minQualOpti = 1;
- std::vector<GFace*> faces = region->faces();
-
- for (int iter=0; iter < niter+2;iter++){
- for (std::vector<GFace*>::iterator it = faces.begin(); it != faces.end(); ++it){
- for (std::multimap<GEntity*, std::pair<MVertex*,MFace> >::iterator it2 =
- _data.lower_bound(*it); it2 != _data.upper_bound(*it) ; ++it2){
- const MFace &f = it2->second.second;
- MVertex *v = it2->second.first;
- MPyramid p (f.getVertex(0), f.getVertex(1), f.getVertex(2), f.getVertex(3), v);
- minQual = std::min(minQual, std::abs(p.minSICNShapeMeasure()));
- std::vector<MElement*> e = adj[v];
- e.push_back(&p);
- v->setEntity (region);
- double relax = std::min((double)(iter+1)/niter, 1.0);
- // printf("%g (%d) --> ",e.size(),p.minSICNShapeMeasure());
- _relocateVertexGolden( v, e, relax);
- minQualOpti = std::min(minQualOpti, std::abs(p.minSICNShapeMeasure()));
- // printf("%g \n",p.minSICNShapeMeasure());
- v->setEntity (*it);
- }
+ std::vector<GFace *> faces = region->faces();
+
+ for(int iter = 0; iter < niter + 2; iter++) {
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ ++it) {
+ for(std::multimap<GEntity *, std::pair<MVertex *, MFace> >::iterator
+ it2 = _data.lower_bound(*it);
+ it2 != _data.upper_bound(*it); ++it2) {
+ const MFace &f = it2->second.second;
+ MVertex *v = it2->second.first;
+ MPyramid p(f.getVertex(0), f.getVertex(1), f.getVertex(2),
+ f.getVertex(3), v);
+ minQual = std::min(minQual, std::abs(p.minSICNShapeMeasure()));
+ std::vector<MElement *> e = adj[v];
+ e.push_back(&p);
+ v->setEntity(region);
+ double relax = std::min((double)(iter + 1) / niter, 1.0);
+ // printf("%g (%d) --> ",e.size(),p.minSICNShapeMeasure());
+ _relocateVertexGolden(v, e, relax);
+ minQualOpti =
+ std::min(minQualOpti, std::abs(p.minSICNShapeMeasure()));
+ // printf("%g \n",p.minSICNShapeMeasure());
+ v->setEntity(*it);
+ }
}
}
- //printf("relocation improves %g --> %g\n", minQual, minQualOpti);
+ // printf("relocation improves %g --> %g\n", minQual, minQualOpti);
}
int buildPyramids(GModel *gm)
{
if(empty()) return 0;
int NBPY = 0;
- for (GModel::fiter it = gm->firstFace(); it != gm->lastFace(); ++it){
+ for(GModel::fiter it = gm->firstFace(); it != gm->lastFace(); ++it) {
std::set<MFace, Less_Face> allFaces;
- for (unsigned int i = 0; i < (*it)->triangles.size(); i++){
- allFaces.insert ((*it)->triangles[i]->getFace(0));
- delete (*it)->triangles[i];
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
+ allFaces.insert((*it)->triangles[i]->getFace(0));
+ delete(*it)->triangles[i];
}
(*it)->triangles.clear();
- for (std::multimap<GEntity*, std::pair<MVertex*,MFace> >::iterator it2 =
- _data.lower_bound(*it); it2 != _data.upper_bound(*it) ; ++it2){
+ for(std::multimap<GEntity *, std::pair<MVertex *, MFace> >::iterator it2 =
+ _data.lower_bound(*it);
+ it2 != _data.upper_bound(*it); ++it2) {
const MFace &f = it2->second.second;
MVertex *v = it2->second.first;
- v->onWhat()->mesh_vertices.erase(std::find(v->onWhat()->mesh_vertices.begin(),
- v->onWhat()->mesh_vertices.end(), v));
+ v->onWhat()->mesh_vertices.erase(
+ std::find(v->onWhat()->mesh_vertices.begin(),
+ v->onWhat()->mesh_vertices.end(), v));
std::set<MFace, Less_Face>::iterator itf0 =
- allFaces.find(MFace(f.getVertex(0), f.getVertex(1),v));
+ allFaces.find(MFace(f.getVertex(0), f.getVertex(1), v));
std::set<MFace, Less_Face>::iterator itf1 =
- allFaces.find(MFace(f.getVertex(1), f.getVertex(2),v));
+ allFaces.find(MFace(f.getVertex(1), f.getVertex(2), v));
std::set<MFace, Less_Face>::iterator itf2 =
- allFaces.find(MFace(f.getVertex(2), f.getVertex(3),v));
+ allFaces.find(MFace(f.getVertex(2), f.getVertex(3), v));
std::set<MFace, Less_Face>::iterator itf3 =
- allFaces.find(MFace(f.getVertex(3), f.getVertex(0),v));
- if (itf0 != allFaces.end() && itf1 != allFaces.end() &&
- itf2 != allFaces.end() && itf3 != allFaces.end()){
- (*it)->quadrangles.push_back(new MQuadrangle(f.getVertex(0), f.getVertex(1),
- f.getVertex(2), f.getVertex(3)));
+ allFaces.find(MFace(f.getVertex(3), f.getVertex(0), v));
+ if(itf0 != allFaces.end() && itf1 != allFaces.end() &&
+ itf2 != allFaces.end() && itf3 != allFaces.end()) {
+ (*it)->quadrangles.push_back(new MQuadrangle(
+ f.getVertex(0), f.getVertex(1), f.getVertex(2), f.getVertex(3)));
allFaces.erase(*itf0);
allFaces.erase(*itf1);
allFaces.erase(*itf2);
allFaces.erase(*itf3);
- // printf("some pyramids should be created %d regions\n", (*it)->numRegions());
- for (int iReg = 0; iReg < (*it)->numRegions(); iReg++){
- if (iReg == 1) {
+ // printf("some pyramids should be created %d regions\n",
+ // (*it)->numRegions());
+ for(int iReg = 0; iReg < (*it)->numRegions(); iReg++) {
+ if(iReg == 1) {
Msg::Error("Cannot build pyramids on non manifold faces");
v = new MVertex(v->x(), v->y(), v->z(), (*it)->getRegion(iReg));
}
else
- v->setEntity ((*it)->getRegion(iReg));
- // A quad face connected to an hex or a primsm --> leave the quad face as is
- if (_toDelete.find(f) == _toDelete.end()){
- (*it)->getRegion(iReg)->pyramids.push_back
- (new MPyramid(f.getVertex(0), f.getVertex(1), f.getVertex(2),
- f.getVertex(3), v));
+ v->setEntity((*it)->getRegion(iReg));
+ // A quad face connected to an hex or a primsm --> leave the quad
+ // face as is
+ if(_toDelete.find(f) == _toDelete.end()) {
+ (*it)->getRegion(iReg)->pyramids.push_back(
+ new MPyramid(f.getVertex(0), f.getVertex(1), f.getVertex(2),
+ f.getVertex(3), v));
(*it)->getRegion(iReg)->mesh_vertices.push_back(v);
NBPY++;
}
@@ -147,29 +157,28 @@ class splitQuadRecovery {
}
}
}
- for (std::set<MFace, Less_Face>::iterator itf = allFaces.begin();
- itf != allFaces.end(); ++itf){
- (*it)->triangles.push_back
- (new MTriangle(itf->getVertex(0), itf->getVertex(1), itf->getVertex(2)));
+ for(std::set<MFace, Less_Face>::iterator itf = allFaces.begin();
+ itf != allFaces.end(); ++itf) {
+ (*it)->triangles.push_back(new MTriangle(
+ itf->getVertex(0), itf->getVertex(1), itf->getVertex(2)));
}
}
return NBPY;
}
};
-void getBoundingInfoAndSplitQuads(GRegion *gr,
- std::map<MFace,GEntity*,Less_Face> &allBoundingFaces,
- std::set<MVertex*> &allBoundingVertices,
- splitQuadRecovery &sqr)
+void getBoundingInfoAndSplitQuads(
+ GRegion *gr, std::map<MFace, GEntity *, Less_Face> &allBoundingFaces,
+ std::set<MVertex *> &allBoundingVertices, splitQuadRecovery &sqr)
{
- std::map<MFace, GEntity*, Less_Face> allBoundingFaces_temp;
+ std::map<MFace, GEntity *, Less_Face> allBoundingFaces_temp;
// Get all the faces that are on the boundary
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator it = faces.begin();
- while (it != faces.end()){
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator it = faces.begin();
+ while(it != faces.end()) {
GFace *gf = (*it);
- for(unsigned int i = 0; i < gf->getNumMeshElements(); i++){
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
allBoundingFaces_temp[gf->getMeshElement(i)->getFace(0)] = gf;
}
++it;
@@ -178,36 +187,39 @@ void getBoundingInfoAndSplitQuads(GRegion *gr,
// if some elements pre-exist in the mesh, then use the internal faces of
// those
- for (unsigned int i=0;i<gr->getNumMeshElements();i++){
+ for(unsigned int i = 0; i < gr->getNumMeshElements(); i++) {
MElement *e = gr->getMeshElement(i);
- for (int j = 0; j < e->getNumFaces(); j++){
- std::map<MFace, GEntity*, Less_Face>::iterator it =
+ for(int j = 0; j < e->getNumFaces(); j++) {
+ std::map<MFace, GEntity *, Less_Face>::iterator it =
allBoundingFaces_temp.find(e->getFace(j));
- if (it == allBoundingFaces_temp.end()) allBoundingFaces_temp[e->getFace(j)] = gr;
- else allBoundingFaces_temp.erase(it);
+ if(it == allBoundingFaces_temp.end())
+ allBoundingFaces_temp[e->getFace(j)] = gr;
+ else
+ allBoundingFaces_temp.erase(it);
}
}
- std::map<MFace, GEntity*, Less_Face>::iterator itx = allBoundingFaces_temp.begin();
- for (; itx != allBoundingFaces_temp.end();++itx){
+ std::map<MFace, GEntity *, Less_Face>::iterator itx =
+ allBoundingFaces_temp.begin();
+ for(; itx != allBoundingFaces_temp.end(); ++itx) {
const MFace &f = itx->first;
// split the quad face into 4 triangular faces
- if (f.getNumVertices() == 4){
+ if(f.getNumVertices() == 4) {
sqr.setEmpty(false);
MVertex *v0 = f.getVertex(0);
MVertex *v1 = f.getVertex(1);
MVertex *v2 = f.getVertex(2);
MVertex *v3 = f.getVertex(3);
- MVertex *newv = new MVertex((v0->x() + v1->x() + v2->x() + v3->x())*0.25,
- (v0->y() + v1->y() + v2->y() + v3->y())*0.25,
- (v0->z() + v1->z() + v2->z() + v3->z())*0.25,
- itx->second);
- sqr.add(f,newv,itx->second);
+ MVertex *newv = new MVertex(
+ (v0->x() + v1->x() + v2->x() + v3->x()) * 0.25,
+ (v0->y() + v1->y() + v2->y() + v3->y()) * 0.25,
+ (v0->z() + v1->z() + v2->z() + v3->z()) * 0.25, itx->second);
+ sqr.add(f, newv, itx->second);
sqr._invmap[f] = newv;
- allBoundingFaces[MFace(v0,v1,newv)] = itx->second;
- allBoundingFaces[MFace(v1,v2,newv)] = itx->second;
- allBoundingFaces[MFace(v2,v3,newv)] = itx->second;
- allBoundingFaces[MFace(v3,v0,newv)] = itx->second;
+ allBoundingFaces[MFace(v0, v1, newv)] = itx->second;
+ allBoundingFaces[MFace(v1, v2, newv)] = itx->second;
+ allBoundingFaces[MFace(v2, v3, newv)] = itx->second;
+ allBoundingFaces[MFace(v3, v0, newv)] = itx->second;
itx->second->mesh_vertices.push_back(newv);
allBoundingVertices.insert(v0);
allBoundingVertices.insert(v1);
@@ -215,7 +227,7 @@ void getBoundingInfoAndSplitQuads(GRegion *gr,
allBoundingVertices.insert(v3);
allBoundingVertices.insert(newv);
}
- else{
+ else {
allBoundingFaces[f] = itx->second;
allBoundingVertices.insert(f.getVertex(0));
allBoundingVertices.insert(f.getVertex(1));
@@ -224,42 +236,45 @@ void getBoundingInfoAndSplitQuads(GRegion *gr,
}
}
-void MeshDelaunayVolume(std::vector<GRegion*> ®ions)
+void MeshDelaunayVolume(std::vector<GRegion *> ®ions)
{
if(regions.empty()) return;
if(CTX::instance()->mesh.algo3d != ALGO_3D_DELAUNAY &&
- CTX::instance()->mesh.algo3d != ALGO_3D_MMG3D) return;
+ CTX::instance()->mesh.algo3d != ALGO_3D_MMG3D)
+ return;
GRegion *gr = regions[0];
- std::vector<GFace*> faces = gr->faces();
- std::set<GFace*, GEntityLessThan> allFacesSet;
- for(unsigned int i = 0; i < regions.size(); i++){
- std::vector<GFace*> const& f = regions[i]->faces();
- std::vector<GFace*> const& f_e = regions[i]->embeddedFaces();
+ std::vector<GFace *> faces = gr->faces();
+ std::set<GFace *, GEntityLessThan> allFacesSet;
+ for(unsigned int i = 0; i < regions.size(); i++) {
+ std::vector<GFace *> const &f = regions[i]->faces();
+ std::vector<GFace *> const &f_e = regions[i]->embeddedFaces();
allFacesSet.insert(f.begin(), f.end());
allFacesSet.insert(f_e.begin(), f_e.end());
}
- std::vector<GFace*> allFaces(allFacesSet.begin(), allFacesSet.end());
+ std::vector<GFace *> allFaces(allFacesSet.begin(), allFacesSet.end());
gr->set(allFaces);
- std::set<GEdge*> allEmbEdgesSet;
- for(unsigned int i = 0; i < regions.size(); i++){
- std::vector<GEdge*> const& e = regions[i]->embeddedEdges();
+ std::set<GEdge *> allEmbEdgesSet;
+ for(unsigned int i = 0; i < regions.size(); i++) {
+ std::vector<GEdge *> const &e = regions[i]->embeddedEdges();
allEmbEdgesSet.insert(e.begin(), e.end());
}
- std::vector<GEdge*> allEmbEdges(allEmbEdgesSet.begin(), allEmbEdgesSet.end());
- std::vector<GEdge*> oldEmbEdges = gr->embeddedEdges();
+ std::vector<GEdge *> allEmbEdges(allEmbEdgesSet.begin(),
+ allEmbEdgesSet.end());
+ std::vector<GEdge *> oldEmbEdges = gr->embeddedEdges();
gr->embeddedEdges() = allEmbEdges;
- std::set<GVertex*> allEmbVerticesSet;
- for(unsigned int i = 0; i < regions.size(); i++){
- std::vector<GVertex*> const& e = regions[i]->embeddedVertices();
+ std::set<GVertex *> allEmbVerticesSet;
+ for(unsigned int i = 0; i < regions.size(); i++) {
+ std::vector<GVertex *> const &e = regions[i]->embeddedVertices();
allEmbVerticesSet.insert(e.begin(), e.end());
}
- std::vector<GVertex*> allEmbVertices(allEmbVerticesSet.begin(), allEmbVerticesSet.end());
- std::vector<GVertex*> oldEmbVertices = gr->embeddedVertices();
+ std::vector<GVertex *> allEmbVertices(allEmbVerticesSet.begin(),
+ allEmbVerticesSet.end());
+ std::vector<GVertex *> oldEmbVertices = gr->embeddedVertices();
gr->embeddedVertices() = allEmbVertices;
bool success = meshGRegionBoundaryRecovery(gr);
@@ -275,9 +290,10 @@ void MeshDelaunayVolume(std::vector<GRegion*> ®ions)
*/
// sort triangles in all model faces in order to be able to search in vectors
- std::vector<GFace*>::iterator itf = allFaces.begin();
- while(itf != allFaces.end()){
- std::sort((*itf)->triangles.begin(), (*itf)->triangles.end(), compareMTriangleLexicographic());
+ std::vector<GFace *>::iterator itf = allFaces.begin();
+ while(itf != allFaces.end()) {
+ std::sort((*itf)->triangles.begin(), (*itf)->triangles.end(),
+ compareMTriangleLexicographic());
++itf;
}
@@ -286,23 +302,22 @@ void MeshDelaunayVolume(std::vector<GRegion*> ®ions)
gr->embeddedEdges() = oldEmbEdges;
gr->embeddedVertices() = oldEmbVertices;
- if (!success) return;
+ if(!success) return;
// now do insertion of points
- if(CTX::instance()->mesh.algo3d == ALGO_3D_MMG3D){
+ if(CTX::instance()->mesh.algo3d == ALGO_3D_MMG3D) {
refineMeshMMG(gr);
}
- else if(CTX::instance()->mesh.oldRefinement){
+ else if(CTX::instance()->mesh.oldRefinement) {
insertVerticesInRegion(gr, 2000000000, true);
}
- else{
- void edgeBasedRefinement(const int numThreads,
- const int nptsatonce,
- GRegion *gr);
+ else {
+ void edgeBasedRefinement(const int numThreads, const int nptsatonce,
+ GRegion *gr);
// just to remove tets that are not to be meshed
insertVerticesInRegion(gr, 0);
- for(unsigned int i = 0; i < regions.size(); i++){
+ for(unsigned int i = 0; i < regions.size(); i++) {
Msg::Info("Refining volume %d with %d threads", regions[i]->tag(),
Msg::GetMaxThreads());
edgeBasedRefinement(Msg::GetMaxThreads(), 1, regions[i]);
@@ -318,19 +333,19 @@ namespace nglib {
}
using namespace nglib;
-static void getAllBoundingVertices(GRegion *gr,
- std::set<MVertex*, MVertexLessThanNum>
- &allBoundingVertices)
+static void getAllBoundingVertices(
+ GRegion *gr, std::set<MVertex *, MVertexLessThanNum> &allBoundingVertices)
{
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator it = faces.begin();
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator it = faces.begin();
- while (it != faces.end()){
+ while(it != faces.end()) {
GFace *gf = (*it);
- for(unsigned int i = 0; i < gf->triangles.size(); i++){
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
MTriangle *t = gf->triangles[i];
for(int k = 0; k < 3; k++)
- if(allBoundingVertices.find(t->getVertex(k)) == allBoundingVertices.end())
+ if(allBoundingVertices.find(t->getVertex(k)) ==
+ allBoundingVertices.end())
allBoundingVertices.insert(t->getVertex(k));
}
++it;
@@ -338,17 +353,18 @@ static void getAllBoundingVertices(GRegion *gr,
}
Ng_Mesh *buildNetgenStructure(GRegion *gr, bool importVolumeMesh,
- std::vector<MVertex*> &numberedV)
+ std::vector<MVertex *> &numberedV)
{
Ng_Init();
Ng_Mesh *ngmesh = Ng_NewMesh();
- std::set<MVertex*, MVertexLessThanNum> allBoundingVertices;
+ std::set<MVertex *, MVertexLessThanNum> allBoundingVertices;
getAllBoundingVertices(gr, allBoundingVertices);
- std::set<MVertex*, MVertexLessThanNum>::iterator itv = allBoundingVertices.begin();
+ std::set<MVertex *, MVertexLessThanNum>::iterator itv =
+ allBoundingVertices.begin();
int I = 1;
- while(itv != allBoundingVertices.end()){
+ while(itv != allBoundingVertices.end()) {
double tmp[3];
tmp[0] = (*itv)->x();
tmp[1] = (*itv)->y();
@@ -359,8 +375,8 @@ Ng_Mesh *buildNetgenStructure(GRegion *gr, bool importVolumeMesh,
++itv;
}
- if(importVolumeMesh){
- for(unsigned int i = 0; i < gr->mesh_vertices.size(); i++){
+ if(importVolumeMesh) {
+ for(unsigned int i = 0; i < gr->mesh_vertices.size(); i++) {
double tmp[3];
tmp[0] = gr->mesh_vertices[i]->x();
tmp[1] = gr->mesh_vertices[i]->y();
@@ -369,11 +385,11 @@ Ng_Mesh *buildNetgenStructure(GRegion *gr, bool importVolumeMesh,
Ng_AddPoint(ngmesh, tmp);
}
}
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator it = faces.begin();
- while(it != faces.end()){
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator it = faces.begin();
+ while(it != faces.end()) {
GFace *gf = (*it);
- for(unsigned int i = 0; i< gf->triangles.size(); i++){
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
MTriangle *t = gf->triangles[i];
int tmp[3];
tmp[0] = t->getVertex(0)->getIndex();
@@ -384,8 +400,8 @@ Ng_Mesh *buildNetgenStructure(GRegion *gr, bool importVolumeMesh,
++it;
}
- if(importVolumeMesh){
- for(unsigned int i = 0; i< gr->tetrahedra.size(); i++){
+ if(importVolumeMesh) {
+ for(unsigned int i = 0; i < gr->tetrahedra.size(); i++) {
MTetrahedron *t = gr->tetrahedra[i];
// netgen expects tet with negative volume
if(t->getVolumeSign() > 0) t->reverse();
@@ -402,7 +418,7 @@ Ng_Mesh *buildNetgenStructure(GRegion *gr, bool importVolumeMesh,
}
void TransferVolumeMesh(GRegion *gr, Ng_Mesh *ngmesh,
- std::vector<MVertex*> &numberedV)
+ std::vector<MVertex *> &numberedV)
{
// Gets total number of vertices of Netgen's mesh
int nbv = Ng_GetNP(ngmesh);
@@ -411,7 +427,7 @@ void TransferVolumeMesh(GRegion *gr, Ng_Mesh *ngmesh,
int nbpts = numberedV.size();
// Create new volume vertices
- for(int i = nbpts; i < nbv; i++){
+ for(int i = nbpts; i < nbv; i++) {
double tmp[3];
Ng_GetPoint(ngmesh, i + 1, tmp);
MVertex *v = new MVertex(tmp[0], tmp[1], tmp[2], gr);
@@ -423,20 +439,19 @@ void TransferVolumeMesh(GRegion *gr, Ng_Mesh *ngmesh,
int nbe = Ng_GetNE(ngmesh);
// Create new volume simplices
- for(int i = 0; i < nbe; i++){
+ for(int i = 0; i < nbe; i++) {
int tmp[4];
Ng_GetVolumeElement(ngmesh, i + 1, tmp);
- MTetrahedron *t = new MTetrahedron(numberedV[tmp[0] - 1],
- numberedV[tmp[1] - 1],
- numberedV[tmp[2] - 1],
- numberedV[tmp[3] - 1]);
+ MTetrahedron *t =
+ new MTetrahedron(numberedV[tmp[0] - 1], numberedV[tmp[1] - 1],
+ numberedV[tmp[2] - 1], numberedV[tmp[3] - 1]);
gr->tetrahedra.push_back(t);
}
}
#endif
-void deMeshGRegion::operator() (GRegion *gr)
+void deMeshGRegion::operator()(GRegion *gr)
{
if(gr->geomType() == GEntity::DiscreteVolume) return;
gr->deleteMesh();
@@ -446,8 +461,8 @@ void deMeshGRegion::operator() (GRegion *gr)
// Y_1 (1-u-v) + Y_2 u + Y_3 v = P_y + t N_y
// Z_1 (1-u-v) + Z_2 u + Z_3 v = P_z + t N_z
-int intersect_line_triangle(double X[3], double Y[3], double Z[3] ,
- double P[3], double N[3], const double eps_prec)
+int intersect_line_triangle(double X[3], double Y[3], double Z[3], double P[3],
+ double N[3], const double eps_prec)
{
double mat[3][3], det;
double b[3], res[3];
@@ -468,24 +483,24 @@ int intersect_line_triangle(double X[3], double Y[3], double Z[3] ,
b[1] = P[1] - Y[0];
b[2] = P[2] - Z[0];
- if(!sys3x3_with_tol(mat, b, res, &det)){
+ if(!sys3x3_with_tol(mat, b, res, &det)) {
return 0;
}
// printf("coucou %g %g %g\n",res[0],res[1],res[2]);
- if(res[0] >= eps_prec && res[0] <= 1.0 - eps_prec &&
- res[1] >= eps_prec && res[1] <= 1.0 - eps_prec &&
- 1 - res[0] - res[1] >= eps_prec && 1 - res[0] - res[1] <= 1.0 - eps_prec){
+ if(res[0] >= eps_prec && res[0] <= 1.0 - eps_prec && res[1] >= eps_prec &&
+ res[1] <= 1.0 - eps_prec && 1 - res[0] - res[1] >= eps_prec &&
+ 1 - res[0] - res[1] <= 1.0 - eps_prec) {
// the line clearly intersects the triangle
return (res[2] > 0) ? 1 : 0;
}
- else if(res[0] < -eps_prec || res[0] > 1.0 + eps_prec ||
- res[1] < -eps_prec || res[1] > 1.0 + eps_prec ||
- 1 - res[0] - res[1] < -eps_prec || 1 - res[0] - res[1] > 1.0 + eps_prec){
+ else if(res[0] < -eps_prec || res[0] > 1.0 + eps_prec || res[1] < -eps_prec ||
+ res[1] > 1.0 + eps_prec || 1 - res[0] - res[1] < -eps_prec ||
+ 1 - res[0] - res[1] > 1.0 + eps_prec) {
// the line clearly does NOT intersect the triangle
return 0;
}
- else{
- //printf("non robust stuff\n");
+ else {
+ // printf("non robust stuff\n");
// the intersection is not robust, try another triangle
return -10000;
}
@@ -499,13 +514,13 @@ static void setRand(double r[6])
void meshNormalsPointOutOfTheRegion(GRegion *gr)
{
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator it = faces.begin();
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator it = faces.begin();
// perform intersection check in normalized coordinates
SBoundingBox3d bbox = gr->bounds();
double scaling = norm(SVector3(bbox.max(), bbox.min()));
- if(!scaling){
+ if(!scaling) {
Msg::Warning("Bad scaling in meshNormalsPointOutOfTheRegion");
scaling = 1.;
}
@@ -513,22 +528,24 @@ void meshNormalsPointOutOfTheRegion(GRegion *gr)
double rrr[6];
setRand(rrr);
- while(it != faces.end()){
+ while(it != faces.end()) {
GFace *gf = (*it);
int nb_intersect = 0;
- for(unsigned int i = 0; i < gf->triangles.size(); i++){
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
MTriangle *t = gf->triangles[i];
- double X[3] = {t->getVertex(0)->x(), t->getVertex(1)->x(), t->getVertex(2)->x()};
- double Y[3] = {t->getVertex(0)->y(), t->getVertex(1)->y(), t->getVertex(2)->y()};
- double Z[3] = {t->getVertex(0)->z(), t->getVertex(1)->z(), t->getVertex(2)->z()};
- for(int j = 0; j < 3; j++){
+ double X[3] = {t->getVertex(0)->x(), t->getVertex(1)->x(),
+ t->getVertex(2)->x()};
+ double Y[3] = {t->getVertex(0)->y(), t->getVertex(1)->y(),
+ t->getVertex(2)->y()};
+ double Z[3] = {t->getVertex(0)->z(), t->getVertex(1)->z(),
+ t->getVertex(2)->z()};
+ for(int j = 0; j < 3; j++) {
X[j] /= scaling;
Y[j] /= scaling;
Z[j] /= scaling;
}
- double P[3] = {(X[0] + X[1] + X[2]) / 3.,
- (Y[0] + Y[1] + Y[2]) / 3.,
+ double P[3] = {(X[0] + X[1] + X[2]) / 3., (Y[0] + Y[1] + Y[2]) / 3.,
(Z[0] + Z[1] + Z[2]) / 3.};
double v1[3] = {X[0] - X[1], Y[0] - Y[1], Z[0] - Z[1]};
double v2[3] = {X[2] - X[1], Y[2] - Y[1], Z[2] - Z[1]};
@@ -541,19 +558,19 @@ void meshNormalsPointOutOfTheRegion(GRegion *gr)
N[1] += rrr[2] * v1[1] + rrr[3] * v2[1];
N[2] += rrr[4] * v1[2] + rrr[5] * v2[2];
norme(N);
- std::vector<GFace*>::iterator it_b = faces.begin();
- while(it_b != faces.end()){
+ std::vector<GFace *>::iterator it_b = faces.begin();
+ while(it_b != faces.end()) {
GFace *gf_b = (*it_b);
- for(unsigned int i_b = 0; i_b < gf_b->triangles.size(); i_b++){
+ for(unsigned int i_b = 0; i_b < gf_b->triangles.size(); i_b++) {
MTriangle *t_b = gf_b->triangles[i_b];
- if(t_b != t){
+ if(t_b != t) {
double X_b[3] = {t_b->getVertex(0)->x(), t_b->getVertex(1)->x(),
t_b->getVertex(2)->x()};
double Y_b[3] = {t_b->getVertex(0)->y(), t_b->getVertex(1)->y(),
t_b->getVertex(2)->y()};
double Z_b[3] = {t_b->getVertex(0)->z(), t_b->getVertex(1)->z(),
t_b->getVertex(2)->z()};
- for(int j = 0; j < 3; j++){
+ for(int j = 0; j < 3; j++) {
X_b[j] /= scaling;
Y_b[j] /= scaling;
Z_b[j] /= scaling;
@@ -564,17 +581,19 @@ void meshNormalsPointOutOfTheRegion(GRegion *gr)
}
++it_b;
}
- Msg::Info("Region %d Face %d, %d intersect", gr->tag(), gf->tag(), nb_intersect);
- if(nb_intersect >= 0) break; // negative value means intersection is not "robust"
+ Msg::Info("Region %d Face %d, %d intersect", gr->tag(), gf->tag(),
+ nb_intersect);
+ if(nb_intersect >= 0)
+ break; // negative value means intersection is not "robust"
}
- if(nb_intersect < 0){
+ if(nb_intersect < 0) {
setRand(rrr);
}
- else{
- if(nb_intersect % 2 == 1){
+ else {
+ if(nb_intersect % 2 == 1) {
// odd nb of intersections: the normal points inside the region
- for(unsigned int i = 0; i < gf->triangles.size(); i++){
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
gf->triangles[i]->reverse();
}
}
@@ -585,7 +604,8 @@ void meshNormalsPointOutOfTheRegion(GRegion *gr)
// FILE *fp = Fopen("debug.pos", "w");
// if(fp){
// fprintf(fp, "View \"debug\" {\n");
- // for(std::list<GFace*>::iterator it = faces.begin(); it != faces.end(); it++)
+ // for(std::list<GFace*>::iterator it = faces.begin(); it != faces.end();
+ // it++)
// for(unsigned int i = 0; i < (*it)->triangles.size(); i++)
// (*it)->triangles[i]->writePOS(fp, 1., (*it)->tag());
// fprintf(fp, "};\n");
@@ -593,9 +613,8 @@ void meshNormalsPointOutOfTheRegion(GRegion *gr)
// }
}
-void meshGRegion::operator() (GRegion *gr)
+void meshGRegion::operator()(GRegion *gr)
{
-
gr->model()->setCurrentMeshEntity(gr);
if(gr->geomType() == GEntity::DiscreteVolume) return;
@@ -611,29 +630,31 @@ void meshGRegion::operator() (GRegion *gr)
if(MeshTransfiniteVolume(gr)) return;
- std::vector<GFace*> faces = gr->faces();
+ std::vector<GFace *> faces = gr->faces();
// sanity check for frontal algo
- if(CTX::instance()->mesh.algo3d == ALGO_3D_FRONTAL){
- for(std::vector<GFace*>::iterator it = faces.begin(); it != faces.end(); it++){
- if((*it)->quadrangles.size()){
- Msg::Error("Cannot use frontal 3D algorithm with quadrangles on boundary");
+ if(CTX::instance()->mesh.algo3d == ALGO_3D_FRONTAL) {
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) {
+ if((*it)->quadrangles.size()) {
+ Msg::Error(
+ "Cannot use frontal 3D algorithm with quadrangles on boundary");
return;
}
}
}
- if(CTX::instance()->mesh.algo3d != ALGO_3D_FRONTAL){
+ if(CTX::instance()->mesh.algo3d != ALGO_3D_FRONTAL) {
delaunay.push_back(gr);
}
- else if(CTX::instance()->mesh.algo3d == ALGO_3D_FRONTAL){
+ else if(CTX::instance()->mesh.algo3d == ALGO_3D_FRONTAL) {
#if !defined(HAVE_NETGEN)
Msg::Error("Frontal algorithm requires Netgen");
#else
Msg::Info("Meshing volume %d (Frontal)", gr->tag());
// orient the triangles of with respect to this region
meshNormalsPointOutOfTheRegion(gr);
- std::vector<MVertex*> numberedV;
+ std::vector<MVertex *> numberedV;
Ng_Mesh *ngmesh = buildNetgenStructure(gr, false, numberedV);
Ng_GenerateVolumeMesh(ngmesh, CTX::instance()->mesh.lcMax);
TransferVolumeMesh(gr, ngmesh, numberedV);
@@ -641,10 +662,9 @@ void meshGRegion::operator() (GRegion *gr)
Ng_Exit();
#endif
}
-
}
-void optimizeMeshGRegionNetgen::operator() (GRegion *gr, bool always)
+void optimizeMeshGRegionNetgen::operator()(GRegion *gr, bool always)
{
gr->model()->setCurrentMeshEntity(gr);
@@ -660,7 +680,7 @@ void optimizeMeshGRegionNetgen::operator() (GRegion *gr, bool always)
#else
Msg::Info("Optimizing volume %d", gr->tag());
// import mesh into netgen, including volume tets
- std::vector<MVertex*> numberedV;
+ std::vector<MVertex *> numberedV;
Ng_Mesh *ngmesh = buildNetgenStructure(gr, true, numberedV);
// delete volume vertices and tets
deMeshGRegion dem;
@@ -673,7 +693,7 @@ void optimizeMeshGRegionNetgen::operator() (GRegion *gr, bool always)
#endif
}
-void optimizeMeshGRegionGmsh::operator() (GRegion *gr, bool always)
+void optimizeMeshGRegionGmsh::operator()(GRegion *gr, bool always)
{
gr->model()->setCurrentMeshEntity(gr);
@@ -688,22 +708,21 @@ void optimizeMeshGRegionGmsh::operator() (GRegion *gr, bool always)
optimizeMesh(gr, qmTetrahedron::QMTET_GAMMA);
}
-
bool buildFaceSearchStructure(GModel *model, fs_cont &search)
{
search.clear();
- std::set<GFace*> faces_to_consider;
+ std::set<GFace *> faces_to_consider;
GModel::riter rit = model->firstRegion();
- while(rit != model->lastRegion()){
+ while(rit != model->lastRegion()) {
std::vector<GFace *> _faces = (*rit)->faces();
- faces_to_consider.insert( _faces.begin(),_faces.end());
+ faces_to_consider.insert(_faces.begin(), _faces.end());
rit++;
}
- std::set<GFace*>::iterator fit = faces_to_consider.begin();
- while(fit != faces_to_consider.end()){
- for(unsigned int i = 0; i < (*fit)->getNumMeshElements(); i++){
+ std::set<GFace *>::iterator fit = faces_to_consider.begin();
+ while(fit != faces_to_consider.end()) {
+ for(unsigned int i = 0; i < (*fit)->getNumMeshElements(); i++) {
MFace ff = (*fit)->getMeshElement(i)->getFace(0);
search[ff] = *fit;
}
@@ -717,13 +736,13 @@ bool buildEdgeSearchStructure(GModel *model, es_cont &search)
search.clear();
GModel::eiter eit = model->firstEdge();
- while(eit != model->lastEdge()){
- for(unsigned int i = 0; i < (*eit)->lines.size(); i++){
+ while(eit != model->lastEdge()) {
+ for(unsigned int i = 0; i < (*eit)->lines.size(); i++) {
MVertex *p1 = (*eit)->lines[i]->getVertex(0);
MVertex *p2 = (*eit)->lines[i]->getVertex(1);
MVertex *p = std::min(p1, p2);
- search.insert(std::pair<MVertex*, std::pair<MLine*, GEdge*> >
- (p, std::pair<MLine*, GEdge*>((*eit)->lines[i], *eit)));
+ search.insert(std::pair<MVertex *, std::pair<MLine *, GEdge *> >(
+ p, std::pair<MLine *, GEdge *>((*eit)->lines[i], *eit)));
}
++eit;
}
@@ -733,27 +752,26 @@ bool buildEdgeSearchStructure(GModel *model, es_cont &search)
GFace *findInFaceSearchStructure(MVertex *p1, MVertex *p2, MVertex *p3,
const fs_cont &search)
{
- MFace ff(p1,p2,p3);
+ MFace ff(p1, p2, p3);
fs_cont::const_iterator it = search.find(ff);
- if (it == search.end())return 0;
+ if(it == search.end()) return 0;
return it->second;
}
-GFace *findInFaceSearchStructure(const MFace &ff,
- const fs_cont &search)
+GFace *findInFaceSearchStructure(const MFace &ff, const fs_cont &search)
{
fs_cont::const_iterator it = search.find(ff);
- if (it == search.end())return 0;
+ if(it == search.end()) return 0;
return it->second;
}
-GEdge *findInEdgeSearchStructure(MVertex *p1, MVertex *p2, const es_cont &search)
+GEdge *findInEdgeSearchStructure(MVertex *p1, MVertex *p2,
+ const es_cont &search)
{
MVertex *p = std::min(p1, p2);
for(es_cont::const_iterator it = search.lower_bound(p);
- it != search.upper_bound(p);
- ++it){
+ it != search.upper_bound(p); ++it) {
MLine *l = it->second.first;
GEdge *ge = it->second.second;
if((l->getVertex(0) == p1 || l->getVertex(0) == p2) &&
diff --git a/Mesh/meshGRegion.h b/Mesh/meshGRegion.h
index 26b6a1f3179909c3dd84da769826677d3ecdd768..baa3f2f27617d950ba1cc9ec775308935be08818 100644
--- a/Mesh/meshGRegion.h
+++ b/Mesh/meshGRegion.h
@@ -21,54 +21,56 @@ class MTriangle;
// Create the mesh of the region
class meshGRegion {
- public :
- std::vector<GRegion*> &delaunay;
- meshGRegion(std::vector<GRegion*> &d) : delaunay(d) {}
- void operator () (GRegion *);
+public:
+ std::vector<GRegion *> &delaunay;
+ meshGRegion(std::vector<GRegion *> &d) : delaunay(d) {}
+ void operator()(GRegion *);
};
class meshGRegionExtruded {
- public :
- void operator () (GRegion *);
+public:
+ void operator()(GRegion *);
};
// Optimize the mesh of the region using gmsh's algo
class optimizeMeshGRegionGmsh {
- public :
- void operator () (GRegion *, bool always=false);
+public:
+ void operator()(GRegion *, bool always = false);
};
// Optimize the mesh of the region using netgen's algo
class optimizeMeshGRegionNetgen {
- public :
- void operator () (GRegion *, bool always=false);
+public:
+ void operator()(GRegion *, bool always = false);
};
// destroy the mesh of the region
class deMeshGRegion {
- public :
- void operator () (GRegion *);
+public:
+ void operator()(GRegion *);
};
-void MeshDelaunayVolume(std::vector<GRegion*> &delaunay);
+void MeshDelaunayVolume(std::vector<GRegion *> &delaunay);
bool CreateAnEmptyVolumeMesh(GRegion *gr);
int MeshTransfiniteVolume(GRegion *gr);
int SubdivideExtrudedMesh(GModel *m);
-void carveHole(GRegion *gr, int num, double distance, std::vector<int> &surfaces);
+void carveHole(GRegion *gr, int num, double distance,
+ std::vector<int> &surfaces);
-typedef std::map<MFace,GFace*,Less_Face > fs_cont ;
-typedef std::multimap<MVertex*, std::pair<MLine*, GEdge*> > es_cont ;
-GFace* findInFaceSearchStructure(MVertex *p1, MVertex *p2, MVertex *p3,
+typedef std::map<MFace, GFace *, Less_Face> fs_cont;
+typedef std::multimap<MVertex *, std::pair<MLine *, GEdge *> > es_cont;
+GFace *findInFaceSearchStructure(MVertex *p1, MVertex *p2, MVertex *p3,
const fs_cont &search);
-GFace* findInFaceSearchStructure(const MFace &f, const fs_cont &search);
-GEdge* findInEdgeSearchStructure(MVertex *p1, MVertex *p2, const es_cont &search);
+GFace *findInFaceSearchStructure(const MFace &f, const fs_cont &search);
+GEdge *findInEdgeSearchStructure(MVertex *p1, MVertex *p2,
+ const es_cont &search);
bool buildFaceSearchStructure(GModel *model, fs_cont &search);
bool buildEdgeSearchStructure(GModel *model, es_cont &search);
// adapt the mesh of a region
class adaptMeshGRegion {
- public :
- void operator () (GRegion *);
+public:
+ void operator()(GRegion *);
};
#endif
diff --git a/Mesh/meshGRegionBoundaryRecovery.cpp b/Mesh/meshGRegionBoundaryRecovery.cpp
index 62b5c26434ea7974c25331f57fa9e333099ed3e5..62889c387962ac6e8ede6f7ad9ae16e03697b240 100644
--- a/Mesh/meshGRegionBoundaryRecovery.cpp
+++ b/Mesh/meshGRegionBoundaryRecovery.cpp
@@ -39,69 +39,71 @@ typedef unsigned long intptr_t;
#include "drawContext.h"
#endif
-namespace tetgenBR
-{
+namespace tetgenBR {
#define REAL double
-// dummy tetgenio class
-class tetgenio{
-public:
- int firstnumber;
- int numberofpointattributes;
- int numberoftetrahedronattributes;
- int numberofsegmentconstraints;
- REAL *segmentconstraintlist;
- int numberoffacetconstraints;
- REAL *facetconstraintlist;
- int numberofpoints;
- int *pointlist;
- int *pointattributelist;
- int numberofpointmakers;
- int *pointmarkerlist;
- int numberofpointmtrs;
- int *pointmtrlist;
- int numberofedges;
- int *edgelist;
- int *edgemarkerlist;
- int numberofholes;
- REAL *holelist;
- int numberofregions;
- REAL *regionlist;
- int mesh_dim;
- tetgenio()
- {
- firstnumber = 1;
- numberofpointattributes = 0;
- numberoftetrahedronattributes = 0;
- numberofsegmentconstraints = 0;
- segmentconstraintlist = 0;
- numberoffacetconstraints = 0;
- facetconstraintlist = 0;
- numberofpoints = 0;
- pointlist = 0;
- pointattributelist = 0;
- numberofpointmakers = 0;
- pointmarkerlist = 0;
- numberofpointmtrs = 0;
- pointmtrlist = 0;
- numberofedges = 0;
- edgelist = 0;
- edgemarkerlist = 0;
- numberofholes = 0;
- holelist = 0;
- numberofregions = 0;
- regionlist = 0;
- mesh_dim = 0;
- }
-};
+ // dummy tetgenio class
+ class tetgenio {
+ public:
+ int firstnumber;
+ int numberofpointattributes;
+ int numberoftetrahedronattributes;
+ int numberofsegmentconstraints;
+ REAL *segmentconstraintlist;
+ int numberoffacetconstraints;
+ REAL *facetconstraintlist;
+ int numberofpoints;
+ int *pointlist;
+ int *pointattributelist;
+ int numberofpointmakers;
+ int *pointmarkerlist;
+ int numberofpointmtrs;
+ int *pointmtrlist;
+ int numberofedges;
+ int *edgelist;
+ int *edgemarkerlist;
+ int numberofholes;
+ REAL *holelist;
+ int numberofregions;
+ REAL *regionlist;
+ int mesh_dim;
+ tetgenio()
+ {
+ firstnumber = 1;
+ numberofpointattributes = 0;
+ numberoftetrahedronattributes = 0;
+ numberofsegmentconstraints = 0;
+ segmentconstraintlist = 0;
+ numberoffacetconstraints = 0;
+ facetconstraintlist = 0;
+ numberofpoints = 0;
+ pointlist = 0;
+ pointattributelist = 0;
+ numberofpointmakers = 0;
+ pointmarkerlist = 0;
+ numberofpointmtrs = 0;
+ pointmtrlist = 0;
+ numberofedges = 0;
+ edgelist = 0;
+ edgemarkerlist = 0;
+ numberofholes = 0;
+ holelist = 0;
+ numberofregions = 0;
+ regionlist = 0;
+ mesh_dim = 0;
+ }
+ };
// redefinition of predicates using our own
#define orient3d robustPredicates::orient3d
#define insphere robustPredicates::insphere
-static double orient4d(double*, double *, double *, double *, double *,
- double, double, double, double, double){ return 0.; }
-static int clock(){ return 0; }
+ static double orient4d(double *, double *, double *, double *, double *,
+ double, double, double, double, double)
+ {
+ return 0.;
+ }
+ static int clock() { return 0; }
#define clock_t int
#if !defined(TETLIBRARY)
#define TETLIBRARY
@@ -111,1077 +113,1107 @@ static int clock(){ return 0; }
#include "tetgenBR.cxx"
#undef printf
-bool tetgenmesh::reconstructmesh(void *p)
-{
- GRegion *_gr = (GRegion*)p;
-
- in = new tetgenio();
- b = new tetgenbehavior();
- char opts[128];
- sprintf(opts, "YpeQT%gp/%g", CTX::instance()->mesh.toleranceInitialDelaunay,
- CTX::instance()->mesh.angleToleranceFacetOverlap);
- b->parse_commandline(opts);
-
- double t_start = Cpu();
- std::vector<MVertex*> _vertices;
- std::map<int,MVertex*> _extras;
- // Get the set of vertices from GRegion.
+ bool tetgenmesh::reconstructmesh(void *p)
{
- std::set<MVertex*, MVertexLessThanNum> all;
- std::vector<GFace*> const& f = _gr->faces();
- for(std::vector<GFace*>::const_iterator it = f.begin(); it != f.end(); ++it){
- GFace *gf = *it;
- for(unsigned int i = 0; i < gf->triangles.size(); i++){
- all.insert(gf->triangles[i]->getVertex(0));
- all.insert(gf->triangles[i]->getVertex(1));
- all.insert(gf->triangles[i]->getVertex(2));
+ GRegion *_gr = (GRegion *)p;
+
+ in = new tetgenio();
+ b = new tetgenbehavior();
+ char opts[128];
+ sprintf(opts, "YpeQT%gp/%g", CTX::instance()->mesh.toleranceInitialDelaunay,
+ CTX::instance()->mesh.angleToleranceFacetOverlap);
+ b->parse_commandline(opts);
+
+ double t_start = Cpu();
+ std::vector<MVertex *> _vertices;
+ std::map<int, MVertex *> _extras;
+ // Get the set of vertices from GRegion.
+ {
+ std::set<MVertex *, MVertexLessThanNum> all;
+ std::vector<GFace *> const &f = _gr->faces();
+ for(std::vector<GFace *>::const_iterator it = f.begin(); it != f.end();
+ ++it) {
+ GFace *gf = *it;
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
+ all.insert(gf->triangles[i]->getVertex(0));
+ all.insert(gf->triangles[i]->getVertex(1));
+ all.insert(gf->triangles[i]->getVertex(2));
+ }
}
- }
- std::vector<GEdge*> const& e = _gr->embeddedEdges();
- for(std::vector<GEdge*>::const_iterator it = e.begin(); it != e.end(); ++it){
- GEdge *ge = *it;
- for(unsigned int i = 0; i < ge->lines.size(); i++){
- all.insert(ge->lines[i]->getVertex(0));
- all.insert(ge->lines[i]->getVertex(1));
+ std::vector<GEdge *> const &e = _gr->embeddedEdges();
+ for(std::vector<GEdge *>::const_iterator it = e.begin(); it != e.end();
+ ++it) {
+ GEdge *ge = *it;
+ for(unsigned int i = 0; i < ge->lines.size(); i++) {
+ all.insert(ge->lines[i]->getVertex(0));
+ all.insert(ge->lines[i]->getVertex(1));
+ }
}
- }
- std::vector<GVertex*> const& v = _gr->embeddedVertices();
- for(std::vector<GVertex*>::const_iterator it = v.begin(); it != v.end(); ++it){
- GVertex *gv = *it;
- for(unsigned int i = 0; i < gv->points.size(); i++){
- all.insert(gv->points[i]->getVertex(0));
+ std::vector<GVertex *> const &v = _gr->embeddedVertices();
+ for(std::vector<GVertex *>::const_iterator it = v.begin(); it != v.end();
+ ++it) {
+ GVertex *gv = *it;
+ for(unsigned int i = 0; i < gv->points.size(); i++) {
+ all.insert(gv->points[i]->getVertex(0));
+ }
}
+ all.insert(_gr->mesh_vertices.begin(), _gr->mesh_vertices.end());
+
+ _vertices.insert(_vertices.begin(), all.begin(), all.end());
}
- all.insert(_gr->mesh_vertices.begin(), _gr->mesh_vertices.end());
- _vertices.insert(_vertices.begin(), all.begin(), all.end());
- }
+ initializepools();
- initializepools();
+ // Store all coordinates of the vertices as these will be pertubated in
+ // function delaunayTriangulation
+ std::map<MVertex *, SPoint3> originalCoordinates;
+ for(unsigned int i = 0; i < _vertices.size(); i++) {
+ MVertex *v = _vertices[i];
+ originalCoordinates[v] = v->point();
+ }
- // Store all coordinates of the vertices as these will be pertubated in
- // function delaunayTriangulation
- std::map<MVertex *, SPoint3> originalCoordinates;
- for (unsigned int i = 0; i < _vertices.size(); i++){
- MVertex *v = _vertices[i];
- originalCoordinates[v] = v->point();
- }
+ std::vector<MTetrahedron *> tets;
- std::vector<MTetrahedron*> tets;
+ delaunayMeshIn3D(_vertices, tets, false);
+ if(Msg::GetErrorCount()) return false;
- delaunayMeshIn3D(_vertices, tets, false);
- if (Msg::GetErrorCount()) return false;
+ Msg::Debug("Points have been tetrahedralized");
- Msg::Debug("Points have been tetrahedralized");
+ {
+ point pointloop;
+ REAL x, y, z;
+
+ // Read the points.
+ for(unsigned int i = 0; i < _vertices.size(); i++) {
+ makepoint(&pointloop, UNUSEDVERTEX);
+ // Read the point coordinates.
+ x = pointloop[0] = _vertices[i]->x();
+ y = pointloop[1] = _vertices[i]->y();
+ z = pointloop[2] = _vertices[i]->z();
+ // Determine the smallest and largest x, y and z coordinates.
+ if(i == 0) {
+ xmin = xmax = x;
+ ymin = ymax = y;
+ zmin = zmax = z;
+ }
+ else {
+ xmin = (x < xmin) ? x : xmin;
+ xmax = (x > xmax) ? x : xmax;
+ ymin = (y < ymin) ? y : ymin;
+ ymax = (y > ymax) ? y : ymax;
+ zmin = (z < zmin) ? z : zmin;
+ zmax = (z > zmax) ? z : zmax;
+ }
+ }
- {
- point pointloop;
- REAL x, y, z;
-
- // Read the points.
- for(unsigned int i = 0; i < _vertices.size(); i++){
- makepoint(&pointloop, UNUSEDVERTEX);
- // Read the point coordinates.
- x = pointloop[0] = _vertices[i]->x();
- y = pointloop[1] = _vertices[i]->y();
- z = pointloop[2] = _vertices[i]->z();
- // Determine the smallest and largest x, y and z coordinates.
- if(i == 0){
- xmin = xmax = x;
- ymin = ymax = y;
- zmin = zmax = z;
+ // 'longest' is the largest possible edge length formed by input vertices.
+ x = xmax - xmin;
+ y = ymax - ymin;
+ z = zmax - zmin;
+ longest = sqrt(x * x + y * y + z * z);
+ if(longest == 0.0) {
+ Msg::Warning("The point set is trivial");
+ return true;
}
- else{
- xmin = (x < xmin) ? x : xmin;
- xmax = (x > xmax) ? x : xmax;
- ymin = (y < ymin) ? y : ymin;
- ymax = (y > ymax) ? y : ymax;
- zmin = (z < zmin) ? z : zmin;
- zmax = (z > zmax) ? z : zmax;
+
+ // Two identical points are distinguished by 'lengthlimit'.
+ if(minedgelength == 0.0) {
+ minedgelength = longest * b->epsilon;
}
}
- // 'longest' is the largest possible edge length formed by input vertices.
- x = xmax - xmin;
- y = ymax - ymin;
- z = zmax - zmin;
- longest = sqrt(x * x + y * y + z * z);
- if(longest == 0.0){
- Msg::Warning("The point set is trivial");
- return true;
- }
+ point *idx2verlist;
- // Two identical points are distinguished by 'lengthlimit'.
- if(minedgelength == 0.0){
- minedgelength = longest * b->epsilon;
+ // Create a map from indices to vertices.
+ makeindex2pointmap(idx2verlist);
+ // 'idx2verlist' has length 'in->numberofpoints + 1'.
+ idx2verlist[0] = dummypoint; // Let 0th-entry be dummypoint.
+ // Index the vertices, starting at 1 (vertex index 0 is used as special code
+ // in tetgenBR in case of failure)
+ for(unsigned int i = 0; i < _vertices.size(); i++) {
+ _vertices[i]->setIndex(i + 1);
}
- }
- point *idx2verlist;
+ {
+ tetrahedron *ver2tetarray;
+ triface tetloop, checktet, prevchktet;
+ triface hulltet, face1, face2;
+ tetrahedron tptr;
+ point p[4], q[3];
+ REAL ori; //, attrib, volume;
+ int bondflag;
+ int t1ver;
+ int idx, k;
+
+ Msg::Info("Reconstructing mesh ...");
+
+ // Allocate an array that maps each vertex to its adjacent tets.
+ ver2tetarray = new tetrahedron[_vertices.size() + in->firstnumber];
+ for(unsigned int i = 0; i < _vertices.size() + in->firstnumber; i++) {
+ setpointtype(idx2verlist[i], VOLVERTEX); // initial type.
+ ver2tetarray[i] = NULL;
+ }
- // Create a map from indices to vertices.
- makeindex2pointmap(idx2verlist);
- // 'idx2verlist' has length 'in->numberofpoints + 1'.
- idx2verlist[0] = dummypoint; // Let 0th-entry be dummypoint.
- // Index the vertices, starting at 1 (vertex index 0 is used as special code
- // in tetgenBR in case of failure)
- for(unsigned int i = 0; i < _vertices.size(); i++){
- _vertices[i]->setIndex(i + 1);
- }
+ // Create the tetrahedra and connect those that share a common face.
+ for(unsigned int i = 0; i < tets.size(); i++) {
+ // Get the four vertices.
+ for(int j = 0; j < 4; j++) {
+ p[j] = idx2verlist[tets[i]->getVertex(j)->getIndex()];
+ }
+ // Check the orientation.
+ ori = orient3d(p[0], p[1], p[2], p[3]);
+ if(ori > 0.0) {
+ // Swap the first two vertices.
+ q[0] = p[0];
+ p[0] = p[1];
+ p[1] = q[0];
+ }
+ else if(ori == 0.0) {
+ if(!b->quiet) {
+ printf("Warning: Tet #%d is degenerate.\n", i + in->firstnumber);
+ }
+ }
+ // Create a new tetrahedron.
+ maketetrahedron(&tetloop); // tetloop.ver = 11.
+ setvertices(tetloop, p[0], p[1], p[2], p[3]);
+ // Try connecting this tet to others that share the common faces.
+ for(tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
+ p[3] = oppo(tetloop);
+ // Look for other tets having this vertex.
+ idx = pointmark(p[3]) - in->firstnumber;
+ tptr = ver2tetarray[idx];
+ // Link the current tet to the next one in the stack.
+ tetloop.tet[8 + tetloop.ver] = tptr;
+ // Push the current tet onto the stack.
+ ver2tetarray[idx] = encode(tetloop);
+ decode(tptr, checktet);
+ if(checktet.tet != NULL) {
+ p[0] = org(tetloop); // a
+ p[1] = dest(tetloop); // b
+ p[2] = apex(tetloop); // c
+ prevchktet = tetloop;
+ do {
+ q[0] = org(checktet); // a'
+ q[1] = dest(checktet); // b'
+ q[2] = apex(checktet); // c'
+ // Check the three faces at 'd' in 'checktet'.
+ bondflag = 0;
+ for(int j = 0; j < 3; j++) {
+ // Go to the face [b',a',d], or [c',b',d], or [a',c',d].
+ esym(checktet, face2);
+ if(face2.tet[face2.ver & 3] == NULL) {
+ k = ((j + 1) % 3);
+ if(q[k] == p[0]) { // b', c', a' = a
+ if(q[j] == p[1]) { // a', b', c' = b
+ // [#,#,d] is matched to [b,a,d].
+ esym(tetloop, face1);
+ bond(face1, face2);
+ bondflag++;
+ }
+ }
+ if(q[k] == p[1]) { // b',c',a' = b
+ if(q[j] == p[2]) { // a',b',c' = c
+ // [#,#,d] is matched to [c,b,d].
+ enext(tetloop, face1);
+ esymself(face1);
+ bond(face1, face2);
+ bondflag++;
+ }
+ }
+ if(q[k] == p[2]) { // b',c',a' = c
+ if(q[j] == p[0]) { // a',b',c' = a
+ // [#,#,d] is matched to [a,c,d].
+ eprev(tetloop, face1);
+ esymself(face1);
+ bond(face1, face2);
+ bondflag++;
+ }
+ }
+ }
+ else {
+ bondflag++;
+ }
+ enextself(checktet);
+ } // j
+ // Go to the next tet in the link.
+ tptr = checktet.tet[8 + checktet.ver];
+ if(bondflag == 3) {
+ // All three faces at d in 'checktet' have been connected.
+ // It can be removed from the link.
+ prevchktet.tet[8 + prevchktet.ver] = tptr;
+ }
+ else {
+ // Bakup the previous tet in the link.
+ prevchktet = checktet;
+ }
+ decode(tptr, checktet);
+ } while(checktet.tet != NULL);
+ } // if(checktet.tet != NULL)
+ } // for(tetloop.ver = 0; ...
+ } // i
- {
- tetrahedron *ver2tetarray;
- triface tetloop, checktet, prevchktet;
- triface hulltet, face1, face2;
- tetrahedron tptr;
- point p[4], q[3];
- REAL ori; //, attrib, volume;
- int bondflag;
- int t1ver;
- int idx, k;
-
- Msg::Info("Reconstructing mesh ...");
-
- // Allocate an array that maps each vertex to its adjacent tets.
- ver2tetarray = new tetrahedron[_vertices.size() + in->firstnumber];
- for(unsigned int i = 0; i < _vertices.size() + in->firstnumber; i++){
- setpointtype(idx2verlist[i], VOLVERTEX); // initial type.
- ver2tetarray[i] = NULL;
- }
+ // Remember a tet of the mesh.
+ recenttet = tetloop;
- // Create the tetrahedra and connect those that share a common face.
- for(unsigned int i = 0; i < tets.size(); i++){
- // Get the four vertices.
- for(int j = 0; j < 4; j++){
- p[j] = idx2verlist[tets[i]->getVertex(j)->getIndex()];
- }
- // Check the orientation.
- ori = orient3d(p[0], p[1], p[2], p[3]);
- if(ori > 0.0){
- // Swap the first two vertices.
- q[0] = p[0]; p[0] = p[1]; p[1] = q[0];
- }
- else if(ori == 0.0){
- if(!b->quiet){
- printf("Warning: Tet #%d is degenerate.\n", i + in->firstnumber);
- }
- }
- // Create a new tetrahedron.
- maketetrahedron(&tetloop); // tetloop.ver = 11.
- setvertices(tetloop, p[0], p[1], p[2], p[3]);
- // Try connecting this tet to others that share the common faces.
- for(tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++){
- p[3] = oppo(tetloop);
- // Look for other tets having this vertex.
- idx = pointmark(p[3]) - in->firstnumber;
- tptr = ver2tetarray[idx];
- // Link the current tet to the next one in the stack.
- tetloop.tet[8 + tetloop.ver] = tptr;
- // Push the current tet onto the stack.
- ver2tetarray[idx] = encode(tetloop);
- decode(tptr, checktet);
- if(checktet.tet != NULL){
- p[0] = org(tetloop); // a
- p[1] = dest(tetloop); // b
- p[2] = apex(tetloop); // c
- prevchktet = tetloop;
- do {
- q[0] = org(checktet); // a'
- q[1] = dest(checktet); // b'
- q[2] = apex(checktet); // c'
- // Check the three faces at 'd' in 'checktet'.
- bondflag = 0;
- for(int j = 0; j < 3; j++){
- // Go to the face [b',a',d], or [c',b',d], or [a',c',d].
- esym(checktet, face2);
- if(face2.tet[face2.ver & 3] == NULL){
- k = ((j + 1) % 3);
- if(q[k] == p[0]){ // b', c', a' = a
- if(q[j] == p[1]){ // a', b', c' = b
- // [#,#,d] is matched to [b,a,d].
- esym(tetloop, face1);
- bond(face1, face2);
- bondflag++;
- }
- }
- if(q[k] == p[1]){ // b',c',a' = b
- if(q[j] == p[2]){ // a',b',c' = c
- // [#,#,d] is matched to [c,b,d].
- enext(tetloop, face1);
- esymself(face1);
- bond(face1, face2);
- bondflag++;
- }
- }
- if(q[k] == p[2]){ // b',c',a' = c
- if(q[j] == p[0]){ // a',b',c' = a
- // [#,#,d] is matched to [a,c,d].
- eprev(tetloop, face1);
- esymself(face1);
- bond(face1, face2);
- bondflag++;
- }
- }
- }
- else{
- bondflag++;
- }
- enextself(checktet);
- } // j
- // Go to the next tet in the link.
- tptr = checktet.tet[8 + checktet.ver];
- if(bondflag == 3){
- // All three faces at d in 'checktet' have been connected.
- // It can be removed from the link.
- prevchktet.tet[8 + prevchktet.ver] = tptr;
- }
- else{
- // Bakup the previous tet in the link.
- prevchktet = checktet;
- }
- decode(tptr, checktet);
- } while (checktet.tet != NULL);
- } // if(checktet.tet != NULL)
- } // for(tetloop.ver = 0; ...
- } // i
-
- // Remember a tet of the mesh.
- recenttet = tetloop;
-
- // Create hull tets, create the point-to-tet map, and clean up the
- // temporary spaces used in each tet.
- hullsize = tetrahedrons->items;
+ // Create hull tets, create the point-to-tet map, and clean up the
+ // temporary spaces used in each tet.
+ hullsize = tetrahedrons->items;
- tetrahedrons->traversalinit();
- tetloop.tet = tetrahedrontraverse();
- while (tetloop.tet != (tetrahedron *) NULL){
- tptr = encode(tetloop);
- for(tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++){
- if(tetloop.tet[tetloop.ver] == NULL){
- // Create a hull tet.
- maketetrahedron(&hulltet);
- p[0] = org(tetloop);
- p[1] = dest(tetloop);
- p[2] = apex(tetloop);
- setvertices(hulltet, p[1], p[0], p[2], dummypoint);
- bond(tetloop, hulltet);
- // Try connecting this to others that share common hull edges.
- for(int j = 0; j < 3; j++){
- fsym(hulltet, face2);
- while (1){
- if(face2.tet == NULL) break;
- esymself(face2);
- if(apex(face2) == dummypoint) break;
- fsymself(face2);
- }
- if(face2.tet != NULL){
- // Found an adjacent hull tet.
- assert(face2.tet[face2.ver & 3] == NULL);
- esym(hulltet, face1);
- bond(face1, face2);
- }
- enextself(hulltet);
- }
- //hullsize++;
- }
- // Create the point-to-tet map.
- setpoint2tet((point) (tetloop.tet[4 + tetloop.ver]), tptr);
- // Clean the temporary used space.
- tetloop.tet[8 + tetloop.ver] = NULL;
- }
+ tetrahedrons->traversalinit();
tetloop.tet = tetrahedrontraverse();
- }
+ while(tetloop.tet != (tetrahedron *)NULL) {
+ tptr = encode(tetloop);
+ for(tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
+ if(tetloop.tet[tetloop.ver] == NULL) {
+ // Create a hull tet.
+ maketetrahedron(&hulltet);
+ p[0] = org(tetloop);
+ p[1] = dest(tetloop);
+ p[2] = apex(tetloop);
+ setvertices(hulltet, p[1], p[0], p[2], dummypoint);
+ bond(tetloop, hulltet);
+ // Try connecting this to others that share common hull edges.
+ for(int j = 0; j < 3; j++) {
+ fsym(hulltet, face2);
+ while(1) {
+ if(face2.tet == NULL) break;
+ esymself(face2);
+ if(apex(face2) == dummypoint) break;
+ fsymself(face2);
+ }
+ if(face2.tet != NULL) {
+ // Found an adjacent hull tet.
+ assert(face2.tet[face2.ver & 3] == NULL);
+ esym(hulltet, face1);
+ bond(face1, face2);
+ }
+ enextself(hulltet);
+ }
+ // hullsize++;
+ }
+ // Create the point-to-tet map.
+ setpoint2tet((point)(tetloop.tet[4 + tetloop.ver]), tptr);
+ // Clean the temporary used space.
+ tetloop.tet[8 + tetloop.ver] = NULL;
+ }
+ tetloop.tet = tetrahedrontraverse();
+ }
- hullsize = tetrahedrons->items - hullsize;
+ hullsize = tetrahedrons->items - hullsize;
- delete [] ver2tetarray;
- tets.clear(); // Release all memory in this vector.
- }
+ delete[] ver2tetarray;
+ tets.clear(); // Release all memory in this vector.
+ }
- std::vector<GFace*> const& f_list = _gr->faces();
- std::vector<GEdge*> const& e_list = _gr->embeddedEdges();
+ std::vector<GFace *> const &f_list = _gr->faces();
+ std::vector<GEdge *> const &e_list = _gr->embeddedEdges();
- {
- Msg::Info("Creating surface mesh...");
- face newsh;
- face newseg;
- point p[4];
- int idx;
-
- for(std::vector<GFace*>::const_iterator it = f_list.begin(); it != f_list.end(); ++it){
- GFace *gf = *it;
- for(unsigned int i = 0; i < gf->triangles.size(); i++){
- for(int j = 0; j < 3; j++){
- p[j] = idx2verlist[gf->triangles[i]->getVertex(j)->getIndex()];
- if(pointtype(p[j]) == VOLVERTEX){
- setpointtype(p[j], FACETVERTEX);
- }
- }
- // Create an initial triangulation.
- makeshellface(subfaces, &newsh);
- setshvertices(newsh, p[0], p[1], p[2]);
- setshellmark(newsh, gf->tag()); // the GFace's tag.
- recentsh = newsh;
- for(int j = 0; j < 3; j++){
- makeshellface(subsegs, &newseg);
- setshvertices(newseg, sorg(newsh), sdest(newsh), NULL);
- // Set the default segment marker '-1'.
- setshellmark(newseg, -1);
- ssbond(newsh, newseg);
- senextself(newsh);
- }
- } // i
- } // it
-
- // Connecting triangles, removing redundant segments.
- unifysegments();
-
- Msg::Info("Identifying boundary edges...");
-
- face* shperverlist;
- int* idx2shlist;
- face searchsh, neighsh;
- face segloop, checkseg;
- point checkpt;
-
- // Construct a map from points to subfaces.
- makepoint2submap(subfaces, idx2shlist, shperverlist);
-
- // Process the set of PSC edges.
- // Remeber that all segments have default marker '-1'.
- // int COUNTER = 0;
- for(std::vector<GEdge*>::const_iterator it = e_list.begin(); it != e_list.end();
- ++it){
- GEdge *ge = *it;
- for(unsigned int i = 0; i < ge->lines.size(); i++){
- for(int j = 0; j < 2; j++){
- p[j] = idx2verlist[ge->lines[i]->getVertex(j)->getIndex()];
- setpointtype(p[j], RIDGEVERTEX);
- }
- if(p[0] == p[1]){
- // This is a potential problem in surface mesh.
- continue; // Skip this edge.
- }
- // Find a face contains the edge p[0], p[1].
- newseg.sh = NULL;
- searchsh.sh = NULL;
- idx = pointmark(p[0]) - in->firstnumber;
- for(int j = idx2shlist[idx]; j < idx2shlist[idx + 1]; j++){
- checkpt = sdest(shperverlist[j]);
- if(checkpt == p[1]){
- searchsh = shperverlist[j];
- break; // Found.
- }
- else{
- checkpt = sapex(shperverlist[j]);
- if(checkpt == p[1]){
- senext2(shperverlist[j], searchsh);
- sesymself(searchsh);
- break;
- }
- }
- } // j
- if(searchsh.sh != NULL){
- // Check if this edge is already a segment of the mesh.
- sspivot(searchsh, checkseg);
- if(checkseg.sh != NULL){
- // This segment already exist.
- newseg = checkseg;
+ {
+ Msg::Info("Creating surface mesh...");
+ face newsh;
+ face newseg;
+ point p[4];
+ int idx;
+
+ for(std::vector<GFace *>::const_iterator it = f_list.begin();
+ it != f_list.end(); ++it) {
+ GFace *gf = *it;
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
+ for(int j = 0; j < 3; j++) {
+ p[j] = idx2verlist[gf->triangles[i]->getVertex(j)->getIndex()];
+ if(pointtype(p[j]) == VOLVERTEX) {
+ setpointtype(p[j], FACETVERTEX);
+ }
}
- else{
- // Create a new segment at this edge.
+ // Create an initial triangulation.
+ makeshellface(subfaces, &newsh);
+ setshvertices(newsh, p[0], p[1], p[2]);
+ setshellmark(newsh, gf->tag()); // the GFace's tag.
+ recentsh = newsh;
+ for(int j = 0; j < 3; j++) {
makeshellface(subsegs, &newseg);
- setshvertices(newseg, p[0], p[1], NULL);
- ssbond(searchsh, newseg);
- spivot(searchsh, neighsh);
- if(neighsh.sh != NULL){
- ssbond(neighsh, newseg);
+ setshvertices(newseg, sorg(newsh), sdest(newsh), NULL);
+ // Set the default segment marker '-1'.
+ setshellmark(newseg, -1);
+ ssbond(newsh, newseg);
+ senextself(newsh);
+ }
+ } // i
+ } // it
+
+ // Connecting triangles, removing redundant segments.
+ unifysegments();
+
+ Msg::Info("Identifying boundary edges...");
+
+ face *shperverlist;
+ int *idx2shlist;
+ face searchsh, neighsh;
+ face segloop, checkseg;
+ point checkpt;
+
+ // Construct a map from points to subfaces.
+ makepoint2submap(subfaces, idx2shlist, shperverlist);
+
+ // Process the set of PSC edges.
+ // Remeber that all segments have default marker '-1'.
+ // int COUNTER = 0;
+ for(std::vector<GEdge *>::const_iterator it = e_list.begin();
+ it != e_list.end(); ++it) {
+ GEdge *ge = *it;
+ for(unsigned int i = 0; i < ge->lines.size(); i++) {
+ for(int j = 0; j < 2; j++) {
+ p[j] = idx2verlist[ge->lines[i]->getVertex(j)->getIndex()];
+ setpointtype(p[j], RIDGEVERTEX);
+ }
+ if(p[0] == p[1]) {
+ // This is a potential problem in surface mesh.
+ continue; // Skip this edge.
+ }
+ // Find a face contains the edge p[0], p[1].
+ newseg.sh = NULL;
+ searchsh.sh = NULL;
+ idx = pointmark(p[0]) - in->firstnumber;
+ for(int j = idx2shlist[idx]; j < idx2shlist[idx + 1]; j++) {
+ checkpt = sdest(shperverlist[j]);
+ if(checkpt == p[1]) {
+ searchsh = shperverlist[j];
+ break; // Found.
+ }
+ else {
+ checkpt = sapex(shperverlist[j]);
+ if(checkpt == p[1]) {
+ senext2(shperverlist[j], searchsh);
+ sesymself(searchsh);
+ break;
+ }
+ }
+ } // j
+ if(searchsh.sh != NULL) {
+ // Check if this edge is already a segment of the mesh.
+ sspivot(searchsh, checkseg);
+ if(checkseg.sh != NULL) {
+ // This segment already exist.
+ newseg = checkseg;
+ }
+ else {
+ // Create a new segment at this edge.
+ makeshellface(subsegs, &newseg);
+ setshvertices(newseg, p[0], p[1], NULL);
+ ssbond(searchsh, newseg);
+ spivot(searchsh, neighsh);
+ if(neighsh.sh != NULL) {
+ ssbond(neighsh, newseg);
+ }
}
}
- }
- else{
- // It is a dangling segment (not belong to any facets).
- // Check if segment [p[0],p[1]] already exists.
- // TODO: Change the brute-force search. Slow!
- /* point *ppt;
- subsegs->traversalinit();
- segloop.sh = shellfacetraverse(subsegs);
- while (segloop.sh != NULL){
- ppt = (point *) &(segloop.sh[3]);
- if(((ppt[0] == p[0]) && (ppt[1] == p[1])) ||
- ((ppt[0] == p[1]) && (ppt[1] == p[0]))){
- // Found!
- newseg = segloop;
- break;
- }
- segloop.sh = shellfacetraverse(subsegs);
- }*/
- if(newseg.sh == NULL){
- makeshellface(subsegs, &newseg);
- setshvertices(newseg, p[0], p[1], NULL);
- }
- }
- setshellmark(newseg, ge->tag());
- } // i
- } // e_list
+ else {
+ // It is a dangling segment (not belong to any facets).
+ // Check if segment [p[0],p[1]] already exists.
+ // TODO: Change the brute-force search. Slow!
+ /* point *ppt;
+ subsegs->traversalinit();
+ segloop.sh = shellfacetraverse(subsegs);
+ while (segloop.sh != NULL){
+ ppt = (point *) &(segloop.sh[3]);
+ if(((ppt[0] == p[0]) && (ppt[1] == p[1])) ||
+ ((ppt[0] == p[1]) && (ppt[1] == p[0]))){
+ // Found!
+ newseg = segloop;
+ break;
+ }
+ segloop.sh = shellfacetraverse(subsegs);
+ }*/
+ if(newseg.sh == NULL) {
+ makeshellface(subsegs, &newseg);
+ setshvertices(newseg, p[0], p[1], NULL);
+ }
+ }
+ setshellmark(newseg, ge->tag());
+ } // i
+ } // e_list
- delete [] shperverlist;
- delete [] idx2shlist;
+ delete[] shperverlist;
+ delete[] idx2shlist;
- Msg::Debug(" %ld (%ld) subfaces (segments).", subfaces->items,
- subsegs->items);
+ Msg::Debug(" %ld (%ld) subfaces (segments).", subfaces->items,
+ subsegs->items);
- // The total number of iunput segments.
- insegments = subsegs->items;
+ // The total number of iunput segments.
+ insegments = subsegs->items;
- if(0){
- outmesh2medit("dump2");
+ if(0) {
+ outmesh2medit("dump2");
+ }
}
- }
-
- delete [] idx2verlist;
+ delete[] idx2verlist;
- // Boundary recovery.
+ // Boundary recovery.
- clock_t t;
- Msg::Info("Boundary Recovery...");
- recoverboundary(t);
+ clock_t t;
+ Msg::Info("Boundary Recovery...");
+ recoverboundary(t);
- carveholes();
+ carveholes();
- if(subvertstack->objects > 0l){
- suppresssteinerpoints();
- }
+ if(subvertstack->objects > 0l) {
+ suppresssteinerpoints();
+ }
- recoverdelaunay();
+ recoverdelaunay();
- // let's try
- optimizemesh();
+ // let's try
+ optimizemesh();
- if((dupverts > 0l) || (unuverts > 0l)){
- // Remove hanging nodes.
- // cannot call this here due to 8 additional exterior vertices we inserted
- // jettisonnodes();
- }
+ if((dupverts > 0l) || (unuverts > 0l)) {
+ // Remove hanging nodes.
+ // cannot call this here due to 8 additional exterior vertices we inserted
+ // jettisonnodes();
+ }
- long tetnumber, facenumber;
+ long tetnumber, facenumber;
- Msg::Debug("Statistics:\n");
- Msg::Debug(" Input points: %ld", _vertices.size());
- if(b->plc){
- Msg::Debug(" Input facets: %ld", f_list.size());
- Msg::Debug(" Input segments: %ld", e_list.size());
- }
+ Msg::Debug("Statistics:\n");
+ Msg::Debug(" Input points: %ld", _vertices.size());
+ if(b->plc) {
+ Msg::Debug(" Input facets: %ld", f_list.size());
+ Msg::Debug(" Input segments: %ld", e_list.size());
+ }
- tetnumber = tetrahedrons->items - hullsize;
- facenumber = (tetnumber * 4l + hullsize) / 2l;
+ tetnumber = tetrahedrons->items - hullsize;
+ facenumber = (tetnumber * 4l + hullsize) / 2l;
- if(b->weighted){ // -w option
- Msg::Debug(" Mesh points: %ld", points->items - nonregularcount);
- }
- else{
- Msg::Debug(" Mesh points: %ld", points->items);
- }
- Msg::Debug(" Mesh tetrahedra: %ld", tetnumber);
- Msg::Debug(" Mesh faces: %ld", facenumber);
- if(meshedges > 0l){
- Msg::Debug(" Mesh edges: %ld", meshedges);
- }
- else{
- if(!nonconvex){
- long vsize = points->items - dupverts - unuverts;
- if(b->weighted) vsize -= nonregularcount;
- meshedges = vsize + facenumber - tetnumber - 1;
+ if(b->weighted) { // -w option
+ Msg::Debug(" Mesh points: %ld", points->items - nonregularcount);
+ }
+ else {
+ Msg::Debug(" Mesh points: %ld", points->items);
+ }
+ Msg::Debug(" Mesh tetrahedra: %ld", tetnumber);
+ Msg::Debug(" Mesh faces: %ld", facenumber);
+ if(meshedges > 0l) {
Msg::Debug(" Mesh edges: %ld", meshedges);
}
- }
-
- if(b->plc || b->refine){
- Msg::Debug(" Mesh faces on facets: %ld", subfaces->items);
- Msg::Debug(" Mesh edges on segments: %ld", subsegs->items);
- if(st_volref_count > 0l){
- Msg::Debug(" Steiner points inside domain: %ld", st_volref_count);
+ else {
+ if(!nonconvex) {
+ long vsize = points->items - dupverts - unuverts;
+ if(b->weighted) vsize -= nonregularcount;
+ meshedges = vsize + facenumber - tetnumber - 1;
+ Msg::Debug(" Mesh edges: %ld", meshedges);
+ }
}
- if(st_facref_count > 0l){
- Msg::Debug(" Steiner points on facets: %ld", st_facref_count);
+
+ if(b->plc || b->refine) {
+ Msg::Debug(" Mesh faces on facets: %ld", subfaces->items);
+ Msg::Debug(" Mesh edges on segments: %ld", subsegs->items);
+ if(st_volref_count > 0l) {
+ Msg::Debug(" Steiner points inside domain: %ld", st_volref_count);
+ }
+ if(st_facref_count > 0l) {
+ Msg::Debug(" Steiner points on facets: %ld", st_facref_count);
+ }
+ if(st_segref_count > 0l) {
+ Msg::Debug(" Steiner points on segments: %ld", st_segref_count);
+ }
}
- if(st_segref_count > 0l){
- Msg::Debug(" Steiner points on segments: %ld", st_segref_count);
+ else {
+ Msg::Debug(" Convex hull faces: %ld", hullsize);
+ if(meshhulledges > 0l) {
+ Msg::Debug(" Convex hull edges: %ld", meshhulledges);
+ }
}
- }
- else{
- Msg::Debug(" Convex hull faces: %ld", hullsize);
- if (meshhulledges > 0l){
- Msg::Debug(" Convex hull edges: %ld", meshhulledges);
+ if(b->weighted) { // -w option
+ Msg::Debug(" Skipped non-regular points: %ld", nonregularcount);
}
- }
- if(b->weighted){ // -w option
- Msg::Debug(" Skipped non-regular points: %ld", nonregularcount);
- }
- // Debug
- if(0){
- outmesh2medit("dump");
- }
+ // Debug
+ if(0) {
+ outmesh2medit("dump");
+ }
- {
- // Write mesh into to GRegion.
+ {
+ // Write mesh into to GRegion.
- Msg::Info("Writing to GRegion...");
+ Msg::Info("Writing to GRegion...");
- point p[4];
+ point p[4];
- // In some hard cases, the surface mesh may be modified.
- // Find the list of GFaces, GEdges that have been modified.
- std::set<int> l_faces, l_edges;
+ // In some hard cases, the surface mesh may be modified.
+ // Find the list of GFaces, GEdges that have been modified.
+ std::set<int> l_faces, l_edges;
- if(points->items > (int)_vertices.size()){
- face parentseg, parentsh, spinsh;
- point pointloop;
- // Create newly added mesh vertices.
- // The new vertices must be added at the end of the point list.
- points->traversalinit();
- pointloop = pointtraverse();
- while (pointloop != (point) NULL){
- if(issteinerpoint(pointloop)){
- // Check if this Steiner point locates on boundary.
- if(pointtype(pointloop) == FREESEGVERTEX){
- sdecode(point2sh(pointloop), parentseg);
- assert(parentseg.sh != NULL);
- l_edges.insert(shellmark(parentseg));
- // Get the GEdge containing this vertex.
- GEdge *ge = NULL;
- GFace *gf = NULL;
- int etag = shellmark(parentseg);
- for(std::vector<GEdge*>::const_iterator it = e_list.begin();
- it != e_list.end(); ++it){
- if((*it)->tag() == etag){
- ge = *it;
- break;
+ if(points->items > (int)_vertices.size()) {
+ face parentseg, parentsh, spinsh;
+ point pointloop;
+ // Create newly added mesh vertices.
+ // The new vertices must be added at the end of the point list.
+ points->traversalinit();
+ pointloop = pointtraverse();
+ while(pointloop != (point)NULL) {
+ if(issteinerpoint(pointloop)) {
+ // Check if this Steiner point locates on boundary.
+ if(pointtype(pointloop) == FREESEGVERTEX) {
+ sdecode(point2sh(pointloop), parentseg);
+ assert(parentseg.sh != NULL);
+ l_edges.insert(shellmark(parentseg));
+ // Get the GEdge containing this vertex.
+ GEdge *ge = NULL;
+ GFace *gf = NULL;
+ int etag = shellmark(parentseg);
+ for(std::vector<GEdge *>::const_iterator it = e_list.begin();
+ it != e_list.end(); ++it) {
+ if((*it)->tag() == etag) {
+ ge = *it;
+ break;
+ }
}
- }
- if(ge != NULL){
- MEdgeVertex *v = new MEdgeVertex(pointloop[0], pointloop[1],
- pointloop[2], ge, 0);
- double uu = 0;
- if(reparamMeshVertexOnEdge(v, ge, uu)){
- v->setParameter(0, uu);
+ if(ge != NULL) {
+ MEdgeVertex *v = new MEdgeVertex(pointloop[0], pointloop[1],
+ pointloop[2], ge, 0);
+ double uu = 0;
+ if(reparamMeshVertexOnEdge(v, ge, uu)) {
+ v->setParameter(0, uu);
+ }
+ v->setIndex(pointmark(pointloop));
+ _gr->mesh_vertices.push_back(v);
+ _extras[pointmark(pointloop) - in->firstnumber] = v;
}
- v->setIndex(pointmark(pointloop));
- _gr->mesh_vertices.push_back(v);
- _extras[pointmark(pointloop) - in->firstnumber] = v;
- }
- spivot(parentseg, parentsh);
- if(parentsh.sh != NULL){
- if(ge == NULL){
- // We treat this vertex a facet vertex.
- int ftag = shellmark(parentsh);
- for(std::vector<GFace*>::const_iterator it = f_list.begin();
- it != f_list.end(); ++it){
- if((*it)->tag() == ftag){
- gf = *it;
- break;
+ spivot(parentseg, parentsh);
+ if(parentsh.sh != NULL) {
+ if(ge == NULL) {
+ // We treat this vertex a facet vertex.
+ int ftag = shellmark(parentsh);
+ for(std::vector<GFace *>::const_iterator it = f_list.begin();
+ it != f_list.end(); ++it) {
+ if((*it)->tag() == ftag) {
+ gf = *it;
+ break;
+ }
}
- }
- if(gf != NULL){
- MFaceVertex *v = new MFaceVertex(pointloop[0], pointloop[1],
- pointloop[2], gf, 0, 0);
- SPoint2 param;
- if(reparamMeshVertexOnFace(v, gf, param)){
- v->setParameter(0, param.x());
- v->setParameter(1, param.y());
+ if(gf != NULL) {
+ MFaceVertex *v = new MFaceVertex(pointloop[0], pointloop[1],
+ pointloop[2], gf, 0, 0);
+ SPoint2 param;
+ if(reparamMeshVertexOnFace(v, gf, param)) {
+ v->setParameter(0, param.x());
+ v->setParameter(1, param.y());
+ }
+ v->setIndex(pointmark(pointloop));
+ _gr->mesh_vertices.push_back(v);
+ _extras[pointmark(pointloop) - in->firstnumber] = v;
}
- v->setIndex(pointmark(pointloop));
- _gr->mesh_vertices.push_back(v);
- _extras[pointmark(pointloop) - in->firstnumber] = v;
+ }
+ // Record all the GFaces' tag at this segment.
+ spinsh = parentsh;
+ while(1) {
+ l_faces.insert(shellmark(spinsh));
+ spivotself(spinsh);
+ if(spinsh.sh == parentsh.sh) break;
}
}
- // Record all the GFaces' tag at this segment.
- spinsh = parentsh;
- while (1){
- l_faces.insert(shellmark(spinsh));
- spivotself(spinsh);
- if(spinsh.sh == parentsh.sh) break;
+ if((ge == NULL) && (gf == NULL)) {
+ // Create an interior mesh vertex.
+ MVertex *v =
+ new MVertex(pointloop[0], pointloop[1], pointloop[2], _gr);
+ v->setIndex(pointmark(pointloop));
+ _extras[pointmark(pointloop) - in->firstnumber] = v;
+ _gr->mesh_vertices.push_back(v);
}
}
- if((ge == NULL) && (gf == NULL)){
- // Create an interior mesh vertex.
- MVertex *v = new MVertex(pointloop[0], pointloop[1], pointloop[2], _gr);
- v->setIndex(pointmark(pointloop));
- _extras[pointmark(pointloop) - in->firstnumber] = v;
- _gr->mesh_vertices.push_back(v);
- }
- }
- else if(pointtype(pointloop) == FREEFACETVERTEX){
- sdecode(point2sh(pointloop), parentsh);
- assert(parentsh.sh != NULL);
- l_faces.insert(shellmark(parentsh));
- // Get the GFace containing this vertex.
- GFace *gf = NULL;
- int ftag = shellmark(parentsh);
- for(std::vector<GFace*>::const_iterator it = f_list.begin();
- it != f_list.end(); ++it){
- if((*it)->tag() == ftag){
- gf = *it;
- break;
+ else if(pointtype(pointloop) == FREEFACETVERTEX) {
+ sdecode(point2sh(pointloop), parentsh);
+ assert(parentsh.sh != NULL);
+ l_faces.insert(shellmark(parentsh));
+ // Get the GFace containing this vertex.
+ GFace *gf = NULL;
+ int ftag = shellmark(parentsh);
+ for(std::vector<GFace *>::const_iterator it = f_list.begin();
+ it != f_list.end(); ++it) {
+ if((*it)->tag() == ftag) {
+ gf = *it;
+ break;
+ }
}
- }
- if(gf != NULL){
- MFaceVertex *v = new MFaceVertex(pointloop[0], pointloop[1],
- pointloop[2], gf, 0, 0);
- SPoint2 param;
- if(reparamMeshVertexOnFace(v, gf, param)){
- v->setParameter(0, param.x());
- v->setParameter(1, param.y());
+ if(gf != NULL) {
+ MFaceVertex *v = new MFaceVertex(pointloop[0], pointloop[1],
+ pointloop[2], gf, 0, 0);
+ SPoint2 param;
+ if(reparamMeshVertexOnFace(v, gf, param)) {
+ v->setParameter(0, param.x());
+ v->setParameter(1, param.y());
+ }
+ v->setIndex(pointmark(pointloop));
+ _gr->mesh_vertices.push_back(v);
+ _extras[pointmark(pointloop) - in->firstnumber] = v;
+ }
+ else {
+ // Create a mesh vertex.
+ MVertex *v =
+ new MVertex(pointloop[0], pointloop[1], pointloop[2], _gr);
+ v->setIndex(pointmark(pointloop));
+ _gr->mesh_vertices.push_back(v);
+ _extras[pointmark(pointloop) - in->firstnumber] = v;
}
- v->setIndex(pointmark(pointloop));
- _gr->mesh_vertices.push_back(v);
- _extras[pointmark(pointloop) - in->firstnumber] = v;
}
- else{
- // Create a mesh vertex.
- MVertex *v = new MVertex(pointloop[0], pointloop[1], pointloop[2], _gr);
+ else {
+ MVertex *v =
+ new MVertex(pointloop[0], pointloop[1], pointloop[2], _gr);
v->setIndex(pointmark(pointloop));
_gr->mesh_vertices.push_back(v);
- _extras[pointmark(pointloop) - in->firstnumber] = v;
+ _extras[pointmark(pointloop) - in->firstnumber] = v;
}
}
- else{
- MVertex *v = new MVertex(pointloop[0], pointloop[1], pointloop[2], _gr);
- v->setIndex(pointmark(pointloop));
- _gr->mesh_vertices.push_back(v);
- _extras[pointmark(pointloop) - in->firstnumber] = v;
- }
+ pointloop = pointtraverse();
}
- pointloop = pointtraverse();
+ // assert((int)_vertices.size() == points->items);
}
- // assert((int)_vertices.size() == points->items);
- }
- if(!_extras.empty())
- Msg::Info("We add %d steiner points...", _extras.size());
-
- if(l_edges.size() > 0){
- // There are Steiner points on segments!
- face segloop;
- // Re-create the segment mesh in the corresponding GEdges.
- for(std::set<int>::iterator it = l_edges.begin(); it!=l_edges.end(); ++it){
- // Find the GFace with tag = *it.
-
- // TODO C++11 use std::find_if
- GEdge *ge = NULL;
- int etag = *it;
- for(std::vector<GEdge*>::const_iterator eit = e_list.begin();
- eit != e_list.end(); ++eit){
- if((*eit)->tag() == etag){
- ge = (*eit);
- break;
- }
- }
- assert(ge != NULL);
- // Msg::Info("Steiner points exist on GEdge %d", ge->tag());
- // Delete the old triangles.
- for(unsigned int i = 0; i < ge->lines.size(); i++)
- delete ge->lines[i];
- ge->lines.clear();
- ge->deleteVertexArrays();
- // Create the new triangles.
- segloop.shver = 0;
- subsegs->traversalinit();
- segloop.sh = shellfacetraverse(subsegs);
- while (segloop.sh != NULL){
- if(shellmark(segloop) == etag){
- p[0] = sorg(segloop);
- p[1] = sdest(segloop);
- int idx1 = pointmark(p[0]) - in->firstnumber;
- MVertex *v1 = idx1 >= (int)_vertices.size() ? _extras[idx1] : _vertices[idx1];
- int idx2 = pointmark(p[1]) - in->firstnumber;
- MVertex *v2 = idx2 >= (int)_vertices.size() ? _extras[idx2] : _vertices[idx2];
- MLine *t = new MLine(v1, v2);
- ge->lines.push_back(t);
+ if(!_extras.empty())
+ Msg::Info("We add %d steiner points...", _extras.size());
+
+ if(l_edges.size() > 0) {
+ // There are Steiner points on segments!
+ face segloop;
+ // Re-create the segment mesh in the corresponding GEdges.
+ for(std::set<int>::iterator it = l_edges.begin(); it != l_edges.end();
+ ++it) {
+ // Find the GFace with tag = *it.
+
+ // TODO C++11 use std::find_if
+ GEdge *ge = NULL;
+ int etag = *it;
+ for(std::vector<GEdge *>::const_iterator eit = e_list.begin();
+ eit != e_list.end(); ++eit) {
+ if((*eit)->tag() == etag) {
+ ge = (*eit);
+ break;
+ }
}
+ assert(ge != NULL);
+ // Msg::Info("Steiner points exist on GEdge %d", ge->tag());
+ // Delete the old triangles.
+ for(unsigned int i = 0; i < ge->lines.size(); i++)
+ delete ge->lines[i];
+ ge->lines.clear();
+ ge->deleteVertexArrays();
+ // Create the new triangles.
+ segloop.shver = 0;
+ subsegs->traversalinit();
segloop.sh = shellfacetraverse(subsegs);
- }
- } // it
- }
-
- if(l_faces.size() > 0){
- // There are Steiner points on facets!
- face subloop;
- // Re-create the surface mesh in the corresponding GFaces.
- for(std::set<int>::iterator it = l_faces.begin(); it != l_faces.end(); ++it){
- // Find the GFace with tag = *it.
- GFace *gf = NULL;
- int ftag = *it;
- // TODO C++11 std::find_if
- for(std::vector<GFace*>::const_iterator fit = f_list.begin(); fit != f_list.end(); ++fit){
- if((*fit)->tag() == ftag){
- gf = (*fit);
- break;
+ while(segloop.sh != NULL) {
+ if(shellmark(segloop) == etag) {
+ p[0] = sorg(segloop);
+ p[1] = sdest(segloop);
+ int idx1 = pointmark(p[0]) - in->firstnumber;
+ MVertex *v1 =
+ idx1 >= (int)_vertices.size() ? _extras[idx1] : _vertices[idx1];
+ int idx2 = pointmark(p[1]) - in->firstnumber;
+ MVertex *v2 =
+ idx2 >= (int)_vertices.size() ? _extras[idx2] : _vertices[idx2];
+ MLine *t = new MLine(v1, v2);
+ ge->lines.push_back(t);
+ }
+ segloop.sh = shellfacetraverse(subsegs);
}
- }
- assert(gf != NULL);
- // Delete the old triangles.
- Msg::Info("Steiner points exist on GFace %d", gf->tag());
- for(unsigned int i = 0; i < gf->triangles.size(); i++)
- delete gf->triangles[i];
- gf->triangles.clear();
- gf->deleteVertexArrays();
- // Create the new triangles.
- subloop.shver = 0;
- subfaces->traversalinit();
- subloop.sh = shellfacetraverse(subfaces);
- while (subloop.sh != NULL){
- if(shellmark(subloop) == ftag){
- p[0] = sorg(subloop);
- p[1] = sdest(subloop);
- p[2] = sapex(subloop);
- int idx1 = pointmark(p[0]) - in->firstnumber;
- MVertex *v1 = idx1 >= (int)_vertices.size() ? _extras[idx1] : _vertices[idx1];
- int idx2 = pointmark(p[1]) - in->firstnumber;
- MVertex *v2 = idx2 >= (int)_vertices.size() ? _extras[idx2] : _vertices[idx2];
- int idx3 = pointmark(p[2]) - in->firstnumber;
- MVertex *v3 = idx3 >= (int)_vertices.size() ? _extras[idx3] : _vertices[idx3];
- MTriangle *t = new MTriangle(v1, v2, v3);
- gf->triangles.push_back(t);
+ } // it
+ }
+
+ if(l_faces.size() > 0) {
+ // There are Steiner points on facets!
+ face subloop;
+ // Re-create the surface mesh in the corresponding GFaces.
+ for(std::set<int>::iterator it = l_faces.begin(); it != l_faces.end();
+ ++it) {
+ // Find the GFace with tag = *it.
+ GFace *gf = NULL;
+ int ftag = *it;
+ // TODO C++11 std::find_if
+ for(std::vector<GFace *>::const_iterator fit = f_list.begin();
+ fit != f_list.end(); ++fit) {
+ if((*fit)->tag() == ftag) {
+ gf = (*fit);
+ break;
+ }
}
+ assert(gf != NULL);
+ // Delete the old triangles.
+ Msg::Info("Steiner points exist on GFace %d", gf->tag());
+ for(unsigned int i = 0; i < gf->triangles.size(); i++)
+ delete gf->triangles[i];
+ gf->triangles.clear();
+ gf->deleteVertexArrays();
+ // Create the new triangles.
+ subloop.shver = 0;
+ subfaces->traversalinit();
subloop.sh = shellfacetraverse(subfaces);
- }
- } // it
- }
+ while(subloop.sh != NULL) {
+ if(shellmark(subloop) == ftag) {
+ p[0] = sorg(subloop);
+ p[1] = sdest(subloop);
+ p[2] = sapex(subloop);
+ int idx1 = pointmark(p[0]) - in->firstnumber;
+ MVertex *v1 =
+ idx1 >= (int)_vertices.size() ? _extras[idx1] : _vertices[idx1];
+ int idx2 = pointmark(p[1]) - in->firstnumber;
+ MVertex *v2 =
+ idx2 >= (int)_vertices.size() ? _extras[idx2] : _vertices[idx2];
+ int idx3 = pointmark(p[2]) - in->firstnumber;
+ MVertex *v3 =
+ idx3 >= (int)_vertices.size() ? _extras[idx3] : _vertices[idx3];
+ MTriangle *t = new MTriangle(v1, v2, v3);
+ gf->triangles.push_back(t);
+ }
+ subloop.sh = shellfacetraverse(subfaces);
+ }
+ } // it
+ }
- triface tetloop;
+ triface tetloop;
- tetloop.ver = 11;
- tetrahedrons->traversalinit();
- tetloop.tet = tetrahedrontraverse();
-
- while (tetloop.tet != (tetrahedron *) NULL){
- p[0] = org(tetloop);
- p[1] = dest(tetloop);
- p[2] = apex(tetloop);
- p[3] = oppo(tetloop);
-
- int idx1 = pointmark(p[0]) - in->firstnumber;
- MVertex *v1 = idx1 >= (int)_vertices.size() ? _extras[idx1] : _vertices[idx1];
- int idx2 = pointmark(p[1]) - in->firstnumber;
- MVertex *v2 = idx2 >= (int)_vertices.size() ? _extras[idx2] : _vertices[idx2];
- int idx3 = pointmark(p[2]) - in->firstnumber;
- MVertex *v3 = idx3 >= (int)_vertices.size() ? _extras[idx3] : _vertices[idx3];
- int idx4 = pointmark(p[3]) - in->firstnumber;
- MVertex *v4 = idx4 >= (int)_vertices.size() ? _extras[idx4] : _vertices[idx4];
- MTetrahedron *t = new MTetrahedron(v1, v2, v3, v4);
- _gr->tetrahedra.push_back(t);
+ tetloop.ver = 11;
+ tetrahedrons->traversalinit();
tetloop.tet = tetrahedrontraverse();
- }
- } // mesh output
- Msg::Info("Reconstruct time : %g sec", Cpu() - t_start);
+ while(tetloop.tet != (tetrahedron *)NULL) {
+ p[0] = org(tetloop);
+ p[1] = dest(tetloop);
+ p[2] = apex(tetloop);
+ p[3] = oppo(tetloop);
+
+ int idx1 = pointmark(p[0]) - in->firstnumber;
+ MVertex *v1 =
+ idx1 >= (int)_vertices.size() ? _extras[idx1] : _vertices[idx1];
+ int idx2 = pointmark(p[1]) - in->firstnumber;
+ MVertex *v2 =
+ idx2 >= (int)_vertices.size() ? _extras[idx2] : _vertices[idx2];
+ int idx3 = pointmark(p[2]) - in->firstnumber;
+ MVertex *v3 =
+ idx3 >= (int)_vertices.size() ? _extras[idx3] : _vertices[idx3];
+ int idx4 = pointmark(p[3]) - in->firstnumber;
+ MVertex *v4 =
+ idx4 >= (int)_vertices.size() ? _extras[idx4] : _vertices[idx4];
+ MTetrahedron *t = new MTetrahedron(v1, v2, v3, v4);
+ _gr->tetrahedra.push_back(t);
+ tetloop.tet = tetrahedrontraverse();
+ }
+ } // mesh output
- // Put all coordinates back so they are not pertubated anymore (pertubation done
- // in delaunayTriangulation)
- for (std::map<MVertex *, SPoint3>::iterator vIter = originalCoordinates.begin();
- vIter != originalCoordinates.end(); ++vIter) {
- const SPoint3 &coordinates = vIter->second;
- vIter->first->setXYZ(coordinates.x(), coordinates.y(), coordinates.z());
- }
+ Msg::Info("Reconstruct time : %g sec", Cpu() - t_start);
- return true;
-}
+ // Put all coordinates back so they are not pertubated anymore (pertubation
+ // done in delaunayTriangulation)
+ for(std::map<MVertex *, SPoint3>::iterator vIter =
+ originalCoordinates.begin();
+ vIter != originalCoordinates.end(); ++vIter) {
+ const SPoint3 &coordinates = vIter->second;
+ vIter->first->setXYZ(coordinates.x(), coordinates.y(), coordinates.z());
+ }
-// Dump the input surface mesh.
-// 'mfilename' is a filename without suffix.
-void tetgenmesh::outsurfacemesh(const char* mfilename)
-{
- FILE *outfile = NULL;
- char sfilename[256];
- int firstindex;
-
- point pointloop;
- int pointnumber;
- strcpy(sfilename, mfilename);
- strcat(sfilename, ".node");
- outfile = fopen(sfilename, "w");
- if(!b->quiet){
- printf("Writing %s.\n", sfilename);
+ return true;
}
- fprintf(outfile, "%ld 3 0 0\n", points->items);
- // Determine the first index (0 or 1).
- firstindex = b->zeroindex ? 0 : in->firstnumber;
- points->traversalinit();
- pointloop = pointtraverse();
- pointnumber = firstindex; // in->firstnumber;
- while (pointloop != (point) NULL){
- // Point number, x, y and z coordinates.
- fprintf(outfile, "%4d %.17g %.17g %.17g", pointnumber,
- pointloop[0], pointloop[1], pointloop[2]);
- fprintf(outfile, "\n");
+
+ // Dump the input surface mesh.
+ // 'mfilename' is a filename without suffix.
+ void tetgenmesh::outsurfacemesh(const char *mfilename)
+ {
+ FILE *outfile = NULL;
+ char sfilename[256];
+ int firstindex;
+
+ point pointloop;
+ int pointnumber;
+ strcpy(sfilename, mfilename);
+ strcat(sfilename, ".node");
+ outfile = fopen(sfilename, "w");
+ if(!b->quiet) {
+ printf("Writing %s.\n", sfilename);
+ }
+ fprintf(outfile, "%ld 3 0 0\n", points->items);
+ // Determine the first index (0 or 1).
+ firstindex = b->zeroindex ? 0 : in->firstnumber;
+ points->traversalinit();
pointloop = pointtraverse();
- pointnumber++;
- }
- fclose(outfile);
-
- face faceloop;
- point torg, tdest, tapex;
- strcpy(sfilename, mfilename);
- strcat(sfilename, ".smesh");
- outfile = fopen(sfilename, "w");
- if(!b->quiet){
- printf("Writing %s.\n", sfilename);
- }
- int shift = 0; // Default no shiftment.
- if((in->firstnumber == 1) && (firstindex == 0)){
- shift = 1; // Shift the output indices by 1.
- }
- fprintf(outfile, "0 3 0 0\n");
- fprintf(outfile, "%ld 1\n", subfaces->items);
- subfaces->traversalinit();
- faceloop.sh = shellfacetraverse(subfaces);
- while (faceloop.sh != (shellface *) NULL){
- torg = sorg(faceloop);
- tdest = sdest(faceloop);
- tapex = sapex(faceloop);
- fprintf(outfile, "3 %4d %4d %4d %d\n",
- pointmark(torg) - shift, pointmark(tdest) - shift,
- pointmark(tapex) - shift, shellmark(faceloop));
+ pointnumber = firstindex; // in->firstnumber;
+ while(pointloop != (point)NULL) {
+ // Point number, x, y and z coordinates.
+ fprintf(outfile, "%4d %.17g %.17g %.17g", pointnumber, pointloop[0],
+ pointloop[1], pointloop[2]);
+ fprintf(outfile, "\n");
+ pointloop = pointtraverse();
+ pointnumber++;
+ }
+ fclose(outfile);
+
+ face faceloop;
+ point torg, tdest, tapex;
+ strcpy(sfilename, mfilename);
+ strcat(sfilename, ".smesh");
+ outfile = fopen(sfilename, "w");
+ if(!b->quiet) {
+ printf("Writing %s.\n", sfilename);
+ }
+ int shift = 0; // Default no shiftment.
+ if((in->firstnumber == 1) && (firstindex == 0)) {
+ shift = 1; // Shift the output indices by 1.
+ }
+ fprintf(outfile, "0 3 0 0\n");
+ fprintf(outfile, "%ld 1\n", subfaces->items);
+ subfaces->traversalinit();
faceloop.sh = shellfacetraverse(subfaces);
- }
- fprintf(outfile, "0\n");
- fprintf(outfile, "0\n");
- fclose(outfile);
-
- face edgeloop;
- int edgenumber;
- strcpy(sfilename, mfilename);
- strcat(sfilename, ".edge");
- outfile = fopen(sfilename, "w");
- if(!b->quiet){
- printf("Writing %s.\n", sfilename);
- }
- fprintf(outfile, "%ld 1\n", subsegs->items);
- subsegs->traversalinit();
- edgeloop.sh = shellfacetraverse(subsegs);
- edgenumber = firstindex; // in->firstnumber;
- while (edgeloop.sh != (shellface *) NULL){
- torg = sorg(edgeloop);
- tdest = sdest(edgeloop);
- fprintf(outfile, "%5d %4d %4d %d\n", edgenumber,
- pointmark(torg) - shift, pointmark(tdest) - shift,
- shellmark(edgeloop));
- edgenumber++;
+ while(faceloop.sh != (shellface *)NULL) {
+ torg = sorg(faceloop);
+ tdest = sdest(faceloop);
+ tapex = sapex(faceloop);
+ fprintf(outfile, "3 %4d %4d %4d %d\n", pointmark(torg) - shift,
+ pointmark(tdest) - shift, pointmark(tapex) - shift,
+ shellmark(faceloop));
+ faceloop.sh = shellfacetraverse(subfaces);
+ }
+ fprintf(outfile, "0\n");
+ fprintf(outfile, "0\n");
+ fclose(outfile);
+
+ face edgeloop;
+ int edgenumber;
+ strcpy(sfilename, mfilename);
+ strcat(sfilename, ".edge");
+ outfile = fopen(sfilename, "w");
+ if(!b->quiet) {
+ printf("Writing %s.\n", sfilename);
+ }
+ fprintf(outfile, "%ld 1\n", subsegs->items);
+ subsegs->traversalinit();
edgeloop.sh = shellfacetraverse(subsegs);
- }
- fclose(outfile);
-}
-
-void tetgenmesh::outmesh2medit(const char* mfilename)
-{
- FILE *outfile;
- char mefilename[256];
- tetrahedron* tetptr;
- triface tface, tsymface;
- face segloop, checkmark;
- point ptloop, p1, p2, p3, p4;
- long ntets, faces;
- int shift = 0;
- int marker;
-
- if(mfilename != (char *) NULL && mfilename[0] != '\0'){
- strcpy(mefilename, mfilename);
- }
- else{
- strcpy(mefilename, "unnamed");
- }
- strcat(mefilename, ".mesh");
-
- if(!b->quiet){
- printf("Writing %s.\n", mefilename);
- }
- outfile = fopen(mefilename, "w");
- if(outfile == (FILE *) NULL){
- printf("File I/O Error: Cannot create file %s.\n", mefilename);
- return;
+ edgenumber = firstindex; // in->firstnumber;
+ while(edgeloop.sh != (shellface *)NULL) {
+ torg = sorg(edgeloop);
+ tdest = sdest(edgeloop);
+ fprintf(outfile, "%5d %4d %4d %d\n", edgenumber,
+ pointmark(torg) - shift, pointmark(tdest) - shift,
+ shellmark(edgeloop));
+ edgenumber++;
+ edgeloop.sh = shellfacetraverse(subsegs);
+ }
+ fclose(outfile);
}
- fprintf(outfile, "MeshVersionFormatted 1\n");
- fprintf(outfile, "\n");
- fprintf(outfile, "Dimension\n");
- fprintf(outfile, "3\n");
- fprintf(outfile, "\n");
-
- fprintf(outfile, "\n# Set of mesh vertices\n");
- fprintf(outfile, "Vertices\n");
- fprintf(outfile, "%ld\n", points->items);
-
- points->traversalinit();
- ptloop = pointtraverse();
- //pointnumber = 1;
- while (ptloop != (point) NULL){
- // Point coordinates.
- fprintf(outfile, "%.17g %.17g %.17g", ptloop[0], ptloop[1], ptloop[2]);
- fprintf(outfile, " 0\n");
- //setpointmark(ptloop, pointnumber);
- ptloop = pointtraverse();
- //pointnumber++;
- }
+ void tetgenmesh::outmesh2medit(const char *mfilename)
+ {
+ FILE *outfile;
+ char mefilename[256];
+ tetrahedron *tetptr;
+ triface tface, tsymface;
+ face segloop, checkmark;
+ point ptloop, p1, p2, p3, p4;
+ long ntets, faces;
+ int shift = 0;
+ int marker;
+
+ if(mfilename != (char *)NULL && mfilename[0] != '\0') {
+ strcpy(mefilename, mfilename);
+ }
+ else {
+ strcpy(mefilename, "unnamed");
+ }
+ strcat(mefilename, ".mesh");
- // Medit need start number form 1.
- if(in->firstnumber == 1){
- shift = 0;
- }
- else{
- shift = 1;
- }
+ if(!b->quiet) {
+ printf("Writing %s.\n", mefilename);
+ }
+ outfile = fopen(mefilename, "w");
+ if(outfile == (FILE *)NULL) {
+ printf("File I/O Error: Cannot create file %s.\n", mefilename);
+ return;
+ }
- // Compute the number of faces.
- ntets = tetrahedrons->items - hullsize;
+ fprintf(outfile, "MeshVersionFormatted 1\n");
+ fprintf(outfile, "\n");
+ fprintf(outfile, "Dimension\n");
+ fprintf(outfile, "3\n");
+ fprintf(outfile, "\n");
- fprintf(outfile, "\n# Set of Tetrahedra\n");
- fprintf(outfile, "Tetrahedra\n");
- fprintf(outfile, "%ld\n", ntets);
+ fprintf(outfile, "\n# Set of mesh vertices\n");
+ fprintf(outfile, "Vertices\n");
+ fprintf(outfile, "%ld\n", points->items);
- tetrahedrons->traversalinit();
- tetptr = tetrahedrontraverse();
- while (tetptr != (tetrahedron *) NULL){
- if(!b->reversetetori){
- p1 = (point) tetptr[4];
- p2 = (point) tetptr[5];
- }
- else{
- p1 = (point) tetptr[5];
- p2 = (point) tetptr[4];
+ points->traversalinit();
+ ptloop = pointtraverse();
+ // pointnumber = 1;
+ while(ptloop != (point)NULL) {
+ // Point coordinates.
+ fprintf(outfile, "%.17g %.17g %.17g", ptloop[0], ptloop[1], ptloop[2]);
+ fprintf(outfile, " 0\n");
+ // setpointmark(ptloop, pointnumber);
+ ptloop = pointtraverse();
+ // pointnumber++;
}
- p3 = (point) tetptr[6];
- p4 = (point) tetptr[7];
- fprintf(outfile, "%5d %5d %5d %5d",
- pointmark(p1)+shift, pointmark(p2)+shift,
- pointmark(p3)+shift, pointmark(p4)+shift);
- if(numelemattrib > 0){
- fprintf(outfile, " %.17g", elemattribute(tetptr, 0));
+
+ // Medit need start number form 1.
+ if(in->firstnumber == 1) {
+ shift = 0;
}
- else{
- fprintf(outfile, " 0");
+ else {
+ shift = 1;
}
- fprintf(outfile, "\n");
+
+ // Compute the number of faces.
+ ntets = tetrahedrons->items - hullsize;
+
+ fprintf(outfile, "\n# Set of Tetrahedra\n");
+ fprintf(outfile, "Tetrahedra\n");
+ fprintf(outfile, "%ld\n", ntets);
+
+ tetrahedrons->traversalinit();
tetptr = tetrahedrontraverse();
- }
+ while(tetptr != (tetrahedron *)NULL) {
+ if(!b->reversetetori) {
+ p1 = (point)tetptr[4];
+ p2 = (point)tetptr[5];
+ }
+ else {
+ p1 = (point)tetptr[5];
+ p2 = (point)tetptr[4];
+ }
+ p3 = (point)tetptr[6];
+ p4 = (point)tetptr[7];
+ fprintf(outfile, "%5d %5d %5d %5d", pointmark(p1) + shift,
+ pointmark(p2) + shift, pointmark(p3) + shift,
+ pointmark(p4) + shift);
+ if(numelemattrib > 0) {
+ fprintf(outfile, " %.17g", elemattribute(tetptr, 0));
+ }
+ else {
+ fprintf(outfile, " 0");
+ }
+ fprintf(outfile, "\n");
+ tetptr = tetrahedrontraverse();
+ }
- //faces = (ntets * 4l + hullsize) / 2l;
- faces = subfaces->items;
- face sface;
-
- fprintf(outfile, "\n# Set of Triangles\n");
- fprintf(outfile, "Triangles\n");
- fprintf(outfile, "%ld\n", faces);
-
- subfaces->traversalinit();
- sface.sh = shellfacetraverse(subfaces);
- while (sface.sh != NULL){
- p1 = sorg(sface);
- p2 = sdest(sface);
- p3 = sapex(sface);
- fprintf(outfile, "%5d %5d %5d",
- pointmark(p1)+shift, pointmark(p2)+shift, pointmark(p3)+shift);
- marker = shellmark(sface);
- fprintf(outfile, " %d\n", marker);
+ // faces = (ntets * 4l + hullsize) / 2l;
+ faces = subfaces->items;
+ face sface;
+
+ fprintf(outfile, "\n# Set of Triangles\n");
+ fprintf(outfile, "Triangles\n");
+ fprintf(outfile, "%ld\n", faces);
+
+ subfaces->traversalinit();
sface.sh = shellfacetraverse(subfaces);
- }
+ while(sface.sh != NULL) {
+ p1 = sorg(sface);
+ p2 = sdest(sface);
+ p3 = sapex(sface);
+ fprintf(outfile, "%5d %5d %5d", pointmark(p1) + shift,
+ pointmark(p2) + shift, pointmark(p3) + shift);
+ marker = shellmark(sface);
+ fprintf(outfile, " %d\n", marker);
+ sface.sh = shellfacetraverse(subfaces);
+ }
- fprintf(outfile, "\nEnd\n");
- fclose(outfile);
-}
+ fprintf(outfile, "\nEnd\n");
+ fclose(outfile);
+ }
} // end namespace
bool meshGRegionBoundaryRecovery(GRegion *gr)
{
bool ret = false;
- try{
+ try {
tetgenBR::tetgenmesh *m = new tetgenBR::tetgenmesh();
- ret = m->reconstructmesh((void*)gr);
+ ret = m->reconstructmesh((void *)gr);
delete m;
- }
- catch(int err){
- if(err == 1){
+ } catch(int err) {
+ if(err == 1) {
Msg::Error("Out of memory in boundary mesh recovery");
ret = false;
}
- else if(err == 3){
+ else if(err == 3) {
std::map<int, MVertex *> all;
- std::vector<GFace*> f = gr->faces();
- for(std::vector<GFace*>::iterator it = f.begin(); it != f.end(); ++it){
+ std::vector<GFace *> f = gr->faces();
+ for(std::vector<GFace *>::iterator it = f.begin(); it != f.end(); ++it) {
GFace *gf = *it;
- for(unsigned int i = 0; i < gf->triangles.size(); i++){
- for(int j = 0; j < 3; j++){
+ for(unsigned int i = 0; i < gf->triangles.size(); i++) {
+ for(int j = 0; j < 3; j++) {
MVertex *v = gf->triangles[i]->getVertex(j);
all[v->getIndex()] = v;
}
}
}
- std::vector<GEdge*> const& e = gr->embeddedEdges();
- for(std::vector<GEdge*>::const_iterator it = e.begin(); it != e.end(); ++it){
+ std::vector<GEdge *> const &e = gr->embeddedEdges();
+ for(std::vector<GEdge *>::const_iterator it = e.begin(); it != e.end();
+ ++it) {
GEdge *ge = *it;
- for(unsigned int i = 0; i < ge->lines.size(); i++){
- for(int j = 0; j < 2; j++){
+ for(unsigned int i = 0; i < ge->lines.size(); i++) {
+ for(int j = 0; j < 2; j++) {
MVertex *v = ge->lines[i]->getVertex(j);
all[v->getIndex()] = v;
}
}
}
- std::vector<GVertex*> const& v = gr->embeddedVertices();
- for(std::vector<GVertex*>::const_iterator it = v.begin(); it != v.end(); ++it){
+ std::vector<GVertex *> const &v = gr->embeddedVertices();
+ for(std::vector<GVertex *>::const_iterator it = v.begin(); it != v.end();
+ ++it) {
GVertex *gv = *it;
- for(unsigned int i = 0; i < gv->points.size(); i++){
+ for(unsigned int i = 0; i < gv->points.size(); i++) {
MVertex *v = gv->points[i]->getVertex(0);
all[v->getIndex()] = v;
}
}
- for(unsigned int i = 0; i < gr->mesh_vertices.size(); i++){
+ for(unsigned int i = 0; i < gr->mesh_vertices.size(); i++) {
MVertex *v = gr->mesh_vertices[i];
all[v->getIndex()] = v;
}
std::string what;
bool pnt = true;
- switch(tetgenBR::sevent.e_type){
+ switch(tetgenBR::sevent.e_type) {
case 1: what = "segment-segment intersection"; break;
case 2: what = "segment-facet intersection"; break;
case 3: what = "facet-facet intersection"; break;
- case 4: what = "overlapping segments"; pnt = false; break;
- case 5: what = "segment in facet"; pnt = false; break;
- case 6: what = "overlapping facets"; pnt = false; break;
+ case 4:
+ what = "overlapping segments";
+ pnt = false;
+ break;
+ case 5:
+ what = "segment in facet";
+ pnt = false;
+ break;
+ case 6:
+ what = "overlapping facets";
+ pnt = false;
+ break;
case 7: what = "vertex in segment"; break;
case 8: what = "vertex in facet"; break;
default: what = "unknown"; break;
}
- int vtags[2][3] = {{tetgenBR::sevent.f_vertices1[0],
- tetgenBR::sevent.f_vertices1[1],
- tetgenBR::sevent.f_vertices1[2]},
- {tetgenBR::sevent.f_vertices2[0],
- tetgenBR::sevent.f_vertices2[1],
- tetgenBR::sevent.f_vertices2[2]}};
+ int vtags[2][3] = {
+ {tetgenBR::sevent.f_vertices1[0], tetgenBR::sevent.f_vertices1[1],
+ tetgenBR::sevent.f_vertices1[2]},
+ {tetgenBR::sevent.f_vertices2[0], tetgenBR::sevent.f_vertices2[1],
+ tetgenBR::sevent.f_vertices2[2]}};
int ftags[2] = {tetgenBR::sevent.f_marker1, tetgenBR::sevent.f_marker2};
int etags[2] = {tetgenBR::sevent.s_marker1, tetgenBR::sevent.s_marker2};
std::ostringstream pb;
std::vector<double> x, y, z, val;
- for(int f = 0; f < 2; f++){
- if(ftags[f] > 0){
+ for(int f = 0; f < 2; f++) {
+ if(ftags[f] > 0) {
GFace *gf = gr->model()->getFaceByTag(ftags[f]);
- if(gf){
+ if(gf) {
gr->model()->addLastMeshEntityError(gf);
pb << " surface " << ftags[f];
}
}
- if(etags[f] > 0){
+ if(etags[f] > 0) {
GEdge *ge = gr->model()->getEdgeByTag(etags[f]);
- if(ge){
+ if(ge) {
gr->model()->addLastMeshEntityError(ge);
pb << " curve " << etags[f];
}
}
- for(int i = 0; i < 3; i++){
+ for(int i = 0; i < 3; i++) {
MVertex *v = all[vtags[f][i]];
- if(v){
+ if(v) {
gr->model()->addLastMeshVertexError(v);
x.push_back(v->x());
y.push_back(v->y());
@@ -1190,7 +1222,7 @@ bool meshGRegionBoundaryRecovery(GRegion *gr)
}
}
}
- if(pnt){
+ if(pnt) {
double px = tetgenBR::sevent.int_point[0];
double py = tetgenBR::sevent.int_point[1];
double pz = tetgenBR::sevent.int_point[2];
@@ -1200,18 +1232,18 @@ bool meshGRegionBoundaryRecovery(GRegion *gr)
z.push_back(pz);
val.push_back(3.);
}
- Msg::Error("Invalid boundary mesh (%s) on%s", what.c_str(), pb.str().c_str());
+ Msg::Error("Invalid boundary mesh (%s) on%s", what.c_str(),
+ pb.str().c_str());
#if defined(HAVE_POST)
new PView("Boundary mesh issue", x, y, z, val);
#if defined(HAVE_FLTK)
- if(FlGui::available())
- FlGui::instance()->updateViews(true, true);
+ if(FlGui::available()) FlGui::instance()->updateViews(true, true);
drawContext::global()->draw();
#endif
#endif
ret = false;
}
- else{
+ else {
Msg::Error("Could not recover boundary mesh: error %d", err);
ret = false;
}
@@ -1221,9 +1253,6 @@ bool meshGRegionBoundaryRecovery(GRegion *gr)
#else
-bool meshGRegionBoundaryRecovery(GRegion *gr)
-{
- return false;
-}
+bool meshGRegionBoundaryRecovery(GRegion *gr) { return false; }
#endif
diff --git a/Mesh/meshGRegionCarveHole.cpp b/Mesh/meshGRegionCarveHole.cpp
index 7e12e782f4885db7d6481c96e35f6c2298484d63..7b929665e3a4baf407fc052e417229cb27f11caf 100644
--- a/Mesh/meshGRegionCarveHole.cpp
+++ b/Mesh/meshGRegionCarveHole.cpp
@@ -16,7 +16,8 @@
#if !defined(HAVE_ANN)
-void carveHole(GRegion *gr, int num, double distance, std::vector<int> &surfaces)
+void carveHole(GRegion *gr, int num, double distance,
+ std::vector<int> &surfaces)
{
Msg::Error("Gmsh must be compiled with ANN support to carve holes in meshes");
}
@@ -26,38 +27,38 @@ void carveHole(GRegion *gr, int num, double distance, std::vector<int> &surfaces
#include "ANN/ANN.h"
template <class T>
-void carveHole(std::vector<T*> &elements, double distance, ANNkd_tree *kdtree)
+void carveHole(std::vector<T *> &elements, double distance, ANNkd_tree *kdtree)
{
// delete all elements that have at least one vertex closer than
// 'distance' from the carving surface vertices
ANNidxArray index = new ANNidx[1];
ANNdistArray dist = new ANNdist[1];
- std::vector<T*> temp;
- for(unsigned int i = 0; i < elements.size(); i++){
- for(std::size_t j = 0; j < elements[i]->getNumVertices(); j++){
+ std::vector<T *> temp;
+ for(unsigned int i = 0; i < elements.size(); i++) {
+ for(std::size_t j = 0; j < elements[i]->getNumVertices(); j++) {
MVertex *v = elements[i]->getVertex(j);
double xyz[3] = {v->x(), v->y(), v->z()};
kdtree->annkSearch(xyz, 1, index, dist);
double d = std::sqrt(dist[0]);
- if(d < distance){
+ if(d < distance) {
delete elements[i];
break;
}
- else if(j == elements[i]->getNumVertices() - 1){
+ else if(j == elements[i]->getNumVertices() - 1) {
temp.push_back(elements[i]);
}
}
}
elements = temp;
- delete [] index;
- delete [] dist;
+ delete[] index;
+ delete[] dist;
}
template <class T>
-void addFaces(std::vector<T*> &elements, std::set<MFace, Less_Face> &faces)
+void addFaces(std::vector<T *> &elements, std::set<MFace, Less_Face> &faces)
{
- for(unsigned int i = 0; i < elements.size(); i++){
- for(int j = 0; j < elements[i]->getNumFaces(); j++){
+ for(unsigned int i = 0; i < elements.size(); i++) {
+ for(int j = 0; j < elements[i]->getNumFaces(); j++) {
MFace f = elements[i]->getFace(j);
std::set<MFace, Less_Face>::iterator it = faces.find(f);
if(it == faces.end())
@@ -68,16 +69,18 @@ void addFaces(std::vector<T*> &elements, std::set<MFace, Less_Face> &faces)
}
}
-void carveHole(GRegion *gr, int num, double distance, std::vector<int> &surfaces)
+void carveHole(GRegion *gr, int num, double distance,
+ std::vector<int> &surfaces)
{
- Msg::Info("Carving hole %d from surface %d at distance %g", num, surfaces[0], distance);
+ Msg::Info("Carving hole %d from surface %d at distance %g", num, surfaces[0],
+ distance);
GModel *m = gr->model();
// add all points from carving surfaces into kdtree
int numnodes = 0;
- for(unsigned int i = 0; i < surfaces.size(); i++){
+ for(unsigned int i = 0; i < surfaces.size(); i++) {
GFace *gf = m->getFaceByTag(surfaces[i]);
- if(!gf){
+ if(!gf) {
Msg::Error("Unknown carving surface %d", surfaces[i]);
return;
}
@@ -86,9 +89,9 @@ void carveHole(GRegion *gr, int num, double distance, std::vector<int> &surfaces
ANNpointArray kdnodes = annAllocPts(numnodes, 3);
int k = 0;
- for(unsigned int i = 0; i < surfaces.size(); i++){
+ for(unsigned int i = 0; i < surfaces.size(); i++) {
GFace *gf = m->getFaceByTag(surfaces[i]);
- for(unsigned int j = 0; j < gf->mesh_vertices.size(); j++){
+ for(unsigned int j = 0; j < gf->mesh_vertices.size(); j++) {
kdnodes[k][0] = gf->mesh_vertices[j]->x();
kdnodes[k][1] = gf->mesh_vertices[j]->y();
kdnodes[k][2] = gf->mesh_vertices[j]->z();
@@ -115,8 +118,8 @@ void carveHole(GRegion *gr, int num, double distance, std::vector<int> &surfaces
GFace *gf = m->getFaceByTag(num);
if(!gf) return;
std::set<MFace, Less_Face> faces;
- std::vector<GFace*> f = gr->faces();
- for(std::vector<GFace*>::iterator it = f.begin(); it != f.end(); it++){
+ std::vector<GFace *> f = gr->faces();
+ for(std::vector<GFace *>::iterator it = f.begin(); it != f.end(); it++) {
addFaces((*it)->triangles, faces);
addFaces((*it)->quadrangles, faces);
}
@@ -125,18 +128,20 @@ void carveHole(GRegion *gr, int num, double distance, std::vector<int> &surfaces
addFaces(gr->prisms, faces);
addFaces(gr->pyramids, faces);
- std::set<MVertex*> verts;
- for(std::set<MFace, Less_Face>::iterator it = faces.begin(); it != faces.end(); it++){
- for(std::size_t i = 0; i < it->getNumVertices(); i++){
+ std::set<MVertex *> verts;
+ for(std::set<MFace, Less_Face>::iterator it = faces.begin();
+ it != faces.end(); it++) {
+ for(std::size_t i = 0; i < it->getNumVertices(); i++) {
it->getVertex(i)->setEntity(gf);
verts.insert(it->getVertex(i));
}
if(it->getNumVertices() == 3)
- gf->triangles.push_back(new MTriangle(it->getVertex(0), it->getVertex(1),
- it->getVertex(2)));
+ gf->triangles.push_back(
+ new MTriangle(it->getVertex(0), it->getVertex(1), it->getVertex(2)));
else if(it->getNumVertices() == 4)
- gf->quadrangles.push_back(new MQuadrangle(it->getVertex(0), it->getVertex(1),
- it->getVertex(2), it->getVertex(3)));
+ gf->quadrangles.push_back(
+ new MQuadrangle(it->getVertex(0), it->getVertex(1), it->getVertex(2),
+ it->getVertex(3)));
}
}
diff --git a/Mesh/meshGRegionDelaunayInsertion.cpp b/Mesh/meshGRegionDelaunayInsertion.cpp
index 9a70093ee0933e82fff2428251644365354bd3c0..be9a5e72bf964499f82106170e0a1ad4d80e651e 100644
--- a/Mesh/meshGRegionDelaunayInsertion.cpp
+++ b/Mesh/meshGRegionDelaunayInsertion.cpp
@@ -76,9 +76,7 @@ struct edgeContainerB {
size_t _size, _size_obj;
edgeContainerB(unsigned int N = 1000000)
- : _hash(N)
- , _size(0)
- , _size_obj(sizeof(MEdge))
+ : _hash(N), _size(0), _size_obj(sizeof(MEdge))
{
}
@@ -177,9 +175,7 @@ struct faceXtet {
MTet4 *t1;
int i1;
- faceXtet(MTet4 *_t = 0, int iFac = 0)
- : t1(_t)
- , i1(iFac)
+ faceXtet(MTet4 *_t = 0, int iFac = 0) : t1(_t), i1(iFac)
{
unsorted[0] = v[0] = t1->tet()->getVertex(faces[iFac][0]);
unsorted[1] = v[1] = t1->tet()->getVertex(faces[iFac][1]);
@@ -233,7 +229,9 @@ void connectTets_vector2_templ(size_t _size, ITER beg, ITER end,
for(ITER IT = beg; IT != end; ++IT) {
MTet4 *t = *IT;
if(!t->isDeleted()) {
- for(int j = 0; j < 4; j++) { conn.push_back(faceXtet(t, j)); }
+ for(int j = 0; j < 4; j++) {
+ conn.push_back(faceXtet(t, j));
+ }
}
}
if(!conn.size()) return;
@@ -323,7 +321,9 @@ static void removeFromCavity(std::vector<faceXtet> &shell,
if(opposite) {
for(int j = 0; j < 4; j++) {
faceXtet fxt3(opposite, j);
- if(fxt3 == fxt2) { shell.push_back(fxt3); }
+ if(fxt3 == fxt2) {
+ shell.push_back(fxt3);
+ }
}
}
}
@@ -381,7 +381,9 @@ int makeCavityStarShaped(std::vector<faceXtet> &shell,
++it) {
faceXtet &fxt = *it;
bool starShaped = fxt.visible(v);
- if(!starShaped) { wrong.push_back(fxt); }
+ if(!starShaped) {
+ wrong.push_back(fxt);
+ }
}
if(wrong.empty()) return 0;
// printf("cavity %p (shell size %d cavity size %d)is not star shaped "
@@ -419,12 +421,16 @@ void findCavity(std::vector<faceXtet> &shell, std::vector<MTet4 *> &cavity,
std::queue<MTet4 *> cavity_queue;
- if(!cavity.empty()) { cavity_queue.push(cavity.back()); }
+ if(!cavity.empty()) {
+ cavity_queue.push(cavity.back());
+ }
while(!cavity_queue.empty()) {
for(int i = 0; i < 4; i++) {
MTet4 *const neighbour = cavity_queue.front()->getNeigh(i);
- if(!neighbour) { shell.push_back(faceXtet(cavity_queue.front(), i)); }
+ if(!neighbour) {
+ shell.push_back(faceXtet(cavity_queue.front(), i));
+ }
else if(!neighbour->isDeleted()) {
if(neighbour->inCircumSphere(v) &&
(neighbour->onWhat() == cavity_queue.front()->onWhat())) {
@@ -784,7 +790,9 @@ void adaptMeshGRegion::operator()(GRegion *gr)
// add all the new tets in the container
for(unsigned int i = 0; i < newTets.size(); i++) {
- if(!newTets[i]->isDeleted()) { allTets.push_back(newTets[i]); }
+ if(!newTets[i]->isDeleted()) {
+ allTets.push_back(newTets[i]);
+ }
else {
delete newTets[i]->tet();
delete newTets[i];
@@ -975,11 +983,15 @@ void optimizeMesh(GRegion *gr, const qmTetrahedron::Measures &qm)
}
// printf("coucou\n");
- if(!newTets.size()) { break; }
+ if(!newTets.size()) {
+ break;
+ }
// add all the new tets in the container
for(unsigned int i = 0; i < newTets.size(); i++) {
- if(!newTets[i]->isDeleted()) { allTets.push_back(newTets[i]); }
+ if(!newTets[i]->isDeleted()) {
+ allTets.push_back(newTets[i]);
+ }
else {
delete newTets[i]->tet();
delete newTets[i];
diff --git a/Mesh/meshGRegionDelaunayInsertion.h b/Mesh/meshGRegionDelaunayInsertion.h
index eb2c3d7a6255230c6cebbef9020b201ce423d0b8..5a18d9d180fbaa23ad52bcf5ce81ce662e4b66e7 100644
--- a/Mesh/meshGRegionDelaunayInsertion.h
+++ b/Mesh/meshGRegionDelaunayInsertion.h
@@ -22,8 +22,8 @@ class GFace;
class GModel;
double tetcircumcenter(double a[3], double b[3], double c[3], double d[3],
- double circumcenter[3], double *xi, double *eta, double *zeta);
-
+ double circumcenter[3], double *xi, double *eta,
+ double *zeta);
class MTet4Factory;
@@ -50,20 +50,20 @@ class MTet4Factory;
// refinement.
// * ?
-class MTet4
-{
+class MTet4 {
friend class MTet4Factory;
- private:
+
+private:
bool deleted;
double circum_radius;
MTetrahedron *base;
MTet4 *neigh[4];
GRegion *gr;
- public :
+
+public:
static int radiusNorm; // 2 is euclidian norm, -1 is infinite norm
- ~MTet4(){}
- MTet4()
- : deleted(false), circum_radius(0.0), base(0), gr(0)
+ ~MTet4() {}
+ MTet4() : deleted(false), circum_radius(0.0), base(0), gr(0)
{
neigh[0] = neigh[1] = neigh[2] = neigh[3] = 0;
}
@@ -89,10 +89,11 @@ class MTet4
double B[4] = {v1->x(), v1->y(), v1->z()};
double C[4] = {v2->x(), v2->y(), v2->z()};
double D[4] = {v3->x(), v3->y(), v3->z()};
- tetcircumcenter (A,B,C,D,res,NULL,NULL,NULL);
+ tetcircumcenter(A, B, C, D, res, NULL, NULL, NULL);
}
- void setup(MTetrahedron *t, std::vector<double> &sizes, std::vector<double> &sizesBGM)
+ void setup(MTetrahedron *t, std::vector<double> &sizes,
+ std::vector<double> &sizesBGM)
{
base = t;
neigh[0] = neigh[1] = neigh[2] = neigh[3] = 0;
@@ -104,25 +105,25 @@ class MTet4
circum_radius = std::sqrt(dx * dx + dy * dy + dz * dz);
/*
if (base->getVertex(0)->getIndex() >= sizes.size() ||
- base->getVertex(1)->getIndex() >= sizes.size() ||
- base->getVertex(2)->getIndex() >= sizes.size() ||
- base->getVertex(3)->getIndex() >= sizes.size()){
+ base->getVertex(1)->getIndex() >= sizes.size() ||
+ base->getVertex(2)->getIndex() >= sizes.size() ||
+ base->getVertex(3)->getIndex() >= sizes.size()){
printf("ERROR %d vs %d %d %d %d\n",sizes.size() ,
- base->getVertex(0)->getIndex(),
- base->getVertex(1)->getIndex(),
- base->getVertex(2)->getIndex(),
- base->getVertex(3)->getIndex());
+ base->getVertex(0)->getIndex(),
+ base->getVertex(1)->getIndex(),
+ base->getVertex(2)->getIndex(),
+ base->getVertex(3)->getIndex());
}
*/
- double lc1 = 0.25*(sizes[base->getVertex(0)->getIndex()]+
- sizes[base->getVertex(1)->getIndex()]+
- sizes[base->getVertex(2)->getIndex()]+
- sizes[base->getVertex(3)->getIndex()]);
- double lcBGM = 0.25*(sizesBGM[base->getVertex(0)->getIndex()]+
- sizesBGM[base->getVertex(1)->getIndex()]+
- sizesBGM[base->getVertex(2)->getIndex()]+
- sizesBGM[base->getVertex(3)->getIndex()]);
+ double lc1 = 0.25 * (sizes[base->getVertex(0)->getIndex()] +
+ sizes[base->getVertex(1)->getIndex()] +
+ sizes[base->getVertex(2)->getIndex()] +
+ sizes[base->getVertex(3)->getIndex()]);
+ double lcBGM = 0.25 * (sizesBGM[base->getVertex(0)->getIndex()] +
+ sizesBGM[base->getVertex(1)->getIndex()] +
+ sizesBGM[base->getVertex(2)->getIndex()] +
+ sizesBGM[base->getVertex(3)->getIndex()]);
double lc = Extend2dMeshIn3dVolumes() ? std::min(lc1, lcBGM) : lcBGM;
circum_radius /= lc;
deleted = false;
@@ -142,24 +143,22 @@ class MTet4
/*
if (base->getVertex(0)->getIndex() >= sizes.size() ||
- base->getVertex(1)->getIndex() >= sizes.size() ||
- base->getVertex(2)->getIndex() >= sizes.size()){
+ base->getVertex(1)->getIndex() >= sizes.size() ||
+ base->getVertex(2)->getIndex() >= sizes.size()){
printf("ERROR %d vs %d %d %d %d\n",sizes.size() ,
- base->getVertex(0)->getIndex(),
- base->getVertex(1)->getIndex(),
- base->getVertex(2)->getIndex(),
- base->getVertex(3)->getIndex());
+ base->getVertex(0)->getIndex(),
+ base->getVertex(1)->getIndex(),
+ base->getVertex(2)->getIndex(),
+ base->getVertex(3)->getIndex());
}
*/
- double lc1 = 0.25*(sizes[base->getVertex(0)->getIndex()]+
- sizes[base->getVertex(1)->getIndex()]+
- sizes[base->getVertex(2)->getIndex()]+
- lcA);
- double lcBGM = 0.25*(sizesBGM[base->getVertex(0)->getIndex()]+
- sizesBGM[base->getVertex(1)->getIndex()]+
- sizesBGM[base->getVertex(2)->getIndex()]+
- lcB);
+ double lc1 = 0.25 * (sizes[base->getVertex(0)->getIndex()] +
+ sizes[base->getVertex(1)->getIndex()] +
+ sizes[base->getVertex(2)->getIndex()] + lcA);
+ double lcBGM = 0.25 * (sizesBGM[base->getVertex(0)->getIndex()] +
+ sizesBGM[base->getVertex(1)->getIndex()] +
+ sizesBGM[base->getVertex(2)->getIndex()] + lcB);
double lc = Extend2dMeshIn3dVolumes() ? std::min(lc1, lcBGM) : lcBGM;
circum_radius /= lc;
deleted = false;
@@ -168,13 +167,13 @@ class MTet4
GRegion *onWhat() const { return gr; }
void setOnWhat(GRegion *g) { gr = g; }
bool isDeleted() const { return deleted; }
- void forceRadius(double r){ circum_radius = r; }
+ void forceRadius(double r) { circum_radius = r; }
double getRadius() const { return circum_radius; }
double getQuality() const { return circum_radius; }
- void setQuality(const double &q){ circum_radius = q; }
+ void setQuality(const double &q) { circum_radius = q; }
MTetrahedron *tet() const { return base; }
MTetrahedron *&tet() { return base; }
- void setTet(MTetrahedron *t) { base=t; }
+ void setTet(MTetrahedron *t) { base = t; }
void setNeigh(int iN, MTet4 *n) { neigh[iN] = n; }
MTet4 *getNeigh(int iN) const { return neigh[iN]; }
int inCircumSphere(const double *p) const;
@@ -187,45 +186,39 @@ class MTet4
{
return inCircumSphere(v->x(), v->y(), v->z());
}
- double getVolume() const {
-
- double pa[3] = {base->getVertex(0)->x(),
- base->getVertex(0)->y(),
- base->getVertex(0)->z()};
- double pb[3] = {base->getVertex(1)->x(),
- base->getVertex(1)->y(),
- base->getVertex(1)->z()};
- double pc[3] = {base->getVertex(2)->x(),
- base->getVertex(2)->y(),
- base->getVertex(2)->z()};
- double pd[3] = {base->getVertex(3)->x(),
- base->getVertex(3)->y(),
- base->getVertex(3)->z()};
- return std::abs(robustPredicates::orient3d(pa, pb, pc, pd))/6.0;
- }
- void setDeleted(bool const d)
+ double getVolume() const
{
- deleted = d;
+ double pa[3] = {base->getVertex(0)->x(), base->getVertex(0)->y(),
+ base->getVertex(0)->z()};
+ double pb[3] = {base->getVertex(1)->x(), base->getVertex(1)->y(),
+ base->getVertex(1)->z()};
+ double pc[3] = {base->getVertex(2)->x(), base->getVertex(2)->y(),
+ base->getVertex(2)->z()};
+ double pd[3] = {base->getVertex(3)->x(), base->getVertex(3)->y(),
+ base->getVertex(3)->z()};
+ return std::abs(robustPredicates::orient3d(pa, pb, pc, pd)) / 6.0;
}
+ void setDeleted(bool const d) { deleted = d; }
bool assertNeigh() const
{
- if (deleted) return true;
- for (int i = 0; i < 4; i++)
- if (neigh[i] && (neigh[i]->isNeigh(this) == false)) return false;
+ if(deleted) return true;
+ for(int i = 0; i < 4; i++)
+ if(neigh[i] && (neigh[i]->isNeigh(this) == false)) return false;
return true;
}
inline bool isNeigh(const MTet4 *t) const
{
- for (int i = 0; i < 4; i++)
- if (neigh[i] == t) return true;
+ for(int i = 0; i < 4; i++)
+ if(neigh[i] == t) return true;
return false;
}
};
-void connectTets(std::list<MTet4*> &, const std::set<MFace, Less_Face> * = 0);
-void connectTets(std::vector<MTet4*> &, const std::set<MFace, Less_Face> * = 0);
+void connectTets(std::list<MTet4 *> &, const std::set<MFace, Less_Face> * = 0);
+void connectTets(std::vector<MTet4 *> &,
+ const std::set<MFace, Less_Face> * = 0);
// IN --> Vertices ---- OUT --> Tets
-void delaunayMeshIn3D(std::vector<MVertex*> &, std::vector<MTetrahedron*> &,
+void delaunayMeshIn3D(std::vector<MVertex *> &, std::vector<MTetrahedron *> &,
bool removeBox = true);
void insertVerticesInRegion(GRegion *gr, int maxVert = 2000000000,
bool _classify = true);
@@ -233,59 +226,59 @@ void bowyerWatsonFrontalLayers(GRegion *gr, bool hex);
GRegion *getRegionFromBoundingFaces(GModel *model,
std::set<GFace *> &faces_bound);
-struct compareTet4Ptr
-{
- bool operator()(MTet4 const* const a, MTet4 const* const b) const
+struct compareTet4Ptr {
+ bool operator()(MTet4 const *const a, MTet4 const *const b) const
{
- if (a->getRadius() > b->getRadius()) return true;
- if (a->getRadius() < b->getRadius()) return false;
+ if(a->getRadius() > b->getRadius()) return true;
+ if(a->getRadius() < b->getRadius()) return false;
return a->tet()->getNum() < b->tet()->getNum();
}
};
-class MTet4Factory
-{
- public:
- typedef std::set<MTet4*, compareTet4Ptr> container;
+class MTet4Factory {
+public:
+ typedef std::set<MTet4 *, compareTet4Ptr> container;
typedef container::iterator iterator;
- private:
+
+private:
container allTets;
#ifdef _GMSH_PRE_ALLOCATE_STRATEGY_
- MTet4* allSlots;
+ MTet4 *allSlots;
int s_last, s_alloc;
- std::stack<MTet4*> emptySlots;
+ std::stack<MTet4 *> emptySlots;
inline MTet4 *getANewSlot()
{
- if (s_last >= s_alloc) return 0;
- MTet4 * t = &(allSlots[s_last]);
+ if(s_last >= s_alloc) return 0;
+ MTet4 *t = &(allSlots[s_last]);
s_last++;
return t;
}
inline MTet4 *getAnEmptySlot()
{
- if(!emptySlots.empty()){
- MTet4* t = emptySlots.top();
+ if(!emptySlots.empty()) {
+ MTet4 *t = emptySlots.top();
emptySlots.pop();
return t;
}
return getANewSlot();
};
#endif
- public :
+public:
MTet4Factory(int _size = 1000000)
{
#ifdef _GMSH_PRE_ALLOCATE_STRATEGY_
- s_last = 0; s_alloc = _size;
+ s_last = 0;
+ s_alloc = _size;
allSlots = new MTet4[s_alloc];
#endif
}
~MTet4Factory()
{
#ifdef _GMSH_PRE_ALLOCATE_STRATEGY_
- delete [] allSlots;
+ delete[] allSlots;
#endif
}
- MTet4 *Create(MTetrahedron * t, std::vector<double> &sizes,
+ MTet4 *Create(MTetrahedron *t, std::vector<double> &sizes,
std::vector<double> &sizesBGM)
{
#ifdef _GMSH_PRE_ALLOCATE_STRATEGY_
@@ -296,7 +289,7 @@ class MTet4Factory
t4->setup(t, sizes, sizesBGM);
return t4;
}
- MTet4 *Create(MTetrahedron * t, std::vector<double> &sizes,
+ MTet4 *Create(MTetrahedron *t, std::vector<double> &sizes,
std::vector<double> &sizesBGM, double lc1, double lc2)
{
#ifdef _GMSH_PRE_ALLOCATE_STRATEGY_
@@ -310,7 +303,7 @@ class MTet4Factory
void Free(MTet4 *t)
{
- if (t->tet()) delete t->tet();
+ if(t->tet()) delete t->tet();
t->tet() = 0;
#ifdef _GMSH_PRE_ALLOCATE_STRATEGY_
emptySlots.push(t);
@@ -326,7 +319,7 @@ class MTet4Factory
t->forceRadius(r);
allTets.insert(t);
}
- container &getAllTets(){ return allTets; }
+ container &getAllTets() { return allTets; }
};
void optimizeMesh(GRegion *gr, const qmTetrahedron::Measures &qm);
diff --git a/Mesh/meshGRegionExtruded.cpp b/Mesh/meshGRegionExtruded.cpp
index b6842e9a979cac0ede3f6965a195a6cfa358d0eb..9a7ba49c6a309545e4bf7abab3333f9ebea4f0da 100644
--- a/Mesh/meshGRegionExtruded.cpp
+++ b/Mesh/meshGRegionExtruded.cpp
@@ -18,38 +18,38 @@
#include "GmshMessage.h"
#include "QuadTriExtruded3D.h"
-static void addTetrahedron(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
+static void addTetrahedron(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
GRegion *to)
{
to->tetrahedra.push_back(new MTetrahedron(v1, v2, v3, v4));
}
-static void addPyramid(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, GRegion *to)
+static void addPyramid(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, GRegion *to)
{
to->pyramids.push_back(new MPyramid(v1, v2, v3, v4, v5));
}
-static void addPrism(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, MVertex* v6, GRegion *to)
+static void addPrism(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, MVertex *v6, GRegion *to)
{
to->prisms.push_back(new MPrism(v1, v2, v3, v4, v5, v6));
}
-static void addHexahedron(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* v5, MVertex* v6, MVertex* v7, MVertex* v8,
+static void addHexahedron(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *v5, MVertex *v6, MVertex *v7, MVertex *v8,
GRegion *to)
{
to->hexahedra.push_back(new MHexahedron(v1, v2, v3, v4, v5, v6, v7, v8));
}
-static void createPriPyrTet(std::vector<MVertex*> &v, GRegion *to, MElement* source)
+static void createPriPyrTet(std::vector<MVertex *> &v, GRegion *to,
+ MElement *source)
{
int dup[3];
int j = 0;
for(int i = 0; i < 3; i++)
- if(v[i] == v[i + 3])
- dup[j++] = i;
+ if(v[i] == v[i + 3]) dup[j++] = i;
if(j == 2) {
if(dup[0] == 0 && dup[1] == 1)
@@ -73,13 +73,13 @@ static void createPriPyrTet(std::vector<MVertex*> &v, GRegion *to, MElement* sou
}
}
-static void createHexPri(std::vector<MVertex*> &v, GRegion *to, MElement* source)
+static void createHexPri(std::vector<MVertex *> &v, GRegion *to,
+ MElement *source)
{
int dup[4];
int j = 0;
for(int i = 0; i < 4; i++)
- if(v[i] == v[i + 4])
- dup[j++] = i;
+ if(v[i] == v[i + 4]) dup[j++] = i;
if(j == 2) {
if(dup[0] == 0 && dup[1] == 1)
@@ -95,37 +95,38 @@ static void createHexPri(std::vector<MVertex*> &v, GRegion *to, MElement* source
}
else {
addHexahedron(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], to);
- if(j) Msg::Error("Degenerated hexahedron in extrusion of volume %d", to->tag());
+ if(j)
+ Msg::Error("Degenerated hexahedron in extrusion of volume %d", to->tag());
}
}
-static void createTet(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4, GRegion *to,
- MElement* source)
+static void createTet(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ GRegion *to, MElement *source)
{
if(v1 != v2 && v1 != v3 && v1 != v4 && v2 != v3 && v2 != v4 && v3 != v4)
addTetrahedron(v1, v2, v3, v4, to);
}
static int getExtrudedVertices(MElement *ele, ExtrudeParams *ep, int j, int k,
- MVertexRTree &pos, std::vector<MVertex*> &verts)
+ MVertexRTree &pos, std::vector<MVertex *> &verts)
{
double x[8], y[8], z[8];
int n = ele->getNumVertices();
- for(int p = 0; p < n; p++){
+ for(int p = 0; p < n; p++) {
MVertex *v = ele->getVertex(p);
x[p] = x[p + n] = v->x();
y[p] = y[p + n] = v->y();
z[p] = z[p + n] = v->z();
}
- for(int p = 0; p < n; p++){
+ for(int p = 0; p < n; p++) {
ep->Extrude(j, k, x[p], y[p], z[p]);
ep->Extrude(j, k + 1, x[p + n], y[p + n], z[p + n]);
}
- for(int p = 0; p < 2 * n; p++){
+ for(int p = 0; p < 2 * n; p++) {
MVertex *tmp = pos.find(x[p], y[p], z[p]);
if(!tmp)
- Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g)",
- x[p], y[p], z[p]);
+ Msg::Error("Could not find extruded vertex (%.16g, %.16g, %.16g)", x[p],
+ y[p], z[p]);
else
verts.push_back(tmp);
}
@@ -137,18 +138,18 @@ static void extrudeMesh(GFace *from, GRegion *to, MVertexRTree &pos)
ExtrudeParams *ep = to->meshAttributes.extrude;
// interior vertices
- std::vector<MVertex*> mesh_vertices = from->mesh_vertices;
+ std::vector<MVertex *> mesh_vertices = from->mesh_vertices;
// add all embedded vertices
- std::vector<MVertex*> embedded = from->getEmbeddedMeshVertices();
+ std::vector<MVertex *> embedded = from->getEmbeddedMeshVertices();
mesh_vertices.insert(mesh_vertices.end(), embedded.begin(), embedded.end());
// add all vertices on surface seams
- std::set<MVertex*> seam;
- std::vector<GEdge*> const& l_edges = from->edges();
- for (std::vector<GEdge*>::const_iterator it = l_edges.begin();
- it != l_edges.end(); ++it){
- if ((*it)->isSeam(from)){
+ std::set<MVertex *> seam;
+ std::vector<GEdge *> const &l_edges = from->edges();
+ for(std::vector<GEdge *>::const_iterator it = l_edges.begin();
+ it != l_edges.end(); ++it) {
+ if((*it)->isSeam(from)) {
seam.insert((*it)->mesh_vertices.begin(), (*it)->mesh_vertices.end());
if((*it)->getBeginVertex())
seam.insert((*it)->getBeginVertex()->mesh_vertices.begin(),
@@ -161,13 +162,13 @@ static void extrudeMesh(GFace *from, GRegion *to, MVertexRTree &pos)
mesh_vertices.insert(mesh_vertices.end(), seam.begin(), seam.end());
// create extruded vertices
- for(unsigned int i = 0; i < mesh_vertices.size(); i++){
+ for(unsigned int i = 0; i < mesh_vertices.size(); i++) {
MVertex *v = mesh_vertices[i];
for(int j = 0; j < ep->mesh.NbLayer; j++) {
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
double x = v->x(), y = v->y(), z = v->z();
ep->Extrude(j, k + 1, x, y, z);
- if(j != ep->mesh.NbLayer - 1 || k != ep->mesh.NbElmLayer[j] - 1){
+ if(j != ep->mesh.NbLayer - 1 || k != ep->mesh.NbElmLayer[j] - 1) {
MVertex *newv = new MVertex(x, y, z, to);
to->mesh_vertices.push_back(newv);
pos.insert(newv);
@@ -176,7 +177,7 @@ static void extrudeMesh(GFace *from, GRegion *to, MVertexRTree &pos)
}
}
- if(ep && ep->mesh.ExtrudeMesh && ep->mesh.QuadToTri && ep->mesh.Recombine){
+ if(ep && ep->mesh.ExtrudeMesh && ep->mesh.QuadToTri && ep->mesh.Recombine) {
meshQuadToTriRegion(to, pos);
return;
}
@@ -184,26 +185,27 @@ static void extrudeMesh(GFace *from, GRegion *to, MVertexRTree &pos)
// create elements (note that it would be faster to access the *interior*
// nodes by direct indexing, but it's just simpler to query everything by
// position)
- for(unsigned int i = 0; i < from->triangles.size(); i++){
+ for(unsigned int i = 0; i < from->triangles.size(); i++) {
for(int j = 0; j < ep->mesh.NbLayer; j++) {
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
- std::vector<MVertex*> verts;
+ std::vector<MVertex *> verts;
if(getExtrudedVertices(from->triangles[i], ep, j, k, pos, verts) == 6) {
- createPriPyrTet(verts, to,from->triangles[i]);
+ createPriPyrTet(verts, to, from->triangles[i]);
}
}
}
}
- if(from->quadrangles.size() && !ep->mesh.Recombine){
+ if(from->quadrangles.size() && !ep->mesh.Recombine) {
Msg::Error("Cannot extrude quadrangles without Recombine");
}
- else{
- for(unsigned int i = 0; i < from->quadrangles.size(); i++){
+ else {
+ for(unsigned int i = 0; i < from->quadrangles.size(); i++) {
for(int j = 0; j < ep->mesh.NbLayer; j++) {
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
- std::vector<MVertex*> verts;
- if(getExtrudedVertices(from->quadrangles[i], ep, j, k, pos, verts) == 8)
+ std::vector<MVertex *> verts;
+ if(getExtrudedVertices(from->quadrangles[i], ep, j, k, pos, verts) ==
+ 8)
createHexPri(verts, to, from->quadrangles[i]);
}
}
@@ -214,15 +216,15 @@ static void extrudeMesh(GFace *from, GRegion *to, MVertexRTree &pos)
static void insertAllVertices(GRegion *gr, MVertexRTree &pos)
{
pos.insert(gr->mesh_vertices);
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator itf = faces.begin();
- while(itf != faces.end()){
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator itf = faces.begin();
+ while(itf != faces.end()) {
pos.insert((*itf)->mesh_vertices);
- std::vector<MVertex*> embedded = (*itf)->getEmbeddedMeshVertices();
+ std::vector<MVertex *> embedded = (*itf)->getEmbeddedMeshVertices();
pos.insert(embedded);
- std::vector<GEdge*> const& edges = (*itf)->edges();
- std::vector<GEdge*>::const_iterator ite = edges.begin();
- while(ite != edges.end()){
+ std::vector<GEdge *> const &edges = (*itf)->edges();
+ std::vector<GEdge *>::const_iterator ite = edges.begin();
+ while(ite != edges.end()) {
pos.insert((*ite)->mesh_vertices);
pos.insert((*ite)->getBeginVertex()->mesh_vertices);
pos.insert((*ite)->getEndVertex()->mesh_vertices);
@@ -232,7 +234,7 @@ static void insertAllVertices(GRegion *gr, MVertexRTree &pos)
}
}
-void meshGRegionExtruded::operator() (GRegion *gr)
+void meshGRegionExtruded::operator()(GRegion *gr)
{
gr->model()->setCurrentMeshEntity(gr);
@@ -254,7 +256,7 @@ void meshGRegionExtruded::operator() (GRegion *gr)
// volume is extruded from a surface
GFace *from = gr->model()->getFaceByTag(std::abs(ep->geo.Source));
- if(!from){
+ if(!from) {
Msg::Error("Unknown source surface %d for extrusion", ep->geo.Source);
return;
}
@@ -263,7 +265,7 @@ void meshGRegionExtruded::operator() (GRegion *gr)
// carve holes if any (only do it now if the mesh is final, i.e., if
// the mesh is recombined)
- if(ep->mesh.Holes.size() && ep->mesh.Recombine){
+ if(ep->mesh.Holes.size() && ep->mesh.Recombine) {
std::map<int, std::pair<double, std::vector<int> > >::iterator it;
for(it = ep->mesh.Holes.begin(); it != ep->mesh.Holes.end(); it++)
carveHole(gr, it->first, it->second.first, it->second.second);
@@ -271,39 +273,39 @@ void meshGRegionExtruded::operator() (GRegion *gr)
}
static int edgeExists(MVertex *v1, MVertex *v2,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
- std::pair<MVertex*, MVertex*> p(std::min(v1, v2), std::max(v1, v2));
+ std::pair<MVertex *, MVertex *> p(std::min(v1, v2), std::max(v1, v2));
return edges.count(p);
}
static void createEdge(MVertex *v1, MVertex *v2,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
- std::pair<MVertex*, MVertex*> p(std::min(v1, v2), std::max(v1, v2));
+ std::pair<MVertex *, MVertex *> p(std::min(v1, v2), std::max(v1, v2));
edges.insert(p);
}
static void deleteEdge(MVertex *v1, MVertex *v2,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
- std::pair<MVertex*, MVertex*> p(std::min(v1, v2), std::max(v1, v2));
+ std::pair<MVertex *, MVertex *> p(std::min(v1, v2), std::max(v1, v2));
edges.erase(p);
}
// subdivide the 3 lateral faces of each prism
static void phase1(GRegion *gr, MVertexRTree &pos,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
ExtrudeParams *ep = gr->meshAttributes.extrude;
GFace *from = gr->model()->getFaceByTag(std::abs(ep->geo.Source));
if(!from) return;
- for(unsigned int i = 0; i < from->triangles.size(); i++){
+ for(unsigned int i = 0; i < from->triangles.size(); i++) {
for(int j = 0; j < ep->mesh.NbLayer; j++) {
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
- std::vector<MVertex*> v;
- if(getExtrudedVertices(from->triangles[i], ep, j, k, pos, v) == 6){
+ std::vector<MVertex *> v;
+ if(getExtrudedVertices(from->triangles[i], ep, j, k, pos, v) == 6) {
#if 0 // old
if(!edgeExists(v[0], v[4], edges))
createEdge(v[1], v[3], edges);
@@ -312,12 +314,18 @@ static void phase1(GRegion *gr, MVertexRTree &pos,
if(!edgeExists(v[3], v[2], edges))
createEdge(v[0], v[5], edges);
#else // new from Michel Benhamou
- if(v[1] < v[0]) createEdge(v[1], v[3], edges);
- else createEdge(v[0], v[4], edges);
- if(v[1] < v[2]) createEdge(v[1], v[5], edges);
- else createEdge(v[4], v[2], edges);
- if(v[0] < v[2]) createEdge(v[0], v[5], edges);
- else createEdge(v[3], v[2], edges);
+ if(v[1] < v[0])
+ createEdge(v[1], v[3], edges);
+ else
+ createEdge(v[0], v[4], edges);
+ if(v[1] < v[2])
+ createEdge(v[1], v[5], edges);
+ else
+ createEdge(v[4], v[2], edges);
+ if(v[0] < v[2])
+ createEdge(v[0], v[5], edges);
+ else
+ createEdge(v[3], v[2], edges);
#endif
}
}
@@ -327,21 +335,20 @@ static void phase1(GRegion *gr, MVertexRTree &pos,
// modify lateral edges to make them "tet-compatible"
static void phase2(GRegion *gr, MVertexRTree &pos,
- std::set<std::pair<MVertex*, MVertex*> > &edges,
- std::set<std::pair<MVertex*, MVertex*> > &edges_swap,
+ std::set<std::pair<MVertex *, MVertex *> > &edges,
+ std::set<std::pair<MVertex *, MVertex *> > &edges_swap,
int &swap)
{
ExtrudeParams *ep = gr->meshAttributes.extrude;
GFace *from = gr->model()->getFaceByTag(std::abs(ep->geo.Source));
if(!from) return;
- for(unsigned int i = 0; i < from->triangles.size(); i++){
+ for(unsigned int i = 0; i < from->triangles.size(); i++) {
for(int j = 0; j < ep->mesh.NbLayer; j++) {
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
- std::vector<MVertex*> v;
- if(getExtrudedVertices(from->triangles[i], ep, j, k, pos, v) == 6){
- if(edgeExists(v[3], v[1], edges) &&
- edgeExists(v[4], v[2], edges) &&
+ std::vector<MVertex *> v;
+ if(getExtrudedVertices(from->triangles[i], ep, j, k, pos, v) == 6) {
+ if(edgeExists(v[3], v[1], edges) && edgeExists(v[4], v[2], edges) &&
edgeExists(v[0], v[5], edges)) {
swap++;
if(!edgeExists(v[3], v[1], edges_swap)) {
@@ -394,20 +401,19 @@ static void phase2(GRegion *gr, MVertexRTree &pos,
// create tets
static void phase3(GRegion *gr, MVertexRTree &pos,
- std::set<std::pair<MVertex*, MVertex*> > &edges)
+ std::set<std::pair<MVertex *, MVertex *> > &edges)
{
ExtrudeParams *ep = gr->meshAttributes.extrude;
GFace *from = gr->model()->getFaceByTag(std::abs(ep->geo.Source));
if(!from) return;
- for(unsigned int i = 0; i < from->triangles.size(); i++){
- MTriangle* tri = from->triangles[i];
+ for(unsigned int i = 0; i < from->triangles.size(); i++) {
+ MTriangle *tri = from->triangles[i];
for(int j = 0; j < ep->mesh.NbLayer; j++) {
for(int k = 0; k < ep->mesh.NbElmLayer[j]; k++) {
- std::vector<MVertex*> v;
- if(getExtrudedVertices(tri, ep, j, k, pos, v) == 6){
- if(edgeExists(v[3], v[1], edges) &&
- edgeExists(v[4], v[2], edges) &&
+ std::vector<MVertex *> v;
+ if(getExtrudedVertices(tri, ep, j, k, pos, v) == 6) {
+ if(edgeExists(v[3], v[1], edges) && edgeExists(v[4], v[2], edges) &&
edgeExists(v[3], v[2], edges)) {
createTet(v[0], v[1], v[2], v[3], gr, tri);
createTet(v[3], v[4], v[5], v[2], gr, tri);
@@ -459,18 +465,19 @@ int SubdivideExtrudedMesh(GModel *m)
// get all non-recombined extruded regions and vertices; also,
// create a vector of quadToTri regions that have NOT been meshed
// yet
- std::vector<GRegion*> regions, regions_quadToTri;
+ std::vector<GRegion *> regions, regions_quadToTri;
MVertexRTree pos(CTX::instance()->geom.tolerance * CTX::instance()->lc);
- for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); it++){
+ for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); it++) {
ExtrudeParams *ep = (*it)->meshAttributes.extrude;
if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == EXTRUDED_ENTITY &&
- !ep->mesh.Recombine){
+ !ep->mesh.Recombine) {
regions.push_back(*it);
insertAllVertices(*it, pos);
}
- // create vector of valid quadToTri regions...not all will necessarily be meshed here.
+ // create vector of valid quadToTri regions...not all will necessarily be
+ // meshed here.
if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == EXTRUDED_ENTITY &&
- ep->mesh.Recombine && ep->mesh.QuadToTri){
+ ep->mesh.Recombine && ep->mesh.QuadToTri) {
regions_quadToTri.push_back(*it);
}
}
@@ -479,13 +486,13 @@ int SubdivideExtrudedMesh(GModel *m)
Msg::Info("Subdividing extruded mesh");
// create edges on lateral sides of "prisms"
- std::set<std::pair<MVertex*, MVertex*> > edges;
+ std::set<std::pair<MVertex *, MVertex *> > edges;
for(unsigned int i = 0; i < regions.size(); i++)
phase1(regions[i], pos, edges);
// swap lateral edges to make them "tet-compatible"
int j = 0, swap;
- std::set<std::pair<MVertex*, MVertex*> > edges_swap;
+ std::set<std::pair<MVertex *, MVertex *> > edges_swap;
do {
swap = 0;
for(unsigned int i = 0; i < regions.size(); i++)
@@ -500,7 +507,7 @@ int SubdivideExtrudedMesh(GModel *m)
} while(swap);
// delete volume elements and create tetrahedra instead
- for(unsigned int i = 0; i < regions.size(); i++){
+ for(unsigned int i = 0; i < regions.size(); i++) {
GRegion *gr = regions[i];
for(unsigned int i = 0; i < gr->tetrahedra.size(); i++)
@@ -509,8 +516,7 @@ int SubdivideExtrudedMesh(GModel *m)
for(unsigned int i = 0; i < gr->hexahedra.size(); i++)
delete gr->hexahedra[i];
gr->hexahedra.clear();
- for(unsigned int i = 0; i < gr->prisms.size(); i++)
- delete gr->prisms[i];
+ for(unsigned int i = 0; i < gr->prisms.size(); i++) delete gr->prisms[i];
gr->prisms.clear();
for(unsigned int i = 0; i < gr->pyramids.size(); i++)
delete gr->pyramids[i];
@@ -518,11 +524,12 @@ int SubdivideExtrudedMesh(GModel *m)
phase3(gr, pos, edges);
// re-Extrude bounding surfaces using edges as constraint
- std::vector<GFace*> faces = gr->faces();
- for(std::vector<GFace*>::iterator it = faces.begin(); it != faces.end(); it++){
+ std::vector<GFace *> faces = gr->faces();
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) {
ExtrudeParams *ep = (*it)->meshAttributes.extrude;
if(ep && ep->mesh.ExtrudeMesh && ep->geo.Mode == EXTRUDED_ENTITY &&
- !ep->mesh.Recombine){
+ !ep->mesh.Recombine) {
GFace *gf = *it;
Msg::Info("Remeshing surface %d", gf->tag());
for(unsigned int i = 0; i < gf->triangles.size(); i++)
@@ -543,28 +550,29 @@ int SubdivideExtrudedMesh(GModel *m)
// if a lateral surface should remain static for any other reason).
// If this function detects allNonGlobalSharedLaterals, it won't
// mesh the region (should already be done in ExtrudeMesh).
- for(unsigned int i = 0; i < regions_quadToTri.size(); i++){
+ for(unsigned int i = 0; i < regions_quadToTri.size(); i++) {
GRegion *gr = regions_quadToTri[i];
- MVertexRTree pos_local(CTX::instance()->geom.tolerance * CTX::instance()->lc);
+ MVertexRTree pos_local(CTX::instance()->geom.tolerance *
+ CTX::instance()->lc);
insertAllVertices(gr, pos_local);
meshQuadToTriRegionAfterGlobalSubdivide(gr, &edges, pos_local);
}
// carve holes if any
// TODO: update extrusion information
- for(unsigned int i = 0; i < regions.size(); i++){
+ for(unsigned int i = 0; i < regions.size(); i++) {
GRegion *gr = regions[i];
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if(ep->mesh.Holes.size()){
+ if(ep->mesh.Holes.size()) {
std::map<int, std::pair<double, std::vector<int> > >::iterator it;
for(it = ep->mesh.Holes.begin(); it != ep->mesh.Holes.end(); it++)
carveHole(gr, it->first, it->second.first, it->second.second);
}
}
- for(unsigned int i = 0; i < regions_quadToTri.size(); i++){
+ for(unsigned int i = 0; i < regions_quadToTri.size(); i++) {
GRegion *gr = regions_quadToTri[i];
ExtrudeParams *ep = gr->meshAttributes.extrude;
- if(ep->mesh.Holes.size()){
+ if(ep->mesh.Holes.size()) {
std::map<int, std::pair<double, std::vector<int> > >::iterator it;
for(it = ep->mesh.Holes.begin(); it != ep->mesh.Holes.end(); it++)
carveHole(gr, it->first, it->second.first, it->second.second);
diff --git a/Mesh/meshGRegionLocalMeshMod.cpp b/Mesh/meshGRegionLocalMeshMod.cpp
index 7d1b70aadebfd58f06977dd3cbdc546d14a1c11c..dbefc64f2a6a128962eaf36acbfd80d6383c08b4 100644
--- a/Mesh/meshGRegionLocalMeshMod.cpp
+++ b/Mesh/meshGRegionLocalMeshMod.cpp
@@ -12,50 +12,51 @@
#include "MPrism.h"
#include "MPyramid.h"
-static int edges[6][2] = {{0,1},{0,2},{0,3},{1,2},{1,3},{2,3}};
-static int efaces[6][2] = {{0,2},{0,1},{1,2},{0,3},{2,3},{1,3}};
-//static int enofaces[6][2] = {{1,3},{2,3},{0,3},{1,2},{0,1},{0,2}};
-//static int facesXedges[4][3] = {{0,1,3},{1,2,5},{0,2,4},{3,4,5}};
-static int faces[4][3] = {{0,1,2},{0,2,3},{0,1,3},{1,2,3}};
-static int vnofaces[4] = {3,1,2,0};
-static int vFac[4][3] = {{0,1,2},{0,2,3},{0,1,3},{1,2,3}};
+static int edges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
+static int efaces[6][2] = {{0, 2}, {0, 1}, {1, 2}, {0, 3}, {2, 3}, {1, 3}};
+// static int enofaces[6][2] = {{1,3},{2,3},{0,3},{1,2},{0,1},{0,2}};
+// static int facesXedges[4][3] = {{0,1,3},{1,2,5},{0,2,4},{3,4,5}};
+static int faces[4][3] = {{0, 1, 2}, {0, 2, 3}, {0, 1, 3}, {1, 2, 3}};
+static int vnofaces[4] = {3, 1, 2, 0};
+static int vFac[4][3] = {{0, 1, 2}, {0, 2, 3}, {0, 1, 3}, {1, 2, 3}};
// as input, we give a tet and an edge, as return, we get
// all tets that share this edge and all vertices that are
// forming the outer ring of the cavity
// we return true if the cavity is closed and false if it is open
-void computeNeighboringTetsOfACavity(const std::vector<MTet4*> &cavity,
- std::vector<MTet4*> &outside)
+void computeNeighboringTetsOfACavity(const std::vector<MTet4 *> &cavity,
+ std::vector<MTet4 *> &outside)
{
outside.clear();
- for (unsigned int i = 0; i < cavity.size(); i++){
- for (int j = 0; j < 4; j++){
- MTet4 * neigh = cavity[i]->getNeigh(j);
- if(neigh){
+ for(unsigned int i = 0; i < cavity.size(); i++) {
+ for(int j = 0; j < 4; j++) {
+ MTet4 *neigh = cavity[i]->getNeigh(j);
+ if(neigh) {
bool found = false;
- for (unsigned int k = 0; k < outside.size(); k++){
- if(outside[k] == neigh){
+ for(unsigned int k = 0; k < outside.size(); k++) {
+ if(outside[k] == neigh) {
found = true;
break;
}
}
- if(!found){
- for (unsigned int k = 0; k < cavity.size(); k++){
- if(cavity[k] == neigh){
+ if(!found) {
+ for(unsigned int k = 0; k < cavity.size(); k++) {
+ if(cavity[k] == neigh) {
found = true;
}
}
}
- if(!found)outside.push_back(neigh);
+ if(!found) outside.push_back(neigh);
}
}
}
}
bool buildEdgeCavity(MTet4 *t, int iLocalEdge, MVertex **v1, MVertex **v2,
- std::vector<MTet4*> &cavity, std::vector<MTet4*> &outside,
- std::vector<MVertex*> &ring)
+ std::vector<MTet4 *> &cavity,
+ std::vector<MTet4 *> &outside,
+ std::vector<MVertex *> &ring)
{
cavity.clear();
ring.clear();
@@ -68,7 +69,7 @@ bool buildEdgeCavity(MTet4 *t, int iLocalEdge, MVertex **v1, MVertex **v2,
ring.push_back(lastinring);
cavity.push_back(t);
- while (1){
+ while(1) {
MVertex *ov1 = t->tet()->getVertex(edges[5 - iLocalEdge][0]);
MVertex *ov2 = t->tet()->getVertex(edges[5 - iLocalEdge][1]);
int K = ov1 == lastinring ? 1 : 0;
@@ -78,54 +79,61 @@ bool buildEdgeCavity(MTet4 *t, int iLocalEdge, MVertex **v1, MVertex **v2,
int iFace;
int iFace1 = efaces[iLocalEdge][0];
int iFace2 = efaces[iLocalEdge][1];
- if (faces[iFace1][0] == edges[5-iLocalEdge][K] ||
- faces[iFace1][1] == edges[5-iLocalEdge][K] ||
- faces[iFace1][2] == edges[5-iLocalEdge][K] ) iFace = iFace1;
- else if (faces[iFace2][0] == edges[5-iLocalEdge][K] ||
- faces[iFace2][1] == edges[5-iLocalEdge][K] ||
- faces[iFace2][2] == edges[5-iLocalEdge][K] ) iFace = iFace2;
- else { Msg::Error("Error of connexion"); return false; }
- t=t->getNeigh(iFace);
- if (!t) return false;
- if (t->isDeleted()){ Msg::Error("Weird!!"); return false; }
- if (t == cavity[0]) break;
+ if(faces[iFace1][0] == edges[5 - iLocalEdge][K] ||
+ faces[iFace1][1] == edges[5 - iLocalEdge][K] ||
+ faces[iFace1][2] == edges[5 - iLocalEdge][K])
+ iFace = iFace1;
+ else if(faces[iFace2][0] == edges[5 - iLocalEdge][K] ||
+ faces[iFace2][1] == edges[5 - iLocalEdge][K] ||
+ faces[iFace2][2] == edges[5 - iLocalEdge][K])
+ iFace = iFace2;
+ else {
+ Msg::Error("Error of connexion");
+ return false;
+ }
+ t = t->getNeigh(iFace);
+ if(!t) return false;
+ if(t->isDeleted()) {
+ Msg::Error("Weird!!");
+ return false;
+ }
+ if(t == cavity[0]) break;
ring.push_back(lastinring);
cavity.push_back(t);
iLocalEdge = -1;
- for (int i = 0; i < 6; i++){
+ for(int i = 0; i < 6; i++) {
MVertex *a = t->tet()->getVertex(edges[i][0]);
MVertex *b = t->tet()->getVertex(edges[i][1]);
- if ((a == *v1 && b == *v2) || (a == *v2 && b == *v1)){
+ if((a == *v1 && b == *v2) || (a == *v2 && b == *v1)) {
iLocalEdge = i;
break;
}
}
- if (iLocalEdge == -1){
+ if(iLocalEdge == -1) {
Msg::Error("loc = %d", iLocalEdge);
return false;
}
// FIXME when hybrid mesh, this loops for ever
- if (cavity.size() > 1000) {
+ if(cavity.size() > 1000) {
// printf("cavity size gets laaaarge\n");
return false;
}
// printf("%d %d\n",ITER++, cavity.size());
}
- computeNeighboringTetsOfACavity (cavity,outside);
+ computeNeighboringTetsOfACavity(cavity, outside);
return true;
}
-
void BuildSwapPattern3(SwapPattern *sc)
{
- static int trgl[][3] = { {0,1,2} };
- static int trgul[][5] = { {0,-1,-1,-1,-1} };
-
- sc->nbr_triangles = 1 ;
- sc->nbr_triangles_2 = 1 ;
- sc->nbr_trianguls = 1 ;
- sc->triangles = trgl ;
- sc->trianguls = trgul ;
+ static int trgl[][3] = {{0, 1, 2}};
+ static int trgul[][5] = {{0, -1, -1, -1, -1}};
+
+ sc->nbr_triangles = 1;
+ sc->nbr_triangles_2 = 1;
+ sc->nbr_trianguls = 1;
+ sc->triangles = trgl;
+ sc->trianguls = trgul;
}
/*
@@ -139,162 +147,171 @@ void BuildSwapPattern3(SwapPattern *sc)
*/
-
void BuildSwapPattern4(SwapPattern *sc)
{
- static int trgl[][3] =
- { {0,1,2}, {2,3,0}, {1,2,3}, {3,0,1} };
- static int trgul[][5] =
- { {0,1,-1,-1,-1}, {2,3,-1,-1,-1} };
-
- sc->nbr_triangles = 4 ;
- sc->nbr_triangles_2 = 2 ;
- sc->nbr_trianguls = 2 ;
- sc->triangles = trgl ;
- sc->trianguls = trgul ;
+ static int trgl[][3] = {{0, 1, 2}, {2, 3, 0}, {1, 2, 3}, {3, 0, 1}};
+ static int trgul[][5] = {{0, 1, -1, -1, -1}, {2, 3, -1, -1, -1}};
+
+ sc->nbr_triangles = 4;
+ sc->nbr_triangles_2 = 2;
+ sc->nbr_trianguls = 2;
+ sc->triangles = trgl;
+ sc->trianguls = trgul;
}
void BuildSwapPattern5(SwapPattern *sc)
{
- static int trgl[][3] =
- { {0,1,2}, {0,2,3}, {0,3,4}, {0,1,4}, {1,3,4},
- {1,2,3}, {2,3,4}, {0,2,4}, {0,1,3}, {1,2,4} };
- static int trgul[][5] =
- { {0,1,2,-1,-1}, {3,4,5,-1,-1}, {0,6,7,-1,-1}, {2,5,8,-1,-1}, {3,6,9,-1,-1} };
-
- sc->nbr_triangles = 10 ;
- sc->nbr_triangles_2 = 3 ;
- sc->nbr_trianguls = 5 ;
- sc->triangles = trgl ;
- sc->trianguls = trgul ;
+ static int trgl[][3] = {{0, 1, 2}, {0, 2, 3}, {0, 3, 4}, {0, 1, 4},
+ {1, 3, 4}, {1, 2, 3}, {2, 3, 4}, {0, 2, 4},
+ {0, 1, 3}, {1, 2, 4}};
+ static int trgul[][5] = {{0, 1, 2, -1, -1},
+ {3, 4, 5, -1, -1},
+ {0, 6, 7, -1, -1},
+ {2, 5, 8, -1, -1},
+ {3, 6, 9, -1, -1}};
+
+ sc->nbr_triangles = 10;
+ sc->nbr_triangles_2 = 3;
+ sc->nbr_trianguls = 5;
+ sc->triangles = trgl;
+ sc->trianguls = trgul;
}
void BuildSwapPattern6(SwapPattern *sc)
{
- static int trgl[][3] =
- { {0,1,2}, {0,2,3}, {0,3,4}, {0,4,5}, {0,2,5}, {2,4,5}, {2,3,4}, {0,3,5},
- {3,4,5}, {0,2,4}, {2,3,5}, {1,2,3}, {0,1,3}, {0,1,5}, {1,4,5}, {1,3,4},
- {0,1,4}, {1,3,5}, {1,2,4}, {1,2,5} };
- static int trgul[][5] =
- { {0,1,2,3,-1}, {0,4,5,6,-1}, {0,1,7,8,-1}, {0,3,6,9,-1}, {0,4,8,10,-1},
- {2,3,11,12,-1}, {11,13,14,15,-1}, {7,8,11,12,-1}, {3,11,15,16,-1},
- {8,11,13,17,-1}, {6,13,14,18,-1}, {3,6,16,18,-1}, {5,6,13,19,-1},
- {8,10,13,19,-1} };
-
- sc->nbr_triangles = 20 ;
- sc->nbr_triangles_2 = 4 ;
- sc->nbr_trianguls = 14 ;
- sc->triangles = trgl ;
- sc->trianguls = trgul ;
+ static int trgl[][3] = {
+ {0, 1, 2}, {0, 2, 3}, {0, 3, 4}, {0, 4, 5}, {0, 2, 5}, {2, 4, 5}, {2, 3, 4},
+ {0, 3, 5}, {3, 4, 5}, {0, 2, 4}, {2, 3, 5}, {1, 2, 3}, {0, 1, 3}, {0, 1, 5},
+ {1, 4, 5}, {1, 3, 4}, {0, 1, 4}, {1, 3, 5}, {1, 2, 4}, {1, 2, 5}};
+ static int trgul[][5] = {
+ {0, 1, 2, 3, -1}, {0, 4, 5, 6, -1}, {0, 1, 7, 8, -1},
+ {0, 3, 6, 9, -1}, {0, 4, 8, 10, -1}, {2, 3, 11, 12, -1},
+ {11, 13, 14, 15, -1}, {7, 8, 11, 12, -1}, {3, 11, 15, 16, -1},
+ {8, 11, 13, 17, -1}, {6, 13, 14, 18, -1}, {3, 6, 16, 18, -1},
+ {5, 6, 13, 19, -1}, {8, 10, 13, 19, -1}};
+
+ sc->nbr_triangles = 20;
+ sc->nbr_triangles_2 = 4;
+ sc->nbr_trianguls = 14;
+ sc->triangles = trgl;
+ sc->trianguls = trgul;
}
void BuildSwapPattern7(SwapPattern *sc)
{
- static int trgl[][3] =
- { {0,1,2}, {0,2,3}, {0,3,4}, {0,4,5}, {0,5,6}, {0,3,6}, {3,5,6}, {3,4,5}, {0,4,6},
- {4,5,6}, {0,3,5}, {3,4,6}, {0,2,4}, {2,3,4}, {0,2,6}, {2,5,6}, {2,4,5}, {0,2,5},
- {2,4,6}, {2,3,5}, {2,3,6}, {0,1,3}, {1,2,3}, {0,1,4}, {1,3,4}, {0,1,6}, {1,5,6},
- {1,4,5}, {0,1,5}, {1,4,6}, {1,3,5}, {1,3,6}, {1,2,4}, {1,2,5}, {1,2,6} };
- static int trgul[][5] =
- { {0,1,2,3,4}, {0,1,5,6,7}, {0,1,2,8,9}, {0,1,4,7,10}, {0,1,5,9,11}, {0,3,4,12,13},
- {0,13,14,15,16}, {0,8,9,12,13}, {0,4,13,16,17}, {0,9,13,14,18}, {0,7,14,15,19},
- {0,4,7,17,19}, {0,6,7,14,20}, {0,9,11,14,20}, {2,3,4,21,22}, {5,6,7,21,22},
- {2,8,9,21,22}, {4,7,10,21,22}, {5,9,11,21,22}, {3,4,22,23,24}, {22,24,25,26,27},
- {8,9,22,23,24}, {4,22,24,27,28}, {9,22,24,25,29}, {7,22,25,26,30}, {4,7,22,28,30},
- {6,7,22,25,31}, {9,11,22,25,31}, {3,4,13,23,32}, {13,25,26,27,32}, {8,9,13,23,32},
- {4,13,27,28,32}, {9,13,25,29,32}, {13,16,25,26,33}, {4,13,16,28,33},
- {13,15,16,25,34}, {9,13,18,25,34}, {7,19,25,26,33}, {4,7,19,28,33},
- {7,15,19,25,34}, {6,7,20,25,34}, {9,11,20,25,34} };
-
- sc->nbr_triangles = 35 ;
- sc->nbr_triangles_2 = 5 ;
- sc->nbr_trianguls = 42 ;
- sc->triangles = trgl ;
- sc->trianguls = trgul ;
+ static int trgl[][3] = {
+ {0, 1, 2}, {0, 2, 3}, {0, 3, 4}, {0, 4, 5}, {0, 5, 6}, {0, 3, 6},
+ {3, 5, 6}, {3, 4, 5}, {0, 4, 6}, {4, 5, 6}, {0, 3, 5}, {3, 4, 6},
+ {0, 2, 4}, {2, 3, 4}, {0, 2, 6}, {2, 5, 6}, {2, 4, 5}, {0, 2, 5},
+ {2, 4, 6}, {2, 3, 5}, {2, 3, 6}, {0, 1, 3}, {1, 2, 3}, {0, 1, 4},
+ {1, 3, 4}, {0, 1, 6}, {1, 5, 6}, {1, 4, 5}, {0, 1, 5}, {1, 4, 6},
+ {1, 3, 5}, {1, 3, 6}, {1, 2, 4}, {1, 2, 5}, {1, 2, 6}};
+ static int trgul[][5] = {
+ {0, 1, 2, 3, 4}, {0, 1, 5, 6, 7}, {0, 1, 2, 8, 9},
+ {0, 1, 4, 7, 10}, {0, 1, 5, 9, 11}, {0, 3, 4, 12, 13},
+ {0, 13, 14, 15, 16}, {0, 8, 9, 12, 13}, {0, 4, 13, 16, 17},
+ {0, 9, 13, 14, 18}, {0, 7, 14, 15, 19}, {0, 4, 7, 17, 19},
+ {0, 6, 7, 14, 20}, {0, 9, 11, 14, 20}, {2, 3, 4, 21, 22},
+ {5, 6, 7, 21, 22}, {2, 8, 9, 21, 22}, {4, 7, 10, 21, 22},
+ {5, 9, 11, 21, 22}, {3, 4, 22, 23, 24}, {22, 24, 25, 26, 27},
+ {8, 9, 22, 23, 24}, {4, 22, 24, 27, 28}, {9, 22, 24, 25, 29},
+ {7, 22, 25, 26, 30}, {4, 7, 22, 28, 30}, {6, 7, 22, 25, 31},
+ {9, 11, 22, 25, 31}, {3, 4, 13, 23, 32}, {13, 25, 26, 27, 32},
+ {8, 9, 13, 23, 32}, {4, 13, 27, 28, 32}, {9, 13, 25, 29, 32},
+ {13, 16, 25, 26, 33}, {4, 13, 16, 28, 33}, {13, 15, 16, 25, 34},
+ {9, 13, 18, 25, 34}, {7, 19, 25, 26, 33}, {4, 7, 19, 28, 33},
+ {7, 15, 19, 25, 34}, {6, 7, 20, 25, 34}, {9, 11, 20, 25, 34}};
+
+ sc->nbr_triangles = 35;
+ sc->nbr_triangles_2 = 5;
+ sc->nbr_trianguls = 42;
+ sc->triangles = trgl;
+ sc->trianguls = trgul;
}
-bool edgeSwap(std::vector<MTet4 *> &newTets,
- MTet4 *tet,
- int iLocalEdge,
+bool edgeSwap(std::vector<MTet4 *> &newTets, MTet4 *tet, int iLocalEdge,
const qmTetrahedron::Measures &cr,
const std::set<MFace, Less_Face> &embeddedFaces)
{
-
- //static int edges[6][2] = {{0,1},{0,2},{0,3},{1,2},{1,3},{2,3}};
- int permut[6] = {0,3,1,2,5,4};
+ // static int edges[6][2] = {{0,1},{0,2},{0,3},{1,2},{1,3},{2,3}};
+ int permut[6] = {0, 3, 1, 2, 5, 4};
iLocalEdge = permut[iLocalEdge];
- std::vector<MTet4*> cavity;
- std::vector<MTet4*> outside;
- std::vector<MVertex*> ring;
+ std::vector<MTet4 *> cavity;
+ std::vector<MTet4 *> outside;
+ std::vector<MVertex *> ring;
MVertex *v1, *v2;
// printf("a\n");
- bool closed = buildEdgeCavity(tet, iLocalEdge, &v1, &v2, cavity, outside, ring);
+ bool closed =
+ buildEdgeCavity(tet, iLocalEdge, &v1, &v2, cavity, outside, ring);
// printf("b\n");
- if (!closed) return false;
+ if(!closed) return false;
double volumeRef = 0.0;
double tetQualityRef = 1;
- for(unsigned int i = 0; i < cavity.size(); i++){
+ for(unsigned int i = 0; i < cavity.size(); i++) {
double vol = fabs(cavity[i]->tet()->getVolume());
- tetQualityRef = std::min(tetQualityRef,cavity[i]->getQuality());
+ tetQualityRef = std::min(tetQualityRef, cavity[i]->getQuality());
volumeRef += vol;
}
// build swap patterns
SwapPattern sp;
- switch (ring.size()){
- case 3 : BuildSwapPattern3(&sp); break;
- case 4 : BuildSwapPattern4(&sp); break;
- case 5 : BuildSwapPattern5(&sp); break;
- case 6 : BuildSwapPattern6(&sp); break;
- case 7 : BuildSwapPattern7(&sp); break;
- default : return false;
+ switch(ring.size()) {
+ case 3: BuildSwapPattern3(&sp); break;
+ case 4: BuildSwapPattern4(&sp); break;
+ case 5: BuildSwapPattern5(&sp); break;
+ case 6: BuildSwapPattern6(&sp); break;
+ case 7: BuildSwapPattern7(&sp); break;
+ default: return false;
}
// compute qualities of all tets that appear in the patterns
double tetQuality1[100], tetQuality2[100];
double volume1[100], volume2[100];
- for (int i = 0; i < sp.nbr_triangles; i++){
+ for(int i = 0; i < sp.nbr_triangles; i++) {
int p1 = sp.triangles[i][0];
int p2 = sp.triangles[i][1];
int p3 = sp.triangles[i][2];
- tetQuality1[i] = qmTetrahedron::qm(ring[p1], ring[p2], ring[p3], v1, cr, &(volume1[i]));
- tetQuality2[i] = qmTetrahedron::qm(ring[p1], ring[p2], ring[p3], v2, cr, &(volume2[i]));
+ tetQuality1[i] =
+ qmTetrahedron::qm(ring[p1], ring[p2], ring[p3], v1, cr, &(volume1[i]));
+ tetQuality2[i] =
+ qmTetrahedron::qm(ring[p1], ring[p2], ring[p3], v2, cr, &(volume2[i]));
}
// look for the best triangulation, i.e. the one that maximize the
// minimum element quality
double minQuality[100];
// for all triangulations
- for (int i = 0; i < sp.nbr_trianguls; i++){
+ for(int i = 0; i < sp.nbr_trianguls; i++) {
// for all triangles in a triangulation
minQuality[i] = 1;
double volume = 0;
- for (int j = 0; j < sp.nbr_triangles_2; j++){
+ for(int j = 0; j < sp.nbr_triangles_2; j++) {
int iT = sp.trianguls[i][j];
minQuality[i] = std::min(minQuality[i], tetQuality1[iT]);
minQuality[i] = std::min(minQuality[i], tetQuality2[iT]);
volume += (volume1[iT] + volume2[iT]);
}
// printf("config %3d qual %12.5E volume %12.5E\n",i,minQuality[i],volume);
- if (fabs(volume-volumeRef) > 1.e-10 * (volume+volumeRef)) minQuality[i] = -1;
+ if(fabs(volume - volumeRef) > 1.e-10 * (volume + volumeRef))
+ minQuality[i] = -1;
}
int iBest = 0;
double best = -1.0;
- for (int i = 0; i < sp.nbr_trianguls; i++){
- if(minQuality[i] > best){
+ for(int i = 0; i < sp.nbr_trianguls; i++) {
+ if(minQuality[i] > best) {
best = minQuality[i];
iBest = i;
}
}
// if there exist no swap that enhance the quality
- if (best <= tetQualityRef) return false;
+ if(best <= tetQualityRef) return false;
// does random swaps if (best < .01) return false;
// we have the best configuration, so we swap
@@ -303,7 +320,7 @@ bool edgeSwap(std::vector<MTet4 *> &newTets,
// printf("a swap with %d tets reconnect %d tets cavity %d tets\n",
// ring.size(),outside.size(),cavity.size());
- for (int j = 0; j < sp.nbr_triangles_2; j++){
+ for(int j = 0; j < sp.nbr_triangles_2; j++) {
int iT = sp.trianguls[iBest][j];
int p1 = sp.triangles[iT][0];
int p2 = sp.triangles[iT][1];
@@ -312,7 +329,7 @@ bool edgeSwap(std::vector<MTet4 *> &newTets,
MVertex *pv2 = ring[p2];
MVertex *pv3 = ring[p3];
MTetrahedron *tr1 = new MTetrahedron(pv1, pv2, pv3, v1);
- MTetrahedron *tr2 = new MTetrahedron (pv3, pv2, pv1, v2);
+ MTetrahedron *tr2 = new MTetrahedron(pv3, pv2, pv1, v2);
MTet4 *t41 = new MTet4(tr1, tetQuality1[iT]);
MTet4 *t42 = new MTet4(tr2, tetQuality2[iT]);
t41->setOnWhat(cavity[0]->onWhat());
@@ -333,15 +350,16 @@ bool edgeSwap(std::vector<MTet4 *> &newTets,
bool edgeSplit(std::vector<MTet4 *> &newTets, MTet4 *tet, MVertex *newVertex,
int iLocalEdge, const qmTetrahedron::Measures &cr)
{
- std::vector<MTet4*> cavity;
- std::vector<MTet4*> outside;
- std::vector<MVertex*> ring;
+ std::vector<MTet4 *> cavity;
+ std::vector<MTet4 *> outside;
+ std::vector<MVertex *> ring;
MVertex *v1, *v2;
- bool closed = buildEdgeCavity(tet, iLocalEdge, &v1, &v2, cavity, outside, ring);
- if (!closed) return false;
+ bool closed =
+ buildEdgeCavity(tet, iLocalEdge, &v1, &v2, cavity, outside, ring);
+ if(!closed) return false;
- for(unsigned int j = 0; j < ring.size(); j++){
+ for(unsigned int j = 0; j < ring.size(); j++) {
MVertex *pv1 = ring[j];
MVertex *pv2 = ring[(j + 1) % ring.size()];
MTetrahedron *tr1 = new MTetrahedron(pv1, pv2, newVertex, v1);
@@ -365,25 +383,26 @@ bool edgeSplit(std::vector<MTet4 *> &newTets, MTet4 *tet, MVertex *newVertex,
// swap a face i.e. remove a face shared by 2 tets
bool faceSwap(std::vector<MTet4 *> &newTets, MTet4 *t1, int iLocalFace,
- const qmTetrahedron::Measures &cr, const std::set<MFace, Less_Face> &embeddedFaces)
+ const qmTetrahedron::Measures &cr,
+ const std::set<MFace, Less_Face> &embeddedFaces)
{
MTet4 *t2 = t1->getNeigh(iLocalFace);
- if (!t2) return false;
- if (t1->onWhat() != t2->onWhat()) return false;
+ if(!t2) return false;
+ if(t1->onWhat() != t2->onWhat()) return false;
MVertex *v1 = t1->tet()->getVertex(vnofaces[iLocalFace]);
MVertex *f1 = t1->tet()->getVertex(faces[iLocalFace][0]);
MVertex *f2 = t1->tet()->getVertex(faces[iLocalFace][1]);
MVertex *f3 = t1->tet()->getVertex(faces[iLocalFace][2]);
MVertex *v2 = 0;
- for (int i = 0; i < 4; i++){
+ for(int i = 0; i < 4; i++) {
MVertex *v = t2->tet()->getVertex(i);
- if (v != f1 && v != f2 && v != f3){
+ if(v != f1 && v != f2 && v != f3) {
v2 = v;
break;
}
}
- if (!v2){
+ if(!v2) {
Msg::Warning("Impossible to swap face");
return false;
}
@@ -402,27 +421,33 @@ bool faceSwap(std::vector<MTet4 *> &newTets, MTet4 *t1, int iLocalFace,
double vol5;
double q5 = qmTetrahedron::qm(f3, f1, v1, v2, cr, &vol5);
+ if(fabs(vol1 + vol2 - vol3 - vol4 - vol5) > 1.e-10 * (vol1 + vol2))
+ return false;
+ if(std::min(q1, q2) > std::min(std::min(q3, q4), q5)) return false;
+ // printf("%g %g %g\n",vol1 + vol2, vol3 + vol4 + vol5,vol1 + vol2 - vol3 -
+ // vol4 - vol5); printf("qs = %g %g vs %g %g %g\n",q1,q2,q3,q4,q5);
- if (fabs(vol1 + vol2 - vol3 - vol4 - vol5) > 1.e-10 * (vol1 + vol2)) return false;
- if (std::min(q1, q2) > std::min(std::min(q3, q4), q5)) return false;
- // printf("%g %g %g\n",vol1 + vol2, vol3 + vol4 + vol5,vol1 + vol2 - vol3 - vol4 - vol5);
- // printf("qs = %g %g vs %g %g %g\n",q1,q2,q3,q4,q5);
-
- std::vector<MTet4*> outside;
- for(int i = 0; i < 4; i++){
- if(t1->getNeigh(i) && t1->getNeigh(i) != t2){
+ std::vector<MTet4 *> outside;
+ for(int i = 0; i < 4; i++) {
+ if(t1->getNeigh(i) && t1->getNeigh(i) != t2) {
bool found = false;
- for(unsigned int j = 0; j < outside.size(); j++){
- if(outside[j] == t1->getNeigh(i)) { found = true; break; }
+ for(unsigned int j = 0; j < outside.size(); j++) {
+ if(outside[j] == t1->getNeigh(i)) {
+ found = true;
+ break;
+ }
}
if(!found) outside.push_back(t1->getNeigh(i));
}
}
- for(int i = 0; i < 4; i++){
- if(t2->getNeigh(i) && t2->getNeigh(i) != t1){
+ for(int i = 0; i < 4; i++) {
+ if(t2->getNeigh(i) && t2->getNeigh(i) != t1) {
bool found = false;
- for(unsigned int j = 0; j < outside.size(); j++){
- if(outside[j] == t2->getNeigh(i)) { found = true; break; }
+ for(unsigned int j = 0; j < outside.size(); j++) {
+ if(outside[j] == t2->getNeigh(i)) {
+ found = true;
+ break;
+ }
}
if(!found) outside.push_back(t2->getNeigh(i));
}
@@ -452,35 +477,35 @@ bool faceSwap(std::vector<MTet4 *> &newTets, MTet4 *t1, int iLocalFace,
return true;
}
-void buildVertexCavity_recur(MTet4 *t, MVertex *v, std::vector<MTet4*> &cavity)
+void buildVertexCavity_recur(MTet4 *t, MVertex *v, std::vector<MTet4 *> &cavity)
{
// if (recur > 20)printf("oufti %d\n",recur);
- if(t->isDeleted()){
+ if(t->isDeleted()) {
Msg::Fatal("a deleted triangle is a neighbor of a non deleted triangle");
}
int iV = -1;
- for (int i = 0; i < 4; i++){
- if (t->tet()->getVertex(i) == v){
+ for(int i = 0; i < 4; i++) {
+ if(t->tet()->getVertex(i) == v) {
iV = i;
break;
}
}
- if (iV == -1){
+ if(iV == -1) {
Msg::Error("Trying to build a cavity of tets for a vertex that does not "
"belong to this tet");
return;
}
- for (int i = 0; i < 3; i++){
+ for(int i = 0; i < 3; i++) {
MTet4 *neigh = t->getNeigh(vFac[iV][i]);
- if (neigh){
+ if(neigh) {
bool found = false;
- for(unsigned int j = 0; j < cavity.size(); j++){
- if(cavity[j] == neigh){
+ for(unsigned int j = 0; j < cavity.size(); j++) {
+ if(cavity[j] == neigh) {
found = true;
j = cavity.size();
}
}
- if(!found){
+ if(!found) {
cavity.push_back(neigh);
buildVertexCavity_recur(neigh, v, cavity);
}
@@ -493,15 +518,11 @@ void buildVertexCavity_recur(MTet4 *t, MVertex *v, std::vector<MTet4*> &cavity)
// another one (of course, not the other one on the unswappable edge)
// after that crap, the sliver is trashed
-bool collapseVertex(std::vector<MTet4 *> &newTets,
- MTet4 *t,
- int iVertex,
- int iTarget,
- const qmTetrahedron::Measures &cr,
- const localMeshModAction action,
- double *minQual)
+bool collapseVertex(std::vector<MTet4 *> &newTets, MTet4 *t, int iVertex,
+ int iTarget, const qmTetrahedron::Measures &cr,
+ const localMeshModAction action, double *minQual)
{
- if(t->isDeleted()){
+ if(t->isDeleted()) {
Msg::Warning("Impossible to collapse vertex");
return false;
}
@@ -512,25 +533,27 @@ bool collapseVertex(std::vector<MTet4 *> &newTets,
if(v->onWhat()->dim() < 3) return false;
if(tg->onWhat()->dim() < 3) return false;
- std::vector<MTet4*> cavity_v;
- std::vector<MTet4*> outside;
+ std::vector<MTet4 *> cavity_v;
+ std::vector<MTet4 *> outside;
cavity_v.push_back(t);
buildVertexCavity_recur(t, v, cavity_v);
- std::vector<MTet4*> toDelete;
- std::vector<MTet4*> toUpdate;
+ std::vector<MTet4 *> toDelete;
+ std::vector<MTet4 *> toUpdate;
double volume = 0;
double worst = 1.0;
- for(unsigned int i = 0; i < cavity_v.size(); i++){
+ for(unsigned int i = 0; i < cavity_v.size(); i++) {
bool found = false;
volume += fabs(cavity_v[i]->tet()->getVolume());
double q = cavity_v[i]->getQuality();
- worst = std::min(worst,q);
- for (int j = 0; j < 4; j++){
- if (cavity_v[i]->tet()->getVertex(j) == tg)found=true;
+ worst = std::min(worst, q);
+ for(int j = 0; j < 4; j++) {
+ if(cavity_v[i]->tet()->getVertex(j) == tg) found = true;
}
- if (found) toDelete.push_back(cavity_v[i]);
- else toUpdate.push_back(cavity_v[i]);
+ if(found)
+ toDelete.push_back(cavity_v[i]);
+ else
+ toUpdate.push_back(cavity_v[i]);
}
double x = v->x();
@@ -544,9 +567,9 @@ bool collapseVertex(std::vector<MTet4 *> &newTets,
double worstAfter = 1.0;
std::vector<double> newQuals(toUpdate.size());
- for (unsigned int i = 0; i < toUpdate.size(); i++){
+ for(unsigned int i = 0; i < toUpdate.size(); i++) {
double vv;
- newQuals[i] = qmTetrahedron::qm(toUpdate[i]->tet(),cr,&vv);
+ newQuals[i] = qmTetrahedron::qm(toUpdate[i]->tet(), cr, &vv);
worstAfter = std::min(worstAfter, newQuals[i]);
volume_update += vv;
}
@@ -554,31 +577,36 @@ bool collapseVertex(std::vector<MTet4 *> &newTets,
// printf("%12.5E %12.5E %12.5E %12.5E %d\n",
// volume,volume_update,worstAfter,worst,toUpdate.size());
- if (fabs(volume-volume_update) > 1.e-10 * volume || worstAfter < worst){
+ if(fabs(volume - volume_update) > 1.e-10 * volume || worstAfter < worst) {
v->x() = x;
v->y() = y;
v->z() = z;
return false;
}
- if (action == GMSH_EVALONLY){
+ if(action == GMSH_EVALONLY) {
*minQual = worstAfter;
return true;
}
// ok we collapse
computeNeighboringTetsOfACavity(cavity_v, outside);
- for (unsigned int i = 0; i < toUpdate.size(); i++){
- MTetrahedron *tr1 = new MTetrahedron
- (toUpdate[i]->tet()->getVertex(0) == v ? tg : toUpdate[i]->tet()->getVertex(0),
- toUpdate[i]->tet()->getVertex(1) == v ? tg : toUpdate[i]->tet()->getVertex(1),
- toUpdate[i]->tet()->getVertex(2) == v ? tg : toUpdate[i]->tet()->getVertex(2),
- toUpdate[i]->tet()->getVertex(3) == v ? tg : toUpdate[i]->tet()->getVertex(3));
+ for(unsigned int i = 0; i < toUpdate.size(); i++) {
+ MTetrahedron *tr1 = new MTetrahedron(
+ toUpdate[i]->tet()->getVertex(0) == v ? tg :
+ toUpdate[i]->tet()->getVertex(0),
+ toUpdate[i]->tet()->getVertex(1) == v ? tg :
+ toUpdate[i]->tet()->getVertex(1),
+ toUpdate[i]->tet()->getVertex(2) == v ? tg :
+ toUpdate[i]->tet()->getVertex(2),
+ toUpdate[i]->tet()->getVertex(3) == v ? tg :
+ toUpdate[i]->tet()->getVertex(3));
MTet4 *t41 = new MTet4(tr1, cr);
t41->setOnWhat(cavity_v[0]->onWhat());
t41->setQuality(newQuals[i]);
outside.push_back(t41);
newTets.push_back(t41);
}
- for(unsigned int i = 0; i < cavity_v.size(); i++) cavity_v[i]->setDeleted(true);
+ for(unsigned int i = 0; i < cavity_v.size(); i++)
+ cavity_v[i]->setDeleted(true);
connectTets(outside);
@@ -587,13 +615,13 @@ bool collapseVertex(std::vector<MTet4 *> &newTets,
bool smoothVertex(MTet4 *t, int iVertex, const qmTetrahedron::Measures &cr)
{
- if(t->isDeleted()){
+ if(t->isDeleted()) {
Msg::Warning("Impossible to collapse vertex");
return false;
}
if(t->tet()->getVertex(iVertex)->onWhat()->dim() < 3) return false;
- std::vector<MTet4*> cavity;
+ std::vector<MTet4 *> cavity;
cavity.push_back(t);
buildVertexCavity_recur(t, t->tet()->getVertex(iVertex), cavity);
@@ -601,22 +629,28 @@ bool smoothVertex(MTet4 *t, int iVertex, const qmTetrahedron::Measures &cr)
double vTot = 0;
double worst = 1.0;
- for(unsigned int i = 0 ; i < cavity.size(); i++){
+ for(unsigned int i = 0; i < cavity.size(); i++) {
double volume = fabs(cavity[i]->tet()->getVolume());
double q = cavity[i]->getQuality();
- worst = std::min(worst,q);
- xcg += 0.25 * (cavity[i]->tet()->getVertex(0)->x() +
- cavity[i]->tet()->getVertex(1)->x() +
- cavity[i]->tet()->getVertex(2)->x() +
- cavity[i]->tet()->getVertex(3)->x()) * volume;
- ycg += 0.25 * (cavity[i]->tet()->getVertex(0)->y() +
- cavity[i]->tet()->getVertex(1)->y() +
- cavity[i]->tet()->getVertex(2)->y() +
- cavity[i]->tet()->getVertex(3)->y()) * volume;
- zcg += 0.25 * (cavity[i]->tet()->getVertex(0)->z() +
- cavity[i]->tet()->getVertex(1)->z() +
- cavity[i]->tet()->getVertex(2)->z() +
- cavity[i]->tet()->getVertex(3)->z()) * volume;
+ worst = std::min(worst, q);
+ xcg += 0.25 *
+ (cavity[i]->tet()->getVertex(0)->x() +
+ cavity[i]->tet()->getVertex(1)->x() +
+ cavity[i]->tet()->getVertex(2)->x() +
+ cavity[i]->tet()->getVertex(3)->x()) *
+ volume;
+ ycg += 0.25 *
+ (cavity[i]->tet()->getVertex(0)->y() +
+ cavity[i]->tet()->getVertex(1)->y() +
+ cavity[i]->tet()->getVertex(2)->y() +
+ cavity[i]->tet()->getVertex(3)->y()) *
+ volume;
+ zcg += 0.25 *
+ (cavity[i]->tet()->getVertex(0)->z() +
+ cavity[i]->tet()->getVertex(1)->z() +
+ cavity[i]->tet()->getVertex(2)->z() +
+ cavity[i]->tet()->getVertex(3)->z()) *
+ volume;
vTot += volume;
}
xcg /= (vTot);
@@ -633,36 +667,36 @@ bool smoothVertex(MTet4 *t, int iVertex, const qmTetrahedron::Measures &cr)
t->tet()->getVertex(iVertex)->z() = zcg;
double worstAfter = 1.0;
std::vector<double> newQuals(cavity.size());
- for (unsigned int i = 0; i < cavity.size(); i++){
+ for(unsigned int i = 0; i < cavity.size(); i++) {
double volume;
- newQuals[i] = qmTetrahedron::qm(cavity[i]->tet(),cr,&volume);
+ newQuals[i] = qmTetrahedron::qm(cavity[i]->tet(), cr, &volume);
volumeAfter += volume;
- worstAfter = std::min(worstAfter,newQuals[i]);
+ worstAfter = std::min(worstAfter, newQuals[i]);
}
- if (fabs(volumeAfter-vTot) > 1.e-10 * vTot || worstAfter < worst){
+ if(fabs(volumeAfter - vTot) > 1.e-10 * vTot || worstAfter < worst) {
t->tet()->getVertex(iVertex)->x() = x;
t->tet()->getVertex(iVertex)->y() = y;
t->tet()->getVertex(iVertex)->z() = z;
return false; // smoothVertexOptimize(t, iVertex, cr);
}
- else{
+ else {
// restore new quality
- for(unsigned int i = 0; i < cavity.size(); i++){
+ for(unsigned int i = 0; i < cavity.size(); i++) {
cavity[i]->setQuality(newQuals[i]);
}
return true;
}
}
-struct smoothVertexData3D{
+struct smoothVertexData3D {
MVertex *v;
std::vector<MTet4 *> ts;
double LC;
};
-double smoothing_objective_function_3D(double X, double Y, double Z,
- MVertex *v, std::vector<MTet4 *> &ts)
+double smoothing_objective_function_3D(double X, double Y, double Z, MVertex *v,
+ std::vector<MTet4 *> &ts)
{
const double oldX = v->x();
const double oldY = v->y();
@@ -671,11 +705,12 @@ double smoothing_objective_function_3D(double X, double Y, double Z,
v->y() = Y;
v->z() = Z;
- std::vector < MTet4 * >::iterator it = ts.begin();
- std::vector < MTet4 * >::iterator ite = ts.end();
+ std::vector<MTet4 *>::iterator it = ts.begin();
+ std::vector<MTet4 *>::iterator ite = ts.end();
double qMin = 1, vol;
- while(it != ite){
- qMin = std::min(qmTetrahedron::qm((*it)->tet(), qmTetrahedron::QMTET_GAMMA, &vol), qMin);
+ while(it != ite) {
+ qMin = std::min(
+ qmTetrahedron::qm((*it)->tet(), qmTetrahedron::QMTET_GAMMA, &vol), qMin);
++it;
}
v->x() = oldX;
@@ -684,20 +719,20 @@ double smoothing_objective_function_3D(double X, double Y, double Z,
return -qMin;
}
-void deriv_smoothing_objective_function_3D(double *XYZ, double *dF,
- double &F, void *data)
+void deriv_smoothing_objective_function_3D(double *XYZ, double *dF, double &F,
+ void *data)
{
- smoothVertexData3D *svd = (smoothVertexData3D*)data;
+ smoothVertexData3D *svd = (smoothVertexData3D *)data;
MVertex *v = svd->v;
const double LARGE = svd->LC * 1.e5;
const double SMALL = 1. / LARGE;
F = smoothing_objective_function_3D(XYZ[0], XYZ[1], XYZ[2], v, svd->ts);
- double F_X = smoothing_objective_function_3D
- (XYZ[0] + SMALL, XYZ[1], XYZ[2], v, svd->ts);
- double F_Y = smoothing_objective_function_3D
- (XYZ[0], XYZ[1] + SMALL, XYZ[2], v, svd->ts);
- double F_Z = smoothing_objective_function_3D
- (XYZ[0], XYZ[1], XYZ[2] + SMALL, v, svd->ts);
+ double F_X =
+ smoothing_objective_function_3D(XYZ[0] + SMALL, XYZ[1], XYZ[2], v, svd->ts);
+ double F_Y =
+ smoothing_objective_function_3D(XYZ[0], XYZ[1] + SMALL, XYZ[2], v, svd->ts);
+ double F_Z =
+ smoothing_objective_function_3D(XYZ[0], XYZ[1], XYZ[2] + SMALL, v, svd->ts);
dF[0] = (F_X - F) * LARGE;
dF[1] = (F_Y - F) * LARGE;
dF[2] = (F_Z - F) * LARGE;
@@ -705,11 +740,13 @@ void deriv_smoothing_objective_function_3D(double *XYZ, double *dF,
double smooth_obj_3D(double *XYZ, void *data)
{
- smoothVertexData3D *svd = (smoothVertexData3D*)data;
- return smoothing_objective_function_3D(XYZ[0], XYZ[1], XYZ[2], svd->v, svd->ts);
+ smoothVertexData3D *svd = (smoothVertexData3D *)data;
+ return smoothing_objective_function_3D(XYZ[0], XYZ[1], XYZ[2], svd->v,
+ svd->ts);
}
-bool smoothVertexOptimize(MTet4 *t, int iVertex, const qmTetrahedron::Measures &cr)
+bool smoothVertexOptimize(MTet4 *t, int iVertex,
+ const qmTetrahedron::Measures &cr)
{
if(t->tet()->getVertex(iVertex)->onWhat()->dim() < 3) return false;
@@ -721,14 +758,14 @@ bool smoothVertexOptimize(MTet4 *t, int iVertex, const qmTetrahedron::Measures &
double xyzopti[3] = {vd.v->x(), vd.v->y(), vd.v->z()};
- //double val = 0.;
+ // double val = 0.;
Msg::Error("Fletcher-Reeves minimizer routine must be reimplemented");
- //minimize_N(3, smooth_obj_3D, deriv_smoothing_objective_function_3D, &vd, 4,
+ // minimize_N(3, smooth_obj_3D, deriv_smoothing_objective_function_3D, &vd, 4,
// xyzopti, val);
double vTot = 0;
- for(unsigned int i = 0; i < vd.ts.size(); i++){
+ for(unsigned int i = 0; i < vd.ts.size(); i++) {
double volume = fabs(vd.ts[i]->tet()->getVolume());
vTot += volume;
}
@@ -744,21 +781,21 @@ bool smoothVertexOptimize(MTet4 *t, int iVertex, const qmTetrahedron::Measures &
t->tet()->getVertex(iVertex)->z() = xyzopti[2];
std::vector<double> newQuals(vd.ts.size());
- for(unsigned int i = 0; i < vd.ts.size(); i++){
+ for(unsigned int i = 0; i < vd.ts.size(); i++) {
double volume;
newQuals[i] = qmTetrahedron::qm(vd.ts[i]->tet(), cr, &volume);
volumeAfter += volume;
}
- if(fabs(volumeAfter-vTot) > 1.e-10 * vTot){
+ if(fabs(volumeAfter - vTot) > 1.e-10 * vTot) {
t->tet()->getVertex(iVertex)->x() = x;
t->tet()->getVertex(iVertex)->y() = y;
t->tet()->getVertex(iVertex)->z() = z;
return false;
}
- else{
+ else {
// restore new quality
- for(unsigned int i = 0; i < vd.ts.size(); i++){
+ for(unsigned int i = 0; i < vd.ts.size(); i++) {
vd.ts[i]->setQuality(newQuals[i]);
}
return true;
diff --git a/Mesh/meshGRegionLocalMeshMod.h b/Mesh/meshGRegionLocalMeshMod.h
index 8c27426f6383303a039ca802a3467c8482eaea85..ed3440c2d454271327d89a9cd967c983bb70abc0 100644
--- a/Mesh/meshGRegionLocalMeshMod.h
+++ b/Mesh/meshGRegionLocalMeshMod.h
@@ -13,16 +13,16 @@
// the "bulk" of the mesh and cannot be applied to boudnaries. I'm
// working on it
-enum localMeshModAction {GMSH_DOIT, GMSH_EVALONLY};
+enum localMeshModAction { GMSH_DOIT, GMSH_EVALONLY };
-void LaplaceSmoothing (GRegion *gr);
+void LaplaceSmoothing(GRegion *gr);
-bool edgeSwap(std::vector<MTet4*> &newTets, MTet4 *tet,
- int iLocalEdge, const qmTetrahedron::Measures &cr,
+bool edgeSwap(std::vector<MTet4 *> &newTets, MTet4 *tet, int iLocalEdge,
+ const qmTetrahedron::Measures &cr,
const std::set<MFace, Less_Face> &embeddedFaces);
-bool faceSwap(std::vector<MTet4*> &newTets, MTet4 *tet,
- int iLocalFace, const qmTetrahedron::Measures &cr,
+bool faceSwap(std::vector<MTet4 *> &newTets, MTet4 *tet, int iLocalFace,
+ const qmTetrahedron::Measures &cr,
const std::set<MFace, Less_Face> &embeddedFaces);
bool smoothVertex(MTet4 *t, int iLocalVertex,
@@ -31,23 +31,20 @@ bool smoothVertex(MTet4 *t, int iLocalVertex,
bool smoothVertexOptimize(MTet4 *t, int iVertex,
const qmTetrahedron::Measures &cr);
-bool collapseVertex(std::vector<MTet4*> &newTets, MTet4 *t,
- int iVertex, int iTarget,
- const qmTetrahedron::Measures &cr,
- const localMeshModAction = GMSH_DOIT,
- double *result = 0);
+bool collapseVertex(std::vector<MTet4 *> &newTets, MTet4 *t, int iVertex,
+ int iTarget, const qmTetrahedron::Measures &cr,
+ const localMeshModAction = GMSH_DOIT, double *result = 0);
-bool egeSplit(std::vector<MTet4*> &newTets, MTet4 *tet,
- MVertex *newVertex, int iLocalEdge,
- const qmTetrahedron::Measures &cr);
+bool egeSplit(std::vector<MTet4 *> &newTets, MTet4 *tet, MVertex *newVertex,
+ int iLocalEdge, const qmTetrahedron::Measures &cr);
typedef struct {
- int nbr_triangles ; /* number of different triangles */
- int (*triangles)[3] ; /* triangles array */
- int nbr_trianguls ; /* number of different triangulations */
- int nbr_triangles_2 ; /* number of triangles / triangulation */
- int (*trianguls)[5] ; /* retriangulations array */
-} SwapPattern ;
+ int nbr_triangles; /* number of different triangles */
+ int (*triangles)[3]; /* triangles array */
+ int nbr_trianguls; /* number of different triangulations */
+ int nbr_triangles_2; /* number of triangles / triangulation */
+ int (*trianguls)[5]; /* retriangulations array */
+} SwapPattern;
void BuildSwapPattern3(SwapPattern *sc);
void BuildSwapPattern4(SwapPattern *sc);
@@ -55,5 +52,4 @@ void BuildSwapPattern5(SwapPattern *sc);
void BuildSwapPattern6(SwapPattern *sc);
void BuildSwapPattern7(SwapPattern *sc);
-
#endif
diff --git a/Mesh/meshGRegionMMG3D.cpp b/Mesh/meshGRegionMMG3D.cpp
index 9cfd6e76b8381b4476600f26b8fb324b348a5b16..6b8e5d50737e50afb17fed442443cc8e7c465d71 100644
--- a/Mesh/meshGRegionMMG3D.cpp
+++ b/Mesh/meshGRegionMMG3D.cpp
@@ -20,46 +20,51 @@
extern "C" {
#include <libmmg3d.h>
-#define M_UNUSED (1 << 0)
+#define M_UNUSED (1 << 0)
}
-static void MMG2gmsh(GRegion *gr, MMG_pMesh mmg, std::map<int,MVertex*> &mmg2gmsh)
+static void MMG2gmsh(GRegion *gr, MMG_pMesh mmg,
+ std::map<int, MVertex *> &mmg2gmsh)
{
- std::map<int,MVertex*> kToMVertex;
- for (int k=1;k<= mmg->np ; k++){
+ std::map<int, MVertex *> kToMVertex;
+ for(int k = 1; k <= mmg->np; k++) {
MMG_pPoint ppt = &mmg->point[k];
- if (ppt->tag & M_UNUSED) continue;
- std::map<int,MVertex*>::iterator it = mmg2gmsh.find(ppt->ref);
- if (it == mmg2gmsh.end()){
- MVertex *v = new MVertex(ppt->c[0],ppt->c[1],ppt->c[2],gr);
+ if(ppt->tag & M_UNUSED) continue;
+ std::map<int, MVertex *>::iterator it = mmg2gmsh.find(ppt->ref);
+ if(it == mmg2gmsh.end()) {
+ MVertex *v = new MVertex(ppt->c[0], ppt->c[1], ppt->c[2], gr);
gr->mesh_vertices.push_back(v);
kToMVertex[k] = v;
}
- else kToMVertex[k] = it->second;
+ else
+ kToMVertex[k] = it->second;
}
- for (int k=1; k<=mmg->ne; k++) {
+ for(int k = 1; k <= mmg->ne; k++) {
MMG_pTetra ptetra = &mmg->tetra[k];
- if ( ptetra->v[0] ){
+ if(ptetra->v[0]) {
MVertex *v1 = kToMVertex[ptetra->v[0]];
MVertex *v2 = kToMVertex[ptetra->v[1]];
MVertex *v3 = kToMVertex[ptetra->v[2]];
MVertex *v4 = kToMVertex[ptetra->v[3]];
- if (!v1 || !v2 || !v3 || !v4){
- Msg::Error("Element %d Unknown Vertex in MMG2gmsh %d(%p) %d(%p) %d(%p) %d(%p)",
- k,ptetra->v[0],v1,ptetra->v[1],v2,ptetra->v[2],v3,ptetra->v[3],v4);
+ if(!v1 || !v2 || !v3 || !v4) {
+ Msg::Error(
+ "Element %d Unknown Vertex in MMG2gmsh %d(%p) %d(%p) %d(%p) %d(%p)",
+ k, ptetra->v[0], v1, ptetra->v[1], v2, ptetra->v[2], v3, ptetra->v[3],
+ v4);
}
- else gr->tetrahedra.push_back(new MTetrahedron(v1,v2,v3,v4));
+ else
+ gr->tetrahedra.push_back(new MTetrahedron(v1, v2, v3, v4));
}
}
}
static void gmsh2MMG(GRegion *gr, MMG_pMesh mmg, MMG_pSol sol,
- std::map<int,MVertex*> &mmg2gmsh)
+ std::map<int, MVertex *> &mmg2gmsh)
{
mmg->ne = gr->tetrahedra.size();
- std::set<MVertex*> allVertices;
- for (unsigned int i = 0; i < gr->tetrahedra.size(); i++){
+ std::set<MVertex *> allVertices;
+ for(unsigned int i = 0; i < gr->tetrahedra.size(); i++) {
allVertices.insert(gr->tetrahedra[i]->getVertex(0));
allVertices.insert(gr->tetrahedra[i]->getVertex(1));
allVertices.insert(gr->tetrahedra[i]->getVertex(2));
@@ -67,11 +72,11 @@ static void gmsh2MMG(GRegion *gr, MMG_pMesh mmg, MMG_pSol sol,
}
mmg->np = sol->np = allVertices.size();
- std::vector<GFace*> f = gr->faces();
+ std::vector<GFace *> f = gr->faces();
// TODO C++11 std::accumulate
mmg->nt = 0;
- for (std::vector<GFace*>::iterator it = f.begin(); it != f.end() ; ++it){
+ for(std::vector<GFace *>::iterator it = f.begin(); it != f.end(); ++it) {
mmg->nt += (*it)->triangles.size();
}
@@ -79,227 +84,233 @@ static void gmsh2MMG(GRegion *gr, MMG_pMesh mmg, MMG_pSol sol,
mmg->ntmax = 700000;
mmg->nemax = 7000000;
- mmg->point = (MMG_pPoint)calloc(mmg->npmax+1,sizeof(MMG_Point));
- mmg->tetra = (MMG_pTetra)calloc(mmg->nemax+1,sizeof(MMG_Tetra));
- mmg->tria = (MMG_pTria) calloc(mmg->ntmax+1,sizeof(MMG_Tria));
- //mmg->disp = (MMG_pDispl)calloc(mmg->npmax+1,sizeof(MMG_Displ));
- mmg->adja = (int*)calloc(4*mmg->nemax+5,sizeof(int));
+ mmg->point = (MMG_pPoint)calloc(mmg->npmax + 1, sizeof(MMG_Point));
+ mmg->tetra = (MMG_pTetra)calloc(mmg->nemax + 1, sizeof(MMG_Tetra));
+ mmg->tria = (MMG_pTria)calloc(mmg->ntmax + 1, sizeof(MMG_Tria));
+ // mmg->disp = (MMG_pDispl)calloc(mmg->npmax+1,sizeof(MMG_Displ));
+ mmg->adja = (int *)calloc(4 * mmg->nemax + 5, sizeof(int));
sol->offset = 6;
- sol->met = (double*)calloc(sol->npmax+1,sol->offset*sizeof(double));
- sol->metold = (double*)calloc(sol->npmax+1,sol->offset*sizeof(double));
+ sol->met = (double *)calloc(sol->npmax + 1, sol->offset * sizeof(double));
+ sol->metold = (double *)calloc(sol->npmax + 1, sol->offset * sizeof(double));
- std::map<MVertex*,std::pair<double,int> > LCS;
- for (std::vector<GFace*>::iterator it = f.begin(); it != f.end() ; ++it){
- for (unsigned int i = 0; i < (*it)->triangles.size(); i++){
+ std::map<MVertex *, std::pair<double, int> > LCS;
+ for(std::vector<GFace *>::iterator it = f.begin(); it != f.end(); ++it) {
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
MTriangle *t = (*it)->triangles[i];
double L = t->maxEdge();
- for (int k = 0; k < 3; k++){
- MVertex *v = t->getVertex(k);
- std::map<MVertex*,std::pair<double,int> >::iterator itv = LCS.find(v);
- if (itv != LCS.end()){
- itv->second.first += L;
- itv->second.second ++;
- }
- else {
- LCS[v] = std::make_pair(L,1);
- }
+ for(int k = 0; k < 3; k++) {
+ MVertex *v = t->getVertex(k);
+ std::map<MVertex *, std::pair<double, int> >::iterator itv =
+ LCS.find(v);
+ if(itv != LCS.end()) {
+ itv->second.first += L;
+ itv->second.second++;
+ }
+ else {
+ LCS[v] = std::make_pair(L, 1);
+ }
}
}
}
- //printf("%d vertices %d on faces\n", (int) allVertices.size(), (int) LCS.size());
+ // printf("%d vertices %d on faces\n", (int) allVertices.size(), (int)
+ // LCS.size());
- int k=1;
- int count = 1;//sol->offset;
- std::map<int,int> gmsh2mmg_num;
- for (std::set<MVertex*>::iterator it = allVertices.begin();
- it != allVertices.end(); ++it){
+ int k = 1;
+ int count = 1; // sol->offset;
+ std::map<int, int> gmsh2mmg_num;
+ for(std::set<MVertex *>::iterator it = allVertices.begin();
+ it != allVertices.end(); ++it) {
MMG_pPoint ppt = &mmg->point[k];
ppt->c[0] = (*it)->x();
ppt->c[1] = (*it)->y();
ppt->c[2] = (*it)->z();
- ppt->ref = (*it)->getNum();
+ ppt->ref = (*it)->getNum();
gmsh2mmg_num[(*it)->getNum()] = k;
MVertex *v = *it;
double U = 0, V = 0;
- if (!v->onWhat()) continue;
+ if(!v->onWhat()) continue;
- if (v->onWhat()->dim() == 1){
- v->getParameter(0,U);
+ if(v->onWhat()->dim() == 1) {
+ v->getParameter(0, U);
}
- else if (v->onWhat()->dim() == 2){
- v->getParameter(0,U);
- v->getParameter(1,V);
+ else if(v->onWhat()->dim() == 2) {
+ v->getParameter(0, U);
+ v->getParameter(1, V);
}
- //double lc = BGM_MeshSize(v->onWhat(), U,V,v->x(), v->y(), v->z());
- SMetric3 m = BGM_MeshMetric(v->onWhat(), U,V,v->x(), v->y(), v->z());
+ // double lc = BGM_MeshSize(v->onWhat(), U,V,v->x(), v->y(), v->z());
+ SMetric3 m = BGM_MeshMetric(v->onWhat(), U, V, v->x(), v->y(), v->z());
- std::map<MVertex*,std::pair<double,int> >::iterator itv = LCS.find(v);
- if (itv != LCS.end()){
+ std::map<MVertex *, std::pair<double, int> >::iterator itv = LCS.find(v);
+ if(itv != LCS.end()) {
mmg2gmsh[(*it)->getNum()] = *it;
- //if (CTX::instance()->mesh.lcExtendFromBoundary){
- double LL = itv->second.first/itv->second.second;
- SMetric3 l4(1./(LL*LL));
- SMetric3 MM = intersection_conserve_mostaniso (l4, m);
- m = MM;
- //lc = std::min(LL,lc);
- // }
+ // if (CTX::instance()->mesh.lcExtendFromBoundary){
+ double LL = itv->second.first / itv->second.second;
+ SMetric3 l4(1. / (LL * LL));
+ SMetric3 MM = intersection_conserve_mostaniso(l4, m);
+ m = MM;
+ // lc = std::min(LL,lc);
+ // }
}
- sol->met[count++] = m(0,0);
- sol->met[count++] = m(1,0);
- sol->met[count++] = m(2,0);
- sol->met[count++] = m(1,1);
- sol->met[count++] = m(2,1);
- sol->met[count++] = m(2,2);
- // printf("%g %g %g %g %g %g\n",m(0,0),m(0,1),m(0,2),m(1,1),m(1,2),m(2,2));
+ sol->met[count++] = m(0, 0);
+ sol->met[count++] = m(1, 0);
+ sol->met[count++] = m(2, 0);
+ sol->met[count++] = m(1, 1);
+ sol->met[count++] = m(2, 1);
+ sol->met[count++] = m(2, 2);
+ // printf("%g %g %g %g %g
+ // %g\n",m(0,0),m(0,1),m(0,2),m(1,1),m(1,2),m(2,2));
// for (int i=0; i<sol->offset; i++) {
// sol->met[isol + i] = lc;
- // printf("sol[%d] = %12.5E\n",isol + i,lc);
+ // printf("sol[%d] = %12.5E\n",isol + i,lc);
// }
k++;
}
- for (k = 1; k <= mmg->ne; k++) {
+ for(k = 1; k <= mmg->ne; k++) {
MMG_pTetra ptetra = &mmg->tetra[k];
- ptetra->v[0] = gmsh2mmg_num[gr->tetrahedra[k-1]->getVertex(0)->getNum()];
- ptetra->v[1] = gmsh2mmg_num[gr->tetrahedra[k-1]->getVertex(1)->getNum()];
- ptetra->v[2] = gmsh2mmg_num[gr->tetrahedra[k-1]->getVertex(2)->getNum()];
- ptetra->v[3] = gmsh2mmg_num[gr->tetrahedra[k-1]->getVertex(3)->getNum()];
- ptetra->ref = gr->tag();
+ ptetra->v[0] = gmsh2mmg_num[gr->tetrahedra[k - 1]->getVertex(0)->getNum()];
+ ptetra->v[1] = gmsh2mmg_num[gr->tetrahedra[k - 1]->getVertex(1)->getNum()];
+ ptetra->v[2] = gmsh2mmg_num[gr->tetrahedra[k - 1]->getVertex(2)->getNum()];
+ ptetra->v[3] = gmsh2mmg_num[gr->tetrahedra[k - 1]->getVertex(3)->getNum()];
+ ptetra->ref = gr->tag();
}
k = 1;
- for (std::vector<GFace*>::iterator it = f.begin(); it != f.end() ; ++it){
- for (unsigned int i = 0; i < (*it)->triangles.size(); i++){
+ for(std::vector<GFace *>::iterator it = f.begin(); it != f.end(); ++it) {
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
MMG_pTria ptriangle = &mmg->tria[k];
- ptriangle->v[0] = gmsh2mmg_num[(*it)->triangles[i]->getVertex(0)->getNum()];
- ptriangle->v[1] = gmsh2mmg_num[(*it)->triangles[i]->getVertex(1)->getNum()];
- ptriangle->v[2] = gmsh2mmg_num[(*it)->triangles[i]->getVertex(2)->getNum()];
- ptriangle->ref = (*it)->tag();
+ ptriangle->v[0] =
+ gmsh2mmg_num[(*it)->triangles[i]->getVertex(0)->getNum()];
+ ptriangle->v[1] =
+ gmsh2mmg_num[(*it)->triangles[i]->getVertex(1)->getNum()];
+ ptriangle->v[2] =
+ gmsh2mmg_num[(*it)->triangles[i]->getVertex(2)->getNum()];
+ ptriangle->ref = (*it)->tag();
k++;
}
}
- //mmg->disp = 0;
-
+ // mmg->disp = 0;
}
static void updateSizes(GRegion *gr, MMG_pMesh mmg, MMG_pSol sol,
- std::map<int,MVertex*> &mmg2gmsh)
+ std::map<int, MVertex *> &mmg2gmsh)
{
- std::vector<GFace*> f = gr->faces();
+ std::vector<GFace *> f = gr->faces();
- std::map<MVertex*,std::pair<double,int> > LCS;
+ std::map<MVertex *, std::pair<double, int> > LCS;
// if (CTX::instance()->mesh.lcExtendFromBoundary){
- for (std::vector<GFace*>::iterator it = f.begin(); it != f.end() ; ++it){
- for (unsigned int i = 0; i < (*it)->triangles.size(); i++){
- MTriangle *t = (*it)->triangles[i];
- double L = t->maxEdge();
- for (int k=0;k<3;k++){
- MVertex *v = t->getVertex(k);
- std::map<MVertex*,std::pair<double,int> >::iterator itv = LCS.find(v);
- if (itv != LCS.end()){
- itv->second.first += L;
- itv->second.second ++;
- }
- else {
- LCS[v] = std::make_pair(L,1);
- }
- }
+ for(std::vector<GFace *>::iterator it = f.begin(); it != f.end(); ++it) {
+ for(unsigned int i = 0; i < (*it)->triangles.size(); i++) {
+ MTriangle *t = (*it)->triangles[i];
+ double L = t->maxEdge();
+ for(int k = 0; k < 3; k++) {
+ MVertex *v = t->getVertex(k);
+ std::map<MVertex *, std::pair<double, int> >::iterator itv =
+ LCS.find(v);
+ if(itv != LCS.end()) {
+ itv->second.first += L;
+ itv->second.second++;
+ }
+ else {
+ LCS[v] = std::make_pair(L, 1);
+ }
}
}
- // }
-
+ }
+ // }
- int count = 1;
- for (int k=1 ; k<=mmg->np; k++){
- MMG_pPoint ppt = &mmg->point[k];
- if (ppt->tag & M_UNUSED) continue;
+ int count = 1;
+ for(int k = 1; k <= mmg->np; k++) {
+ MMG_pPoint ppt = &mmg->point[k];
+ if(ppt->tag & M_UNUSED) continue;
- SMetric3 m = BGM_MeshMetric(gr, 0,0,ppt->c[0],ppt->c[1],ppt->c[2]);
+ SMetric3 m = BGM_MeshMetric(gr, 0, 0, ppt->c[0], ppt->c[1], ppt->c[2]);
- std::map<int,MVertex*>::iterator it = mmg2gmsh.find(k);
+ std::map<int, MVertex *>::iterator it = mmg2gmsh.find(k);
- if (it != mmg2gmsh.end() && CTX::instance()->mesh.lcExtendFromBoundary){
- std::map<MVertex*,std::pair<double,int> >::iterator itv = LCS.find(it->second);
- if (itv != LCS.end()){
- double LL = itv->second.first/itv->second.second;
- SMetric3 l4(1./(LL*LL));
- //printf("adding a size %g\n",LL);
- SMetric3 MM = intersection_conserve_mostaniso (l4, m);
- m = MM;
+ if(it != mmg2gmsh.end() && CTX::instance()->mesh.lcExtendFromBoundary) {
+ std::map<MVertex *, std::pair<double, int> >::iterator itv =
+ LCS.find(it->second);
+ if(itv != LCS.end()) {
+ double LL = itv->second.first / itv->second.second;
+ SMetric3 l4(1. / (LL * LL));
+ // printf("adding a size %g\n",LL);
+ SMetric3 MM = intersection_conserve_mostaniso(l4, m);
+ m = MM;
}
}
- if (m.determinant() < 1.e-30){
- m(0,0) += 1.e-12;
- m(1,1) += 1.e-12;
- m(2,2) += 1.e-12;
+ if(m.determinant() < 1.e-30) {
+ m(0, 0) += 1.e-12;
+ m(1, 1) += 1.e-12;
+ m(2, 2) += 1.e-12;
}
- sol->met[count++] = m(0,0);
- sol->met[count++] = m(1,0);
- sol->met[count++] = m(2,0);
- sol->met[count++] = m(1,1);
- sol->met[count++] = m(2,1);
- sol->met[count++] = m(2,2);
+ sol->met[count++] = m(0, 0);
+ sol->met[count++] = m(1, 0);
+ sol->met[count++] = m(2, 0);
+ sol->met[count++] = m(1, 1);
+ sol->met[count++] = m(2, 1);
+ sol->met[count++] = m(2, 2);
}
free(sol->metold);
- sol->metold = (double*)calloc(sol->npmax+1,sol->offset*sizeof(double));
+ sol->metold = (double *)calloc(sol->npmax + 1, sol->offset * sizeof(double));
}
static void freeMMG(MMG_pMesh mmgMesh, MMG_pSol mmgSol)
{
free(mmgMesh->point);
- //free(mmgMesh->disp);
+ // free(mmgMesh->disp);
free(mmgMesh->adja);
free(mmgMesh->tria);
free(mmgMesh->tetra);
free(mmgMesh);
- //if ( mmgSol->npfixe ){
- free(mmgSol->met);
- free(mmgSol->metold);
+ // if ( mmgSol->npfixe ){
+ free(mmgSol->met);
+ free(mmgSol->metold);
//}
free(mmgSol);
}
void refineMeshMMG(GRegion *gr)
{
- MMG_pMesh mmg = (MMG_pMesh)calloc(1,sizeof(MMG_Mesh));
- MMG_pSol sol = (MMG_pSol)calloc(1,sizeof(MMG_Sol));
- std::map<int,MVertex*> mmg2gmsh;
- gmsh2MMG (gr, mmg, sol,mmg2gmsh);
+ MMG_pMesh mmg = (MMG_pMesh)calloc(1, sizeof(MMG_Mesh));
+ MMG_pSol sol = (MMG_pSol)calloc(1, sizeof(MMG_Sol));
+ std::map<int, MVertex *> mmg2gmsh;
+ gmsh2MMG(gr, mmg, sol, mmg2gmsh);
int iterMax = 11;
- for (int ITER=0;ITER<iterMax;ITER++){
- int nT = mmg->ne;
+ for(int ITER = 0; ITER < iterMax; ITER++) {
+ int nT = mmg->ne;
int verb_mmg = (Msg::GetVerbosity() > 9) ? -1 : 0;
- int opt[9] = {1,0,64,0,0,0, verb_mmg , 0,0};
+ int opt[9] = {1, 0, 64, 0, 0, 0, verb_mmg, 0, 0};
Msg::Debug("-------- GMSH LAUNCHES MMG3D ---------------");
- mmg3d::MMG_mmg3dlib(opt,mmg,sol);
+ mmg3d::MMG_mmg3dlib(opt, mmg, sol);
Msg::Debug("-------- MG3D TERMINATED -------------------");
- Msg::Info("MMG3D succeeded (ITER=%d) %d vertices %d tetrahedra",
- ITER, mmg->np, mmg->ne);
+ Msg::Info("MMG3D succeeded (ITER=%d) %d vertices %d tetrahedra", ITER,
+ mmg->np, mmg->ne);
// Here we should interact with BGM
- updateSizes(gr,mmg, sol,mmg2gmsh);
+ updateSizes(gr, mmg, sol, mmg2gmsh);
- int nTnow = mmg->ne;
- if (fabs((double)(nTnow - nT)) < 0.05 * nT) break;
+ int nTnow = mmg->ne;
+ if(fabs((double)(nTnow - nT)) < 0.05 * nT) break;
}
- //char test[] = "test.mesh";
- //MMG_saveMesh(mmg, test);
+ // char test[] = "test.mesh";
+ // MMG_saveMesh(mmg, test);
gr->deleteVertexArrays();
- for (unsigned int i = 0; i < gr->tetrahedra.size();++i)
+ for(unsigned int i = 0; i < gr->tetrahedra.size(); ++i)
delete gr->tetrahedra[i];
gr->tetrahedra.clear();
- for (unsigned int i = 0; i < gr->mesh_vertices.size(); ++i)
+ for(unsigned int i = 0; i < gr->mesh_vertices.size(); ++i)
delete gr->mesh_vertices[i];
gr->mesh_vertices.clear();
diff --git a/Mesh/meshGRegionRelocateVertex.cpp b/Mesh/meshGRegionRelocateVertex.cpp
index 831f8cc84e3fcdf39e30c909621654cb76ad45bb..d19f752a4f677984532d5fdb59b881c7e708d4fb 100644
--- a/Mesh/meshGRegionRelocateVertex.cpp
+++ b/Mesh/meshGRegionRelocateVertex.cpp
@@ -291,7 +291,9 @@ static double _relocateVertex(GFace *gf, MVertex *ver,
SPoint2 p1(0, 0);
SPoint2 p2;
- if(ver->getParameter(0, p2[0])) { ver->getParameter(1, p2[1]); }
+ if(ver->getParameter(0, p2[0])) {
+ ver->getParameter(1, p2[1]);
+ }
else {
return _relocateVertex2(gf, ver, lt, tol);
}
diff --git a/Mesh/meshGRegionRelocateVertex.h b/Mesh/meshGRegionRelocateVertex.h
index f267ef73d8acb97e655713fff5aa04bf43c626ab..3d465d259b5aa2d221687c5b5168e8383eb60362 100644
--- a/Mesh/meshGRegionRelocateVertex.h
+++ b/Mesh/meshGRegionRelocateVertex.h
@@ -4,9 +4,11 @@
class GRegion;
class GFace;
class MElement;
-void RelocateVertices (GRegion* region, int niter, double tol = 1.e-2);
-void RelocateVertices (std::vector<GRegion*> ®ions, int niter, double tol = 1.e-2);
-void RelocateVertices (GFace*, int niter, double tol = 1.e-3);
-void _relocateVertexGolden(MVertex *ver, const std::vector<MElement*> <, double relax, double tol= 1.e-2);
+void RelocateVertices(GRegion *region, int niter, double tol = 1.e-2);
+void RelocateVertices(std::vector<GRegion *> ®ions, int niter,
+ double tol = 1.e-2);
+void RelocateVertices(GFace *, int niter, double tol = 1.e-3);
+void _relocateVertexGolden(MVertex *ver, const std::vector<MElement *> <,
+ double relax, double tol = 1.e-2);
#endif
diff --git a/Mesh/meshGRegionTransfinite.cpp b/Mesh/meshGRegionTransfinite.cpp
index 2d34d3e8a6738c50fca0908fde47cea0b6933643..1b86c72041a432beee7f3e4eb5bd7fb91f05f7ae 100644
--- a/Mesh/meshGRegionTransfinite.cpp
+++ b/Mesh/meshGRegionTransfinite.cpp
@@ -50,117 +50,105 @@
match.
*/
-#define CREATE_HEX new MHexahedron(tab[i ][j ][k ], \
- tab[i + 1][j ][k ], \
- tab[i + 1][j + 1][k ], \
- tab[i ][j + 1][k ], \
- tab[i ][j ][k + 1], \
- tab[i + 1][j ][k + 1], \
- tab[i + 1][j + 1][k + 1], \
- tab[i ][j + 1][k + 1])
-
-#define CREATE_PRISM_1 new MPrism(tab[i ][j ][k ], \
- tab[i + 1][j ][k ], \
- tab[i ][j + 1][k ], \
- tab[i ][j ][k + 1], \
- tab[i + 1][j ][k + 1], \
- tab[i ][j + 1][k + 1])
-
-#define CREATE_PRISM_2 new MPrism(tab[i + 1][j + 1][k ], \
- tab[i ][j + 1][k ], \
- tab[i + 1][j ][k ], \
- tab[i + 1][j + 1][k + 1], \
- tab[i ][j + 1][k + 1], \
- tab[i + 1][j ][k + 1])
-
-#define CREATE_SIM_1 new MTetrahedron(tab[i ][j ][k ], \
- tab[i + 1][j ][k ], \
- tab[i ][j + 1][k ], \
- tab[i ][j ][k + 1])
-
-#define CREATE_SIM_2 new MTetrahedron(tab[i + 1][j ][k ], \
- tab[i ][j + 1][k ], \
- tab[i ][j ][k + 1], \
- tab[i + 1][j ][k + 1])
-
-#define CREATE_SIM_3 new MTetrahedron(tab[i ][j ][k + 1], \
- tab[i + 1][j ][k + 1], \
- tab[i ][j + 1][k ], \
- tab[i ][j + 1][k + 1])
-
-#define CREATE_SIM_4 new MTetrahedron(tab[i + 1][j ][k ], \
- tab[i ][j + 1][k ], \
- tab[i + 1][j ][k + 1], \
- tab[i + 1][j + 1][k ])
-
-#define CREATE_SIM_5 new MTetrahedron(tab[i ][j + 1][k ], \
- tab[i ][j + 1][k + 1], \
- tab[i + 1][j ][k + 1], \
- tab[i + 1][j + 1][k ])
-
-#define CREATE_SIM_6 new MTetrahedron(tab[i + 1][j ][k + 1], \
- tab[i ][j + 1][k + 1], \
- tab[i + 1][j + 1][k + 1], \
- tab[i + 1][j + 1][k ])
+#define CREATE_HEX \
+ new MHexahedron(tab[i][j][k], tab[i + 1][j][k], tab[i + 1][j + 1][k], \
+ tab[i][j + 1][k], tab[i][j][k + 1], tab[i + 1][j][k + 1], \
+ tab[i + 1][j + 1][k + 1], tab[i][j + 1][k + 1])
+
+#define CREATE_PRISM_1 \
+ new MPrism(tab[i][j][k], tab[i + 1][j][k], tab[i][j + 1][k], \
+ tab[i][j][k + 1], tab[i + 1][j][k + 1], tab[i][j + 1][k + 1])
+
+#define CREATE_PRISM_2 \
+ new MPrism(tab[i + 1][j + 1][k], tab[i][j + 1][k], tab[i + 1][j][k], \
+ tab[i + 1][j + 1][k + 1], tab[i][j + 1][k + 1], \
+ tab[i + 1][j][k + 1])
+
+#define CREATE_SIM_1 \
+ new MTetrahedron(tab[i][j][k], tab[i + 1][j][k], tab[i][j + 1][k], \
+ tab[i][j][k + 1])
+
+#define CREATE_SIM_2 \
+ new MTetrahedron(tab[i + 1][j][k], tab[i][j + 1][k], tab[i][j][k + 1], \
+ tab[i + 1][j][k + 1])
+
+#define CREATE_SIM_3 \
+ new MTetrahedron(tab[i][j][k + 1], tab[i + 1][j][k + 1], tab[i][j + 1][k], \
+ tab[i][j + 1][k + 1])
+
+#define CREATE_SIM_4 \
+ new MTetrahedron(tab[i + 1][j][k], tab[i][j + 1][k], tab[i + 1][j][k + 1], \
+ tab[i + 1][j + 1][k])
+
+#define CREATE_SIM_5 \
+ new MTetrahedron(tab[i][j + 1][k], tab[i][j + 1][k + 1], \
+ tab[i + 1][j][k + 1], tab[i + 1][j + 1][k])
+
+#define CREATE_SIM_6 \
+ new MTetrahedron(tab[i + 1][j][k + 1], tab[i][j + 1][k + 1], \
+ tab[i + 1][j + 1][k + 1], tab[i + 1][j + 1][k])
static double transfiniteHex(double f1, double f2, double f3, double f4,
- double f5, double f6,
- double c1, double c2, double c3, double c4,
- double c5, double c6, double c7, double c8,
- double c9, double c10, double c11, double c12,
- double s1, double s2, double s3, double s4,
- double s5, double s6, double s7, double s8,
- double u, double v, double w)
+ double f5, double f6, double c1, double c2,
+ double c3, double c4, double c5, double c6,
+ double c7, double c8, double c9, double c10,
+ double c11, double c12, double s1, double s2,
+ double s3, double s4, double s5, double s6,
+ double s7, double s8, double u, double v, double w)
{
- return (1-u)*f4 + u*f2 + (1-v)*f1 + v*f3 + (1-w)*f5 + w*f6 -
- ((1-u)*(1-v)*c9 + (1-u)*v*c12 + u*(1-v)*c10 + u*v*c11) -
- ((1-v)*(1-w)*c1 + (1-v)*w*c5 + v*(1-w)*c3 + v*w*c7) -
- ((1-u)*(1-w)*c4 + (1-w)*u*c2 + w*(1-u)*c8 + u*w*c6) +
- (1-u)*(1-v)*(1-w)*s1 + u*(1-v)*(1-w)*s2 + u*v*(1-w)*s3 + (1-u)*v*(1-w)*s4 +
- (1-u)*(1-v)*w*s5 + u*(1-v)*w*s6 + u*v*w*s7 + (1-u)*v*w*s8;
+ return (1 - u) * f4 + u * f2 + (1 - v) * f1 + v * f3 + (1 - w) * f5 + w * f6 -
+ ((1 - u) * (1 - v) * c9 + (1 - u) * v * c12 + u * (1 - v) * c10 +
+ u * v * c11) -
+ ((1 - v) * (1 - w) * c1 + (1 - v) * w * c5 + v * (1 - w) * c3 +
+ v * w * c7) -
+ ((1 - u) * (1 - w) * c4 + (1 - w) * u * c2 + w * (1 - u) * c8 +
+ u * w * c6) +
+ (1 - u) * (1 - v) * (1 - w) * s1 + u * (1 - v) * (1 - w) * s2 +
+ u * v * (1 - w) * s3 + (1 - u) * v * (1 - w) * s4 +
+ (1 - u) * (1 - v) * w * s5 + u * (1 - v) * w * s6 + u * v * w * s7 +
+ (1 - u) * v * w * s8;
}
-static MVertex *transfiniteHex(GRegion *gr,
- MVertex *f1, MVertex *f2, MVertex *f3, MVertex *f4,
- MVertex *f5, MVertex *f6,
- MVertex *c1, MVertex *c2, MVertex *c3, MVertex *c4,
- MVertex *c5, MVertex *c6, MVertex *c7, MVertex *c8,
- MVertex *c9, MVertex *c10, MVertex *c11, MVertex *c12,
- MVertex *s1, MVertex *s2, MVertex *s3, MVertex *s4,
- MVertex *s5, MVertex *s6, MVertex *s7, MVertex *s8,
- double u, double v, double w)
+static MVertex *
+transfiniteHex(GRegion *gr, MVertex *f1, MVertex *f2, MVertex *f3, MVertex *f4,
+ MVertex *f5, MVertex *f6, MVertex *c1, MVertex *c2, MVertex *c3,
+ MVertex *c4, MVertex *c5, MVertex *c6, MVertex *c7, MVertex *c8,
+ MVertex *c9, MVertex *c10, MVertex *c11, MVertex *c12,
+ MVertex *s1, MVertex *s2, MVertex *s3, MVertex *s4, MVertex *s5,
+ MVertex *s6, MVertex *s7, MVertex *s8, double u, double v,
+ double w)
{
- double x = transfiniteHex(f1->x(), f2->x(), f3->x(), f4->x(), f5->x(), f6->x(),
- c1->x(), c2->x(), c3->x(), c4->x(), c5->x(), c6->x(),
- c7->x(), c8->x(), c9->x(), c10->x(), c11->x(), c12->x(),
- s1->x(), s2->x(), s3->x(), s4->x(),
- s5->x(), s6->x(), s7->x(), s8->x(),
- u, v, w);
- double y = transfiniteHex(f1->y(), f2->y(), f3->y(), f4->y(), f5->y(), f6->y(),
- c1->y(), c2->y(), c3->y(), c4->y(), c5->y(), c6->y(),
- c7->y(), c8->y(), c9->y(), c10->y(), c11->y(), c12->y(),
- s1->y(), s2->y(), s3->y(), s4->y(),
- s5->y(), s6->y(), s7->y(), s8->y(),
- u, v, w);
- double z = transfiniteHex(f1->z(), f2->z(), f3->z(), f4->z(), f5->z(), f6->z(),
- c1->z(), c2->z(), c3->z(), c4->z(), c5->z(), c6->z(),
- c7->z(), c8->z(), c9->z(), c10->z(), c11->z(), c12->z(),
- s1->z(), s2->z(), s3->z(), s4->z(),
- s5->z(), s6->z(), s7->z(), s8->z(),
- u, v, w);
+ double x = transfiniteHex(
+ f1->x(), f2->x(), f3->x(), f4->x(), f5->x(), f6->x(), c1->x(), c2->x(),
+ c3->x(), c4->x(), c5->x(), c6->x(), c7->x(), c8->x(), c9->x(), c10->x(),
+ c11->x(), c12->x(), s1->x(), s2->x(), s3->x(), s4->x(), s5->x(), s6->x(),
+ s7->x(), s8->x(), u, v, w);
+ double y = transfiniteHex(
+ f1->y(), f2->y(), f3->y(), f4->y(), f5->y(), f6->y(), c1->y(), c2->y(),
+ c3->y(), c4->y(), c5->y(), c6->y(), c7->y(), c8->y(), c9->y(), c10->y(),
+ c11->y(), c12->y(), s1->y(), s2->y(), s3->y(), s4->y(), s5->y(), s6->y(),
+ s7->y(), s8->y(), u, v, w);
+ double z = transfiniteHex(
+ f1->z(), f2->z(), f3->z(), f4->z(), f5->z(), f6->z(), c1->z(), c2->z(),
+ c3->z(), c4->z(), c5->z(), c6->z(), c7->z(), c8->z(), c9->z(), c10->z(),
+ c11->z(), c12->z(), s1->z(), s2->z(), s3->z(), s4->z(), s5->z(), s6->z(),
+ s7->z(), s8->z(), u, v, w);
return new MVertex(x, y, z, gr);
}
class GOrientedTransfiniteFace {
- private:
+private:
GFace *_gf;
int _LL, _HH;
int _permutation, _index;
- std::vector<MVertex*> _list;
- public:
+ std::vector<MVertex *> _list;
+
+public:
GOrientedTransfiniteFace()
- : _gf(0), _LL(0), _HH(0), _permutation(-1), _index(-1) {}
- GOrientedTransfiniteFace(GFace *gf, std::vector<MVertex*> &corners)
+ : _gf(0), _LL(0), _HH(0), _permutation(-1), _index(-1)
+ {
+ }
+ GOrientedTransfiniteFace(GFace *gf, std::vector<MVertex *> &corners)
: _gf(gf), _LL(0), _HH(0), _permutation(-1), _index(-1)
{
_LL = gf->transfinite_vertices.size() - 1;
@@ -170,28 +158,33 @@ class GOrientedTransfiniteFace {
Msg::Debug("Face %d: L = %d H = %d", gf->tag(), _LL, _HH);
// get the corners of the transfinite volume interpolation
- std::vector<MVertex*> s(8);
- if(corners.size() == 8){
- for(int i = 0; i < 8; i++)
- s[i] = corners[i];
+ std::vector<MVertex *> s(8);
+ if(corners.size() == 8) {
+ for(int i = 0; i < 8; i++) s[i] = corners[i];
}
- else if(corners.size() == 6){
- s[0] = corners[0]; s[1] = corners[1]; s[2] = corners[2]; s[3] = corners[0];
- s[4] = corners[3]; s[5] = corners[4]; s[6] = corners[5]; s[7] = corners[3];
+ else if(corners.size() == 6) {
+ s[0] = corners[0];
+ s[1] = corners[1];
+ s[2] = corners[2];
+ s[3] = corners[0];
+ s[4] = corners[3];
+ s[5] = corners[4];
+ s[6] = corners[5];
+ s[7] = corners[3];
}
else
return;
// get the corners of the transfinite surface mesh
- std::vector<MVertex*> c(4);
+ std::vector<MVertex *> c(4);
if(_gf->meshAttributes.corners.empty() ||
- _gf->meshAttributes.corners.size() == 4){
+ _gf->meshAttributes.corners.size() == 4) {
c[0] = _gf->transfinite_vertices[0][0];
c[1] = _gf->transfinite_vertices[_LL][0];
c[2] = _gf->transfinite_vertices[_LL][_HH];
c[3] = _gf->transfinite_vertices[0][_HH];
}
- else if(_gf->meshAttributes.corners.size() == 3){
+ else if(_gf->meshAttributes.corners.size() == 3) {
c[0] = _gf->transfinite_vertices[0][0];
c[1] = _gf->transfinite_vertices[_LL][0];
c[2] = _gf->transfinite_vertices[_LL][_HH];
@@ -201,10 +194,10 @@ class GOrientedTransfiniteFace {
return;
// map the surface mesh onto the canonical transfinite hexahedron
- int faces[] = {0, 1, 5, 4, 1, 2, 6, 5, 3, 2, 6, 7,
- 0, 3, 7, 4, 0, 1, 2, 3, 4, 5, 6, 7};
- int permutations[] = {0, 1, 2, 3, 1, 2, 3, 0, 2, 3, 0, 1, 3, 0, 1, 2,
- 3, 2, 1, 0, 2, 1, 0, 3, 1, 0, 3, 2, 0, 3, 2, 1};
+ int faces[] = {0, 1, 5, 4, 1, 2, 6, 5, 3, 2, 6, 7,
+ 0, 3, 7, 4, 0, 1, 2, 3, 4, 5, 6, 7};
+ int permutations[] = {0, 1, 2, 3, 1, 2, 3, 0, 2, 3, 0, 1, 3, 0, 1, 2,
+ 3, 2, 1, 0, 2, 1, 0, 3, 1, 0, 3, 2, 0, 3, 2, 1};
for(int p = 0; p < 8; p++) {
for(int f = 0; f < 6; f++) {
if(s[faces[4 * f + 0]] == c[permutations[4 * p + 0]] &&
@@ -231,14 +224,14 @@ class GOrientedTransfiniteFace {
}
// returns the number or points in the transfinite mesh in both
// parameter directions
- int getNumU(){ return (_permutation % 2) ? _HH + 1: _LL + 1; }
- int getNumV(){ return (_permutation % 2) ? _LL + 1: _HH + 1; }
+ int getNumU() { return (_permutation % 2) ? _HH + 1 : _LL + 1; }
+ int getNumV() { return (_permutation % 2) ? _LL + 1 : _HH + 1; }
// returns the (i,j) vertex in the face, i and j being defined in
// the coordinate system of the reference transfinite hexahedron
MVertex *getVertex(int i, int j)
{
int index = -1, m = i, n = j, M = getNumU(), N = getNumV();
- switch (_permutation) {
+ switch(_permutation) {
case 0: index = (n + N * m); break;
case 1: index = (M * N - M * (n + 1) + m); break;
case 2: index = (M * N - (n + N * m) - 1); break;
@@ -250,54 +243,59 @@ class GOrientedTransfiniteFace {
}
MVertex *v = 0;
if(index >= 0 && index < (int)_list.size()) v = _list[index];
- if(index < 0 || index >= (int)_list.size() || !v){
+ if(index < 0 || index >= (int)_list.size() || !v) {
Msg::Error("Wrong index in transfinite mesh of surface %d: "
- "m=%d n=%d M=%d N=%d perm=%d", _gf->tag(), m, n, M, N, _permutation);
+ "m=%d n=%d M=%d N=%d perm=%d",
+ _gf->tag(), m, n, M, N, _permutation);
return _list[0];
}
return v;
}
};
-void findTransfiniteCorners(GRegion *gr, std::vector<MVertex*> &corners)
+void findTransfiniteCorners(GRegion *gr, std::vector<MVertex *> &corners)
{
- if(gr->meshAttributes.corners.size()){
+ if(gr->meshAttributes.corners.size()) {
// corners have been specified explicitly
for(unsigned int i = 0; i < gr->meshAttributes.corners.size(); i++)
corners.push_back(gr->meshAttributes.corners[i]->mesh_vertices[0]);
}
- else{
+ else {
// try to find the corners automatically
- std::vector<GFace*> faces = gr->faces();
+ std::vector<GFace *> faces = gr->faces();
GFace *gf = 0;
- if(faces.size() == 6){
+ if(faces.size() == 6) {
// any face will do as a starting face
gf = faces.front();
}
- else if(faces.size() == 5){
+ else if(faces.size() == 5) {
// we need to start with a triangular face
- for(std::vector<GFace*>::iterator it = faces.begin(); it != faces.end(); it++){
- if((*it)->edges().size() == 3 || (*it)->meshAttributes.corners.size() == 3){
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) {
+ if((*it)->edges().size() == 3 ||
+ (*it)->meshAttributes.corners.size() == 3) {
gf = *it;
break;
}
}
}
- if(gf){
- std::vector<GEdge*> fedges = gf->edges();
- std::vector<GEdge*> redges = gr->edges();
+ if(gf) {
+ std::vector<GEdge *> fedges = gf->edges();
+ std::vector<GEdge *> redges = gr->edges();
// TODO C++11 Fix the UB if *it doesn't exist in this container
- for(std::vector<GEdge*>::const_iterator it = fedges.begin(); it != fedges.end(); it++)
+ for(std::vector<GEdge *>::const_iterator it = fedges.begin();
+ it != fedges.end(); it++)
redges.erase(std::find(redges.begin(), redges.end(), *it));
findTransfiniteCorners(gf, corners);
unsigned int N = corners.size();
- for(unsigned int i = 0; i < N; i++){
- for(std::vector<GEdge*>::const_iterator it = redges.begin(); it != redges.end(); it++){
- if((*it)->getBeginVertex()->mesh_vertices[0] == corners[i]){
+ for(unsigned int i = 0; i < N; i++) {
+ for(std::vector<GEdge *>::const_iterator it = redges.begin();
+ it != redges.end(); it++) {
+ if((*it)->getBeginVertex()->mesh_vertices[0] == corners[i]) {
corners.push_back((*it)->getEndVertex()->mesh_vertices[0]);
break;
}
- else if((*it)->getEndVertex()->mesh_vertices[0] == corners[i]){
+ else if((*it)->getEndVertex()->mesh_vertices[0] == corners[i]) {
corners.push_back((*it)->getBeginVertex()->mesh_vertices[0]);
break;
}
@@ -313,24 +311,26 @@ int MeshTransfiniteVolume(GRegion *gr)
Msg::Info("Meshing volume %d (transfinite)", gr->tag());
- std::vector<GFace*> faces = gr->faces();
- if(faces.size() != 5 && faces.size() != 6){
- Msg::Error("Transfinite algorithm only available for 5- and 6-face volumes");
+ std::vector<GFace *> faces = gr->faces();
+ if(faces.size() != 5 && faces.size() != 6) {
+ Msg::Error(
+ "Transfinite algorithm only available for 5- and 6-face volumes");
return 0;
}
- std::vector<MVertex*> corners;
+ std::vector<MVertex *> corners;
findTransfiniteCorners(gr, corners);
- if(corners.size() != 6 && corners.size() != 8){
- Msg::Error("Volume %d is transfinite but has %d corners",
- gr->tag(), corners.size());
+ if(corners.size() != 6 && corners.size() != 8) {
+ Msg::Error("Volume %d is transfinite but has %d corners", gr->tag(),
+ corners.size());
return 0;
}
std::vector<GOrientedTransfiniteFace> orientedFaces(6);
- for(std::vector<GFace*>::iterator it = faces.begin(); it != faces.end(); ++it){
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ ++it) {
GOrientedTransfiniteFace f(*it, corners);
- if(f.index() < 0){
+ if(f.index() < 0) {
Msg::Error("Incompatible surface %d in transfinite volume %d",
(*it)->tag(), gr->tag());
return 0;
@@ -347,19 +347,19 @@ int MeshTransfiniteVolume(GRegion *gr)
lengths_i.push_back(0.);
lengths_j.push_back(0.);
lengths_k.push_back(0.);
- for(int i = 0; i < N_i - 1; i++){
+ for(int i = 0; i < N_i - 1; i++) {
MVertex *v1 = orientedFaces[4].getVertex(i, 0);
MVertex *v2 = orientedFaces[4].getVertex(i + 1, 0);
L_i += v1->distance(v2);
lengths_i.push_back(L_i);
}
- for(int i = 0; i < N_j - 1; i++){
+ for(int i = 0; i < N_j - 1; i++) {
MVertex *v1 = orientedFaces[1].getVertex(i, 0);
MVertex *v2 = orientedFaces[1].getVertex(i + 1, 0);
L_j += v1->distance(v2);
lengths_j.push_back(L_j);
}
- for(int i = 0; i < N_k - 1; i++){
+ for(int i = 0; i < N_k - 1; i++) {
MVertex *v1 = orientedFaces[1].getVertex(0, i);
MVertex *v2 = orientedFaces[1].getVertex(0, i + 1);
L_k += v1->distance(v2);
@@ -378,11 +378,12 @@ int MeshTransfiniteVolume(GRegion *gr)
MVertex *s6 = orientedFaces[5].getVertex(N_i - 1, N_j - 1);
MVertex *s7 = orientedFaces[5].getVertex(0, N_j - 1);
- std::vector<std::vector<std::vector<MVertex*> > > &tab(gr->transfinite_vertices);
+ std::vector<std::vector<std::vector<MVertex *> > > &tab(
+ gr->transfinite_vertices);
tab.resize(N_i);
- for(int i = 0; i < N_i; i++){
+ for(int i = 0; i < N_i; i++) {
tab[i].resize(N_j);
- for(int j = 0; j < N_j; j++){
+ for(int j = 0; j < N_j; j++) {
tab[i][j].resize(N_k);
}
}
@@ -424,11 +425,9 @@ int MeshTransfiniteVolume(GRegion *gr)
f3 = c8;
if(i && j && k && i != N_i - 1 && j != N_j - 1 && k != N_k - 1) {
- MVertex *newv = transfiniteHex
- (gr, f0, f1, f2, f3, f4, f5,
- c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11,
- s0, s1, s2, s3, s4, s5, s6, s7,
- u, v, w);
+ MVertex *newv = transfiniteHex(
+ gr, f0, f1, f2, f3, f4, f5, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9,
+ c10, c11, s0, s1, s2, s3, s4, s5, s6, s7, u, v, w);
gr->mesh_vertices.push_back(newv);
tab[i][j][k] = newv;
}
@@ -458,11 +457,13 @@ int MeshTransfiniteVolume(GRegion *gr)
// for QuadTri, get external boundary diagonals for element
// subdivision purposes
- std::set< std::pair<MVertex*, MVertex*> > boundary_diags;
- if(gr->meshAttributes.QuadTri){
- if(!getTransfiniteBoundaryDiags( gr, &boundary_diags)){
- Msg::Error("In MeshTransfiniteVolume(), getTransfiniteBoundaryDiags() failed. "
- "Aborting mesh of region %d.", gr->tag());
+ std::set<std::pair<MVertex *, MVertex *> > boundary_diags;
+ if(gr->meshAttributes.QuadTri) {
+ if(!getTransfiniteBoundaryDiags(gr, &boundary_diags)) {
+ Msg::Error(
+ "In MeshTransfiniteVolume(), getTransfiniteBoundaryDiags() failed. "
+ "Aborting mesh of region %d.",
+ gr->tag());
return 0;
}
}
@@ -471,27 +472,32 @@ int MeshTransfiniteVolume(GRegion *gr)
for(int i = 0; i < N_i - 1; i++) {
for(int j = 0; j < N_j - 1; j++) {
for(int k = 0; k < N_k - 1; k++) {
- if(gr->meshAttributes.QuadTri){
+ if(gr->meshAttributes.QuadTri) {
// create vertex array
- std::vector<MVertex*> verts;
+ std::vector<MVertex *> verts;
verts.resize(8);
- verts[0] = tab[i][j][k]; verts[1] = tab[i+1][j][k];
- verts[2] = tab[i+1][j+1][k]; verts[3] = tab[i][j+1][k];
- verts[4] = tab[i][j][k+1]; verts[5] = tab[i+1][j][k+1];
- verts[6] = tab[i+1][j+1][k+1]; verts[7] = tab[i][j+1][k+1];
- if((!orientedFaces[3].recombined() && i == 0) ||
- (!orientedFaces[1].recombined() && i == N_i-2) ||
- (!orientedFaces[0].recombined() && j == 0) ||
- (!orientedFaces[2].recombined() && j == N_j-2) ||
- (!orientedFaces[4].recombined() && k == 0) ||
- (!orientedFaces[5].recombined() && k == N_k-2)){
+ verts[0] = tab[i][j][k];
+ verts[1] = tab[i + 1][j][k];
+ verts[2] = tab[i + 1][j + 1][k];
+ verts[3] = tab[i][j + 1][k];
+ verts[4] = tab[i][j][k + 1];
+ verts[5] = tab[i + 1][j][k + 1];
+ verts[6] = tab[i + 1][j + 1][k + 1];
+ verts[7] = tab[i][j + 1][k + 1];
+ if((!orientedFaces[3].recombined() && i == 0) ||
+ (!orientedFaces[1].recombined() && i == N_i - 2) ||
+ (!orientedFaces[0].recombined() && j == 0) ||
+ (!orientedFaces[2].recombined() && j == N_j - 2) ||
+ (!orientedFaces[4].recombined() && k == 0) ||
+ (!orientedFaces[5].recombined() && k == N_k - 2)) {
// make subdivided element
meshTransfElemWithInternalVertex(gr, verts, &boundary_diags);
}
// if not adjacent to unrecombined edge
else
- gr->hexahedra.push_back(new MHexahedron(verts[0], verts[1], verts[2], verts[3],
- verts[4], verts[5], verts[6], verts[7]));
+ gr->hexahedra.push_back(
+ new MHexahedron(verts[0], verts[1], verts[2], verts[3],
+ verts[4], verts[5], verts[6], verts[7]));
// continue, skipping the rest which is for non-divided elements
continue;
}
@@ -500,47 +506,49 @@ int MeshTransfiniteVolume(GRegion *gr)
orientedFaces[4].recombined() && orientedFaces[5].recombined()) {
gr->hexahedra.push_back(CREATE_HEX);
}
- else if(!orientedFaces[0].recombined() && orientedFaces[1].recombined() &&
- !orientedFaces[2].recombined() && orientedFaces[3].recombined() &&
- orientedFaces[4].recombined() && orientedFaces[5].recombined()) {
- gr->prisms.push_back(new MPrism(tab[i ][j ][k ],
- tab[i + 1][j ][k ],
- tab[i ][j ][k + 1],
- tab[i ][j + 1][k ],
- tab[i + 1][j + 1][k ],
- tab[i ][j + 1][k + 1]));
- gr->prisms.push_back(new MPrism(tab[i + 1][j ][k + 1],
- tab[i ][j ][k + 1],
- tab[i + 1][j ][k ],
- tab[i + 1][j + 1][k + 1],
- tab[i ][j + 1][k + 1],
- tab[i + 1][j + 1][k ]));
+ else if(!orientedFaces[0].recombined() &&
+ orientedFaces[1].recombined() &&
+ !orientedFaces[2].recombined() &&
+ orientedFaces[3].recombined() &&
+ orientedFaces[4].recombined() &&
+ orientedFaces[5].recombined()) {
+ gr->prisms.push_back(new MPrism(
+ tab[i][j][k], tab[i + 1][j][k], tab[i][j][k + 1],
+ tab[i][j + 1][k], tab[i + 1][j + 1][k], tab[i][j + 1][k + 1]));
+ gr->prisms.push_back(
+ new MPrism(tab[i + 1][j][k + 1], tab[i][j][k + 1],
+ tab[i + 1][j][k], tab[i + 1][j + 1][k + 1],
+ tab[i][j + 1][k + 1], tab[i + 1][j + 1][k]));
}
- else if(orientedFaces[0].recombined() && !orientedFaces[1].recombined() &&
- orientedFaces[2].recombined() && !orientedFaces[3].recombined() &&
- orientedFaces[4].recombined() && orientedFaces[5].recombined()) {
- gr->prisms.push_back(new MPrism(tab[i + 1][j ][k ],
- tab[i + 1][j + 1][k ],
- tab[i + 1][j ][k + 1],
- tab[i ][j ][k ],
- tab[i ][j + 1][k ],
- tab[i ][j ][k + 1]));
- gr->prisms.push_back(new MPrism(tab[i + 1][j + 1][k + 1],
- tab[i + 1][j ][k + 1],
- tab[i + 1][j + 1][k ],
- tab[i ][j + 1][k + 1],
- tab[i ][j ][k + 1],
- tab[i ][j + 1][k ]));
+ else if(orientedFaces[0].recombined() &&
+ !orientedFaces[1].recombined() &&
+ orientedFaces[2].recombined() &&
+ !orientedFaces[3].recombined() &&
+ orientedFaces[4].recombined() &&
+ orientedFaces[5].recombined()) {
+ gr->prisms.push_back(new MPrism(
+ tab[i + 1][j][k], tab[i + 1][j + 1][k], tab[i + 1][j][k + 1],
+ tab[i][j][k], tab[i][j + 1][k], tab[i][j][k + 1]));
+ gr->prisms.push_back(
+ new MPrism(tab[i + 1][j + 1][k + 1], tab[i + 1][j][k + 1],
+ tab[i + 1][j + 1][k], tab[i][j + 1][k + 1],
+ tab[i][j][k + 1], tab[i][j + 1][k]));
}
- else if(orientedFaces[0].recombined() && orientedFaces[1].recombined() &&
- orientedFaces[2].recombined() && orientedFaces[3].recombined() &&
- !orientedFaces[4].recombined() && !orientedFaces[5].recombined()) {
+ else if(orientedFaces[0].recombined() &&
+ orientedFaces[1].recombined() &&
+ orientedFaces[2].recombined() &&
+ orientedFaces[3].recombined() &&
+ !orientedFaces[4].recombined() &&
+ !orientedFaces[5].recombined()) {
gr->prisms.push_back(CREATE_PRISM_1);
gr->prisms.push_back(CREATE_PRISM_2);
}
- else if(!orientedFaces[0].recombined() && !orientedFaces[1].recombined() &&
- !orientedFaces[2].recombined() && !orientedFaces[3].recombined() &&
- !orientedFaces[4].recombined() && !orientedFaces[5].recombined()) {
+ else if(!orientedFaces[0].recombined() &&
+ !orientedFaces[1].recombined() &&
+ !orientedFaces[2].recombined() &&
+ !orientedFaces[3].recombined() &&
+ !orientedFaces[4].recombined() &&
+ !orientedFaces[5].recombined()) {
gr->tetrahedra.push_back(CREATE_SIM_1);
gr->tetrahedra.push_back(CREATE_SIM_2);
gr->tetrahedra.push_back(CREATE_SIM_3);
@@ -549,7 +557,8 @@ int MeshTransfiniteVolume(GRegion *gr)
gr->tetrahedra.push_back(CREATE_SIM_6);
}
else {
- Msg::Error("Wrong surface recombination in transfinite volume %d", gr->tag());
+ Msg::Error("Wrong surface recombination in transfinite volume %d",
+ gr->tag());
return 0;
}
}
@@ -559,17 +568,20 @@ int MeshTransfiniteVolume(GRegion *gr)
else if(faces.size() == 5) {
for(int j = 0; j < N_j - 1; j++) {
for(int k = 0; k < N_k - 1; k++) {
- if(gr->meshAttributes.QuadTri){
+ if(gr->meshAttributes.QuadTri) {
// create vertex array
- std::vector<MVertex*> verts;
+ std::vector<MVertex *> verts;
verts.resize(6);
- verts[0] = tab[0][j][k]; verts[1] = tab[1][j][k];
- verts[2] = tab[1][j+1][k]; verts[3] = tab[0][j][k+1];
- verts[4] = tab[1][j][k+1]; verts[5] = tab[1][j+1][k+1];
- if((!orientedFaces[0].recombined() && j == 0) ||
- (!orientedFaces[2].recombined() && j == N_j-2) ||
- (!orientedFaces[4].recombined() && k == 0) ||
- (!orientedFaces[5].recombined() && k == N_k-2) ){
+ verts[0] = tab[0][j][k];
+ verts[1] = tab[1][j][k];
+ verts[2] = tab[1][j + 1][k];
+ verts[3] = tab[0][j][k + 1];
+ verts[4] = tab[1][j][k + 1];
+ verts[5] = tab[1][j + 1][k + 1];
+ if((!orientedFaces[0].recombined() && j == 0) ||
+ (!orientedFaces[2].recombined() && j == N_j - 2) ||
+ (!orientedFaces[4].recombined() && k == 0) ||
+ (!orientedFaces[5].recombined() && k == N_k - 2)) {
// make subdivided element
meshTransfElemWithInternalVertex(gr, verts, &boundary_diags);
}
@@ -585,31 +597,27 @@ int MeshTransfiniteVolume(GRegion *gr)
(orientedFaces[0].recombined() && orientedFaces[1].recombined() &&
orientedFaces[2].recombined() && !orientedFaces[4].recombined() &&
!orientedFaces[5].recombined())) {
- gr->prisms.push_back(new MPrism(tab[0 ][j ][k ],
- tab[1 ][j ][k ],
- tab[1 ][j + 1][k ],
- tab[0 ][j ][k + 1],
- tab[1 ][j ][k + 1],
- tab[1 ][j + 1][k + 1]));
+ gr->prisms.push_back(new MPrism(
+ tab[0][j][k], tab[1][j][k], tab[1][j + 1][k], tab[0][j][k + 1],
+ tab[1][j][k + 1], tab[1][j + 1][k + 1]));
}
- else if(!orientedFaces[0].recombined() && !orientedFaces[1].recombined() &&
- !orientedFaces[2].recombined() && !orientedFaces[4].recombined() &&
+ else if(!orientedFaces[0].recombined() &&
+ !orientedFaces[1].recombined() &&
+ !orientedFaces[2].recombined() &&
+ !orientedFaces[4].recombined() &&
!orientedFaces[5].recombined()) {
- gr->tetrahedra.push_back(new MTetrahedron(tab[0 ][j ][k ],
- tab[1 ][j ][k ],
- tab[1 ][j + 1][k ],
- tab[0 ][j ][k + 1]));
- gr->tetrahedra.push_back(new MTetrahedron(tab[1 ][j ][k ],
- tab[1 ][j + 1][k ],
- tab[0 ][j ][k + 1],
- tab[1 ][j ][k + 1]));
- gr->tetrahedra.push_back(new MTetrahedron(tab[0 ][j ][k + 1],
- tab[1 ][j + 1][k + 1],
- tab[1 ][j ][k + 1],
- tab[1 ][j + 1][k ]));
+ gr->tetrahedra.push_back(new MTetrahedron(
+ tab[0][j][k], tab[1][j][k], tab[1][j + 1][k], tab[0][j][k + 1]));
+ gr->tetrahedra.push_back(
+ new MTetrahedron(tab[1][j][k], tab[1][j + 1][k], tab[0][j][k + 1],
+ tab[1][j][k + 1]));
+ gr->tetrahedra.push_back(
+ new MTetrahedron(tab[0][j][k + 1], tab[1][j + 1][k + 1],
+ tab[1][j][k + 1], tab[1][j + 1][k]));
}
else {
- Msg::Error("Wrong surface recombination in transfinite volume %d", gr->tag());
+ Msg::Error("Wrong surface recombination in transfinite volume %d",
+ gr->tag());
return 0;
}
}
@@ -617,25 +625,30 @@ int MeshTransfiniteVolume(GRegion *gr)
for(int i = 1; i < N_i - 1; i++) {
for(int j = 0; j < N_j - 1; j++) {
for(int k = 0; k < N_k - 1; k++) {
- if(gr->meshAttributes.QuadTri){
+ if(gr->meshAttributes.QuadTri) {
// create vertex array
- std::vector<MVertex*> verts;
+ std::vector<MVertex *> verts;
verts.resize(8);
- verts[0] = tab[i][j][k]; verts[1] = tab[i+1][j][k];
- verts[2] = tab[i+1][j+1][k]; verts[3] = tab[i][j+1][k];
- verts[4] = tab[i][j][k+1]; verts[5] = tab[i+1][j][k+1];
- verts[6] = tab[i+1][j+1][k+1]; verts[7] = tab[i][j+1][k+1];
- if((!orientedFaces[1].recombined() && i == N_i-2) ||
- (!orientedFaces[0].recombined() && j == 0) ||
- (!orientedFaces[2].recombined() && j == N_j-2) ||
- (!orientedFaces[4].recombined() && k == 0) ||
- (!orientedFaces[5].recombined() && k == N_k-2)){
+ verts[0] = tab[i][j][k];
+ verts[1] = tab[i + 1][j][k];
+ verts[2] = tab[i + 1][j + 1][k];
+ verts[3] = tab[i][j + 1][k];
+ verts[4] = tab[i][j][k + 1];
+ verts[5] = tab[i + 1][j][k + 1];
+ verts[6] = tab[i + 1][j + 1][k + 1];
+ verts[7] = tab[i][j + 1][k + 1];
+ if((!orientedFaces[1].recombined() && i == N_i - 2) ||
+ (!orientedFaces[0].recombined() && j == 0) ||
+ (!orientedFaces[2].recombined() && j == N_j - 2) ||
+ (!orientedFaces[4].recombined() && k == 0) ||
+ (!orientedFaces[5].recombined() && k == N_k - 2)) {
// make subdivided element
meshTransfElemWithInternalVertex(gr, verts, &boundary_diags);
}
else
- gr->hexahedra.push_back(new MHexahedron(verts[0], verts[1], verts[2], verts[3],
- verts[4], verts[5], verts[6], verts[7]));
+ gr->hexahedra.push_back(
+ new MHexahedron(verts[0], verts[1], verts[2], verts[3],
+ verts[4], verts[5], verts[6], verts[7]));
// continue, skipping the rest which is for non-divided elements
continue;
}
@@ -644,14 +657,18 @@ int MeshTransfiniteVolume(GRegion *gr)
orientedFaces[5].recombined()) {
gr->hexahedra.push_back(CREATE_HEX);
}
- else if(orientedFaces[0].recombined() && orientedFaces[1].recombined() &&
- orientedFaces[2].recombined() && !orientedFaces[4].recombined() &&
+ else if(orientedFaces[0].recombined() &&
+ orientedFaces[1].recombined() &&
+ orientedFaces[2].recombined() &&
+ !orientedFaces[4].recombined() &&
!orientedFaces[5].recombined()) {
gr->prisms.push_back(CREATE_PRISM_1);
gr->prisms.push_back(CREATE_PRISM_2);
}
- else if(!orientedFaces[0].recombined() && !orientedFaces[1].recombined() &&
- !orientedFaces[2].recombined() && !orientedFaces[4].recombined() &&
+ else if(!orientedFaces[0].recombined() &&
+ !orientedFaces[1].recombined() &&
+ !orientedFaces[2].recombined() &&
+ !orientedFaces[4].recombined() &&
!orientedFaces[5].recombined()) {
gr->tetrahedra.push_back(CREATE_SIM_1);
gr->tetrahedra.push_back(CREATE_SIM_2);
@@ -661,7 +678,8 @@ int MeshTransfiniteVolume(GRegion *gr)
gr->tetrahedra.push_back(CREATE_SIM_6);
}
else {
- Msg::Error("Wrong surface recombination in transfinite volume %d", gr->tag());
+ Msg::Error("Wrong surface recombination in transfinite volume %d",
+ gr->tag());
return 0;
}
}
diff --git a/Mesh/meshMetric.cpp b/Mesh/meshMetric.cpp
index b41cb70742d5178194a130844e243ecef6df23a1..f77b835e97326b4a80dd94afb49ce4fdb907c316 100644
--- a/Mesh/meshMetric.cpp
+++ b/Mesh/meshMetric.cpp
@@ -16,22 +16,22 @@
meshMetric::meshMetric(GModel *gm)
{
hasAnalyticalMetric = false;
- _dim = gm->getDim();
- std::map<MElement*, MElement*> newP;
- std::map<MElement*, MElement*> newD;
+ _dim = gm->getDim();
+ std::map<MElement *, MElement *> newP;
+ std::map<MElement *, MElement *> newD;
- if (_dim == 2){
- for (GModel::fiter fit = gm->firstFace(); fit != gm->lastFace(); ++fit){
- for (unsigned int i=0;i<(*fit)->getNumMeshElements();i++){
+ if(_dim == 2) {
+ for(GModel::fiter fit = gm->firstFace(); fit != gm->lastFace(); ++fit) {
+ for(unsigned int i = 0; i < (*fit)->getNumMeshElements(); i++) {
MElement *e = (*fit)->getMeshElement(i);
MElement *copy = e->copy(_vertexMap, newP, newD);
_elements.push_back(copy);
}
}
}
- else if (_dim == 3){
- for (GModel::riter rit = gm->firstRegion(); rit != gm->lastRegion(); ++rit){
- for (unsigned int i=0;i<(*rit)->getNumMeshElements();i++){
+ else if(_dim == 3) {
+ for(GModel::riter rit = gm->firstRegion(); rit != gm->lastRegion(); ++rit) {
+ for(unsigned int i = 0; i < (*rit)->getNumMeshElements(); i++) {
MElement *e = (*rit)->getMeshElement(i);
MElement *copy = e->copy(_vertexMap, newP, newD);
_elements.push_back(copy);
@@ -39,25 +39,25 @@ meshMetric::meshMetric(GModel *gm)
}
}
_octree = new MElementOctree(_elements);
- buildVertexToElement (_elements,_adj);
+ buildVertexToElement(_elements, _adj);
}
-meshMetric::meshMetric(std::vector<MElement*> elements)
+meshMetric::meshMetric(std::vector<MElement *> elements)
{
hasAnalyticalMetric = false;
- _dim = elements[0]->getDim();
- std::map<MElement*, MElement*> newP;
- std::map<MElement*, MElement*> newD;
+ _dim = elements[0]->getDim();
+ std::map<MElement *, MElement *> newP;
+ std::map<MElement *, MElement *> newD;
- for (unsigned int i=0;i<elements.size();i++){
+ for(unsigned int i = 0; i < elements.size(); i++) {
MElement *e = elements[i];
MElement *copy = e->copy(_vertexMap, newP, newD);
_elements.push_back(copy);
}
_octree = new MElementOctree(_elements);
- buildVertexToElement (_elements,_adj);
+ buildVertexToElement(_elements, _adj);
}
void meshMetric::addMetric(int technique, simpleFunction<double> *fct,
@@ -70,39 +70,41 @@ void meshMetric::addMetric(int technique, simpleFunction<double> *fct,
setOfParameters[metricNumber] = parameters;
setOfTechniques[metricNumber] = technique;
- if (fct->hasDerivatives()) hasAnalyticalMetric = true;
+ if(fct->hasDerivatives()) hasAnalyticalMetric = true;
computeMetric(metricNumber);
}
void meshMetric::updateMetrics()
{
- if (!setOfMetrics.size()){
+ if(!setOfMetrics.size()) {
Msg::Error("Can't intersect metrics, no metric registered");
return;
}
- v2t_cont :: iterator it = _adj.begin();
- for (;it != _adj.end();it++) {
+ v2t_cont ::iterator it = _adj.begin();
+ for(; it != _adj.end(); it++) {
MVertex *ver = it->first;
_nodalMetrics[ver] = setOfMetrics[0][ver];
_nodalSizes[ver] = setOfSizes[0][ver];
- if (setOfMetrics.size() > 1)
- for (unsigned int i=1;i<setOfMetrics.size();i++){
- _nodalMetrics[ver] = (_dim == 3) ?
- intersection_conserve_mostaniso(_nodalMetrics[ver],setOfMetrics[i][ver]) :
- intersection_conserve_mostaniso_2d(_nodalMetrics[ver],setOfMetrics[i][ver]);
- _nodalSizes[ver] = std::min(_nodalSizes[ver],setOfSizes[i][ver]);
+ if(setOfMetrics.size() > 1)
+ for(unsigned int i = 1; i < setOfMetrics.size(); i++) {
+ _nodalMetrics[ver] =
+ (_dim == 3) ? intersection_conserve_mostaniso(_nodalMetrics[ver],
+ setOfMetrics[i][ver]) :
+ intersection_conserve_mostaniso_2d(
+ _nodalMetrics[ver], setOfMetrics[i][ver]);
+ _nodalSizes[ver] = std::min(_nodalSizes[ver], setOfSizes[i][ver]);
}
}
- needMetricUpdate=false;
+ needMetricUpdate = false;
}
-void meshMetric::exportInfo(const char * fileendname)
+void meshMetric::exportInfo(const char *fileendname)
{
- if (needMetricUpdate) updateMetrics();
- std::stringstream sg,sm,sl,sh,shm;
+ if(needMetricUpdate) updateMetrics();
+ std::stringstream sg, sm, sl, sh, shm;
sg << "meshmetric_gradients_" << fileendname;
sm << "meshmetric_metric_" << fileendname;
sl << "meshmetric_levelset_" << fileendname;
@@ -118,11 +120,11 @@ void meshMetric::exportInfo(const char * fileendname)
out_ls << "View \"ls\"{" << std::endl;
out_hess << "View \"hessian\"{" << std::endl;
out_hessmat << "View \"hessian_mat\"{" << std::endl;
- std::vector<MElement*>::iterator itelem = _elements.begin();
- std::vector<MElement*>::iterator itelemen = _elements.end();
- for (;itelem!=itelemen;itelem++){
- MElement* e = *itelem;
- if (e->getDim() == 2) {
+ std::vector<MElement *>::iterator itelem = _elements.begin();
+ std::vector<MElement *>::iterator itelemen = _elements.end();
+ for(; itelem != itelemen; itelem++) {
+ MElement *e = *itelem;
+ if(e->getDim() == 2) {
out_metric << "TT(";
out_grad << "VT(";
out_ls << "ST(";
@@ -136,21 +138,21 @@ void meshMetric::exportInfo(const char * fileendname)
out_hess << "SS(";
out_hessmat << "TS(";
}
- for (std::size_t i = 0; i < e->getNumVertices(); i++) {
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) {
MVertex *ver = e->getVertex(i);
out_metric << ver->x() << "," << ver->y() << "," << ver->z();
out_grad << ver->x() << "," << ver->y() << "," << ver->z();
out_ls << ver->x() << "," << ver->y() << "," << ver->z();
out_hess << ver->x() << "," << ver->y() << "," << ver->z();
out_hessmat << ver->x() << "," << ver->y() << "," << ver->z();
- if (i!=e->getNumVertices()-1){
+ if(i != e->getNumVertices() - 1) {
out_metric << ",";
out_grad << ",";
out_ls << ",";
out_hess << ",";
out_hessmat << ",";
}
- else{
+ else {
out_metric << "){";
out_grad << "){";
out_ls << "){";
@@ -158,11 +160,12 @@ void meshMetric::exportInfo(const char * fileendname)
out_hessmat << "){";
}
}
- for ( std::size_t i = 0; i < e->getNumVertices(); i++) {
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) {
MVertex *ver = e->getVertex(i);
out_ls << vals[ver];
- out_hess << (hessians[ver](0,0) + hessians[ver](1,1) + hessians[ver](2,2));
- if (i == (e->getNumVertices() - 1)){
+ out_hess << (hessians[ver](0, 0) + hessians[ver](1, 1) +
+ hessians[ver](2, 2));
+ if(i == (e->getNumVertices() - 1)) {
out_ls << "};" << std::endl;
out_hess << "};" << std::endl;
}
@@ -170,14 +173,16 @@ void meshMetric::exportInfo(const char * fileendname)
out_ls << ",";
out_hess << ",";
}
- for (int k=0;k<3;k++){
+ for(int k = 0; k < 3; k++) {
out_grad << grads[ver](k);
- if ((k == 2) && (i == (e->getNumVertices() - 1))) out_grad << "};" << std::endl;
- else out_grad << ",";
- for (int l=0;l<3;l++){
- out_metric << _nodalMetrics[ver](k,l);
- out_hessmat << hessians[ver](k,l);
- if ((k == 2) && (l == 2) && (i == (e->getNumVertices() - 1))) {
+ if((k == 2) && (i == (e->getNumVertices() - 1)))
+ out_grad << "};" << std::endl;
+ else
+ out_grad << ",";
+ for(int l = 0; l < 3; l++) {
+ out_metric << _nodalMetrics[ver](k, l);
+ out_hessmat << hessians[ver](k, l);
+ if((k == 2) && (l == 2) && (i == (e->getNumVertices() - 1))) {
out_metric << "};" << std::endl;
out_hessmat << "};" << std::endl;
}
@@ -203,359 +208,441 @@ void meshMetric::exportInfo(const char * fileendname)
meshMetric::~meshMetric()
{
- if (_octree) delete _octree;
- for (unsigned int i=0; i< _elements.size(); i++)
- delete _elements[i];
+ if(_octree) delete _octree;
+ for(unsigned int i = 0; i < _elements.size(); i++) delete _elements[i];
}
void meshMetric::computeValues()
{
-
- v2t_cont :: iterator it = _adj.begin();
- while (it != _adj.end()) {
- std::vector<MElement*> lt = it->second;
+ v2t_cont ::iterator it = _adj.begin();
+ while(it != _adj.end()) {
+ std::vector<MElement *> lt = it->second;
MVertex *ver = it->first;
- vals[ver]= (*_fct)(ver->x(),ver->y(),ver->z());
+ vals[ver] = (*_fct)(ver->x(), ver->y(), ver->z());
it++;
}
-
}
// Determines set of vertices to use for least squares
-std::vector<MVertex*> getLSBlob(unsigned int minNbPt, v2t_cont::iterator it,
- v2t_cont &adj)
+std::vector<MVertex *> getLSBlob(unsigned int minNbPt, v2t_cont::iterator it,
+ v2t_cont &adj)
{
-
// static const double RADFACT = 3;
//
// SPoint3 p0 = it->first->point(); // Vertex coordinates (center of circle)
//
// double rad = 0.;
- // for (std::vector<MElement*>::iterator itEl = it->second.begin(); itEl != it->second.end(); itEl++)
+ // for (std::vector<MElement*>::iterator itEl = it->second.begin(); itEl !=
+ // it->second.end(); itEl++)
// rad = std::max(rad,(*itEl)->getOuterRadius());
// rad *= RADFACT;
- std::vector<MVertex*> vv(1,it->first), bvv = vv; // Vector of vertices in blob and in boundary of blob
+ std::vector<MVertex *> vv(1, it->first),
+ bvv = vv; // Vector of vertices in blob and in boundary of blob
do {
- std::set<MVertex*> nbvv; // Set of vertices in new boundary
- for (std::vector<MVertex*>::iterator itBV = bvv.begin(); itBV != bvv.end(); itBV++) { // For each boundary vertex...
- std::vector<MElement*> &adjBV = adj[*itBV];
- for (std::vector<MElement*>::iterator itBVEl = adjBV.begin(); itBVEl != adjBV.end(); itBVEl++) {
- for (std::size_t iV=0; iV<(*itBVEl)->getNumVertices(); iV++){ // ... look for adjacent vertices...
+ std::set<MVertex *> nbvv; // Set of vertices in new boundary
+ for(std::vector<MVertex *>::iterator itBV = bvv.begin(); itBV != bvv.end();
+ itBV++) { // For each boundary vertex...
+ std::vector<MElement *> &adjBV = adj[*itBV];
+ for(std::vector<MElement *>::iterator itBVEl = adjBV.begin();
+ itBVEl != adjBV.end(); itBVEl++) {
+ for(std::size_t iV = 0; iV < (*itBVEl)->getNumVertices();
+ iV++) { // ... look for adjacent vertices...
MVertex *v = (*itBVEl)->getVertex(iV);
- // if ((find(vv.begin(),vv.end(),v) == vv.end()) && (p0.distance(v->point()) <= rad)) nbvv.insert(v);
- if (find(vv.begin(),vv.end(),v) == vv.end()) nbvv.insert(v); // ... and add them in the new boundary if they are not already in the blob
+ // if ((find(vv.begin(),vv.end(),v) == vv.end()) &&
+ // (p0.distance(v->point()) <= rad)) nbvv.insert(v);
+ if(find(vv.begin(), vv.end(), v) == vv.end())
+ nbvv.insert(v); // ... and add them in the new boundary if they are
+ // not already in the blob
}
}
}
- if (nbvv.empty()) bvv.clear();
+ if(nbvv.empty())
+ bvv.clear();
else {
- bvv.assign(nbvv.begin(),nbvv.end());
- vv.insert(vv.end(),nbvv.begin(),nbvv.end());
+ bvv.assign(nbvv.begin(), nbvv.end());
+ vv.insert(vv.end(), nbvv.begin(), nbvv.end());
}
// } while (!bvv.empty());
- } while (vv.size() < minNbPt); // Repeat until min. number of points is reached
+ } while(vv.size() < minNbPt); // Repeat until min. number of points is reached
return vv;
-
}
// Compute derivatives and second order derivatives using least squares
// 2D LS system: a_i0*x^2+a_i1*x*y+a_i2*y^2+a_i3*x+a_i4*y+a_i5=b_i
-// 3D LS system: a_i0*x^2+a_i1*x*y+a_i2*x*z+a_i3*y^2+a_i4*y*z+a_i5*z^2+a_i6*x+a_i7*y+a_i8*z+a_i9=b_i
+// 3D LS system:
+// a_i0*x^2+a_i1*x*y+a_i2*x*z+a_i3*y^2+a_i4*y*z+a_i5*z^2+a_i6*x+a_i7*y+a_i8*z+a_i9=b_i
void meshMetric::computeHessian()
{
unsigned int sysDim = (_dim == 2) ? 6 : 10;
- unsigned int minNbPtBlob = 3*sysDim;
+ unsigned int minNbPtBlob = 3 * sysDim;
- for (v2t_cont::iterator it = _adj.begin(); it != _adj.end(); it++) {
+ for(v2t_cont::iterator it = _adj.begin(); it != _adj.end(); it++) {
MVertex *ver = it->first;
- std::vector<MVertex*> vv = getLSBlob(minNbPtBlob, it, _adj);
- fullMatrix<double> A(vv.size(),sysDim), ATA(sysDim,sysDim);
+ std::vector<MVertex *> vv = getLSBlob(minNbPtBlob, it, _adj);
+ fullMatrix<double> A(vv.size(), sysDim), ATA(sysDim, sysDim);
fullVector<double> b(vv.size()), ATb(sysDim), coeffs(sysDim);
- for(unsigned int i=0; i<vv.size(); i++) {
+ for(unsigned int i = 0; i < vv.size(); i++) {
const double &x = vv[i]->x(), &y = vv[i]->y(), &z = vv[i]->z();
- if (_dim == 2) {
- A(i,0) = x*x; A(i,1) = x*y; A(i,2) = y*y;
- A(i,3) = x; A(i,4) = y; A(i,5) = 1.;
+ if(_dim == 2) {
+ A(i, 0) = x * x;
+ A(i, 1) = x * y;
+ A(i, 2) = y * y;
+ A(i, 3) = x;
+ A(i, 4) = y;
+ A(i, 5) = 1.;
}
else {
- A(i,0) = x*x; A(i,1) = x*y; A(i,2) = x*z; A(i,3) = y*y; A(i,4) = y*z; A(i,5) = z*z;
- A(i,6) = x; A(i,7) = y; A(i,8) = z; A(i,9) = 1.;
+ A(i, 0) = x * x;
+ A(i, 1) = x * y;
+ A(i, 2) = x * z;
+ A(i, 3) = y * y;
+ A(i, 4) = y * z;
+ A(i, 5) = z * z;
+ A(i, 6) = x;
+ A(i, 7) = y;
+ A(i, 8) = z;
+ A(i, 9) = 1.;
}
b(i) = vals[vv[i]];
}
- ATA.gemm(A,A,1.,0., true, false);
- A.multWithATranspose(b,1.,0.,ATb);
- ATA.luSolve(ATb,coeffs);
+ ATA.gemm(A, A, 1., 0., true, false);
+ A.multWithATranspose(b, 1., 0., ATb);
+ ATA.luSolve(ATb, coeffs);
const double &x = ver->x(), &y = ver->y(), &z = ver->z();
double d2udx2, d2udy2, d2udz2, d2udxy, d2udxz, d2udyz, dudx, dudy, dudz;
- if (_dim == 2) {
- d2udx2 = 2.*coeffs(0); d2udy2 = 2.*coeffs(2); d2udz2 = 0.;
- d2udxy = coeffs(1); d2udxz = 0.; d2udyz = 0.;
- dudx = d2udx2*x+d2udxy*y+coeffs(3);
- dudy = d2udxy*x+d2udy2*y+coeffs(4);
+ if(_dim == 2) {
+ d2udx2 = 2. * coeffs(0);
+ d2udy2 = 2. * coeffs(2);
+ d2udz2 = 0.;
+ d2udxy = coeffs(1);
+ d2udxz = 0.;
+ d2udyz = 0.;
+ dudx = d2udx2 * x + d2udxy * y + coeffs(3);
+ dudy = d2udxy * x + d2udy2 * y + coeffs(4);
dudz = 0.;
}
else {
- d2udx2 = 2.*coeffs(0); d2udy2 = 2.*coeffs(3); d2udz2 = 2.*coeffs(5);
- d2udxy = coeffs(1); d2udxz = coeffs(2); d2udyz = coeffs(4);
- dudx = d2udx2*x+d2udxy*y+d2udxz*z+coeffs(6);
- dudy = d2udxy*x+d2udy2*y+d2udyz*z+coeffs(7);
- dudz = d2udxz*x+d2udyz*y+d2udz2*z+coeffs(8);
+ d2udx2 = 2. * coeffs(0);
+ d2udy2 = 2. * coeffs(3);
+ d2udz2 = 2. * coeffs(5);
+ d2udxy = coeffs(1);
+ d2udxz = coeffs(2);
+ d2udyz = coeffs(4);
+ dudx = d2udx2 * x + d2udxy * y + d2udxz * z + coeffs(6);
+ dudy = d2udxy * x + d2udy2 * y + d2udyz * z + coeffs(7);
+ dudz = d2udxz * x + d2udyz * y + d2udz2 * z + coeffs(8);
}
- double duNorm = sqrt(dudx*dudx+dudy*dudy+dudz*dudz);
- if (duNorm == 0. || _technique == meshMetric::HESSIAN ||
- _technique == meshMetric::EIGENDIRECTIONS ||
- _technique == meshMetric::EIGENDIRECTIONS_LINEARINTERP_H) duNorm = 1.;
- grads[ver] = SVector3(dudx/duNorm,dudy/duNorm,dudz/duNorm);
- hessians[ver](0,0) = d2udx2; hessians[ver](0,1) = d2udxy; hessians[ver](0,2) = d2udxz;
- hessians[ver](1,0) = d2udxy; hessians[ver](1,1) = d2udy2; hessians[ver](1,2) = d2udyz;
- hessians[ver](2,0) = d2udxz; hessians[ver](2,1) = d2udyz; hessians[ver](2,2) = d2udz2;
+ double duNorm = sqrt(dudx * dudx + dudy * dudy + dudz * dudz);
+ if(duNorm == 0. || _technique == meshMetric::HESSIAN ||
+ _technique == meshMetric::EIGENDIRECTIONS ||
+ _technique == meshMetric::EIGENDIRECTIONS_LINEARINTERP_H)
+ duNorm = 1.;
+ grads[ver] = SVector3(dudx / duNorm, dudy / duNorm, dudz / duNorm);
+ hessians[ver](0, 0) = d2udx2;
+ hessians[ver](0, 1) = d2udxy;
+ hessians[ver](0, 2) = d2udxz;
+ hessians[ver](1, 0) = d2udxy;
+ hessians[ver](1, 1) = d2udy2;
+ hessians[ver](1, 2) = d2udyz;
+ hessians[ver](2, 0) = d2udxz;
+ hessians[ver](2, 1) = d2udyz;
+ hessians[ver](2, 2) = d2udz2;
}
}
void meshMetric::computeMetricLevelSet(MVertex *ver, SMetric3 &hessian,
- SMetric3 &metric, double &size,
- double x, double y, double z)
+ SMetric3 &metric, double &size, double x,
+ double y, double z)
{
double signed_dist;
SVector3 gr;
- if(ver){
+ if(ver) {
signed_dist = vals[ver];
gr = grads[ver];
hessian = hessians[ver];
}
- else{
- signed_dist = (*_fct)(x,y,z);
- _fct->gradient(x,y,z,gr(0),gr(1),gr(2));
- _fct->hessian(x,y,z, hessian(0,0),hessian(0,1),hessian(0,2),
- hessian(1,0),hessian(1,1),hessian(1,2),
- hessian(2,0),hessian(2,1),hessian(2,2));
+ else {
+ signed_dist = (*_fct)(x, y, z);
+ _fct->gradient(x, y, z, gr(0), gr(1), gr(2));
+ _fct->hessian(x, y, z, hessian(0, 0), hessian(0, 1), hessian(0, 2),
+ hessian(1, 0), hessian(1, 1), hessian(1, 2), hessian(2, 0),
+ hessian(2, 1), hessian(2, 2));
}
double dist = fabs(signed_dist);
SMetric3 H;
- double norm = gr(0)*gr(0)+gr(1)*gr(1)+gr(2)*gr(2);
- if (dist < _E && norm != 0.0){
- double h = hmin*(hmax/hmin-1)*dist/_E + hmin;
- double C = 1./(h*h) -1./(hmax*hmax);
- H(0,0) += C*gr(0)*gr(0)/norm ;
- H(1,1) += C*gr(1)*gr(1)/norm ;
- H(2,2) += C*gr(2)*gr(2)/norm ;
- H(1,0) = H(0,1) = C*gr(1)*gr(0)/norm ;
- H(2,0) = H(0,2) = C*gr(2)*gr(0)/norm ;
- H(2,1) = H(1,2) = C*gr(2)*gr(1)/norm ;
- }
-
- fullMatrix<double> V(3,3);
+ double norm = gr(0) * gr(0) + gr(1) * gr(1) + gr(2) * gr(2);
+ if(dist < _E && norm != 0.0) {
+ double h = hmin * (hmax / hmin - 1) * dist / _E + hmin;
+ double C = 1. / (h * h) - 1. / (hmax * hmax);
+ H(0, 0) += C * gr(0) * gr(0) / norm;
+ H(1, 1) += C * gr(1) * gr(1) / norm;
+ H(2, 2) += C * gr(2) * gr(2) / norm;
+ H(1, 0) = H(0, 1) = C * gr(1) * gr(0) / norm;
+ H(2, 0) = H(0, 2) = C * gr(2) * gr(0) / norm;
+ H(2, 1) = H(1, 2) = C * gr(2) * gr(1) / norm;
+ }
+
+ fullMatrix<double> V(3, 3);
fullVector<double> S(3);
- H.eig(V,S);
+ H.eig(V, S);
double lambda1, lambda2, lambda3;
lambda1 = S(0);
lambda2 = S(1);
- lambda3 = (_dim == 3)? S(2) : 1.;
+ lambda3 = (_dim == 3) ? S(2) : 1.;
- SVector3 t1 (V(0,0),V(1,0),V(2,0));
- SVector3 t2 (V(0,1),V(1,1),V(2,1));
- SVector3 t3 (V(0,2),V(1,2),V(2,2));
+ SVector3 t1(V(0, 0), V(1, 0), V(2, 0));
+ SVector3 t2(V(0, 1), V(1, 1), V(2, 1));
+ SVector3 t3(V(0, 2), V(1, 2), V(2, 2));
- size = std::min(std::min(1/sqrt(lambda1),1/sqrt(lambda2)),1/sqrt(lambda3));
- metric = SMetric3(lambda1,lambda2,lambda3,t1,t2,t3);
+ size =
+ std::min(std::min(1 / sqrt(lambda1), 1 / sqrt(lambda2)), 1 / sqrt(lambda3));
+ metric = SMetric3(lambda1, lambda2, lambda3, t1, t2, t3);
}
void meshMetric::computeMetricHessian(MVertex *ver, SMetric3 &hessian,
- SMetric3 &metric, double &size,
- double x, double y, double z)
+ SMetric3 &metric, double &size, double x,
+ double y, double z)
{
-
SVector3 gr;
- if(ver != NULL){
+ if(ver != NULL) {
gr = grads[ver];
hessian = hessians[ver];
}
- else if (ver == NULL){
- _fct->gradient(x,y,z,gr(0),gr(1),gr(2));
- _fct->hessian(x,y,z, hessian(0,0),hessian(0,1),hessian(0,2),
- hessian(1,0),hessian(1,1),hessian(1,2),
- hessian(2,0),hessian(2,1),hessian(2,2));
+ else if(ver == NULL) {
+ _fct->gradient(x, y, z, gr(0), gr(1), gr(2));
+ _fct->hessian(x, y, z, hessian(0, 0), hessian(0, 1), hessian(0, 2),
+ hessian(1, 0), hessian(1, 1), hessian(1, 2), hessian(2, 0),
+ hessian(2, 1), hessian(2, 2));
}
double _epsilonP = 1.;
double hminP = 1.e-12;
double hmaxP = 1.e+12;
- fullMatrix<double> V(3,3);
+ fullMatrix<double> V(3, 3);
fullVector<double> S(3);
- hessian.eig(V,S);
-
- double lambda1 = std::min(std::max(fabs(S(0))/_epsilonP,1./(hmaxP*hmaxP)),1./(hminP*hminP));
- double lambda2 = std::min(std::max(fabs(S(1))/_epsilonP,1./(hmaxP*hmaxP)),1./(hminP*hminP));
- double lambda3 = (_dim == 3) ? std::min(std::max(fabs(S(2))/_epsilonP,1./(hmaxP*hmaxP)),1./(hminP*hminP)) : 1.;
-
- SVector3 t1 (V(0,0),V(1,0),V(2,0));
- SVector3 t2 (V(0,1),V(1,1),V(2,1));
- SVector3 t3 = (_dim == 3) ? SVector3(V(0,2),V(1,2),V(2,2)) : SVector3(0.,0.,1.);
-
- size = std::min(std::min(1/sqrt(lambda1),1/sqrt(lambda2)),1/sqrt(lambda3));
- metric = SMetric3(lambda1,lambda2,lambda3,t1,t2,t3);
-
+ hessian.eig(V, S);
+
+ double lambda1 =
+ std::min(std::max(fabs(S(0)) / _epsilonP, 1. / (hmaxP * hmaxP)),
+ 1. / (hminP * hminP));
+ double lambda2 =
+ std::min(std::max(fabs(S(1)) / _epsilonP, 1. / (hmaxP * hmaxP)),
+ 1. / (hminP * hminP));
+ double lambda3 =
+ (_dim == 3) ?
+ std::min(std::max(fabs(S(2)) / _epsilonP, 1. / (hmaxP * hmaxP)),
+ 1. / (hminP * hminP)) :
+ 1.;
+
+ SVector3 t1(V(0, 0), V(1, 0), V(2, 0));
+ SVector3 t2(V(0, 1), V(1, 1), V(2, 1));
+ SVector3 t3 =
+ (_dim == 3) ? SVector3(V(0, 2), V(1, 2), V(2, 2)) : SVector3(0., 0., 1.);
+
+ size =
+ std::min(std::min(1 / sqrt(lambda1), 1 / sqrt(lambda2)), 1 / sqrt(lambda3));
+ metric = SMetric3(lambda1, lambda2, lambda3, t1, t2, t3);
}
void meshMetric::computeMetricFrey(MVertex *ver, SMetric3 &hessian,
- SMetric3 &metric, double &size,
- double x, double y, double z)
+ SMetric3 &metric, double &size, double x,
+ double y, double z)
{
double signed_dist;
SVector3 gr;
- if(ver){
+ if(ver) {
signed_dist = vals[ver];
gr = grads[ver];
hessian = hessians[ver];
}
- else{
- signed_dist = (*_fct)(x,y,z);
- _fct->gradient(x,y,z,gr(0),gr(1),gr(2));
- _fct->hessian(x,y,z, hessian(0,0),hessian(0,1),hessian(0,2),
- hessian(1,0),hessian(1,1),hessian(1,2),
- hessian(2,0),hessian(2,1),hessian(2,2));
+ else {
+ signed_dist = (*_fct)(x, y, z);
+ _fct->gradient(x, y, z, gr(0), gr(1), gr(2));
+ _fct->hessian(x, y, z, hessian(0, 0), hessian(0, 1), hessian(0, 2),
+ hessian(1, 0), hessian(1, 1), hessian(1, 2), hessian(2, 0),
+ hessian(2, 1), hessian(2, 2));
}
double dist = fabs(signed_dist);
- SMetric3 H(1./(hmax*hmax));
- double norm = gr(0)*gr(0)+gr(1)*gr(1)+gr(2)*gr(2);
- if (dist < _E && norm != 0.0){
- double h = hmin*(hmax/hmin-1.0)*dist/_E + hmin;
- double C = 1./(h*h) -1./(hmax*hmax);
- double kappa = hessian(0,0)+hessian(1,1)+hessian(2,2);
- double epsGeom = 4.0*3.14*3.14/(kappa*_Np*_Np);
- H(0,0) += C*gr(0)*gr(0)/(norm) + hessian(0,0)/epsGeom;
- H(1,1) += C*gr(1)*gr(1)/(norm) + hessian(1,1)/epsGeom;
- H(2,2) += C*gr(2)*gr(2)/(norm) + hessian(2,2)/epsGeom;
- H(1,0) = H(0,1) = C*gr(1)*gr(0)/(norm) + hessian(1,0)/epsGeom;
- H(2,0) = H(0,2) = C*gr(2)*gr(0)/(norm) + hessian(2,0)/epsGeom;
- H(2,1) = H(1,2) = C*gr(2)*gr(1)/(norm) + hessian(2,1)/epsGeom;
- }
-
- fullMatrix<double> V(3,3);
+ SMetric3 H(1. / (hmax * hmax));
+ double norm = gr(0) * gr(0) + gr(1) * gr(1) + gr(2) * gr(2);
+ if(dist < _E && norm != 0.0) {
+ double h = hmin * (hmax / hmin - 1.0) * dist / _E + hmin;
+ double C = 1. / (h * h) - 1. / (hmax * hmax);
+ double kappa = hessian(0, 0) + hessian(1, 1) + hessian(2, 2);
+ double epsGeom = 4.0 * 3.14 * 3.14 / (kappa * _Np * _Np);
+ H(0, 0) += C * gr(0) * gr(0) / (norm) + hessian(0, 0) / epsGeom;
+ H(1, 1) += C * gr(1) * gr(1) / (norm) + hessian(1, 1) / epsGeom;
+ H(2, 2) += C * gr(2) * gr(2) / (norm) + hessian(2, 2) / epsGeom;
+ H(1, 0) = H(0, 1) = C * gr(1) * gr(0) / (norm) + hessian(1, 0) / epsGeom;
+ H(2, 0) = H(0, 2) = C * gr(2) * gr(0) / (norm) + hessian(2, 0) / epsGeom;
+ H(2, 1) = H(1, 2) = C * gr(2) * gr(1) / (norm) + hessian(2, 1) / epsGeom;
+ }
+
+ fullMatrix<double> V(3, 3);
fullVector<double> S(3);
- H.eig(V,S);
+ H.eig(V, S);
double lambda1, lambda2, lambda3;
lambda1 = S(0);
lambda2 = S(1);
- lambda3 = (_dim == 3)? S(2) : 1.;
-
- if (dist < _E) {
- lambda1 = std::min(std::max(fabs(S(0))/_epsilon,1./(hmax*hmax)),1./(hmin*hmin));
- lambda2 = std::min(std::max(fabs(S(1))/_epsilon,1./(hmax*hmax)),1./(hmin*hmin));
- lambda3 = (_dim == 3) ? std::min(std::max(fabs(S(2))/_epsilon,1./(hmax*hmax)),1./(hmin*hmin)) : 1.;
- }
-
- SVector3 t1 (V(0,0),V(1,0),V(2,0));
- SVector3 t2 (V(0,1),V(1,1),V(2,1));
- SVector3 t3 (V(0,2),V(1,2),V(2,2));
-
- size = std::min(std::min(1/sqrt(lambda1),1/sqrt(lambda2)),1/sqrt(lambda3));
- metric = SMetric3(lambda1,lambda2,lambda3,t1,t2,t3);
-
+ lambda3 = (_dim == 3) ? S(2) : 1.;
+
+ if(dist < _E) {
+ lambda1 = std::min(std::max(fabs(S(0)) / _epsilon, 1. / (hmax * hmax)),
+ 1. / (hmin * hmin));
+ lambda2 = std::min(std::max(fabs(S(1)) / _epsilon, 1. / (hmax * hmax)),
+ 1. / (hmin * hmin));
+ lambda3 = (_dim == 3) ?
+ std::min(std::max(fabs(S(2)) / _epsilon, 1. / (hmax * hmax)),
+ 1. / (hmin * hmin)) :
+ 1.;
+ }
+
+ SVector3 t1(V(0, 0), V(1, 0), V(2, 0));
+ SVector3 t2(V(0, 1), V(1, 1), V(2, 1));
+ SVector3 t3(V(0, 2), V(1, 2), V(2, 2));
+
+ size =
+ std::min(std::min(1 / sqrt(lambda1), 1 / sqrt(lambda2)), 1 / sqrt(lambda3));
+ metric = SMetric3(lambda1, lambda2, lambda3, t1, t2, t3);
}
void meshMetric::computeMetricEigenDir(MVertex *ver, SMetric3 &hessian,
- SMetric3 &metric, double &size,
- double x, double y, double z)
+ SMetric3 &metric, double &size, double x,
+ double y, double z)
{
double signed_dist;
SVector3 gVec;
- if(ver){
+ if(ver) {
signed_dist = vals[ver];
gVec = grads[ver];
hessian = hessians[ver];
}
- else{
- signed_dist = (*_fct)(x,y,z);
- _fct->gradient(x,y,z,gVec(0),gVec(1),gVec(2));
- _fct->hessian(x,y,z, hessian(0,0),hessian(0,1),hessian(0,2),
- hessian(1,0),hessian(1,1),hessian(1,2),
- hessian(2,0),hessian(2,1),hessian(2,2));
+ else {
+ signed_dist = (*_fct)(x, y, z);
+ _fct->gradient(x, y, z, gVec(0), gVec(1), gVec(2));
+ _fct->hessian(x, y, z, hessian(0, 0), hessian(0, 1), hessian(0, 2),
+ hessian(1, 0), hessian(1, 1), hessian(1, 2), hessian(2, 0),
+ hessian(2, 1), hessian(2, 2));
}
double dist = fabs(signed_dist);
- const double metric_value_hmax = 1./(hmax*hmax);
- const double gMag = gVec.norm(), invGMag = 1./gMag;
-
- if (signed_dist < _E && signed_dist > _E_moins && gMag != 0.0){
- const double metric_value_hmin = 1./(hmin*hmin);
- const SVector3 nVec = invGMag*gVec; // Unit normal vector
- double lambda_n = 0.; // Eigenvalues of metric for normal & tangential directions
- if (_technique==meshMetric::EIGENDIRECTIONS_LINEARINTERP_H){
- //const double h_dist = hmin + ((hmax-hmin)/_E)*dist; // Characteristic element size in the normal direction - linear interp between hmin and hmax
- //lambda_n = 1./(h_dist*h_dist);
+ const double metric_value_hmax = 1. / (hmax * hmax);
+ const double gMag = gVec.norm(), invGMag = 1. / gMag;
+
+ if(signed_dist < _E && signed_dist > _E_moins && gMag != 0.0) {
+ const double metric_value_hmin = 1. / (hmin * hmin);
+ const SVector3 nVec = invGMag * gVec; // Unit normal vector
+ double lambda_n =
+ 0.; // Eigenvalues of metric for normal & tangential directions
+ if(_technique == meshMetric::EIGENDIRECTIONS_LINEARINTERP_H) {
+ // const double h_dist = hmin + ((hmax-hmin)/_E)*dist;
+ // // Characteristic element size in the normal direction - linear interp
+ // between hmin and hmax lambda_n = 1./(h_dist*h_dist);
double beta = CTX::instance()->mesh.smoothRatio;
- double h_dista = std::min( (hmin+(dist*log(beta))), hmax);
- lambda_n = 1./(h_dista*h_dista);
+ double h_dista = std::min((hmin + (dist * log(beta))), hmax);
+ lambda_n = 1. / (h_dista * h_dista);
}
- else if(_technique==meshMetric::EIGENDIRECTIONS){
- const double maximum_distance = (signed_dist>0.) ? _E : fabs(_E_moins); // ... or linear interpolation between 1/h_min^2 and 1/h_max^2
- lambda_n = metric_value_hmin + ((metric_value_hmax-metric_value_hmin)/maximum_distance)*dist;
+ else if(_technique == meshMetric::EIGENDIRECTIONS) {
+ const double maximum_distance =
+ (signed_dist > 0.) ? _E : fabs(_E_moins); // ... or linear interpolation
+ // between 1/h_min^2 and
+ // 1/h_max^2
+ lambda_n =
+ metric_value_hmin +
+ ((metric_value_hmax - metric_value_hmin) / maximum_distance) * dist;
}
- std::vector<SVector3> tVec; // Unit tangential vectors
- std::vector<double> kappa; // Curvatures
- if (_dim == 2) { // 2D curvature formula: cf. R. Goldman, "Curvature formulas for implicit curves and surfaces", Computer Aided Geometric Design 22 (2005), pp. 632–658
+ std::vector<SVector3> tVec; // Unit tangential vectors
+ std::vector<double> kappa; // Curvatures
+ if(_dim == 2) { // 2D curvature formula: cf. R. Goldman, "Curvature formulas
+ // for implicit curves and surfaces", Computer Aided
+ // Geometric Design 22 (2005), pp. 632–658
kappa.resize(2);
- kappa[0] = fabs(-gVec(1)*(-gVec(1)*hessian(0,0)+gVec(0)*hessian(0,1))+
- gVec(0)*(-gVec(1)*hessian(1,0)+gVec(0)*hessian(1,1)))*pow(invGMag,3);
+ kappa[0] =
+ fabs(-gVec(1) * (-gVec(1) * hessian(0, 0) + gVec(0) * hessian(0, 1)) +
+ gVec(0) * (-gVec(1) * hessian(1, 0) + gVec(0) * hessian(1, 1))) *
+ pow(invGMag, 3);
kappa[1] = 1.;
tVec.resize(2);
- tVec[0] = SVector3(-nVec(1),nVec(0),0.);
- tVec[1] = SVector3(0.,0.,1.);
+ tVec[0] = SVector3(-nVec(1), nVec(0), 0.);
+ tVec[1] = SVector3(0., 0., 1.);
}
- else { // 3D curvature formula: cf. A.G. Belyaev, A.A. Pasko and T.L. Kunii, "Ridges and Ravines on Implicit Surfaces," CGI, pp.530-535, Computer Graphics International 1998 (CGI'98), 1998
- fullMatrix<double> ImGG(3,3);
- ImGG(0,0) = 1.-gVec(0)*gVec(0); ImGG(0,1) = -gVec(0)*gVec(1); ImGG(0,2) = -gVec(0)*gVec(2);
- ImGG(1,0) = -gVec(1)*gVec(0); ImGG(1,1) = 1.-gVec(1)*gVec(1); ImGG(1,2) = -gVec(1)*gVec(2);
- ImGG(2,0) = -gVec(2)*gVec(0); ImGG(2,1) = -gVec(2)*gVec(1); ImGG(2,2) = 1.-gVec(2)*gVec(2);
- fullMatrix<double> hess(3,3);
+ else { // 3D curvature formula: cf. A.G. Belyaev, A.A. Pasko and T.L. Kunii,
+ // "Ridges and Ravines on Implicit Surfaces," CGI, pp.530-535,
+ // Computer Graphics International 1998 (CGI'98), 1998
+ fullMatrix<double> ImGG(3, 3);
+ ImGG(0, 0) = 1. - gVec(0) * gVec(0);
+ ImGG(0, 1) = -gVec(0) * gVec(1);
+ ImGG(0, 2) = -gVec(0) * gVec(2);
+ ImGG(1, 0) = -gVec(1) * gVec(0);
+ ImGG(1, 1) = 1. - gVec(1) * gVec(1);
+ ImGG(1, 2) = -gVec(1) * gVec(2);
+ ImGG(2, 0) = -gVec(2) * gVec(0);
+ ImGG(2, 1) = -gVec(2) * gVec(1);
+ ImGG(2, 2) = 1. - gVec(2) * gVec(2);
+ fullMatrix<double> hess(3, 3);
hessian.getMat(hess);
- fullMatrix<double> gN(3,3); // Gradient of unit normal
- gN.gemm(ImGG,hess,1.,0.);
+ fullMatrix<double> gN(3, 3); // Gradient of unit normal
+ gN.gemm(ImGG, hess, 1., 0.);
gN.scale(invGMag);
- fullMatrix<double> eigVecL(3,3), eigVecR(3,3);
+ fullMatrix<double> eigVecL(3, 3), eigVecR(3, 3);
fullVector<double> eigValRe(3), eigValIm(3);
- gN.eig(eigValRe,eigValIm,eigVecL,eigVecR,false); // Eigendecomp. of gradient of unit normal
- kappa.resize(3); // Store abs. val. of eigenvalues (= principal curvatures only in non-normal directions)
+ gN.eig(eigValRe, eigValIm, eigVecL, eigVecR,
+ false); // Eigendecomp. of gradient of unit normal
+ kappa.resize(3); // Store abs. val. of eigenvalues (= principal curvatures
+ // only in non-normal directions)
kappa[0] = fabs(eigValRe(0));
kappa[1] = fabs(eigValRe(1));
kappa[2] = fabs(eigValRe(2));
- tVec.resize(3); // Store normalized eigenvectors (= principal directions only in non-normal directions)
- tVec[0] = SVector3(eigVecR(0,0),eigVecR(1,0),eigVecR(2,0));
+ tVec.resize(3); // Store normalized eigenvectors (= principal directions
+ // only in non-normal directions)
+ tVec[0] = SVector3(eigVecR(0, 0), eigVecR(1, 0), eigVecR(2, 0));
tVec[0].normalize();
- tVec[1] = SVector3(eigVecR(0,1),eigVecR(1,1),eigVecR(2,1));
+ tVec[1] = SVector3(eigVecR(0, 1), eigVecR(1, 1), eigVecR(2, 1));
tVec[1].normalize();
- tVec[2] = SVector3(eigVecR(0,2),eigVecR(1,2),eigVecR(2,2));
+ tVec[2] = SVector3(eigVecR(0, 2), eigVecR(1, 2), eigVecR(2, 2));
tVec[2].normalize();
- std::vector<double> tVecDotNVec(3); // Store dot products with normal vector to look for normal direction
- tVecDotNVec[0] = fabs(dot(tVec[0],nVec));
- tVecDotNVec[1] = fabs(dot(tVec[1],nVec));
- tVecDotNVec[2] = fabs(dot(tVec[2],nVec));
- const int i_N = max_element(tVecDotNVec.begin(),tVecDotNVec.end())-tVecDotNVec.begin(); // Index of normal dir. = max. dot products (close to 0. in tangential dir.)
- kappa.erase(kappa.begin()+i_N); // Remove normal dir.
- tVec.erase(tVec.begin()+i_N);
+ std::vector<double> tVecDotNVec(3); // Store dot products with normal
+ // vector to look for normal direction
+ tVecDotNVec[0] = fabs(dot(tVec[0], nVec));
+ tVecDotNVec[1] = fabs(dot(tVec[1], nVec));
+ tVecDotNVec[2] = fabs(dot(tVec[2], nVec));
+ const int i_N = max_element(tVecDotNVec.begin(), tVecDotNVec.end()) -
+ tVecDotNVec.begin(); // Index of normal dir. = max. dot
+ // products (close to 0. in
+ // tangential dir.)
+ kappa.erase(kappa.begin() + i_N); // Remove normal dir.
+ tVec.erase(tVec.begin() + i_N);
}
- const double invh_t0 = (_Np*kappa[0])/6.283185307, invh_t1 = (_Np*kappa[1])/6.283185307; // Inverse of tangential size 0
- const double lambda_t0 = invh_t0*invh_t0, lambda_t1 = invh_t1*invh_t1;
- const double lambdaP_n = std::min(std::max(lambda_n,metric_value_hmax),metric_value_hmin); // Truncate eigenvalues
- const double lambdaP_t0 = std::min(std::max(lambda_t0,metric_value_hmax),metric_value_hmin);
- const double lambdaP_t1 = (_dim == 2) ? 1. : std::min(std::max(lambda_t1,metric_value_hmax),metric_value_hmin);
- metric = SMetric3(lambdaP_n,lambdaP_t0,lambdaP_t1,nVec,tVec[0],tVec[1]);
- const double h_n = 1./sqrt(lambdaP_n), h_t0 = 1./sqrt(lambdaP_t0), h_t1 = 1./sqrt(lambdaP_t1);
- size = std::min(std::min(h_n,h_t0),h_t1);
- }
- else{// isotropic metric !
+ const double invh_t0 = (_Np * kappa[0]) / 6.283185307,
+ invh_t1 = (_Np * kappa[1]) /
+ 6.283185307; // Inverse of tangential size 0
+ const double lambda_t0 = invh_t0 * invh_t0, lambda_t1 = invh_t1 * invh_t1;
+ const double lambdaP_n =
+ std::min(std::max(lambda_n, metric_value_hmax),
+ metric_value_hmin); // Truncate eigenvalues
+ const double lambdaP_t0 =
+ std::min(std::max(lambda_t0, metric_value_hmax), metric_value_hmin);
+ const double lambdaP_t1 =
+ (_dim == 2) ?
+ 1. :
+ std::min(std::max(lambda_t1, metric_value_hmax), metric_value_hmin);
+ metric =
+ SMetric3(lambdaP_n, lambdaP_t0, lambdaP_t1, nVec, tVec[0], tVec[1]);
+ const double h_n = 1. / sqrt(lambdaP_n), h_t0 = 1. / sqrt(lambdaP_t0),
+ h_t1 = 1. / sqrt(lambdaP_t1);
+ size = std::min(std::min(h_n, h_t0), h_t1);
+ }
+ else { // isotropic metric !
SMetric3 mymetric(metric_value_hmax);
metric = mymetric;
size = hmax;
@@ -568,31 +655,40 @@ void meshMetric::computeMetricIsoLinInterp(MVertex *ver, SMetric3 &hessian,
{
double signed_dist;
SVector3 gr;
- if(ver){
+ if(ver) {
signed_dist = vals[ver];
gr = grads[ver];
hessian = hessians[ver];
}
- else{
- signed_dist = (*_fct)(x,y,z);
- _fct->gradient(x,y,z,gr(0),gr(1),gr(2));
- _fct->hessian(x,y,z, hessian(0,0),hessian(0,1),hessian(0,2),
- hessian(1,0),hessian(1,1),hessian(1,2),
- hessian(2,0),hessian(2,1),hessian(2,2));
+ else {
+ signed_dist = (*_fct)(x, y, z);
+ _fct->gradient(x, y, z, gr(0), gr(1), gr(2));
+ _fct->hessian(x, y, z, hessian(0, 0), hessian(0, 1), hessian(0, 2),
+ hessian(1, 0), hessian(1, 1), hessian(1, 2), hessian(2, 0),
+ hessian(2, 1), hessian(2, 2));
}
double dist = fabs(signed_dist);
double norm = gr.normalize();
- size = hmax; // the characteristic element size in all directions - linear interp between hmin and hmax
- if (norm != 0.) {
- if ((signed_dist >= 0) && (signed_dist < _E)) size = hmin + ((hmax-hmin)/_E)*dist;
- else if ((signed_dist < 0) && (signed_dist > _E_moins)) size = hmin - ((hmax-hmin)/_E_moins)*dist;
- }
-
- double lambda = 1./size/size;
- metric(0,0) = lambda; metric(0,1) = 0.; metric(0,2) = 0.;
- metric(1,0) = 0.; metric(1,1) = lambda; metric(1,2) = 0.;
- metric(2,0) = 0.; metric(2,1) = 0.; metric(2,2) = (_dim == 3)? lambda : 1.;
+ size = hmax; // the characteristic element size in all directions - linear
+ // interp between hmin and hmax
+ if(norm != 0.) {
+ if((signed_dist >= 0) && (signed_dist < _E))
+ size = hmin + ((hmax - hmin) / _E) * dist;
+ else if((signed_dist < 0) && (signed_dist > _E_moins))
+ size = hmin - ((hmax - hmin) / _E_moins) * dist;
+ }
+
+ double lambda = 1. / size / size;
+ metric(0, 0) = lambda;
+ metric(0, 1) = 0.;
+ metric(0, 2) = 0.;
+ metric(1, 0) = 0.;
+ metric(1, 1) = lambda;
+ metric(1, 2) = 0.;
+ metric(2, 0) = 0.;
+ metric(2, 1) = 0.;
+ metric(2, 2) = (_dim == 3) ? lambda : 1.;
}
// this function scales the mesh metric in order
@@ -608,118 +704,123 @@ void meshMetric::computeMetricIsoLinInterp(MVertex *ver, SMetric3 &hessian,
// where d is the dimension of the problem.
// This means that the metric should be scaled by K^{2/d} where
// K is N_target / N
-void meshMetric::scaleMetric(int nbElementsTarget,
- nodalMetricTensor &nmt)
+void meshMetric::scaleMetric(int nbElementsTarget, nodalMetricTensor &nmt)
{
// compute N
double N = 0;
- for (unsigned int i=0;i<_elements.size();i++){
+ for(unsigned int i = 0; i < _elements.size(); i++) {
MElement *e = _elements[i];
SMetric3 m1 = nmt[e->getVertex(0)];
SMetric3 m2 = nmt[e->getVertex(1)];
SMetric3 m3 = nmt[e->getVertex(2)];
- if (_dim == 2){
- SMetric3 m = interpolation(m1,m2,m3,0.3333,0.3333);
- N += sqrt(m.determinant()) * e->getVolume() * 4./sqrt(3.0); //3.0
+ if(_dim == 2) {
+ SMetric3 m = interpolation(m1, m2, m3, 0.3333, 0.3333);
+ N += sqrt(m.determinant()) * e->getVolume() * 4. / sqrt(3.0); // 3.0
}
- else{
+ else {
SMetric3 m4 = nmt[e->getVertex(3)];
- SMetric3 m = interpolation(m1,m2,m3,m4,0.25,0.25,0.25);
- N += sqrt(m.determinant()) * e->getVolume() * 12./sqrt(2.0); //4.0;
+ SMetric3 m = interpolation(m1, m2, m3, m4, 0.25, 0.25, 0.25);
+ N += sqrt(m.determinant()) * e->getVolume() * 12. / sqrt(2.0); // 4.0;
}
}
- double scale = pow ((double)nbElementsTarget/N,2.0/_dim);
- for (nodalMetricTensor::iterator it = nmt.begin(); it != nmt.end() ; ++it){
- if (_dim == 3){
+ double scale = pow((double)nbElementsTarget / N, 2.0 / _dim);
+ for(nodalMetricTensor::iterator it = nmt.begin(); it != nmt.end(); ++it) {
+ if(_dim == 3) {
it->second *= scale;
}
else {
- it->second(0,0) *= scale;
- it->second(1,0) *= scale;
- it->second(1,1) *= scale;
+ it->second(0, 0) *= scale;
+ it->second(1, 0) *= scale;
+ it->second(1, 1) *= scale;
}
SMetric3 &m = it->second;
- fullMatrix<double> V(3,3);
+ fullMatrix<double> V(3, 3);
fullVector<double> S(3);
- m.eig(V,S);
- S(0) = std::min(std::max(S(0),1/(hmax*hmax)),1/(hmin*hmin));
- S(1) = std::min(std::max(S(1),1/(hmax*hmax)),1/(hmin*hmin));
- if (_dim == 3)S(2) = std::min(std::max(S(2),1/(hmax*hmax)),1/(hmin*hmin));
- SVector3 t1 (V(0,0),V(1,0),V(2,0));
- SVector3 t2 (V(0,1),V(1,1),V(2,1));
- SVector3 t3 (V(0,2),V(1,2),V(2,2));
- m = SMetric3(S(0),S(1),S(2),t1,t2,t3);
+ m.eig(V, S);
+ S(0) = std::min(std::max(S(0), 1 / (hmax * hmax)), 1 / (hmin * hmin));
+ S(1) = std::min(std::max(S(1), 1 / (hmax * hmax)), 1 / (hmin * hmin));
+ if(_dim == 3)
+ S(2) = std::min(std::max(S(2), 1 / (hmax * hmax)), 1 / (hmin * hmin));
+ SVector3 t1(V(0, 0), V(1, 0), V(2, 0));
+ SVector3 t2(V(0, 1), V(1, 1), V(2, 1));
+ SVector3 t3(V(0, 2), V(1, 2), V(2, 2));
+ m = SMetric3(S(0), S(1), S(2), t1, t2, t3);
}
}
void meshMetric::computeMetric(int metricNumber)
{
_fct = setOfFcts[metricNumber];
- std::vector<double> parameters = setOfParameters[metricNumber];
+ std::vector<double> parameters = setOfParameters[metricNumber];
int technique = setOfTechniques[metricNumber];
- hmin = parameters.size() >=3 ? parameters[1] : CTX::instance()->mesh.lcMin;
- hmax = parameters.size() >=3 ? parameters[2] : CTX::instance()->mesh.lcMax;
+ hmin = parameters.size() >= 3 ? parameters[1] : CTX::instance()->mesh.lcMin;
+ hmax = parameters.size() >= 3 ? parameters[2] : CTX::instance()->mesh.lcMax;
_E = parameters[0];
_E_moins = (parameters.size() >= 5) ? parameters[4] : -parameters[0];
- if (_E_moins>0.) _E_moins *= -1.;
+ if(_E_moins > 0.) _E_moins *= -1.;
_epsilon = parameters[0];
- _technique = (MetricComputationTechnique)technique;
+ _technique = (MetricComputationTechnique)technique;
_Np = (parameters.size() >= 4) ? parameters[3] : 15.;
computeValues();
computeHessian();
- for (v2t_cont::iterator it=_adj.begin(); it!=_adj.end(); it++) {
-
+ for(v2t_cont::iterator it = _adj.begin(); it != _adj.end(); it++) {
MVertex *ver = it->first;
SMetric3 hessian, metric;
double size;
switch(_technique) {
- case (LEVELSET) : computeMetricLevelSet(ver, hessian, metric, size); break;
- case (HESSIAN) : computeMetricHessian(ver, hessian, metric, size); break;
- case (FREY) : computeMetricFrey(ver, hessian, metric, size); break;
- case (EIGENDIRECTIONS) : computeMetricEigenDir(ver, hessian, metric, size); break;
- case (EIGENDIRECTIONS_LINEARINTERP_H) : computeMetricEigenDir(ver, hessian, metric,size); break;
- case (ISOTROPIC_LINEARINTERP_H) : computeMetricIsoLinInterp(ver, hessian, metric, size); break;
+ case(LEVELSET): computeMetricLevelSet(ver, hessian, metric, size); break;
+ case(HESSIAN): computeMetricHessian(ver, hessian, metric, size); break;
+ case(FREY): computeMetricFrey(ver, hessian, metric, size); break;
+ case(EIGENDIRECTIONS):
+ computeMetricEigenDir(ver, hessian, metric, size);
+ break;
+ case(EIGENDIRECTIONS_LINEARINTERP_H):
+ computeMetricEigenDir(ver, hessian, metric, size);
+ break;
+ case(ISOTROPIC_LINEARINTERP_H):
+ computeMetricIsoLinInterp(ver, hessian, metric, size);
+ break;
}
- setOfSizes[metricNumber].insert(std::make_pair(ver,size));
- setOfMetrics[metricNumber].insert(std::make_pair(ver,metric));
-
+ setOfSizes[metricNumber].insert(std::make_pair(ver, size));
+ setOfMetrics[metricNumber].insert(std::make_pair(ver, metric));
}
- if( _technique == HESSIAN) scaleMetric(_epsilon, setOfMetrics[metricNumber]);
+ if(_technique == HESSIAN) scaleMetric(_epsilon, setOfMetrics[metricNumber]);
}
-double meshMetric::operator() (double x, double y, double z, GEntity *ge)
+double meshMetric::operator()(double x, double y, double z, GEntity *ge)
{
- if (needMetricUpdate) updateMetrics();
- if (!setOfMetrics.size()){
- std::cout << "meshMetric::operator() : No metric defined ! " << std::endl;
+ if(needMetricUpdate) updateMetrics();
+ if(!setOfMetrics.size()) {
+ std::cout << "meshMetric::operator() : No metric defined ! " << std::endl;
throw;
}
- SPoint3 xyz(x,y,z), uvw;
+ SPoint3 xyz(x, y, z), uvw;
double initialTol = MElement::getTolerance();
MElement::setTolerance(1.e-4);
MElement *e = _octree->find(x, y, z, _dim);
MElement::setTolerance(initialTol);
double value = 0.;
- if (e) {
- e->xyz2uvw(xyz,uvw);
- double *val = new double [e->getNumVertices()];
- for (std::size_t i=0;i<e->getNumVertices();i++){
+ if(e) {
+ e->xyz2uvw(xyz, uvw);
+ double *val = new double[e->getNumVertices()];
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) {
val[i] = _nodalSizes[e->getVertex(i)];
}
- value = e->interpolate(val,uvw[0],uvw[1],uvw[2]);
- delete [] val;
+ value = e->interpolate(val, uvw[0], uvw[1], uvw[2]);
+ delete[] val;
}
else {
- Msg::Warning("point %g %g %g not found, looking for nearest node",x,y,z);
+ Msg::Warning("point %g %g %g not found, looking for nearest node", x, y, z);
double minDist = 1.e100;
- for (nodalField::iterator it = _nodalSizes.begin(); it != _nodalSizes.end(); it++) {
+ for(nodalField::iterator it = _nodalSizes.begin(); it != _nodalSizes.end();
+ it++) {
const double dist = xyz.distance(it->first->point());
- if (dist <= minDist) {
+ if(dist <= minDist) {
minDist = dist;
value = it->second;
}
@@ -728,116 +829,130 @@ double meshMetric::operator() (double x, double y, double z, GEntity *ge)
return value;
}
-void meshMetric::operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge)
+void meshMetric::operator()(double x, double y, double z, SMetric3 &metr,
+ GEntity *ge)
{
- if (needMetricUpdate) {
+ if(needMetricUpdate) {
updateMetrics();
}
- if (!setOfMetrics.size()){
- std::cout << "meshMetric::operator() : No metric defined ! " << std::endl;
+ if(!setOfMetrics.size()) {
+ std::cout << "meshMetric::operator() : No metric defined ! " << std::endl;
throw;
}
metr = SMetric3(1.e-22);
- //RECOMPUTE MESH METRIC AT XYZ
- if (hasAnalyticalMetric){
+ // RECOMPUTE MESH METRIC AT XYZ
+ if(hasAnalyticalMetric) {
int nbMetrics = setOfMetrics.size();
std::vector<SMetric3> newSetOfMetrics(nbMetrics);
- for (int iMetric=0;iMetric<nbMetrics;iMetric++){
+ for(int iMetric = 0; iMetric < nbMetrics; iMetric++) {
_fct = setOfFcts[iMetric];
- _technique = (MetricComputationTechnique)setOfTechniques[iMetric];
- if (_fct->hasDerivatives()){
- SMetric3 hessian, metric;
- double size;
- switch(_technique) {
- case (LEVELSET) : computeMetricLevelSet(NULL,hessian,metric,size,x,y,z); break;
- case (HESSIAN) : computeMetricHessian(NULL, hessian,metric,size,x,y,z); break;
- case (FREY) : computeMetricFrey(NULL, hessian,metric,size,x,y,z); break;
- case (EIGENDIRECTIONS) : computeMetricEigenDir(NULL, hessian,metric,size,x,y,z); break;
- case (EIGENDIRECTIONS_LINEARINTERP_H) : computeMetricEigenDir(NULL, hessian,metric,size,x,y,z); break;
- case (ISOTROPIC_LINEARINTERP_H) : computeMetricIsoLinInterp(NULL, hessian,metric,size,x,y,z); break;
- }
- newSetOfMetrics[iMetric] = metric;
+ _technique = (MetricComputationTechnique)setOfTechniques[iMetric];
+ if(_fct->hasDerivatives()) {
+ SMetric3 hessian, metric;
+ double size;
+ switch(_technique) {
+ case(LEVELSET):
+ computeMetricLevelSet(NULL, hessian, metric, size, x, y, z);
+ break;
+ case(HESSIAN):
+ computeMetricHessian(NULL, hessian, metric, size, x, y, z);
+ break;
+ case(FREY):
+ computeMetricFrey(NULL, hessian, metric, size, x, y, z);
+ break;
+ case(EIGENDIRECTIONS):
+ computeMetricEigenDir(NULL, hessian, metric, size, x, y, z);
+ break;
+ case(EIGENDIRECTIONS_LINEARINTERP_H):
+ computeMetricEigenDir(NULL, hessian, metric, size, x, y, z);
+ break;
+ case(ISOTROPIC_LINEARINTERP_H):
+ computeMetricIsoLinInterp(NULL, hessian, metric, size, x, y, z);
+ break;
+ }
+ newSetOfMetrics[iMetric] = metric;
}
- else{
- //find other metrics here
- SMetric3 metric;
- SPoint3 xyz(x,y,z), uvw;
- double initialTol = MElement::getTolerance();
- MElement::setTolerance(1.e-4);
- MElement *e = _octree->find(x, y, z, _dim);
- MElement::setTolerance(initialTol);
- if (e){
- e->xyz2uvw(xyz,uvw);
- SMetric3 m1 = setOfMetrics[iMetric][e->getVertex(0)];
- SMetric3 m2 = setOfMetrics[iMetric][e->getVertex(1)];
- SMetric3 m3 = setOfMetrics[iMetric][e->getVertex(2)];
- if (_dim == 2)
- metric = interpolation(m1,m2,m3,uvw[0],uvw[1]);
- else {
- SMetric3 m4 = setOfMetrics[iMetric][e->getVertex(3)];
- metric = interpolation(m1,m2,m3,m4,uvw[0],uvw[1],uvw[2]);
- }
- newSetOfMetrics[iMetric] = metric;
- }
- else{
- Msg::Warning("point %g %g %g not found, looking for nearest node",x,y,z);
- }
+ else {
+ // find other metrics here
+ SMetric3 metric;
+ SPoint3 xyz(x, y, z), uvw;
+ double initialTol = MElement::getTolerance();
+ MElement::setTolerance(1.e-4);
+ MElement *e = _octree->find(x, y, z, _dim);
+ MElement::setTolerance(initialTol);
+ if(e) {
+ e->xyz2uvw(xyz, uvw);
+ SMetric3 m1 = setOfMetrics[iMetric][e->getVertex(0)];
+ SMetric3 m2 = setOfMetrics[iMetric][e->getVertex(1)];
+ SMetric3 m3 = setOfMetrics[iMetric][e->getVertex(2)];
+ if(_dim == 2)
+ metric = interpolation(m1, m2, m3, uvw[0], uvw[1]);
+ else {
+ SMetric3 m4 = setOfMetrics[iMetric][e->getVertex(3)];
+ metric = interpolation(m1, m2, m3, m4, uvw[0], uvw[1], uvw[2]);
+ }
+ newSetOfMetrics[iMetric] = metric;
+ }
+ else {
+ Msg::Warning("point %g %g %g not found, looking for nearest node", x,
+ y, z);
+ }
}
}
- //intersect metrics here
+ // intersect metrics here
metr = newSetOfMetrics[0];
- for (int i=1;i<nbMetrics;i++)
- metr = intersection_conserve_mostaniso(metr,newSetOfMetrics[i]);
+ for(int i = 1; i < nbMetrics; i++)
+ metr = intersection_conserve_mostaniso(metr, newSetOfMetrics[i]);
}
- //INTERPOLATE DISCRETE MESH METRIC
- else{
- SPoint3 xyz(x,y,z), uvw;
+ // INTERPOLATE DISCRETE MESH METRIC
+ else {
+ SPoint3 xyz(x, y, z), uvw;
double initialTol = MElement::getTolerance();
MElement::setTolerance(1.e-4);
MElement *e = _octree->find(x, y, z, _dim);
MElement::setTolerance(initialTol);
- if (e){
- e->xyz2uvw(xyz,uvw);
+ if(e) {
+ e->xyz2uvw(xyz, uvw);
SMetric3 m1 = _nodalMetrics[e->getVertex(0)];
SMetric3 m2 = _nodalMetrics[e->getVertex(1)];
SMetric3 m3 = _nodalMetrics[e->getVertex(2)];
- if (_dim == 2)
- metr = interpolation(m1,m2,m3,uvw[0],uvw[1]);
+ if(_dim == 2)
+ metr = interpolation(m1, m2, m3, uvw[0], uvw[1]);
else {
- SMetric3 m4 = _nodalMetrics[e->getVertex(3)];
- metr = interpolation(m1,m2,m3,m4,uvw[0],uvw[1],uvw[2]);
+ SMetric3 m4 = _nodalMetrics[e->getVertex(3)];
+ metr = interpolation(m1, m2, m3, m4, uvw[0], uvw[1], uvw[2]);
}
-
}
- else{
- Msg::Warning("point %g %g %g not found, looking for nearest node",x,y,z);
+ else {
+ Msg::Warning("point %g %g %g not found, looking for nearest node", x, y,
+ z);
double minDist = 1.e100;
- for (nodalMetricTensor::iterator it = _nodalMetrics.begin(); it != _nodalMetrics.end(); it++) {
- const double dist = xyz.distance(it->first->point());
- if (dist <= minDist) {
- minDist = dist;
- metr = it->second;
- }
+ for(nodalMetricTensor::iterator it = _nodalMetrics.begin();
+ it != _nodalMetrics.end(); it++) {
+ const double dist = xyz.distance(it->first->point());
+ if(dist <= minDist) {
+ minDist = dist;
+ metr = it->second;
+ }
}
}
}
-
}
-double meshMetric::getLaplacian (MVertex *v)
+double meshMetric::getLaplacian(MVertex *v)
{
MVertex *vNew = _vertexMap[v->getNum()];
- std::map<MVertex*, SMetric3 >::const_iterator it = hessians.find(vNew);
+ std::map<MVertex *, SMetric3>::const_iterator it = hessians.find(vNew);
SMetric3 h = it->second;
- return h(0,0)+h(1,1)+h(2,2);
+ return h(0, 0) + h(1, 1) + h(2, 2);
}
-SVector3 meshMetric::getGradient (MVertex *v)
+SVector3 meshMetric::getGradient(MVertex *v)
{
MVertex *vNew = _vertexMap[v->getNum()];
- std::map<MVertex*,SVector3>::const_iterator it = grads.find(vNew);
+ std::map<MVertex *, SVector3>::const_iterator it = grads.find(vNew);
SVector3 gr = it->second;
return gr;
}
@@ -882,9 +997,10 @@ SVector3 meshMetric::getGradient (MVertex *v)
double logRatio = log (CTX::instance()->mesh.smoothRatio);
for ( ; it !=edges.end(); ++it){
MEdge e = *it;
- std::map<MVertex*,SMetric3>::iterator it1 = _nodalMetrics.find(e.getVertex(0));
- std::map<MVertex*,SMetric3>::iterator it2 = _nodalMetrics.find(e.getVertex(1));
- SVector3 aij (e.getVertex(1)->x()-e.getVertex(0)->x(),
+ std::map<MVertex*,SMetric3>::iterator it1 =
+ _nodalMetrics.find(e.getVertex(0)); std::map<MVertex*,SMetric3>::iterator it2
+ = _nodalMetrics.find(e.getVertex(1)); SVector3 aij
+ (e.getVertex(1)->x()-e.getVertex(0)->x(),
e.getVertex(1)->y()-e.getVertex(0)->y(),
e.getVertex(1)->z()-e.getVertex(0)->z());
SMetric3 m1 = it1->second;
diff --git a/Mesh/meshMetric.h b/Mesh/meshMetric.h
index 77bc30bee45fe002db9e3091562a5e4453bf5756..895e31574094f008ec6c750e5d0b55ea28bc207e 100644
--- a/Mesh/meshMetric.h
+++ b/Mesh/meshMetric.h
@@ -6,7 +6,6 @@
#ifndef _MESH_METRIC_H_
#define _MESH_METRIC_H_
-
#include <map>
#include <algorithm>
#include "STensor3.h"
@@ -20,12 +19,20 @@ class MElementOctree;
class STensor3;
/**Anisotropic mesh size field based on a metric */
-class meshMetric: public Field {
- public:
- typedef enum {LEVELSET=1,HESSIAN=2, FREY=3, EIGENDIRECTIONS=4, EIGENDIRECTIONS_LINEARINTERP_H=5,
- ISOTROPIC_LINEARINTERP_H=6} MetricComputationTechnique;
- private:
- // intersect all metrics added in "setOfMetrics", preserve eigendirections of the "most anisotropic" metric
+class meshMetric : public Field {
+public:
+ typedef enum {
+ LEVELSET = 1,
+ HESSIAN = 2,
+ FREY = 3,
+ EIGENDIRECTIONS = 4,
+ EIGENDIRECTIONS_LINEARINTERP_H = 5,
+ ISOTROPIC_LINEARINTERP_H = 6
+ } MetricComputationTechnique;
+
+private:
+ // intersect all metrics added in "setOfMetrics", preserve eigendirections of
+ // the "most anisotropic" metric
void updateMetrics();
int _dim;
double _epsilon, _E, _E_moins, _Np;
@@ -35,93 +42,110 @@ class meshMetric: public Field {
double hmin, hmax;
simpleFunction<double> *_fct;
- std::vector<MElement*> _elements;
+ std::vector<MElement *> _elements;
v2t_cont _adj;
MElementOctree *_octree;
- std::map<int, MVertex*> _vertexMap;
+ std::map<int, MVertex *> _vertexMap;
+
+ std::map<MVertex *, double> vals;
+ std::map<MVertex *, SVector3> grads;
+ std::map<MVertex *, SMetric3> hessians;
- std::map<MVertex*,double> vals;
- std::map<MVertex*,SVector3> grads;
- std::map<MVertex*,SMetric3> hessians;
+public:
+ typedef std::map<MVertex *, SMetric3> nodalMetricTensor;
+ typedef std::map<MVertex *, double> nodalField;
- public:
- typedef std::map<MVertex*,SMetric3> nodalMetricTensor;
- typedef std::map<MVertex*,double> nodalField;
- private:
+private:
nodalMetricTensor _nodalMetrics;
nodalField _nodalSizes, _detMetric;
- std::map<int,nodalMetricTensor> setOfMetrics;
- std::map<int,nodalField> setOfSizes;
- std::map<int,bool> setOfRecomputeBoolean;
- std::map<int,simpleFunction<double>* > setOfFcts;
- std::map<int,std::vector<double> > setOfParameters;
- std::map<int,int > setOfTechniques;
- // std::map<int,nodalField> setOfDetMetric;
+ std::map<int, nodalMetricTensor> setOfMetrics;
+ std::map<int, nodalField> setOfSizes;
+ std::map<int, bool> setOfRecomputeBoolean;
+ std::map<int, simpleFunction<double> *> setOfFcts;
+ std::map<int, std::vector<double> > setOfParameters;
+ std::map<int, int> setOfTechniques;
+ // std::map<int,nodalField> setOfDetMetric;
- public:
- meshMetric(std::vector<MElement*> elements);
+public:
+ meshMetric(std::vector<MElement *> elements);
meshMetric(GModel *gm);
~meshMetric();
// compute a new metric and add it to the set of metrics
- // parameters[1] = lcmin (default : in global gmsh options CTX::instance()->mesh.lcMin)
- // parameters[2] = lcmax (default : in global gmsh options CTX::instance()->mesh.lcMax)
- // Available algorithms ("techniques"):
- // 1: fct is a LS, metric based on Coupez technique
+ // parameters[1] = lcmin (default : in global gmsh options
+ // CTX::instance()->mesh.lcMin) parameters[2] = lcmax (default : in global
+ // gmsh options CTX::instance()->mesh.lcMax) Available algorithms
+ // ("techniques"): 1: fct is a LS, metric based on Coupez technique
// parameters[0] = thickness of the interface (mandatory)
// 2: metric based on the hessian of fct
// parameters[0] = the final number of elements
- // 3: fct is a LS, variant of (1) based on Frey technique (combines Coupez and curvature)
+ // 3: fct is a LS, variant of (1) based on Frey technique (combines Coupez and
+ // curvature)
// parameters[0] = thickness of the interface (mandatory)
- // parameters[3] = the required minimum number of elements to represent a circle - used for curvature-based metric (default: = 15)
+ // parameters[3] = the required minimum number of elements to represent a
+ // circle - used for curvature-based metric (default: = 15)
// 4: fct is a LS, variant of (3), metric computed in LS eigendirections
- // parameters[0] = thickness of the interface in the positive ls direction (mandatory)
- // parameters[4] = thickness of the interface in the negative ls direction (default: =parameters[0] if not specified)
- // parameters[3] = the required minimum number of elements to represent a circle - used for curvature-based metric (default: = 15)
- // 5: same as 4, except that the transition in band E uses linear interpolation of h, instead of linear interpolation of metric
- // 6: fct is a LS, metric is isotropic with linear interpolation of h in band E
- // 7: metric based on the Hessian of fct, scaled so that the smallest element has size lcmin
+ // parameters[0] = thickness of the interface in the positive ls direction
+ // (mandatory) parameters[4] = thickness of the interface in the negative
+ // ls direction (default: =parameters[0] if not specified) parameters[3] =
+ // the required minimum number of elements to represent a circle - used for
+ // curvature-based metric (default: = 15)
+ // 5: same as 4, except that the transition in band E uses linear
+ // interpolation of h, instead of linear interpolation of metric 6: fct is a
+ // LS, metric is isotropic with linear interpolation of h in band E 7: metric
+ // based on the Hessian of fct, scaled so that the smallest element has size
+ // lcmin
void addMetric(int technique, simpleFunction<double> *fct,
const std::vector<double> ¶meters);
- inline SMetric3 metricAtVertex (MVertex* v) {
- if (needMetricUpdate) updateMetrics();
+ inline SMetric3 metricAtVertex(MVertex *v)
+ {
+ if(needMetricUpdate) updateMetrics();
return _nodalMetrics[v];
}
- // this function scales the mesh metric in order
- // to reach a target number of elements
- void scaleMetric( int nbElementsTarget,
- nodalMetricTensor &nmt );
+ // this function scales the mesh metric in order
+ // to reach a target number of elements
+ void scaleMetric(int nbElementsTarget, nodalMetricTensor &nmt);
void computeMetric(int metricNumber);
- void computeMetricLevelSet(MVertex *ver, SMetric3 &hessian, SMetric3 &metric, double &size, double x=0.0, double y = 0.0, double z = 0.0);
- void computeMetricHessian(MVertex *ver, SMetric3 &hessian, SMetric3 &metric, double &size, double x=0.0, double y = 0.0, double z = 0.0);
- void computeMetricFrey(MVertex *ver, SMetric3 &hessian, SMetric3 &metric, double &size, double x=0.0, double y = 0.0, double z = 0.0);
- void computeMetricEigenDir(MVertex *ver, SMetric3 &hessian, SMetric3 &metric, double &size, double x=0.0, double y = 0.0, double z = 0.0);
- void computeMetricIsoLinInterp(MVertex *ver, SMetric3 &hessian, SMetric3 &metric, double &size, double x=0.0, double y = 0.0, double z = 0.0);
+ void computeMetricLevelSet(MVertex *ver, SMetric3 &hessian, SMetric3 &metric,
+ double &size, double x = 0.0, double y = 0.0,
+ double z = 0.0);
+ void computeMetricHessian(MVertex *ver, SMetric3 &hessian, SMetric3 &metric,
+ double &size, double x = 0.0, double y = 0.0,
+ double z = 0.0);
+ void computeMetricFrey(MVertex *ver, SMetric3 &hessian, SMetric3 &metric,
+ double &size, double x = 0.0, double y = 0.0,
+ double z = 0.0);
+ void computeMetricEigenDir(MVertex *ver, SMetric3 &hessian, SMetric3 &metric,
+ double &size, double x = 0.0, double y = 0.0,
+ double z = 0.0);
+ void computeMetricIsoLinInterp(MVertex *ver, SMetric3 &hessian,
+ SMetric3 &metric, double &size, double x = 0.0,
+ double y = 0.0, double z = 0.0);
void computeValues();
void computeHessian();
- double getLaplacian (MVertex *v);
- SVector3 getGradient (MVertex *v) ;
- virtual bool isotropic () const {return false;}
- virtual const char *getName()
- {
- return "metricField";
- }
+ double getLaplacian(MVertex *v);
+ SVector3 getGradient(MVertex *v);
+ virtual bool isotropic() const { return false; }
+ virtual const char *getName() { return "metricField"; }
virtual std::string getDescription()
{
return "Anisotropic size field based on hessian of a given function";
}
- // get metric at point(x,y,z) (previously computes intersection of metrics if not done yet)
- virtual double operator() (double x, double y, double z, GEntity *ge=0) ;
- virtual void operator() (double x, double y, double z, SMetric3 &metr, GEntity *ge=0);
+ // get metric at point(x,y,z) (previously computes intersection of metrics if
+ // not done yet)
+ virtual double operator()(double x, double y, double z, GEntity *ge = 0);
+ virtual void operator()(double x, double y, double z, SMetric3 &metr,
+ GEntity *ge = 0);
- // export pos files of fct, fct gradients (fct is the lattest fct passed to meshMetric !!) and resulting metric (intersection of all computed metrics)
+ // export pos files of fct, fct gradients (fct is the lattest fct passed to
+ // meshMetric !!) and resulting metric (intersection of all computed metrics)
void exportInfo(const char *fileendname);
};
diff --git a/Mesh/meshPartition.cpp b/Mesh/meshPartition.cpp
index c6365efc70eb3bf81ad19c8b2712e0c53cdbd9ca..a204ca1b157ef2029bcac91396efa9d787b40a43 100644
--- a/Mesh/meshPartition.cpp
+++ b/Mesh/meshPartition.cpp
@@ -22,24 +22,31 @@
#if __cplusplus >= 201103L
#include <unordered_map>
#define hashmap std::unordered_map
-#define hashmapface std::unordered_map\
- <MFace, std::vector<std::pair<MElement*, std::vector<unsigned int> > >,\
- Hash_Face, Equal_Face>
-#define hashmapedge std::unordered_map\
- <MEdge, std::vector<std::pair<MElement*, std::vector<unsigned int> > >,\
- Hash_Edge, Equal_Edge>
-#define hashmapvertex std::unordered_map\
- <MVertex*, std::vector<std::pair<MElement*, std::vector<unsigned int> > > >
+#define hashmapface \
+ std::unordered_map< \
+ MFace, std::vector<std::pair<MElement *, std::vector<unsigned int> > >, \
+ Hash_Face, Equal_Face>
+#define hashmapedge \
+ std::unordered_map< \
+ MEdge, std::vector<std::pair<MElement *, std::vector<unsigned int> > >, \
+ Hash_Edge, Equal_Edge>
+#define hashmapvertex \
+ std::unordered_map< \
+ MVertex *, \
+ std::vector<std::pair<MElement *, std::vector<unsigned int> > > >
#else
#define hashmap std::map
-#define hashmapface std::map\
- <MFace, std::vector<std::pair<MElement*, std::vector<unsigned int> > >,\
- Less_Face>
-#define hashmapedge std::map\
- <MEdge, std::vector<std::pair<MElement*, std::vector<unsigned int> > >,\
- Less_Edge>
-#define hashmapvertex std::map\
- <MVertex*, std::vector<std::pair<MElement*, std::vector<unsigned int> > > >
+#define hashmapface \
+ std::map<MFace, \
+ std::vector<std::pair<MElement *, std::vector<unsigned int> > >, \
+ Less_Face>
+#define hashmapedge \
+ std::map<MEdge, \
+ std::vector<std::pair<MElement *, std::vector<unsigned int> > >, \
+ Less_Edge>
+#define hashmapvertex \
+ std::map<MVertex *, \
+ std::vector<std::pair<MElement *, std::vector<unsigned int> > > >
#endif
#if defined(HAVE_METIS)
@@ -70,9 +77,8 @@ extern "C" {
}
// Graph of the mesh for partitioning purposes.
-class Graph
-{
- private:
+class Graph {
+private:
// The GModel
GModel *_model;
// The number of partitions
@@ -102,10 +108,12 @@ class Graph
unsigned int *_vwgt;
// The partitions output from the partitioner
unsigned int *_partition;
- public:
- Graph(GModel * const model)
+
+public:
+ Graph(GModel *const model)
: _model(model), _nparts(0), _ne(0), _nn(0), _dim(0), _eind(0), _eptr(0),
- _xadj(0), _adjncy(0), _element(0), _vertex(0), _vertexSize(0), _vwgt(0), _partition(0)
+ _xadj(0), _adjncy(0), _element(0), _vertex(0), _vertexSize(0), _vwgt(0),
+ _partition(0)
{
}
void fillDefaultWeights()
@@ -115,15 +123,16 @@ class Graph
CTX::instance()->mesh.partitionTetWeight == 1 &&
CTX::instance()->mesh.partitionPyrWeight == 1 &&
CTX::instance()->mesh.partitionPriWeight == 1 &&
- CTX::instance()->mesh.partitionHexWeight == 1) return;
+ CTX::instance()->mesh.partitionHexWeight == 1)
+ return;
_vwgt = new unsigned int[_ne];
- for(unsigned int i = 0; i < _ne; i++){
- if(!_element[i]){
+ for(unsigned int i = 0; i < _ne; i++) {
+ if(!_element[i]) {
_vwgt[i] = 1;
continue;
}
- switch (_element[i]->getType()){
+ switch(_element[i]->getType()) {
case TYPE_TRI: _vwgt[i] = CTX::instance()->mesh.partitionTriWeight; break;
case TYPE_QUA: _vwgt[i] = CTX::instance()->mesh.partitionQuaWeight; break;
case TYPE_TET: _vwgt[i] = CTX::instance()->mesh.partitionTetWeight; break;
@@ -134,10 +143,7 @@ class Graph
}
}
}
- ~Graph()
- {
- clear();
- }
+ ~Graph() { clear(); }
unsigned int nparts() const { return _nparts; };
unsigned int ne() const { return _ne; };
unsigned int nn() const { return _nn; };
@@ -150,13 +156,13 @@ class Graph
unsigned int *xadj() const { return _xadj; };
unsigned int adjncy(unsigned int i) const { return _adjncy[i]; };
unsigned int *adjncy() const { return _adjncy; };
- MElement* element(unsigned int i) const { return _element[i]; };
+ MElement *element(unsigned int i) const { return _element[i]; };
int vertex(unsigned int i) const { return _vertex[i]; };
unsigned int *vwgt() const { return _vwgt; };
unsigned int partition(unsigned int i) const { return _partition[i]; };
unsigned int *partition() const { return _partition; };
unsigned int numNodes() const { return _ne; };
- unsigned int numEdges() const { return _xadj[_ne]/2; };
+ unsigned int numEdges() const { return _xadj[_ne] / 2; };
void nparts(unsigned int nparts) { _nparts = nparts; };
void ne(unsigned int ne) { _ne = ne; };
void nn(unsigned int nn) { _nn = nn; };
@@ -175,10 +181,10 @@ class Graph
void eptr(unsigned int i, unsigned int eptr) { _eptr[i] = eptr; };
void elementResize(unsigned int size)
{
- _element = new MElement*[size];
+ _element = new MElement *[size];
for(unsigned int i = 0; i < size; i++) _element[i] = 0;
}
- void element(unsigned int i, MElement* element) { _element[i] = element; };
+ void element(unsigned int i, MElement *element) { _element[i] = element; };
void vertexResize(unsigned int size)
{
_vertexSize = size;
@@ -191,66 +197,66 @@ class Graph
void partition(unsigned int *partition) { _partition = partition; };
void clear()
{
- if(_eind){
+ if(_eind) {
delete[] _eind;
_eind = 0;
}
- if(_eptr){
+ if(_eptr) {
delete[] _eptr;
_eptr = 0;
}
- if(_xadj){
+ if(_xadj) {
delete[] _xadj;
_xadj = 0;
}
- if(_adjncy){
+ if(_adjncy) {
delete[] _adjncy;
_adjncy = 0;
}
- if(_element){
+ if(_element) {
delete[] _element;
_element = 0;
}
- if(_vertex){
+ if(_vertex) {
delete[] _vertex;
_vertex = 0;
}
_vertexSize = 0;
- if(_vwgt){
+ if(_vwgt) {
delete[] _vwgt;
_vwgt = 0;
}
- if(_partition){
+ if(_partition) {
delete[] _partition;
_partition = 0;
}
}
void clearDualGraph()
{
- if(_xadj){
+ if(_xadj) {
delete[] _xadj;
_xadj = 0;
}
- if(_adjncy){
+ if(_adjncy) {
delete[] _adjncy;
_adjncy = 0;
}
}
void eraseVertex()
{
- if(_vertex){
+ if(_vertex) {
for(int i = 0; i < _vertexSize; i++) _vertex[i] = -1;
}
}
- std::vector< std::set<MElement*> > getBoundaryElements(int size = 0)
+ std::vector<std::set<MElement *> > getBoundaryElements(int size = 0)
{
- std::vector< std::set<MElement*> > elements
- ((size ? size : _nparts), std::set<MElement*>());
- for(unsigned int i = 0; i < _ne; i++){
- for(unsigned int j = _xadj[i]; j < _xadj[i+1]; j++){
- if(_partition[i] != _partition[_adjncy[j]]){
- if(_element[i]->getDim() == (int)_dim){
+ std::vector<std::set<MElement *> > elements((size ? size : _nparts),
+ std::set<MElement *>());
+ for(unsigned int i = 0; i < _ne; i++) {
+ for(unsigned int j = _xadj[i]; j < _xadj[i + 1]; j++) {
+ if(_partition[i] != _partition[_adjncy[j]]) {
+ if(_element[i]->getDim() == (int)_dim) {
elements[_partition[i]].insert(_element[i]);
}
}
@@ -262,49 +268,51 @@ class Graph
void assignGhostCells()
{
- std::vector<GEntity*> ghostEntities(_nparts, (GEntity*)NULL);
+ std::vector<GEntity *> ghostEntities(_nparts, (GEntity *)NULL);
int elementaryNumber = _model->getMaxElementaryNumber(_dim);
- for(unsigned int i = 1; i <= _nparts; i++){
- switch (_dim) {
- case 1:
- ghostEntities[i - 1] = new ghostEdge(_model, ++elementaryNumber, i);
- _model->add(static_cast<ghostEdge*>(ghostEntities[i - 1]));
- break;
- case 2:
- ghostEntities[i - 1] = new ghostFace(_model, ++elementaryNumber, i);
- _model->add(static_cast<ghostFace*>(ghostEntities[i - 1]));
- break;
- case 3:
- ghostEntities[i - 1] = new ghostRegion(_model, ++elementaryNumber, i);
- _model->add(static_cast<ghostRegion*>(ghostEntities[i - 1]));
- break;
- default:
- break;
- }
- }
-
- for(unsigned int i = 0; i < _ne; i++){
+ for(unsigned int i = 1; i <= _nparts; i++) {
+ switch(_dim) {
+ case 1:
+ ghostEntities[i - 1] = new ghostEdge(_model, ++elementaryNumber, i);
+ _model->add(static_cast<ghostEdge *>(ghostEntities[i - 1]));
+ break;
+ case 2:
+ ghostEntities[i - 1] = new ghostFace(_model, ++elementaryNumber, i);
+ _model->add(static_cast<ghostFace *>(ghostEntities[i - 1]));
+ break;
+ case 3:
+ ghostEntities[i - 1] = new ghostRegion(_model, ++elementaryNumber, i);
+ _model->add(static_cast<ghostRegion *>(ghostEntities[i - 1]));
+ break;
+ default: break;
+ }
+ }
+
+ for(unsigned int i = 0; i < _ne; i++) {
std::set<short> ghostCellsPartition;
- for(unsigned int j = _xadj[i]; j < _xadj[i+1]; j++){
+ for(unsigned int j = _xadj[i]; j < _xadj[i + 1]; j++) {
if(_partition[i] != _partition[_adjncy[j]] &&
- ghostCellsPartition.find(_partition[_adjncy[j]]) == ghostCellsPartition.end()){
- if(_element[i]->getDim() == (int)_dim){
- switch (_dim) {
- case 1:
- static_cast<ghostEdge*>(ghostEntities[_partition[_adjncy[j]]])->
- addElement(_element[i]->getType(), _element[i], _partition[i] + 1);
- break;
- case 2:
- static_cast<ghostFace*>(ghostEntities[_partition[_adjncy[j]]])->
- addElement(_element[i]->getType(), _element[i], _partition[i] + 1);
- break;
- case 3:
- static_cast<ghostRegion*>(ghostEntities[_partition[_adjncy[j]]])->
- addElement(_element[i]->getType(), _element[i], _partition[i] + 1);
- break;
- default:
- break;
+ ghostCellsPartition.find(_partition[_adjncy[j]]) ==
+ ghostCellsPartition.end()) {
+ if(_element[i]->getDim() == (int)_dim) {
+ switch(_dim) {
+ case 1:
+ static_cast<ghostEdge *>(ghostEntities[_partition[_adjncy[j]]])
+ ->addElement(_element[i]->getType(), _element[i],
+ _partition[i] + 1);
+ break;
+ case 2:
+ static_cast<ghostFace *>(ghostEntities[_partition[_adjncy[j]]])
+ ->addElement(_element[i]->getType(), _element[i],
+ _partition[i] + 1);
+ break;
+ case 3:
+ static_cast<ghostRegion *>(ghostEntities[_partition[_adjncy[j]]])
+ ->addElement(_element[i]->getType(), _element[i],
+ _partition[i] + 1);
+ break;
+ default: break;
}
ghostCellsPartition.insert(_partition[_adjncy[j]]);
}
@@ -315,44 +323,44 @@ class Graph
void createDualGraph(bool connectedAll)
{
- int *nptr = new int[_nn+1];
- for(unsigned int i = 0; i < _nn+1; i++) nptr[i] = 0;
+ int *nptr = new int[_nn + 1];
+ for(unsigned int i = 0; i < _nn + 1; i++) nptr[i] = 0;
int *nind = new int[_eptr[_ne]];
for(unsigned int i = 0; i < _eptr[_ne]; i++) nind[i] = 0;
- for(unsigned int i = 0; i < _ne; i++){
- for(unsigned int j = _eptr[i]; j < _eptr[i+1]; j++){
+ for(unsigned int i = 0; i < _ne; i++) {
+ for(unsigned int j = _eptr[i]; j < _eptr[i + 1]; j++) {
nptr[_eind[j]]++;
}
}
- for(unsigned int i = 1; i < _nn; i++) nptr[i] += nptr[i-1];
- for(unsigned int i = _nn; i > 0; i--) nptr[i] = nptr[i-1];
+ for(unsigned int i = 1; i < _nn; i++) nptr[i] += nptr[i - 1];
+ for(unsigned int i = _nn; i > 0; i--) nptr[i] = nptr[i - 1];
nptr[0] = 0;
- for(unsigned int i = 0; i < _ne; i++){
- for(unsigned int j = _eptr[i]; j < _eptr[i+1]; j++){
+ for(unsigned int i = 0; i < _ne; i++) {
+ for(unsigned int j = _eptr[i]; j < _eptr[i + 1]; j++) {
nind[nptr[_eind[j]]++] = i;
}
}
- for(unsigned int i = _nn; i > 0; i--) nptr[i] = nptr[i-1];
+ for(unsigned int i = _nn; i > 0; i--) nptr[i] = nptr[i - 1];
nptr[0] = 0;
- _xadj = new unsigned int[_ne+1];
- for(unsigned int i = 0; i < _ne+1; i++) _xadj[i] = 0;
+ _xadj = new unsigned int[_ne + 1];
+ for(unsigned int i = 0; i < _ne + 1; i++) _xadj[i] = 0;
int *nbrs = new int[_ne];
int *marker = new int[_ne];
- for(unsigned int i = 0; i < _ne; i++){
+ for(unsigned int i = 0; i < _ne; i++) {
nbrs[i] = 0;
marker[i] = 0;
}
- for(unsigned int i = 0; i < _ne; i++){
+ for(unsigned int i = 0; i < _ne; i++) {
unsigned int l = 0;
- for(unsigned int j = _eptr[i]; j < _eptr[i+1]; j++){
- for(int k = nptr[_eind[j]]; k < nptr[_eind[j]+1]; k++){
- if(nind[k] != (int)i){
+ for(unsigned int j = _eptr[i]; j < _eptr[i + 1]; j++) {
+ for(int k = nptr[_eind[j]]; k < nptr[_eind[j] + 1]; k++) {
+ if(nind[k] != (int)i) {
if(marker[nind[k]] == 0) nbrs[l++] = nind[k];
marker[nind[k]]++;
}
@@ -360,10 +368,11 @@ class Graph
}
unsigned int nbrsNeighbors = 0;
- for(unsigned int j = 0; j < l; j++){
+ for(unsigned int j = 0; j < l; j++) {
if(marker[nbrs[j]] >=
- (connectedAll ? 1 :
- _element[i]->numCommonNodesInDualGraph(_element[nbrs[j]])))
+ (connectedAll ?
+ 1 :
+ _element[i]->numCommonNodesInDualGraph(_element[nbrs[j]])))
nbrsNeighbors++;
marker[nbrs[j]] = 0;
nbrs[j] = 0;
@@ -372,31 +381,32 @@ class Graph
_xadj[i] = nbrsNeighbors;
}
- for(unsigned int i = 1; i < _ne; i++) _xadj[i] = _xadj[i] + _xadj[i-1];
- for(unsigned int i = _ne; i > 0; i--) _xadj[i] = _xadj[i-1];
+ for(unsigned int i = 1; i < _ne; i++) _xadj[i] = _xadj[i] + _xadj[i - 1];
+ for(unsigned int i = _ne; i > 0; i--) _xadj[i] = _xadj[i - 1];
_xadj[0] = 0;
_adjncy = new unsigned int[_xadj[_ne]];
for(unsigned int i = 0; i < _xadj[_ne]; i++) _adjncy[i] = 0;
- for(unsigned int i = 0; i < _ne; i++){
+ for(unsigned int i = 0; i < _ne; i++) {
unsigned int l = 0;
- for(unsigned int j = _eptr[i]; j < _eptr[i+1]; j++){
- for(int k = nptr[_eind[j]]; k < nptr[_eind[j]+1]; k++){
- if(nind[k] != (int)i){
- if (marker[nind[k]] == 0) nbrs[l++] = nind[k];
+ for(unsigned int j = _eptr[i]; j < _eptr[i + 1]; j++) {
+ for(int k = nptr[_eind[j]]; k < nptr[_eind[j] + 1]; k++) {
+ if(nind[k] != (int)i) {
+ if(marker[nind[k]] == 0) nbrs[l++] = nind[k];
marker[nind[k]]++;
}
}
}
- for(unsigned int j = 0; j < l; j++){
+ for(unsigned int j = 0; j < l; j++) {
if(marker[nbrs[j]] >=
- (connectedAll ? 1 :
- _element[i]->numCommonNodesInDualGraph(_element[nbrs[j]]))){
- _adjncy[_xadj[i]] = nbrs[j];
- _xadj[i] = _xadj[i]+1;
- }
+ (connectedAll ?
+ 1 :
+ _element[i]->numCommonNodesInDualGraph(_element[nbrs[j]]))) {
+ _adjncy[_xadj[i]] = nbrs[j];
+ _xadj[i] = _xadj[i] + 1;
+ }
marker[nbrs[j]] = 0;
nbrs[j] = 0;
}
@@ -404,7 +414,7 @@ class Graph
delete[] nbrs;
delete[] marker;
- for(unsigned int i = _ne; i > 0; i--) _xadj[i] = _xadj[i-1];
+ for(unsigned int i = _ne; i > 0; i--) _xadj[i] = _xadj[i - 1];
_xadj[0] = 0;
delete[] nptr;
@@ -414,18 +424,19 @@ class Graph
template <class ITERATOR>
static void fillElementsToNodesMap(Graph &graph, const GEntity *const entity,
- int &eptrIndex, int &eindIndex, int &numVertex,
- ITERATOR it_beg, ITERATOR it_end)
+ int &eptrIndex, int &eindIndex,
+ int &numVertex, ITERATOR it_beg,
+ ITERATOR it_end)
{
- for(ITERATOR it = it_beg; it != it_end; ++it){
+ for(ITERATOR it = it_beg; it != it_end; ++it) {
const int numVertices = (*it)->getNumPrimaryVertices();
graph.element(eptrIndex++, *it);
- graph.eptr(eptrIndex, graph.eptr(eptrIndex-1) + numVertices);
- for(int i = 0; i < numVertices; i++){
- if(graph.vertex((*it)->getVertex(i)->getNum()-1) == -1){
- graph.vertex((*it)->getVertex(i)->getNum()-1, numVertex++);
+ graph.eptr(eptrIndex, graph.eptr(eptrIndex - 1) + numVertices);
+ for(int i = 0; i < numVertices; i++) {
+ if(graph.vertex((*it)->getVertex(i)->getNum() - 1) == -1) {
+ graph.vertex((*it)->getVertex(i)->getNum() - 1, numVertex++);
}
- graph.eind(eindIndex, graph.vertex((*it)->getVertex(i)->getNum()-1));
+ graph.eind(eindIndex, graph.vertex((*it)->getVertex(i)->getNum() - 1));
eindIndex++;
}
}
@@ -435,28 +446,32 @@ static int getSizeOfEind(const GModel *const model)
{
int size = 0;
// Loop over regions
- for(GModel::const_riter it = model->firstRegion(); it != model->lastRegion(); ++it){
- size += 4*(*it)->tetrahedra.size();
- size += 8*(*it)->hexahedra.size();
- size += 6*(*it)->prisms.size();
- size += 5*(*it)->pyramids.size();
- size += 4*(*it)->trihedra.size();
+ for(GModel::const_riter it = model->firstRegion(); it != model->lastRegion();
+ ++it) {
+ size += 4 * (*it)->tetrahedra.size();
+ size += 8 * (*it)->hexahedra.size();
+ size += 6 * (*it)->prisms.size();
+ size += 5 * (*it)->pyramids.size();
+ size += 4 * (*it)->trihedra.size();
}
// Loop over faces
- for(GModel::const_fiter it = model->firstFace(); it != model->lastFace(); ++it){
- size += 3*(*it)->triangles.size();
- size += 4*(*it)->quadrangles.size();
+ for(GModel::const_fiter it = model->firstFace(); it != model->lastFace();
+ ++it) {
+ size += 3 * (*it)->triangles.size();
+ size += 4 * (*it)->quadrangles.size();
}
// Loop over edges
- for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge(); ++it){
- size += 2*(*it)->lines.size();
+ for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge();
+ ++it) {
+ size += 2 * (*it)->lines.size();
}
// Loop over vertices
- for(GModel::const_viter it = model->firstVertex(); it != model->lastVertex(); ++it){
- size += 1*(*it)->points.size();
+ for(GModel::const_viter it = model->firstVertex(); it != model->lastVertex();
+ ++it) {
+ size += 1 * (*it)->points.size();
}
return size;
@@ -467,43 +482,35 @@ static int getSizeOfEind(const GModel *const model)
static int MakeGraph(GModel *const model, Graph &graph, int selectDim)
{
int eindSize = 0;
- if(selectDim < 0){
+ if(selectDim < 0) {
graph.ne(model->getNumMeshElements());
graph.nn(model->getNumMeshVertices());
graph.dim(model->getDim());
graph.elementResize(graph.ne());
graph.vertexResize(model->getMaxVertexNumber());
- graph.eptrResize(graph.ne()+1);
- graph.eptr(0,0);
+ graph.eptrResize(graph.ne() + 1);
+ graph.eptr(0, 0);
eindSize = getSizeOfEind(model);
graph.eindResize(eindSize);
}
- else{
- GModel* tmp = new GModel();
- std::vector<GEntity*> entities;
+ else {
+ GModel *tmp = new GModel();
+ std::vector<GEntity *> entities;
model->getEntities(entities);
- std::set<MVertex*> vertices;
- for(unsigned int i = 0; i < entities.size(); i++){
- if(entities[i]->dim() == selectDim){
- switch (entities[i]->dim()) {
- case 3:
- tmp->add(static_cast<GRegion*>(entities[i]));
- break;
- case 2:
- tmp->add(static_cast<GFace*>(entities[i]));
- break;
- case 1:
- tmp->add(static_cast<GEdge*>(entities[i]));
- break;
- case 0:
- tmp->add(static_cast<GVertex*>(entities[i]));
- break;
- default:
- break;
+ std::set<MVertex *> vertices;
+ for(unsigned int i = 0; i < entities.size(); i++) {
+ if(entities[i]->dim() == selectDim) {
+ switch(entities[i]->dim()) {
+ case 3: tmp->add(static_cast<GRegion *>(entities[i])); break;
+ case 2: tmp->add(static_cast<GFace *>(entities[i])); break;
+ case 1: tmp->add(static_cast<GEdge *>(entities[i])); break;
+ case 0: tmp->add(static_cast<GVertex *>(entities[i])); break;
+ default: break;
}
- for(unsigned int j = 0; j < entities[i]->getNumMeshElements(); j++){
- for(unsigned int k = 0; k < entities[i]->getMeshElement(j)->getNumVertices() ; k++){
+ for(unsigned int j = 0; j < entities[i]->getNumMeshElements(); j++) {
+ for(unsigned int k = 0;
+ k < entities[i]->getMeshElement(j)->getNumVertices(); k++) {
vertices.insert(entities[i]->getMeshElement(j)->getVertex(k));
}
}
@@ -515,8 +522,8 @@ static int MakeGraph(GModel *const model, Graph &graph, int selectDim)
graph.dim(tmp->getDim());
graph.elementResize(graph.ne());
graph.vertexResize(model->getMaxVertexNumber());
- graph.eptrResize(graph.ne()+1);
- graph.eptr(0,0);
+ graph.eptrResize(graph.ne() + 1);
+ graph.eptr(0, 0);
eindSize = getSizeOfEind(tmp);
graph.eindResize(eindSize);
@@ -528,18 +535,19 @@ static int MakeGraph(GModel *const model, Graph &graph, int selectDim)
int eindIndex = 0;
int numVertex = 0;
- if(graph.ne() == 0){
+ if(graph.ne() == 0) {
Msg::Error("No mesh elements were found");
return 1;
}
- if(graph.dim() == 0){
+ if(graph.dim() == 0) {
Msg::Error("Cannot partition a point");
return 1;
}
// Loop over regions
- if(selectDim < 0 || selectDim == 3){
- for(GModel::const_riter it = model->firstRegion(); it != model->lastRegion(); ++it){
+ if(selectDim < 0 || selectDim == 3) {
+ for(GModel::const_riter it = model->firstRegion();
+ it != model->lastRegion(); ++it) {
const GRegion *r = *it;
fillElementsToNodesMap(graph, r, eptrIndex, eindIndex, numVertex,
r->tetrahedra.begin(), r->tetrahedra.end());
@@ -555,8 +563,9 @@ static int MakeGraph(GModel *const model, Graph &graph, int selectDim)
}
// Loop over faces
- if(selectDim < 0 || selectDim == 2){
- for(GModel::const_fiter it = model->firstFace(); it != model->lastFace(); ++it){
+ if(selectDim < 0 || selectDim == 2) {
+ for(GModel::const_fiter it = model->firstFace(); it != model->lastFace();
+ ++it) {
const GFace *f = *it;
fillElementsToNodesMap(graph, f, eptrIndex, eindIndex, numVertex,
@@ -567,8 +576,9 @@ static int MakeGraph(GModel *const model, Graph &graph, int selectDim)
}
// Loop over edges
- if(selectDim < 0 || selectDim == 1){
- for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge(); ++it){
+ if(selectDim < 0 || selectDim == 1) {
+ for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge();
+ ++it) {
const GEdge *e = *it;
fillElementsToNodesMap(graph, e, eptrIndex, eindIndex, numVertex,
e->lines.begin(), e->lines.end());
@@ -576,8 +586,9 @@ static int MakeGraph(GModel *const model, Graph &graph, int selectDim)
}
// Loop over vertices
- if(selectDim < 0 || selectDim == 0){
- for(GModel::const_viter it = model->firstVertex(); it != model->lastVertex(); ++it){
+ if(selectDim < 0 || selectDim == 0) {
+ for(GModel::const_viter it = model->firstVertex();
+ it != model->lastVertex(); ++it) {
GVertex *v = *it;
fillElementsToNodesMap(graph, v, eptrIndex, eindIndex, numVertex,
@@ -599,46 +610,40 @@ static int PartitionGraph(Graph &graph)
int metisOptions[METIS_NOPTIONS];
METIS_SetDefaultOptions((idx_t *)metisOptions);
- switch(CTX::instance()->mesh.metisAlgorithm){
- case 1: // Recursive
- metisOptions[METIS_OPTION_PTYPE] = METIS_PTYPE_RB;
- break;
- case 2: // K-way
- metisOptions[METIS_OPTION_PTYPE] = METIS_PTYPE_KWAY;
- break;
- default:
- Msg::Info("Unknown partitioning algorithm");
- break;
+ switch(CTX::instance()->mesh.metisAlgorithm) {
+ case 1: // Recursive
+ metisOptions[METIS_OPTION_PTYPE] = METIS_PTYPE_RB;
+ break;
+ case 2: // K-way
+ metisOptions[METIS_OPTION_PTYPE] = METIS_PTYPE_KWAY;
+ break;
+ default: Msg::Info("Unknown partitioning algorithm"); break;
}
- switch(CTX::instance()->mesh.metisEdgeMatching){
- case 1: // Random matching
- metisOptions[METIS_OPTION_CTYPE] = METIS_CTYPE_RM;
- break;
- case 2: // Sorted heavy-edge matching
- metisOptions[METIS_OPTION_CTYPE] = METIS_CTYPE_SHEM;
- break;
- default:
- Msg::Info("Unknown partitioning edge matching");
- break;
+ switch(CTX::instance()->mesh.metisEdgeMatching) {
+ case 1: // Random matching
+ metisOptions[METIS_OPTION_CTYPE] = METIS_CTYPE_RM;
+ break;
+ case 2: // Sorted heavy-edge matching
+ metisOptions[METIS_OPTION_CTYPE] = METIS_CTYPE_SHEM;
+ break;
+ default: Msg::Info("Unknown partitioning edge matching"); break;
}
- switch(CTX::instance()->mesh.metisRefinementAlgorithm){
- case 1: // FM-based cut refinement
- metisOptions[METIS_OPTION_RTYPE] = METIS_RTYPE_FM;
- break;
- case 2: // Greedy boundary refinement
- metisOptions[METIS_OPTION_RTYPE] = METIS_RTYPE_GREEDY;
- break;
- case 3: // Two-sided node FM refinement
- metisOptions[METIS_OPTION_RTYPE] = METIS_RTYPE_SEP2SIDED;
- break;
- case 4: // One-sided node FM refinement
- metisOptions[METIS_OPTION_RTYPE] = METIS_RTYPE_SEP1SIDED;
- break;
- default:
- Msg::Info("Unknown partitioning refinement algorithm");
- break;
+ switch(CTX::instance()->mesh.metisRefinementAlgorithm) {
+ case 1: // FM-based cut refinement
+ metisOptions[METIS_OPTION_RTYPE] = METIS_RTYPE_FM;
+ break;
+ case 2: // Greedy boundary refinement
+ metisOptions[METIS_OPTION_RTYPE] = METIS_RTYPE_GREEDY;
+ break;
+ case 3: // Two-sided node FM refinement
+ metisOptions[METIS_OPTION_RTYPE] = METIS_RTYPE_SEP2SIDED;
+ break;
+ case 4: // One-sided node FM refinement
+ metisOptions[METIS_OPTION_RTYPE] = METIS_RTYPE_SEP1SIDED;
+ break;
+ default: Msg::Info("Unknown partitioning refinement algorithm"); break;
}
// C numbering
@@ -646,7 +651,7 @@ static int PartitionGraph(Graph &graph)
// Specifies the type of objective
metisOptions[METIS_OPTION_OBJTYPE] = METIS_OBJTYPE_CUT;
// Forces contiguous partitions.
- //metisOptions[METIS_OPTION_CONTIG] = 1;
+ // metisOptions[METIS_OPTION_CONTIG] = 1;
int objval;
unsigned int *epart = new unsigned int[graph.ne()];
@@ -659,44 +664,38 @@ static int PartitionGraph(Graph &graph)
int metisError = 0;
graph.createDualGraph(false);
- if (metisOptions[METIS_OPTION_PTYPE] == METIS_PTYPE_KWAY){
- metisError = METIS_PartGraphKway
- ((idx_t *)&ne, (idx_t *)&ncon, (idx_t *)graph.xadj(),
- (idx_t *)graph.adjncy(), (idx_t *)graph.vwgt(),
- (idx_t *)0, 0, (idx_t *)&numPart, 0, 0,
- (idx_t *)metisOptions, (idx_t *)&objval, (idx_t *)epart);
- }
- else{
- metisError = METIS_PartGraphRecursive
- ((idx_t *)&ne, (idx_t *)&ncon, (idx_t *)graph.xadj(),
- (idx_t *)graph.adjncy(), (idx_t *)graph.vwgt(),
- (idx_t *)0, 0, (idx_t *)&numPart, 0, 0,
- (idx_t *)metisOptions, (idx_t *)&objval, (idx_t *)epart);
- }
-
- switch(metisError){
- case METIS_OK:
- break;
- case METIS_ERROR_INPUT:
- Msg::Error("METIS input error");
- return 1;
- case METIS_ERROR_MEMORY:
- Msg::Error("METIS memoty error");
- return 1;
+ if(metisOptions[METIS_OPTION_PTYPE] == METIS_PTYPE_KWAY) {
+ metisError = METIS_PartGraphKway(
+ (idx_t *)&ne, (idx_t *)&ncon, (idx_t *)graph.xadj(),
+ (idx_t *)graph.adjncy(), (idx_t *)graph.vwgt(), (idx_t *)0, 0,
+ (idx_t *)&numPart, 0, 0, (idx_t *)metisOptions, (idx_t *)&objval,
+ (idx_t *)epart);
+ }
+ else {
+ metisError = METIS_PartGraphRecursive(
+ (idx_t *)&ne, (idx_t *)&ncon, (idx_t *)graph.xadj(),
+ (idx_t *)graph.adjncy(), (idx_t *)graph.vwgt(), (idx_t *)0, 0,
+ (idx_t *)&numPart, 0, 0, (idx_t *)metisOptions, (idx_t *)&objval,
+ (idx_t *)epart);
+ }
+
+ switch(metisError) {
+ case METIS_OK: break;
+ case METIS_ERROR_INPUT: Msg::Error("METIS input error"); return 1;
+ case METIS_ERROR_MEMORY: Msg::Error("METIS memoty error"); return 1;
case METIS_ERROR:
- default:
- Msg::Error("METIS error");
- return 1;
+ default: Msg::Error("METIS error"); return 1;
}
// Check and correct the topology
- for(int i = 1; i < 4; i++){
- for(unsigned int j = 0; j < graph.ne(); j++){
+ for(int i = 1; i < 4; i++) {
+ for(unsigned int j = 0; j < graph.ne(); j++) {
if(graph.element(j)->getDim() == (int)graph.dim()) continue;
- for(unsigned int k = graph.xadj(j); k < graph.xadj(j+1); k++){
- if(graph.element(j)->getDim() == graph.element(graph.adjncy(k))->getDim()-i){
- if(epart[j] != epart[graph.adjncy(k)]){
+ for(unsigned int k = graph.xadj(j); k < graph.xadj(j + 1); k++) {
+ if(graph.element(j)->getDim() ==
+ graph.element(graph.adjncy(k))->getDim() - i) {
+ if(epart[j] != epart[graph.adjncy(k)]) {
epart[j] = epart[graph.adjncy(k)];
break;
}
@@ -707,8 +706,7 @@ static int PartitionGraph(Graph &graph)
graph.partition(epart);
Msg::Info("%d partitions, %d total edge-cuts", numPart, objval);
- }
- catch(...) {
+ } catch(...) {
Msg::Error("METIS exception");
return 2;
}
@@ -718,17 +716,18 @@ static int PartitionGraph(Graph &graph)
}
template <class ENTITY, class ITERATOR>
-static void assignElementsToEntities(GModel *const model,
- hashmap<MElement*, unsigned int> &elmToPartition,
- std::vector<ENTITY *> &newEntities,
- ITERATOR it_beg, ITERATOR it_end, int &elementaryNumber)
+static void
+assignElementsToEntities(GModel *const model,
+ hashmap<MElement *, unsigned int> &elmToPartition,
+ std::vector<ENTITY *> &newEntities, ITERATOR it_beg,
+ ITERATOR it_end, int &elementaryNumber)
{
- for(ITERATOR it = it_beg; it != it_end; ++it){
+ for(ITERATOR it = it_beg; it != it_end; ++it) {
const unsigned int partition = elmToPartition[(*it)] - 1;
- if(!newEntities[partition]){
+ if(!newEntities[partition]) {
std::vector<unsigned int> partitions;
- partitions.push_back(partition+1);
+ partitions.push_back(partition + 1);
ENTITY *de = new ENTITY(model, ++elementaryNumber, partitions);
model->add(de);
newEntities[partition] = de;
@@ -739,11 +738,12 @@ static void assignElementsToEntities(GModel *const model,
}
template <class ITERATOR>
-void setVerticesToEntity(GEntity *const entity, ITERATOR it_beg, ITERATOR it_end)
+void setVerticesToEntity(GEntity *const entity, ITERATOR it_beg,
+ ITERATOR it_end)
{
- for(ITERATOR it = it_beg; it != it_end; ++it){
- for(std::size_t i = 0; i < (*it)->getNumVertices(); i++){
- if(!(*it)->getVertex(i)->onWhat()){
+ for(ITERATOR it = it_beg; it != it_end; ++it) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ if(!(*it)->getVertex(i)->onWhat()) {
(*it)->getVertex(i)->setEntity(entity);
entity->addMeshVertex((*it)->getVertex(i));
}
@@ -754,9 +754,10 @@ void setVerticesToEntity(GEntity *const entity, ITERATOR it_beg, ITERATOR it_end
template <class ITERATOR>
void removeVerticesEntity(ITERATOR it_beg, ITERATOR it_end)
{
- for(ITERATOR it = it_beg; it != it_end; ++it){
- for(std::size_t i = 0; i < (*it)->getNumMeshElements(); i++){
- for(GModel::size_type j = 0; j < (*it)->getMeshElement(i)->getNumVertices(); j++){
+ for(ITERATOR it = it_beg; it != it_end; ++it) {
+ for(std::size_t i = 0; i < (*it)->getNumMeshElements(); i++) {
+ for(GModel::size_type j = 0;
+ j < (*it)->getMeshElement(i)->getNumVertices(); j++) {
(*it)->getMeshElement(i)->getVertex(j)->setEntity(0);
}
}
@@ -773,24 +774,30 @@ static void AssignMeshVertices(GModel *model)
removeVerticesEntity(model->firstRegion(), model->lastRegion());
// Loop over vertices
- for(GModel::const_viter it = model->firstVertex(); it != model->lastVertex(); ++it){
+ for(GModel::const_viter it = model->firstVertex(); it != model->lastVertex();
+ ++it) {
setVerticesToEntity(*it, (*it)->points.begin(), (*it)->points.end());
}
// Loop over edges
- for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge(); ++it){
+ for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge();
+ ++it) {
setVerticesToEntity(*it, (*it)->lines.begin(), (*it)->lines.end());
}
// Loop over faces
- for(GModel::const_fiter it = model->firstFace(); it != model->lastFace(); ++it){
+ for(GModel::const_fiter it = model->firstFace(); it != model->lastFace();
+ ++it) {
setVerticesToEntity(*it, (*it)->triangles.begin(), (*it)->triangles.end());
- setVerticesToEntity(*it, (*it)->quadrangles.begin(), (*it)->quadrangles.end());
+ setVerticesToEntity(*it, (*it)->quadrangles.begin(),
+ (*it)->quadrangles.end());
}
// Loop over regions
- for(GModel::const_riter it = model->firstRegion(); it != model->lastRegion(); ++it){
- setVerticesToEntity(*it, (*it)->tetrahedra.begin(), (*it)->tetrahedra.end());
+ for(GModel::const_riter it = model->firstRegion(); it != model->lastRegion();
+ ++it) {
+ setVerticesToEntity(*it, (*it)->tetrahedra.begin(),
+ (*it)->tetrahedra.end());
setVerticesToEntity(*it, (*it)->hexahedra.begin(), (*it)->hexahedra.end());
setVerticesToEntity(*it, (*it)->prisms.begin(), (*it)->prisms.end());
setVerticesToEntity(*it, (*it)->pyramids.begin(), (*it)->pyramids.end());
@@ -798,30 +805,31 @@ static void AssignMeshVertices(GModel *model)
}
}
-static void fillConnectedElements(std::vector< std::set<MElement*> > &connectedElements,
- Graph &graph)
+static void
+fillConnectedElements(std::vector<std::set<MElement *> > &connectedElements,
+ Graph &graph)
{
std::stack<unsigned int> elementStack;
- std::set<MElement*> elements;
+ std::set<MElement *> elements;
unsigned int startElement = 0;
bool stop = true;
unsigned int size = 0;
int isolatedElements = 0;
do {
- //Inititalization
+ // Inititalization
elementStack.push(startElement);
elements.insert(graph.element(startElement));
- while(elementStack.size() != 0){
+ while(elementStack.size() != 0) {
unsigned int top = elementStack.top();
elementStack.pop();
elements.insert(graph.element(top));
- for(unsigned int i = graph.xadj(top); i < graph.xadj(top+1); i++){
- if(graph.adjncy(i) != 0){
+ for(unsigned int i = graph.xadj(top); i < graph.xadj(top + 1); i++) {
+ if(graph.adjncy(i) != 0) {
elementStack.push(graph.adjncy(i));
- graph.adjncy(i,0);
+ graph.adjncy(i, 0);
}
}
}
@@ -832,21 +840,21 @@ static void fillConnectedElements(std::vector< std::set<MElement*> > &connectedE
stop = (size == graph.ne() ? true : false);
startElement = 0;
- if(!stop){
- for(unsigned int i = 0; i < graph.ne(); i++){
- for(unsigned int j = graph.xadj(i); j < graph.xadj(i+1); j++){
- if(graph.adjncy(j) != 0){
+ if(!stop) {
+ for(unsigned int i = 0; i < graph.ne(); i++) {
+ for(unsigned int j = graph.xadj(i); j < graph.xadj(i + 1); j++) {
+ if(graph.adjncy(j) != 0) {
startElement = i;
i = graph.ne();
break;
}
}
}
- if(startElement == 0){
+ if(startElement == 0) {
int skipIsolatedElements = 0;
- for(unsigned int i = 1; i < graph.ne(); i++){
- if(graph.xadj(i) == graph.xadj(i+1)){
- if(skipIsolatedElements == isolatedElements){
+ for(unsigned int i = 1; i < graph.ne(); i++) {
+ if(graph.xadj(i) == graph.xadj(i + 1)) {
+ if(skipIsolatedElements == isolatedElements) {
startElement = i;
isolatedElements++;
break;
@@ -859,27 +867,28 @@ static void fillConnectedElements(std::vector< std::set<MElement*> > &connectedE
} while(!stop);
}
-static bool dividedNonConnectedEntities(GModel *const model, int dim,
- std::set<GRegion*, GEntityLessThan> ®ions,
- std::set<GFace*, GEntityLessThan> &faces,
- std::set<GEdge*, GEntityLessThan> &edges,
- std::set<GVertex*, GEntityLessThan> &vertices)
+static bool
+dividedNonConnectedEntities(GModel *const model, int dim,
+ std::set<GRegion *, GEntityLessThan> ®ions,
+ std::set<GFace *, GEntityLessThan> &faces,
+ std::set<GEdge *, GEntityLessThan> &edges,
+ std::set<GVertex *, GEntityLessThan> &vertices)
{
bool ret = false;
// Loop over vertices
- if(dim < 0 || dim == 0){
+ if(dim < 0 || dim == 0) {
int elementaryNumber = model->getMaxElementaryNumber(0);
- for(GModel::const_viter it = vertices.begin(); it != vertices.end(); ++it){
- if((*it)->geomType() == GEntity::PartitionVertex){
- partitionVertex* vertex = static_cast<partitionVertex*>(*it);
+ for(GModel::const_viter it = vertices.begin(); it != vertices.end(); ++it) {
+ if((*it)->geomType() == GEntity::PartitionVertex) {
+ partitionVertex *vertex = static_cast<partitionVertex *>(*it);
- if(vertex->getNumMeshElements() > 1){
+ if(vertex->getNumMeshElements() > 1) {
ret = true;
- for(unsigned int i = 0; i < vertex->getNumMeshElements(); i++){
+ for(unsigned int i = 0; i < vertex->getNumMeshElements(); i++) {
// Create the new partitionVertex
- partitionVertex *pvertex = new partitionVertex
- (model, ++elementaryNumber, vertex->getPartitions());
+ partitionVertex *pvertex = new partitionVertex(
+ model, ++elementaryNumber, vertex->getPartitions());
// Assign parent entity
pvertex->setParentEntity(vertex->getParentEntity());
// Add to model
@@ -888,15 +897,15 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
pvertex->addElement(vertex->getMeshElement(i)->getType(),
vertex->getMeshElement(i));
// Move B-Rep
- std::vector<GEdge*> BRepEdges = vertex->edges();
- if(!BRepEdges.empty()){
- for(std::vector<GEdge*>::iterator itBRep = BRepEdges.begin();
- itBRep != BRepEdges.end(); ++itBRep){
- if(vertex == (*itBRep)->getBeginVertex()){
+ std::vector<GEdge *> BRepEdges = vertex->edges();
+ if(!BRepEdges.empty()) {
+ for(std::vector<GEdge *>::iterator itBRep = BRepEdges.begin();
+ itBRep != BRepEdges.end(); ++itBRep) {
+ if(vertex == (*itBRep)->getBeginVertex()) {
(*itBRep)->setVertex(pvertex, 1);
pvertex->addEdge(*itBRep);
}
- if(vertex == (*itBRep)->getEndVertex()){
+ if(vertex == (*itBRep)->getEndVertex()) {
(*itBRep)->setVertex(pvertex, -1);
pvertex->addEdge(*itBRep);
}
@@ -914,7 +923,7 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
}
// Loop over edges
- if(dim < 0 || dim == 1){
+ if(dim < 0 || dim == 1) {
// We build a graph
Graph graph(model);
graph.ne(model->getNumMeshElements(1));
@@ -922,20 +931,20 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
graph.dim(model->getDim());
graph.elementResize(graph.ne());
graph.vertexResize(model->getMaxVertexNumber());
- graph.eptrResize(graph.ne()+1);
- graph.eptr(0,0);
+ graph.eptrResize(graph.ne() + 1);
+ graph.eptr(0, 0);
const int eindSize = getSizeOfEind(model);
graph.eindResize(eindSize);
int elementaryNumber = model->getMaxElementaryNumber(1);
- for(GModel::const_eiter it = edges.begin(); it != edges.end(); ++it){
- if((*it)->geomType() == GEntity::PartitionCurve){
- partitionEdge* edge = static_cast<partitionEdge*>(*it);
+ for(GModel::const_eiter it = edges.begin(); it != edges.end(); ++it) {
+ if((*it)->geomType() == GEntity::PartitionCurve) {
+ partitionEdge *edge = static_cast<partitionEdge *>(*it);
graph.ne(edge->getNumMeshElements());
graph.dim(1);
- graph.eptr(0,0);
+ graph.eptr(0, 0);
graph.clearDualGraph();
graph.eraseVertex();
@@ -950,45 +959,47 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
// if a graph contains more than ((n-1)*(n-2))/2 edges
// (where n is the number of nodes), then it is connected.
- if(((graph.numNodes()-1)*(graph.numNodes()-2))/2 < graph.numEdges()){
+ if(((graph.numNodes() - 1) * (graph.numNodes() - 2)) / 2 <
+ graph.numEdges()) {
continue;
}
- std::vector< std::set<MElement*> > connectedElements;
+ std::vector<std::set<MElement *> > connectedElements;
fillConnectedElements(connectedElements, graph);
- if(connectedElements.size() > 1){
+ if(connectedElements.size() > 1) {
ret = true;
- std::vector<GFace*> BRepFaces = edge->faces();
+ std::vector<GFace *> BRepFaces = edge->faces();
std::vector<int> oldOrientations;
oldOrientations.reserve(BRepFaces.size());
- if(!BRepFaces.empty()){
- for(std::vector<GFace*>::iterator itBRep = BRepFaces.begin();
- itBRep != BRepFaces.end(); ++itBRep){
+ if(!BRepFaces.empty()) {
+ for(std::vector<GFace *>::iterator itBRep = BRepFaces.begin();
+ itBRep != BRepFaces.end(); ++itBRep) {
oldOrientations.push_back((*itBRep)->delEdge(edge));
}
}
- for(unsigned int i = 0; i < connectedElements.size(); i++){
+ for(unsigned int i = 0; i < connectedElements.size(); i++) {
// Create the new partitionEdge
- partitionEdge *pedge = new partitionEdge
- (model, ++elementaryNumber, 0, 0, edge->getPartitions());
+ partitionEdge *pedge = new partitionEdge(
+ model, ++elementaryNumber, 0, 0, edge->getPartitions());
// Assign parent entity
pedge->setParentEntity(edge->getParentEntity());
// Add to model
model->add(pedge);
- for(std::set<MElement*>::iterator itSet = connectedElements[i].begin();
- itSet != connectedElements[i].end(); ++itSet){
+ for(std::set<MElement *>::iterator itSet =
+ connectedElements[i].begin();
+ itSet != connectedElements[i].end(); ++itSet) {
// Add elements
pedge->addElement((*itSet)->getType(), (*itSet));
}
// Move B-Rep
- if(BRepFaces.size() > 0){
+ if(BRepFaces.size() > 0) {
int i = 0;
- for(std::vector<GFace*>::iterator itBRep = BRepFaces.begin();
- itBRep != BRepFaces.end(); ++itBRep){
+ for(std::vector<GFace *>::iterator itBRep = BRepFaces.begin();
+ itBRep != BRepFaces.end(); ++itBRep) {
(*itBRep)->setEdge(pedge, oldOrientations[i]);
pedge->addFace(*itBRep);
i++;
@@ -1008,7 +1019,7 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
}
// Loop over faces
- if(dim < 0 || dim == 2){
+ if(dim < 0 || dim == 2) {
// We build a graph
Graph graph(model);
graph.ne(model->getNumMeshElements(2));
@@ -1016,20 +1027,20 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
graph.dim(model->getDim());
graph.elementResize(graph.ne());
graph.vertexResize(model->getMaxVertexNumber());
- graph.eptrResize(graph.ne()+1);
- graph.eptr(0,0);
+ graph.eptrResize(graph.ne() + 1);
+ graph.eptr(0, 0);
const int eindSize = getSizeOfEind(model);
graph.eindResize(eindSize);
int elementaryNumber = model->getMaxElementaryNumber(2);
- for(GModel::const_fiter it = faces.begin(); it != faces.end(); ++it){
- if((*it)->geomType() == GEntity::PartitionSurface){
- partitionFace* face = static_cast<partitionFace*>(*it);
+ for(GModel::const_fiter it = faces.begin(); it != faces.end(); ++it) {
+ if((*it)->geomType() == GEntity::PartitionSurface) {
+ partitionFace *face = static_cast<partitionFace *>(*it);
graph.ne(face->getNumMeshElements());
graph.dim(2);
- graph.eptr(0,0);
+ graph.eptr(0, 0);
graph.clearDualGraph();
graph.eraseVertex();
@@ -1040,48 +1051,51 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
fillElementsToNodesMap(graph, face, eptrIndex, eindIndex, numVertex,
face->triangles.begin(), face->triangles.end());
fillElementsToNodesMap(graph, face, eptrIndex, eindIndex, numVertex,
- face->quadrangles.begin(), face->quadrangles.end());
+ face->quadrangles.begin(),
+ face->quadrangles.end());
graph.nn(numVertex);
graph.createDualGraph(false);
// if a graph contains more than ((n-1)*(n-2))/2 edges
// (where n is the number of nodes), then it is connected.
- if(((graph.numNodes()-1)*(graph.numNodes()-2))/2 < graph.numEdges()){
+ if(((graph.numNodes() - 1) * (graph.numNodes() - 2)) / 2 <
+ graph.numEdges()) {
continue;
}
- std::vector< std::set<MElement*> > connectedElements;
+ std::vector<std::set<MElement *> > connectedElements;
fillConnectedElements(connectedElements, graph);
- if(connectedElements.size() > 1){
+ if(connectedElements.size() > 1) {
ret = true;
- std::list<GRegion*> BRepRegions = face->regions();
+ std::list<GRegion *> BRepRegions = face->regions();
std::vector<int> oldOrientations;
- if(BRepRegions.size() > 0){
- for(std::list<GRegion*>::iterator itBRep = BRepRegions.begin();
- itBRep != BRepRegions.end(); ++itBRep){
+ if(BRepRegions.size() > 0) {
+ for(std::list<GRegion *>::iterator itBRep = BRepRegions.begin();
+ itBRep != BRepRegions.end(); ++itBRep) {
oldOrientations.push_back((*itBRep)->delFace(face));
}
}
- for(unsigned int i = 0; i < connectedElements.size(); i++){
+ for(unsigned int i = 0; i < connectedElements.size(); i++) {
// Create the new partitionFace
- partitionFace *pface = new partitionFace
- (model, ++elementaryNumber, face->getPartitions());
+ partitionFace *pface = new partitionFace(model, ++elementaryNumber,
+ face->getPartitions());
// Assign parent entity
pface->setParentEntity(face->getParentEntity());
// Add to model
model->add(pface);
- for(std::set<MElement*>::iterator itSet = connectedElements[i].begin();
- itSet != connectedElements[i].end(); ++itSet){
+ for(std::set<MElement *>::iterator itSet =
+ connectedElements[i].begin();
+ itSet != connectedElements[i].end(); ++itSet) {
// Add elements
pface->addElement((*itSet)->getType(), (*itSet));
}
// Move B-Rep
- if(BRepRegions.size() > 0){
+ if(BRepRegions.size() > 0) {
int i = 0;
- for(std::list<GRegion*>::iterator itBRep = BRepRegions.begin();
- itBRep != BRepRegions.end(); ++itBRep){
+ for(std::list<GRegion *>::iterator itBRep = BRepRegions.begin();
+ itBRep != BRepRegions.end(); ++itBRep) {
(*itBRep)->setFace(pface, oldOrientations[i]);
pface->addRegion(*itBRep);
i++;
@@ -1102,7 +1116,7 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
}
// Loop over regions
- if(dim < 0 || dim == 3){
+ if(dim < 0 || dim == 3) {
// We build a graph
Graph graph(model);
graph.ne(model->getNumMeshElements(3));
@@ -1110,20 +1124,20 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
graph.dim(model->getDim());
graph.elementResize(graph.ne());
graph.vertexResize(model->getMaxVertexNumber());
- graph.eptrResize(graph.ne()+1);
- graph.eptr(0,0);
+ graph.eptrResize(graph.ne() + 1);
+ graph.eptr(0, 0);
const int eindSize = getSizeOfEind(model);
graph.eindResize(eindSize);
int elementaryNumber = model->getMaxElementaryNumber(3);
- for(GModel::const_riter it = regions.begin(); it != regions.end(); ++it){
- if((*it)->geomType() == GEntity::PartitionVolume){
- partitionRegion* region = static_cast<partitionRegion*>(*it);
+ for(GModel::const_riter it = regions.begin(); it != regions.end(); ++it) {
+ if((*it)->geomType() == GEntity::PartitionVolume) {
+ partitionRegion *region = static_cast<partitionRegion *>(*it);
graph.ne(region->getNumMeshElements());
graph.dim(3);
- graph.eptr(0,0);
+ graph.eptr(0, 0);
graph.clearDualGraph();
graph.eraseVertex();
@@ -1132,40 +1146,46 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
int numVertex = 0;
fillElementsToNodesMap(graph, region, eptrIndex, eindIndex, numVertex,
- region->tetrahedra.begin(), region->tetrahedra.end());
+ region->tetrahedra.begin(),
+ region->tetrahedra.end());
fillElementsToNodesMap(graph, region, eptrIndex, eindIndex, numVertex,
- region->hexahedra.begin(), region->hexahedra.end());
+ region->hexahedra.begin(),
+ region->hexahedra.end());
fillElementsToNodesMap(graph, region, eptrIndex, eindIndex, numVertex,
region->prisms.begin(), region->prisms.end());
fillElementsToNodesMap(graph, region, eptrIndex, eindIndex, numVertex,
- region->pyramids.begin(), region->pyramids.end());
+ region->pyramids.begin(),
+ region->pyramids.end());
fillElementsToNodesMap(graph, region, eptrIndex, eindIndex, numVertex,
- region->trihedra.begin(), region->trihedra.end());
+ region->trihedra.begin(),
+ region->trihedra.end());
graph.nn(numVertex);
graph.createDualGraph(false);
// if a graph contains more than ((n-1)*(n-2))/2 edges
// (where n is the number of nodes), then it is connected.
- if(((graph.numNodes()-1)*(graph.numNodes()-2))/2 < graph.numEdges()){
+ if(((graph.numNodes() - 1) * (graph.numNodes() - 2)) / 2 <
+ graph.numEdges()) {
continue;
}
- std::vector< std::set<MElement*> > connectedElements;
+ std::vector<std::set<MElement *> > connectedElements;
fillConnectedElements(connectedElements, graph);
- if(connectedElements.size() > 1){
+ if(connectedElements.size() > 1) {
ret = true;
- for(unsigned int i = 0; i < connectedElements.size(); i++){
+ for(unsigned int i = 0; i < connectedElements.size(); i++) {
// Create the new partitionRegion
- partitionRegion *pregion = new partitionRegion
- (model, ++elementaryNumber, region->getPartitions());
+ partitionRegion *pregion = new partitionRegion(
+ model, ++elementaryNumber, region->getPartitions());
// Assign d parent entity
pregion->setParentEntity(region->getParentEntity());
// Add to model
model->add(pregion);
- for(std::set<MElement*>::iterator itSet = connectedElements[i].begin();
- itSet != connectedElements[i].end(); ++itSet){
- //Add elements
+ for(std::set<MElement *>::iterator itSet =
+ connectedElements[i].begin();
+ itSet != connectedElements[i].end(); ++itSet) {
+ // Add elements
pregion->addElement((*itSet)->getType(), (*itSet));
}
}
@@ -1190,23 +1210,24 @@ static bool dividedNonConnectedEntities(GModel *const model, int dim,
// Create the new volume entities (omega)
static void CreateNewEntities(GModel *const model,
- hashmap<MElement*, unsigned int> &elmToPartition)
+ hashmap<MElement *, unsigned int> &elmToPartition)
{
- std::set<GRegion*, GEntityLessThan> regions = model->getRegions();
- std::set<GFace*, GEntityLessThan> faces = model->getFaces();
- std::set<GEdge*, GEntityLessThan> edges = model->getEdges();
- std::set<GVertex*, GEntityLessThan> vertices = model->getVertices();
+ std::set<GRegion *, GEntityLessThan> regions = model->getRegions();
+ std::set<GFace *, GEntityLessThan> faces = model->getFaces();
+ std::set<GEdge *, GEntityLessThan> edges = model->getEdges();
+ std::set<GVertex *, GEntityLessThan> vertices = model->getVertices();
int elementaryNumber = model->getMaxElementaryNumber(0);
- for(GModel::const_viter it = vertices.begin(); it != vertices.end(); ++it){
+ for(GModel::const_viter it = vertices.begin(); it != vertices.end(); ++it) {
std::vector<partitionVertex *> newVertices(model->getNumPartitions(), 0);
assignElementsToEntities(model, elmToPartition, newVertices,
- (*it)->points.begin(), (*it)->points.end(), elementaryNumber);
+ (*it)->points.begin(), (*it)->points.end(),
+ elementaryNumber);
- for(unsigned int i = 0; i < model->getNumPartitions(); i++){
- if(newVertices[i]){
- static_cast<partitionVertex*>(newVertices[i])->setParentEntity((*it));
+ for(unsigned int i = 0; i < model->getNumPartitions(); i++) {
+ if(newVertices[i]) {
+ static_cast<partitionVertex *>(newVertices[i])->setParentEntity((*it));
}
}
@@ -1216,15 +1237,16 @@ static void CreateNewEntities(GModel *const model,
}
elementaryNumber = model->getMaxElementaryNumber(1);
- for(GModel::const_eiter it = edges.begin(); it != edges.end(); ++it){
+ for(GModel::const_eiter it = edges.begin(); it != edges.end(); ++it) {
std::vector<partitionEdge *> newEdges(model->getNumPartitions(), 0);
assignElementsToEntities(model, elmToPartition, newEdges,
- (*it)->lines.begin(), (*it)->lines.end(), elementaryNumber);
+ (*it)->lines.begin(), (*it)->lines.end(),
+ elementaryNumber);
- for(unsigned int i = 0; i < model->getNumPartitions(); i++){
- if(newEdges[i]){
- static_cast<partitionEdge*>(newEdges[i])->setParentEntity(*it);
+ for(unsigned int i = 0; i < model->getNumPartitions(); i++) {
+ if(newEdges[i]) {
+ static_cast<partitionEdge *>(newEdges[i])->setParentEntity(*it);
}
}
@@ -1234,20 +1256,20 @@ static void CreateNewEntities(GModel *const model,
}
elementaryNumber = model->getMaxElementaryNumber(2);
- for(GModel::const_fiter it = faces.begin(); it != faces.end(); ++it){
+ for(GModel::const_fiter it = faces.begin(); it != faces.end(); ++it) {
std::vector<partitionFace *> newFaces(model->getNumPartitions(), 0);
- assignElementsToEntities
- (model, elmToPartition, newFaces,
- (*it)->triangles.begin(), (*it)->triangles.end(), elementaryNumber);
- assignElementsToEntities
- (model, elmToPartition, newFaces,
- (*it)->quadrangles.begin(), (*it)->quadrangles.end(), elementaryNumber);
+ assignElementsToEntities(model, elmToPartition, newFaces,
+ (*it)->triangles.begin(), (*it)->triangles.end(),
+ elementaryNumber);
+ assignElementsToEntities(model, elmToPartition, newFaces,
+ (*it)->quadrangles.begin(),
+ (*it)->quadrangles.end(), elementaryNumber);
- std::list<GRegion*> BRepRegions = (*it)->regions();
- for(unsigned int i = 0; i < model->getNumPartitions(); i++){
- if(newFaces[i]){
- static_cast<partitionFace*>(newFaces[i])->setParentEntity(*it);
+ std::list<GRegion *> BRepRegions = (*it)->regions();
+ for(unsigned int i = 0; i < model->getNumPartitions(); i++) {
+ if(newFaces[i]) {
+ static_cast<partitionFace *>(newFaces[i])->setParentEntity(*it);
}
}
@@ -1258,28 +1280,28 @@ static void CreateNewEntities(GModel *const model,
}
elementaryNumber = model->getMaxElementaryNumber(3);
- for(GModel::const_riter it = regions.begin(); it != regions.end(); ++it){
+ for(GModel::const_riter it = regions.begin(); it != regions.end(); ++it) {
std::vector<partitionRegion *> newRegions(model->getNumPartitions(), 0);
- assignElementsToEntities
- (model, elmToPartition, newRegions,
- (*it)->tetrahedra.begin(), (*it)->tetrahedra.end(), elementaryNumber);
- assignElementsToEntities
- (model, elmToPartition, newRegions,
- (*it)->hexahedra.begin(), (*it)->hexahedra.end(), elementaryNumber);
- assignElementsToEntities
- (model, elmToPartition, newRegions,
- (*it)->prisms.begin(), (*it)->prisms.end(), elementaryNumber);
- assignElementsToEntities
- (model, elmToPartition, newRegions,
- (*it)->pyramids.begin(), (*it)->pyramids.end(), elementaryNumber);
- assignElementsToEntities
- (model, elmToPartition, newRegions,
- (*it)->trihedra.begin(), (*it)->trihedra.end(), elementaryNumber);
+ assignElementsToEntities(model, elmToPartition, newRegions,
+ (*it)->tetrahedra.begin(), (*it)->tetrahedra.end(),
+ elementaryNumber);
+ assignElementsToEntities(model, elmToPartition, newRegions,
+ (*it)->hexahedra.begin(), (*it)->hexahedra.end(),
+ elementaryNumber);
+ assignElementsToEntities(model, elmToPartition, newRegions,
+ (*it)->prisms.begin(), (*it)->prisms.end(),
+ elementaryNumber);
+ assignElementsToEntities(model, elmToPartition, newRegions,
+ (*it)->pyramids.begin(), (*it)->pyramids.end(),
+ elementaryNumber);
+ assignElementsToEntities(model, elmToPartition, newRegions,
+ (*it)->trihedra.begin(), (*it)->trihedra.end(),
+ elementaryNumber);
- for(unsigned int i = 0; i < model->getNumPartitions(); i++){
- if(newRegions[i]){
- static_cast<partitionRegion*>(newRegions[i])->setParentEntity(*it);
+ for(unsigned int i = 0; i < model->getNumPartitions(); i++) {
+ if(newRegions[i]) {
+ static_cast<partitionRegion *>(newRegions[i])->setParentEntity(*it);
}
}
@@ -1303,85 +1325,95 @@ static void CreateNewEntities(GModel *const model,
}
static void fillElementToEntity(GModel *const model,
- hashmap<MElement*, GEntity*> &elmToEntity, int dim)
+ hashmap<MElement *, GEntity *> &elmToEntity,
+ int dim)
{
// Loop over regions
- if(dim < 0 || dim == 3){
- for(GModel::const_riter it = model->firstRegion(); it != model->lastRegion(); ++it){
- for(std::vector<MTetrahedron*>::iterator itElm = (*it)->tetrahedra.begin();
+ if(dim < 0 || dim == 3) {
+ for(GModel::const_riter it = model->firstRegion();
+ it != model->lastRegion(); ++it) {
+ for(std::vector<MTetrahedron *>::iterator itElm =
+ (*it)->tetrahedra.begin();
itElm != (*it)->tetrahedra.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
- for(std::vector<MHexahedron*>::iterator itElm = (*it)->hexahedra.begin();
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
+ for(std::vector<MHexahedron *>::iterator itElm = (*it)->hexahedra.begin();
itElm != (*it)->hexahedra.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
- for(std::vector<MPrism*>::iterator itElm = (*it)->prisms.begin();
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
+ for(std::vector<MPrism *>::iterator itElm = (*it)->prisms.begin();
itElm != (*it)->prisms.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
- for(std::vector<MPyramid*>::iterator itElm = (*it)->pyramids.begin();
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
+ for(std::vector<MPyramid *>::iterator itElm = (*it)->pyramids.begin();
itElm != (*it)->pyramids.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
- for(std::vector<MTrihedron*>::iterator itElm = (*it)->trihedra.begin();
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
+ for(std::vector<MTrihedron *>::iterator itElm = (*it)->trihedra.begin();
itElm != (*it)->trihedra.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
}
}
// Loop over faces
- if(dim < 0 || dim == 2){
- for(GModel::const_fiter it = model->firstFace(); it != model->lastFace(); ++it){
- for(std::vector<MTriangle*>::iterator itElm = (*it)->triangles.begin();
+ if(dim < 0 || dim == 2) {
+ for(GModel::const_fiter it = model->firstFace(); it != model->lastFace();
+ ++it) {
+ for(std::vector<MTriangle *>::iterator itElm = (*it)->triangles.begin();
itElm != (*it)->triangles.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
- for(std::vector<MQuadrangle*>::iterator itElm = (*it)->quadrangles.begin();
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
+ for(std::vector<MQuadrangle *>::iterator itElm =
+ (*it)->quadrangles.begin();
itElm != (*it)->quadrangles.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
}
}
// Loop over edges
- if(dim < 0 || dim == 1){
- for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge(); ++it){
- for(std::vector<MLine*>::iterator itElm = (*it)->lines.begin();
+ if(dim < 0 || dim == 1) {
+ for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge();
+ ++it) {
+ for(std::vector<MLine *>::iterator itElm = (*it)->lines.begin();
itElm != (*it)->lines.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
}
}
// Loop over vertices
- if(dim < 0 || dim == 0){
- for(GModel::const_viter it = model->firstVertex(); it != model->lastVertex(); ++it){
- for(std::vector<MPoint*>::iterator itElm = (*it)->points.begin();
+ if(dim < 0 || dim == 0) {
+ for(GModel::const_viter it = model->firstVertex();
+ it != model->lastVertex(); ++it) {
+ for(std::vector<MPoint *>::iterator itElm = (*it)->points.begin();
itElm != (*it)->points.end(); ++itElm)
- elmToEntity.insert(std::pair<MElement*, GEntity*>(*itElm, *it));
+ elmToEntity.insert(std::pair<MElement *, GEntity *>(*itElm, *it));
}
}
}
-static MElement* getReferenceElement(const std::vector< std::pair<MElement*,
- std::vector<unsigned int> > > &elementPairs)
+static MElement *getReferenceElement(
+ const std::vector<std::pair<MElement *, std::vector<unsigned int> > >
+ &elementPairs)
{
unsigned int min = std::numeric_limits<unsigned int>::max();
- std::vector< std::pair<MElement*, std::vector<unsigned int> > > minSizeElementPairs;
- std::vector< std::pair<MElement*, std::vector<unsigned int> > > minSizeElementPairsTmp;
+ std::vector<std::pair<MElement *, std::vector<unsigned int> > >
+ minSizeElementPairs;
+ std::vector<std::pair<MElement *, std::vector<unsigned int> > >
+ minSizeElementPairsTmp;
// Take only the elements having the less partition in commun. For exemple we
// take (1,2) and (3,8) but not (2,5,9) or (1,4,5,7)
- for(unsigned int i = 0; i < elementPairs.size(); i++){
- if(min > elementPairs[i].second.size()){
+ for(unsigned int i = 0; i < elementPairs.size(); i++) {
+ if(min > elementPairs[i].second.size()) {
minSizeElementPairs.clear();
min = elementPairs[i].second.size();
minSizeElementPairs.push_back(elementPairs[i]);
}
- else if(min == elementPairs[i].second.size()){
+ else if(min == elementPairs[i].second.size()) {
minSizeElementPairs.push_back(elementPairs[i]);
}
}
// Check if the element separated different partitions
- if(minSizeElementPairs.size() == elementPairs.size()){
+ if(minSizeElementPairs.size() == elementPairs.size()) {
bool isEqual = true;
- for(unsigned int i = 1; i < minSizeElementPairs.size(); i++){
- if(minSizeElementPairs[i].second != minSizeElementPairs[0].second){
+ for(unsigned int i = 1; i < minSizeElementPairs.size(); i++) {
+ if(minSizeElementPairs[i].second != minSizeElementPairs[0].second) {
isEqual = false;
break;
}
@@ -1389,19 +1421,21 @@ static MElement* getReferenceElement(const std::vector< std::pair<MElement*,
if(isEqual) return 0;
}
- while(minSizeElementPairs.size() > 1){
+ while(minSizeElementPairs.size() > 1) {
min = std::numeric_limits<unsigned int>::max();
- for(unsigned int i = 0; i < minSizeElementPairs.size(); i++){
+ for(unsigned int i = 0; i < minSizeElementPairs.size(); i++) {
// The partition vector is sorted thus we can check only the first element
- if(minSizeElementPairs[i].second.size() == 0) return minSizeElementPairs[0].first;
- if(min > minSizeElementPairs[i].second[0]){
+ if(minSizeElementPairs[i].second.size() == 0)
+ return minSizeElementPairs[0].first;
+ if(min > minSizeElementPairs[i].second[0]) {
min = minSizeElementPairs[i].second[0];
}
}
- for(unsigned int i = 0; i < minSizeElementPairs.size(); i++){
- if(min == minSizeElementPairs[i].second[0]){
- minSizeElementPairs[i].second.erase(minSizeElementPairs[i].second.begin());
+ for(unsigned int i = 0; i < minSizeElementPairs.size(); i++) {
+ if(min == minSizeElementPairs[i].second[0]) {
+ minSizeElementPairs[i].second.erase(
+ minSizeElementPairs[i].second.begin());
minSizeElementPairsTmp.push_back(minSizeElementPairs[i]);
}
}
@@ -1417,14 +1451,15 @@ static MElement* getReferenceElement(const std::vector< std::pair<MElement*,
return minSizeElementPairs[0].first;
}
-static void getPartitionInVector(std::vector<unsigned int> &partitions,
- const std::vector< std::pair<MElement*,
- std::vector<unsigned int> > > &boundaryPair)
+static void getPartitionInVector(
+ std::vector<unsigned int> &partitions,
+ const std::vector<std::pair<MElement *, std::vector<unsigned int> > >
+ &boundaryPair)
{
- for(unsigned int i = 0; i < boundaryPair.size(); i++){
- for(unsigned int j = 0; j < boundaryPair[i].second.size(); j++){
- if(std::find(partitions.begin(), partitions.end(), boundaryPair[i].second[j]) ==
- partitions.end()){
+ for(unsigned int i = 0; i < boundaryPair.size(); i++) {
+ for(unsigned int j = 0; j < boundaryPair[i].second.size(); j++) {
+ if(std::find(partitions.begin(), partitions.end(),
+ boundaryPair[i].second[j]) == partitions.end()) {
partitions.push_back(boundaryPair[i].second[j]);
}
}
@@ -1434,35 +1469,40 @@ static void getPartitionInVector(std::vector<unsigned int> &partitions,
}
template <class PART_ENTITY, class LESS_PART_ENTITY>
-static PART_ENTITY* createPartitionEntity(
- std::pair< typename std::multimap<PART_ENTITY*, GEntity*,LESS_PART_ENTITY>::iterator,
- typename std::multimap<PART_ENTITY*, GEntity*, LESS_PART_ENTITY>::iterator> &ret,
- GModel *const model, int &numEntity, const std::vector<unsigned int> &partitions,
- GEntity *referenceEntity, PART_ENTITY **newEntity,
+static PART_ENTITY *createPartitionEntity(
+ std::pair<typename std::multimap<PART_ENTITY *, GEntity *,
+ LESS_PART_ENTITY>::iterator,
+ typename std::multimap<PART_ENTITY *, GEntity *,
+ LESS_PART_ENTITY>::iterator> &ret,
+ GModel *const model, int &numEntity,
+ const std::vector<unsigned int> &partitions, GEntity *referenceEntity,
+ PART_ENTITY **newEntity,
typename std::multimap<PART_ENTITY *, GEntity *, LESS_PART_ENTITY> &pentities)
{
PART_ENTITY *ppe = 0;
// Create the new partition entity for the mesh
- if(ret.first == ret.second){
+ if(ret.first == ret.second) {
// Create new entity and add them to the model
ppe = new PART_ENTITY(model, ++numEntity, partitions);
ppe->setParentEntity(referenceEntity->getParentEntity());
- pentities.insert(std::pair<PART_ENTITY*, GEntity*>(ppe, referenceEntity));
+ pentities.insert(std::pair<PART_ENTITY *, GEntity *>(ppe, referenceEntity));
model->add(ppe);
*newEntity = ppe;
}
- else{
- for(typename std::multimap<PART_ENTITY*, GEntity*, LESS_PART_ENTITY>::iterator it = ret.first;
- it != ret.second; ++it){
- if(referenceEntity == it->second){
+ else {
+ for(typename std::multimap<PART_ENTITY *, GEntity *,
+ LESS_PART_ENTITY>::iterator it = ret.first;
+ it != ret.second; ++it) {
+ if(referenceEntity == it->second) {
ppe = it->first;
}
}
- if(!ppe){
+ if(!ppe) {
// Create new entity and add them to the model
ppe = new PART_ENTITY(model, ++numEntity, partitions);
ppe->setParentEntity(referenceEntity->getParentEntity());
- pentities.insert(std::pair<PART_ENTITY*, GEntity*>(ppe, referenceEntity));
+ pentities.insert(
+ std::pair<PART_ENTITY *, GEntity *>(ppe, referenceEntity));
model->add(ppe);
*newEntity = ppe;
}
@@ -1479,56 +1519,59 @@ static partitionFace *assignPartitionBoundary(
{
partitionFace *newEntity = 0;
partitionFace pf(model, 1, partitions);
- std::pair< std::multimap<partitionFace*, GEntity*, Less_partitionFace>::iterator,
- std::multimap<partitionFace*, GEntity*, Less_partitionFace>::iterator>
- ret = pfaces.equal_range(&pf);
-
- partitionFace *ppf = createPartitionEntity(ret, model, numEntity, partitions,
- elementToEntity[reference], &newEntity,
- pfaces);
+ std::pair<
+ std::multimap<partitionFace *, GEntity *, Less_partitionFace>::iterator,
+ std::multimap<partitionFace *, GEntity *, Less_partitionFace>::iterator>
+ ret = pfaces.equal_range(&pf);
+
+ partitionFace *ppf =
+ createPartitionEntity(ret, model, numEntity, partitions,
+ elementToEntity[reference], &newEntity, pfaces);
int numFace = 0;
- for(int i = 0; i < reference->getNumFaces(); i++){
- if(reference->getFace(i) == me){
+ for(int i = 0; i < reference->getNumFaces(); i++) {
+ if(reference->getFace(i) == me) {
numFace = i;
break;
}
}
- if(me.getNumVertices() == 3){
- std::vector<MVertex*> verts;
+ if(me.getNumVertices() == 3) {
+ std::vector<MVertex *> verts;
reference->getFaceVertices(numFace, verts);
- if(verts.size() == 3){
+ if(verts.size() == 3) {
MTriangle *element = new MTriangle(verts);
ppf->addTriangle(element);
}
- else if(verts.size() == 6){
+ else if(verts.size() == 6) {
MTriangle6 *element = new MTriangle6(verts);
ppf->addTriangle(element);
}
- else{
- MTriangleN *element = new MTriangleN(verts, verts[0]->getPolynomialOrder());
+ else {
+ MTriangleN *element =
+ new MTriangleN(verts, verts[0]->getPolynomialOrder());
ppf->addTriangle(element);
}
}
- else if(me.getNumVertices() == 4){
- std::vector<MVertex*> verts;
+ else if(me.getNumVertices() == 4) {
+ std::vector<MVertex *> verts;
reference->getFaceVertices(numFace, verts);
- if(verts.size() == 4){
+ if(verts.size() == 4) {
MQuadrangle *element = new MQuadrangle(verts);
ppf->addQuadrangle(element);
}
- else if(verts.size() == 8){
+ else if(verts.size() == 8) {
MQuadrangle8 *element = new MQuadrangle8(verts);
ppf->addQuadrangle(element);
}
- else if(verts.size() == 9){
+ else if(verts.size() == 9) {
MQuadrangle9 *element = new MQuadrangle9(verts);
ppf->addQuadrangle(element);
}
- else{
- MQuadrangleN *element = new MQuadrangleN(verts, verts[0]->getPolynomialOrder());
+ else {
+ MQuadrangleN *element =
+ new MQuadrangleN(verts, verts[0]->getPolynomialOrder());
ppf->addQuadrangle(element);
}
}
@@ -1544,35 +1587,36 @@ static partitionEdge *assignPartitionBoundary(
{
partitionEdge *newEntity = 0;
partitionEdge pe(model, 1, 0, 0, partitions);
- std::pair< std::multimap<partitionEdge*, GEntity*, Less_partitionEdge>::iterator,
- std::multimap<partitionEdge*, GEntity*, Less_partitionEdge>::iterator>
- ret = pedges.equal_range(&pe);
+ std::pair<
+ std::multimap<partitionEdge *, GEntity *, Less_partitionEdge>::iterator,
+ std::multimap<partitionEdge *, GEntity *, Less_partitionEdge>::iterator>
+ ret = pedges.equal_range(&pe);
- partitionEdge *ppe = createPartitionEntity(ret, model, numEntity, partitions,
- elementToEntity[reference], &newEntity,
- pedges);
+ partitionEdge *ppe =
+ createPartitionEntity(ret, model, numEntity, partitions,
+ elementToEntity[reference], &newEntity, pedges);
int numEdge = 0;
- for(int i = 0; i < reference->getNumEdges(); i++){
- if(reference->getEdge(i) == me){
+ for(int i = 0; i < reference->getNumEdges(); i++) {
+ if(reference->getEdge(i) == me) {
numEdge = i;
break;
}
}
- if(me.getNumVertices() == 2){
- std::vector<MVertex*> verts;
+ if(me.getNumVertices() == 2) {
+ std::vector<MVertex *> verts;
reference->getEdgeVertices(numEdge, verts);
- if(verts.size() == 2){
+ if(verts.size() == 2) {
MLine *element = new MLine(verts);
ppe->addLine(element);
}
- else if(verts.size() == 3){
+ else if(verts.size() == 3) {
MLine3 *element = new MLine3(verts);
ppe->addLine(element);
}
- else{
+ else {
MLineN *element = new MLineN(verts);
ppe->addLine(element);
}
@@ -1589,57 +1633,59 @@ static partitionVertex *assignPartitionBoundary(
{
partitionVertex *newEntity = 0;
partitionVertex pv(model, 1, partitions);
- std::pair< std::multimap<partitionVertex*, GEntity*, Less_partitionVertex>::iterator,
- std::multimap<partitionVertex*, GEntity*, Less_partitionVertex>::iterator >
+ std::pair<
+ std::multimap<partitionVertex *, GEntity *, Less_partitionVertex>::iterator,
+ std::multimap<partitionVertex *, GEntity *, Less_partitionVertex>::iterator>
ret = pvertices.equal_range(&pv);
- partitionVertex *ppv = createPartitionEntity(ret, model, numEntity, partitions,
- elementToEntity[reference], &newEntity,
- pvertices);
+ partitionVertex *ppv =
+ createPartitionEntity(ret, model, numEntity, partitions,
+ elementToEntity[reference], &newEntity, pvertices);
ppv->addPoint(new MPoint(ve));
return newEntity;
}
-static int computeOrientation(MElement* reference, MElement* element)
+static int computeOrientation(MElement *reference, MElement *element)
{
- if(element->getDim() == 2)
- {
- std::vector<MVertex*> vertices;
+ if(element->getDim() == 2) {
+ std::vector<MVertex *> vertices;
element->getVertices(vertices);
MFace face = element->getFace(0);
- for(int i = 0; i < reference->getNumFaces(); i++){
- if(reference->getFace(i) == face){
- std::vector<MVertex*> referenceVertices;
+ for(int i = 0; i < reference->getNumFaces(); i++) {
+ if(reference->getFace(i) == face) {
+ std::vector<MVertex *> referenceVertices;
reference->getFaceVertices(i, referenceVertices);
- if(referenceVertices == vertices) return 1;
- else return -1;
+ if(referenceVertices == vertices)
+ return 1;
+ else
+ return -1;
}
}
}
- else if(element->getDim() == 1)
- {
- std::vector<MVertex*> vertices;
+ else if(element->getDim() == 1) {
+ std::vector<MVertex *> vertices;
element->getVertices(vertices);
MEdge face = element->getEdge(0);
- for(int i = 0; i < reference->getNumEdges(); i++){
- if(reference->getEdge(i) == face){
- std::vector<MVertex*> referenceVertices;
+ for(int i = 0; i < reference->getNumEdges(); i++) {
+ if(reference->getEdge(i) == face) {
+ std::vector<MVertex *> referenceVertices;
reference->getEdgeVertices(i, referenceVertices);
- if(referenceVertices == vertices) return 1;
- else return -1;
+ if(referenceVertices == vertices)
+ return 1;
+ else
+ return -1;
}
}
}
- else if(element->getDim() == 0)
- {
- std::vector<MVertex*> vertices;
+ else if(element->getDim() == 0) {
+ std::vector<MVertex *> vertices;
element->getVertices(vertices);
- std::vector<MVertex*> referenceVertices;
+ std::vector<MVertex *> referenceVertices;
reference->getVertices(referenceVertices);
if(referenceVertices[0] == vertices[0]) return 1;
@@ -1649,153 +1695,163 @@ static int computeOrientation(MElement* reference, MElement* element)
return 0;
}
-static void assignBrep(GModel *const model, std::map<GEntity*, MElement*>
- &boundaryEntityAndRefElement, GEntity *e)
+static void
+assignBrep(GModel *const model,
+ std::map<GEntity *, MElement *> &boundaryEntityAndRefElement,
+ GEntity *e)
{
- if(e->dim() == 2){
- partitionFace* entity = static_cast<partitionFace*>(e);
+ if(e->dim() == 2) {
+ partitionFace *entity = static_cast<partitionFace *>(e);
- for(std::map<GEntity*, MElement*>::iterator it = boundaryEntityAndRefElement.begin();
- it != boundaryEntityAndRefElement.end(); ++it){
- static_cast<GRegion*>(it->first)->setFace
- (entity, computeOrientation(it->second, entity->getMeshElement(0)));
- entity->addRegion(static_cast<GRegion*>(it->first));
+ for(std::map<GEntity *, MElement *>::iterator it =
+ boundaryEntityAndRefElement.begin();
+ it != boundaryEntityAndRefElement.end(); ++it) {
+ static_cast<GRegion *>(it->first)->setFace(
+ entity, computeOrientation(it->second, entity->getMeshElement(0)));
+ entity->addRegion(static_cast<GRegion *>(it->first));
}
}
- else if(e->dim() == 1){
- partitionEdge* entity = static_cast<partitionEdge*>(e);
+ else if(e->dim() == 1) {
+ partitionEdge *entity = static_cast<partitionEdge *>(e);
- for(std::map<GEntity*, MElement*>::iterator it = boundaryEntityAndRefElement.begin();
- it != boundaryEntityAndRefElement.end(); ++it){
- static_cast<GFace*>(it->first)->setEdge
- (entity, computeOrientation(it->second, entity->getMeshElement(0)));
- entity->addFace(static_cast<GFace*>(it->first));
+ for(std::map<GEntity *, MElement *>::iterator it =
+ boundaryEntityAndRefElement.begin();
+ it != boundaryEntityAndRefElement.end(); ++it) {
+ static_cast<GFace *>(it->first)->setEdge(
+ entity, computeOrientation(it->second, entity->getMeshElement(0)));
+ entity->addFace(static_cast<GFace *>(it->first));
}
}
- else if(e->dim() == 0){
- partitionVertex* entity = static_cast<partitionVertex*>(e);
+ else if(e->dim() == 0) {
+ partitionVertex *entity = static_cast<partitionVertex *>(e);
- for(std::map<GEntity*, MElement*>::iterator it = boundaryEntityAndRefElement.begin();
- it != boundaryEntityAndRefElement.end(); ++it){
- static_cast<GEdge*>(it->first)->setVertex
- (entity, computeOrientation(it->second, entity->getMeshElement(0)));
- entity->addEdge(static_cast<GEdge*>(it->first));
+ for(std::map<GEntity *, MElement *>::iterator it =
+ boundaryEntityAndRefElement.begin();
+ it != boundaryEntityAndRefElement.end(); ++it) {
+ static_cast<GEdge *>(it->first)->setVertex(
+ entity, computeOrientation(it->second, entity->getMeshElement(0)));
+ entity->addEdge(static_cast<GEdge *>(it->first));
}
}
}
-void assignNewEntityBRep(Graph &graph, hashmap<MElement*, GEntity*> &elementToEntity)
+void assignNewEntityBRep(Graph &graph,
+ hashmap<MElement *, GEntity *> &elementToEntity)
{
- std::set< std::pair<GEntity*, GEntity*> > brepWithoutOri;
- hashmap<GEntity*, std::set<std::pair<int, GEntity*> > > brep;
- for(unsigned int i = 0; i < graph.ne(); i++){
+ std::set<std::pair<GEntity *, GEntity *> > brepWithoutOri;
+ hashmap<GEntity *, std::set<std::pair<int, GEntity *> > > brep;
+ for(unsigned int i = 0; i < graph.ne(); i++) {
MElement *current = graph.element(i);
- for(unsigned int j = graph.xadj(i); j < graph.xadj(i+1); j++)
- {
- if(current->getDim() == graph.element(graph.adjncy(j))->getDim()+1){
+ for(unsigned int j = graph.xadj(i); j < graph.xadj(i + 1); j++) {
+ if(current->getDim() == graph.element(graph.adjncy(j))->getDim() + 1) {
GEntity *g1 = elementToEntity[current];
GEntity *g2 = elementToEntity[graph.element(graph.adjncy(j))];
- if(brepWithoutOri.find(std::pair<GEntity*, GEntity*>(g1,g2)) == brepWithoutOri.end()){
- const int ori = computeOrientation(current,graph.element(graph.adjncy(j)));
- brepWithoutOri.insert(std::pair<GEntity*, GEntity*>(g1,g2));
- brep[g1].insert(std::pair<int, GEntity*>(ori,g2));
+ if(brepWithoutOri.find(std::pair<GEntity *, GEntity *>(g1, g2)) ==
+ brepWithoutOri.end()) {
+ const int ori =
+ computeOrientation(current, graph.element(graph.adjncy(j)));
+ brepWithoutOri.insert(std::pair<GEntity *, GEntity *>(g1, g2));
+ brep[g1].insert(std::pair<int, GEntity *>(ori, g2));
}
}
}
}
- for(hashmap<GEntity*, std::set<std::pair<int, GEntity*> > >::iterator
- it = brep.begin(); it != brep.end(); ++it){
- switch (it->first->dim()) {
- case 3:
- for(std::set<std::pair<int, GEntity*> >::iterator itSet =
- it->second.begin(); itSet != it->second.end(); ++itSet){
- static_cast<GRegion*>(it->first)->setFace
- (static_cast<GFace*>(itSet->second), itSet->first);
- static_cast<GFace*>(itSet->second)->addRegion
- (static_cast<GRegion*>(it->first));
- }
- break;
- case 2:
- for(std::set<std::pair<int, GEntity*> >::iterator itSet =
- it->second.begin(); itSet != it->second.end(); ++itSet){
- static_cast<GFace*>(it->first)->setEdge
- (static_cast<GEdge*>(itSet->second), itSet->first);
- static_cast<GEdge*>(itSet->second)->addFace
- (static_cast<GFace*>(it->first));
- }
- break;
- case 1:
- for(std::set<std::pair<int, GEntity*> >::iterator itSet =
- it->second.begin(); itSet != it->second.end(); ++itSet){
- static_cast<GEdge*>(it->first)->setVertex
- (static_cast<GVertex*>(itSet->second), itSet->first);
- static_cast<GVertex*>(itSet->second)->addEdge
- (static_cast<GEdge*>(it->first));
- }
- break;
- default:
- break;
+ for(hashmap<GEntity *, std::set<std::pair<int, GEntity *> > >::iterator it =
+ brep.begin();
+ it != brep.end(); ++it) {
+ switch(it->first->dim()) {
+ case 3:
+ for(std::set<std::pair<int, GEntity *> >::iterator itSet =
+ it->second.begin();
+ itSet != it->second.end(); ++itSet) {
+ static_cast<GRegion *>(it->first)->setFace(
+ static_cast<GFace *>(itSet->second), itSet->first);
+ static_cast<GFace *>(itSet->second)
+ ->addRegion(static_cast<GRegion *>(it->first));
+ }
+ break;
+ case 2:
+ for(std::set<std::pair<int, GEntity *> >::iterator itSet =
+ it->second.begin();
+ itSet != it->second.end(); ++itSet) {
+ static_cast<GFace *>(it->first)->setEdge(
+ static_cast<GEdge *>(itSet->second), itSet->first);
+ static_cast<GEdge *>(itSet->second)
+ ->addFace(static_cast<GFace *>(it->first));
+ }
+ break;
+ case 1:
+ for(std::set<std::pair<int, GEntity *> >::iterator itSet =
+ it->second.begin();
+ itSet != it->second.end(); ++itSet) {
+ static_cast<GEdge *>(it->first)->setVertex(
+ static_cast<GVertex *>(itSet->second), itSet->first);
+ static_cast<GVertex *>(itSet->second)
+ ->addEdge(static_cast<GEdge *>(it->first));
+ }
+ break;
+ default: break;
}
}
}
// Create the new entities between each partitions (sigma and bndSigma).
-static void CreatePartitionTopology(GModel *const model,
- const std::vector< std::set<MElement*> >
- &boundaryElements, Graph &meshGraph)
+static void CreatePartitionTopology(
+ GModel *const model,
+ const std::vector<std::set<MElement *> > &boundaryElements, Graph &meshGraph)
{
const int meshDim = model->getDim();
- hashmap<MElement*, GEntity*> elementToEntity;
+ hashmap<MElement *, GEntity *> elementToEntity;
fillElementToEntity(model, elementToEntity, -1);
assignNewEntityBRep(meshGraph, elementToEntity);
- std::multimap<partitionFace*, GEntity*, Less_partitionFace> pfaces;
- std::multimap<partitionEdge*, GEntity*, Less_partitionEdge> pedges;
- std::multimap<partitionVertex*, GEntity*, Less_partitionVertex> pvertices;
+ std::multimap<partitionFace *, GEntity *, Less_partitionFace> pfaces;
+ std::multimap<partitionEdge *, GEntity *, Less_partitionEdge> pedges;
+ std::multimap<partitionVertex *, GEntity *, Less_partitionVertex> pvertices;
hashmapface faceToElement;
hashmapedge edgeToElement;
hashmapvertex vertexToElement;
- std::set<GRegion*, GEntityLessThan> regions = model->getRegions();
- std::set<GFace*, GEntityLessThan> faces = model->getFaces();
- std::set<GEdge*, GEntityLessThan> edges = model->getEdges();
- std::set<GVertex*, GEntityLessThan> vertices = model->getVertices();
+ std::set<GRegion *, GEntityLessThan> regions = model->getRegions();
+ std::set<GFace *, GEntityLessThan> faces = model->getFaces();
+ std::set<GEdge *, GEntityLessThan> edges = model->getEdges();
+ std::set<GVertex *, GEntityLessThan> vertices = model->getVertices();
- if (meshDim >= 3){ // Create partition faces
+ if(meshDim >= 3) { // Create partition faces
Msg::Info(" - Creating partition faces");
- for(unsigned int i = 0; i < model->getNumPartitions(); i++){
- for(std::set<MElement*>::iterator it = boundaryElements[i].begin();
- it != boundaryElements[i].end(); ++it){
- for(int j = 0; j < (*it)->getNumFaces(); j++){
- faceToElement[(*it)->getFace(j)].push_back
- (std::pair<MElement*, std::vector<unsigned int> >
- (*it, std::vector<unsigned int>(1, i+1)));
+ for(unsigned int i = 0; i < model->getNumPartitions(); i++) {
+ for(std::set<MElement *>::iterator it = boundaryElements[i].begin();
+ it != boundaryElements[i].end(); ++it) {
+ for(int j = 0; j < (*it)->getNumFaces(); j++) {
+ faceToElement[(*it)->getFace(j)].push_back(
+ std::pair<MElement *, std::vector<unsigned int> >(
+ *it, std::vector<unsigned int>(1, i + 1)));
}
}
}
int numFaceEntity = model->getMaxElementaryNumber(2);
for(hashmapface::const_iterator it = faceToElement.begin();
- it != faceToElement.end(); ++it){
+ it != faceToElement.end(); ++it) {
MFace f = it->first;
std::vector<unsigned int> partitions;
getPartitionInVector(partitions, it->second);
if(partitions.size() < 2) continue;
- MElement* reference = getReferenceElement(it->second);
+ MElement *reference = getReferenceElement(it->second);
if(!reference) continue;
- partitionFace *pf = assignPartitionBoundary
- (model, f, reference, partitions, pfaces, elementToEntity, numFaceEntity);
- if(pf){
- std::map<GEntity*, MElement*> boundaryEntityAndRefElement;
+ partitionFace *pf =
+ assignPartitionBoundary(model, f, reference, partitions, pfaces,
+ elementToEntity, numFaceEntity);
+ if(pf) {
+ std::map<GEntity *, MElement *> boundaryEntityAndRefElement;
for(unsigned int i = 0; i < it->second.size(); i++)
- boundaryEntityAndRefElement.insert
- (std::pair<GEntity*, MElement*>(elementToEntity[it->second[i].first],
- it->second[i].first));
+ boundaryEntityAndRefElement.insert(std::pair<GEntity *, MElement *>(
+ elementToEntity[it->second[i].first], it->second[i].first));
assignBrep(model, boundaryEntityAndRefElement, pf);
}
@@ -1808,22 +1864,22 @@ static void CreatePartitionTopology(GModel *const model,
fillElementToEntity(model, elementToEntity, 2);
}
- if (meshDim >= 2){ // Create partition edges
+ if(meshDim >= 2) { // Create partition edges
Msg::Info(" - Creating partition edges");
- if (meshDim == 2){
- for(unsigned int i = 0; i < model->getNumPartitions(); i++){
- for(std::set<MElement*>::iterator it = boundaryElements[i].begin();
- it != boundaryElements[i].end(); ++it){
- for(int j = 0; j < (*it)->getNumEdges(); j++){
- edgeToElement[(*it)->getEdge(j)].push_back
- (std::pair<MElement*, std::vector<unsigned int> >
- (*it, std::vector<unsigned int>(1, i+1)));
+ if(meshDim == 2) {
+ for(unsigned int i = 0; i < model->getNumPartitions(); i++) {
+ for(std::set<MElement *>::iterator it = boundaryElements[i].begin();
+ it != boundaryElements[i].end(); ++it) {
+ for(int j = 0; j < (*it)->getNumEdges(); j++) {
+ edgeToElement[(*it)->getEdge(j)].push_back(
+ std::pair<MElement *, std::vector<unsigned int> >(
+ *it, std::vector<unsigned int>(1, i + 1)));
}
}
}
}
- else{
+ else {
Graph subGraph(model);
MakeGraph(model, subGraph, 2);
subGraph.createDualGraph(false);
@@ -1832,17 +1888,21 @@ static void CreatePartitionTopology(GModel *const model,
std::map<unsigned int, std::vector<unsigned int> > mapOfPartitions;
unsigned int mapOfPartitionsTag = 0;
- for(GModel::const_fiter it = model->firstFace(); it != model->lastFace(); ++it){
- if((*it)->geomType() == GEntity::PartitionSurface){
+ for(GModel::const_fiter it = model->firstFace(); it != model->lastFace();
+ ++it) {
+ if((*it)->geomType() == GEntity::PartitionSurface) {
std::vector<unsigned int> partitions =
- static_cast<partitionFace*>(*it)->getPartitions();
- mapOfPartitions.insert(std::pair<unsigned int, std::vector<unsigned int> >
- (mapOfPartitionsTag, partitions));
+ static_cast<partitionFace *>(*it)->getPartitions();
+ mapOfPartitions.insert(
+ std::pair<unsigned int, std::vector<unsigned int> >(
+ mapOfPartitionsTag, partitions));
// Must absolutely be in the same order as in the MakeGraph function
- for(std::vector<MTriangle*>::iterator itElm = (*it)->triangles.begin();
+ for(std::vector<MTriangle *>::iterator itElm =
+ (*it)->triangles.begin();
itElm != (*it)->triangles.end(); ++itElm)
part[partIndex++] = mapOfPartitionsTag;
- for(std::vector<MQuadrangle*>::iterator itElm = (*it)->quadrangles.begin();
+ for(std::vector<MQuadrangle *>::iterator itElm =
+ (*it)->quadrangles.begin();
itElm != (*it)->quadrangles.end(); ++itElm)
part[partIndex++] = mapOfPartitionsTag;
mapOfPartitionsTag++;
@@ -1850,17 +1910,16 @@ static void CreatePartitionTopology(GModel *const model,
}
subGraph.partition(part);
- std::vector< std::set<MElement*> > subBoundaryElements =
+ std::vector<std::set<MElement *> > subBoundaryElements =
subGraph.getBoundaryElements(mapOfPartitionsTag);
- for(unsigned int i = 0; i < mapOfPartitionsTag; i++){
- for(std::set<MElement*>::iterator it = subBoundaryElements[i].begin();
- it != subBoundaryElements[i].end(); ++it){
- for(int j = 0; j < (*it)->getNumEdges(); j++){
- edgeToElement[(*it)->getEdge(j)].push_back
- (std::pair<MElement*, std::vector<unsigned int> >
- (*it, mapOfPartitions[i]));
-
+ for(unsigned int i = 0; i < mapOfPartitionsTag; i++) {
+ for(std::set<MElement *>::iterator it = subBoundaryElements[i].begin();
+ it != subBoundaryElements[i].end(); ++it) {
+ for(int j = 0; j < (*it)->getNumEdges(); j++) {
+ edgeToElement[(*it)->getEdge(j)].push_back(
+ std::pair<MElement *, std::vector<unsigned int> >(
+ *it, mapOfPartitions[i]));
}
}
}
@@ -1868,24 +1927,24 @@ static void CreatePartitionTopology(GModel *const model,
int numEdgeEntity = model->getMaxElementaryNumber(1);
for(hashmapedge::const_iterator it = edgeToElement.begin();
- it != edgeToElement.end(); ++it){
+ it != edgeToElement.end(); ++it) {
MEdge e = it->first;
std::vector<unsigned int> partitions;
getPartitionInVector(partitions, it->second);
if(partitions.size() < 2) continue;
- MElement* reference = getReferenceElement(it->second);
+ MElement *reference = getReferenceElement(it->second);
if(!reference) continue;
- partitionEdge* pe = assignPartitionBoundary
- (model, e, reference, partitions, pedges, elementToEntity, numEdgeEntity);
- if(pe){
- std::map<GEntity*, MElement*> boundaryEntityAndRefElement;
- for(unsigned int i = 0; i < it->second.size(); i++){
- boundaryEntityAndRefElement.insert
- (std::pair<GEntity*, MElement*>(elementToEntity[it->second[i].first],
- it->second[i].first));
+ partitionEdge *pe =
+ assignPartitionBoundary(model, e, reference, partitions, pedges,
+ elementToEntity, numEdgeEntity);
+ if(pe) {
+ std::map<GEntity *, MElement *> boundaryEntityAndRefElement;
+ for(unsigned int i = 0; i < it->second.size(); i++) {
+ boundaryEntityAndRefElement.insert(std::pair<GEntity *, MElement *>(
+ elementToEntity[it->second[i].first], it->second[i].first));
}
assignBrep(model, boundaryEntityAndRefElement, pe);
@@ -1899,21 +1958,21 @@ static void CreatePartitionTopology(GModel *const model,
fillElementToEntity(model, elementToEntity, 1);
}
- if (meshDim >= 1){ // Create partition vertices
+ if(meshDim >= 1) { // Create partition vertices
Msg::Info(" - Creating partition vertices");
- if (meshDim == 1){
- for(unsigned int i = 0; i < model->getNumPartitions(); i++){
- for(std::set<MElement*>::iterator it = boundaryElements[i].begin();
- it != boundaryElements[i].end(); ++it){
- for(int j = 0; j < (*it)->getNumPrimaryVertices(); j++){
- vertexToElement[(*it)->getVertex(j)].push_back
- (std::pair<MElement*, std::vector<unsigned int> >
- (*it, std::vector<unsigned int>(1,i+1)));
+ if(meshDim == 1) {
+ for(unsigned int i = 0; i < model->getNumPartitions(); i++) {
+ for(std::set<MElement *>::iterator it = boundaryElements[i].begin();
+ it != boundaryElements[i].end(); ++it) {
+ for(int j = 0; j < (*it)->getNumPrimaryVertices(); j++) {
+ vertexToElement[(*it)->getVertex(j)].push_back(
+ std::pair<MElement *, std::vector<unsigned int> >(
+ *it, std::vector<unsigned int>(1, i + 1)));
}
}
}
}
- else{
+ else {
Graph subGraph(model);
MakeGraph(model, subGraph, 1);
subGraph.createDualGraph(false);
@@ -1922,14 +1981,16 @@ static void CreatePartitionTopology(GModel *const model,
std::map<unsigned int, std::vector<unsigned int> > mapOfPartitions;
unsigned int mapOfPartitionsTag = 0;
- for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge(); ++it){
- if((*it)->geomType() == GEntity::PartitionCurve){
+ for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge();
+ ++it) {
+ if((*it)->geomType() == GEntity::PartitionCurve) {
std::vector<unsigned int> partitions =
- static_cast<partitionEdge*>(*it)->getPartitions();
- mapOfPartitions.insert(std::pair<unsigned int, std::vector<unsigned int> >
- (mapOfPartitionsTag, partitions));
+ static_cast<partitionEdge *>(*it)->getPartitions();
+ mapOfPartitions.insert(
+ std::pair<unsigned int, std::vector<unsigned int> >(
+ mapOfPartitionsTag, partitions));
// Must absolutely be in the same order as in the MakeGraph function
- for(std::vector<MLine*>::iterator itElm = (*it)->lines.begin();
+ for(std::vector<MLine *>::iterator itElm = (*it)->lines.begin();
itElm != (*it)->lines.end(); ++itElm)
part[partIndex++] = mapOfPartitionsTag;
mapOfPartitionsTag++;
@@ -1937,40 +1998,40 @@ static void CreatePartitionTopology(GModel *const model,
}
subGraph.partition(part);
- std::vector< std::set<MElement*> > subBoundaryElements =
+ std::vector<std::set<MElement *> > subBoundaryElements =
subGraph.getBoundaryElements(mapOfPartitionsTag);
- for(unsigned int i = 0; i < mapOfPartitionsTag; i++){
- for(std::set<MElement*>::iterator it = subBoundaryElements[i].begin();
- it != subBoundaryElements[i].end(); ++it){
- for(int j = 0; j < (*it)->getNumPrimaryVertices(); j++){
- vertexToElement[(*it)->getVertex(j)].push_back
- (std::pair<MElement*, std::vector<unsigned int> >
- (*it, mapOfPartitions[i]));
+ for(unsigned int i = 0; i < mapOfPartitionsTag; i++) {
+ for(std::set<MElement *>::iterator it = subBoundaryElements[i].begin();
+ it != subBoundaryElements[i].end(); ++it) {
+ for(int j = 0; j < (*it)->getNumPrimaryVertices(); j++) {
+ vertexToElement[(*it)->getVertex(j)].push_back(
+ std::pair<MElement *, std::vector<unsigned int> >(
+ *it, mapOfPartitions[i]));
}
}
}
}
int numVertexEntity = model->getMaxElementaryNumber(0);
for(hashmapvertex::const_iterator it = vertexToElement.begin();
- it != vertexToElement.end(); ++it){
+ it != vertexToElement.end(); ++it) {
MVertex *v = it->first;
std::vector<unsigned int> partitions;
getPartitionInVector(partitions, it->second);
if(partitions.size() < 2) continue;
- MElement* reference = getReferenceElement(it->second);
+ MElement *reference = getReferenceElement(it->second);
if(!reference) continue;
- partitionVertex* pv = assignPartitionBoundary
- (model, v, reference, partitions, pvertices, elementToEntity, numVertexEntity);
- if(pv){
- std::map<GEntity*, MElement*> boundaryEntityAndRefElement;
+ partitionVertex *pv =
+ assignPartitionBoundary(model, v, reference, partitions, pvertices,
+ elementToEntity, numVertexEntity);
+ if(pv) {
+ std::map<GEntity *, MElement *> boundaryEntityAndRefElement;
for(unsigned int i = 0; i < it->second.size(); i++)
- boundaryEntityAndRefElement.insert
- (std::pair<GEntity*, MElement*>(elementToEntity[it->second[i].first],
- it->second[i].first));
+ boundaryEntityAndRefElement.insert(std::pair<GEntity *, MElement *>(
+ elementToEntity[it->second[i].first], it->second[i].first));
assignBrep(model, boundaryEntityAndRefElement, pv);
}
@@ -1990,24 +2051,24 @@ static void addPhysical(GModel *const model, GEntity *entity,
if(parent == 0) return;
if(!CTX::instance()->mesh.partitionCreatePhysicals ||
- CTX::instance()->mesh.partitionOldStyleMsh2){
+ CTX::instance()->mesh.partitionOldStyleMsh2) {
// reuse physicals from parent entity
entity->physicals = parent->physicals;
return;
}
unsigned int numPartitions = 0;
- if(entity->dim() == 3){
- numPartitions = static_cast<partitionRegion*>(entity)->numPartitions();
+ if(entity->dim() == 3) {
+ numPartitions = static_cast<partitionRegion *>(entity)->numPartitions();
}
- else if(entity->dim() == 2){
- numPartitions = static_cast<partitionFace*>(entity)->numPartitions();
+ else if(entity->dim() == 2) {
+ numPartitions = static_cast<partitionFace *>(entity)->numPartitions();
}
- else if(entity->dim() == 1){
- numPartitions = static_cast<partitionEdge*>(entity)->numPartitions();
+ else if(entity->dim() == 1) {
+ numPartitions = static_cast<partitionEdge *>(entity)->numPartitions();
}
- else if(entity->dim() == 0){
- numPartitions = static_cast<partitionVertex*>(entity)->numPartitions();
+ else if(entity->dim() == 0) {
+ numPartitions = static_cast<partitionVertex *>(entity)->numPartitions();
}
#if __cplusplus < 201103L
@@ -2015,23 +2076,23 @@ static void addPhysical(GModel *const model, GEntity *entity,
#endif
std::vector<int> physical = parent->getPhysicalEntities();
int dim = entity->dim();
- for(size_t phys = 0; phys < physical.size(); ++phys){
+ for(size_t phys = 0; phys < physical.size(); ++phys) {
std::string name = "_part{";
- for(unsigned int i = 0; i < numPartitions; i++){
+ for(unsigned int i = 0; i < numPartitions; i++) {
if(i > 0) name += ",";
unsigned int partition = 0;
- if(entity->dim() == 3){
- partition = static_cast<partitionRegion*>(entity)->getPartition(i);
+ if(entity->dim() == 3) {
+ partition = static_cast<partitionRegion *>(entity)->getPartition(i);
}
- else if(entity->dim() == 2){
- partition = static_cast<partitionFace*>(entity)->getPartition(i);
+ else if(entity->dim() == 2) {
+ partition = static_cast<partitionFace *>(entity)->getPartition(i);
}
- else if(entity->dim() == 1){
- partition = static_cast<partitionEdge*>(entity)->getPartition(i);
+ else if(entity->dim() == 1) {
+ partition = static_cast<partitionEdge *>(entity)->getPartition(i);
}
- else if(entity->dim() == 0){
- partition = static_cast<partitionVertex*>(entity)->getPartition(i);
+ else if(entity->dim() == 0) {
+ partition = static_cast<partitionVertex *>(entity)->getPartition(i);
}
#if __cplusplus >= 201103L
name += std::to_string(partition);
@@ -2042,7 +2103,8 @@ static void addPhysical(GModel *const model, GEntity *entity,
}
name += "}_physical{";
#if __cplusplus >= 201103L
- name += std::to_string(physical[phys]) + "}_dim{" + std::to_string(dim) + "}";
+ name +=
+ std::to_string(physical[phys]) + "}_dim{" + std::to_string(dim) + "}";
#else
sprintf(intToChar, "%d}_dim{%d}", physical[phys], dim);
name += intToChar;
@@ -2050,35 +2112,35 @@ static void addPhysical(GModel *const model, GEntity *entity,
int number = 0;
hashmap<std::string, int>::iterator it = nameToNumber.find(name);
- if(it == nameToNumber.end()){
+ if(it == nameToNumber.end()) {
number = ++numPhysical;
- iterators[entity->dim()] = model->setPhysicalName
- (iterators[entity->dim()], name, entity->dim(), number);
+ iterators[entity->dim()] = model->setPhysicalName(
+ iterators[entity->dim()], name, entity->dim(), number);
nameToNumber.insert(std::pair<std::string, int>(name, number));
}
- else{
+ else {
number = it->second;
}
entity->addPhysicalEntity(number);
}
- if(physical.size() == 0){
+ if(physical.size() == 0) {
std::string name = "_part{";
- for(unsigned int i = 0; i < numPartitions; i++){
+ for(unsigned int i = 0; i < numPartitions; i++) {
if(i > 0) name += ",";
unsigned int partition = 0;
- if(entity->dim() == 3){
- partition = static_cast<partitionRegion*>(entity)->getPartition(i);
+ if(entity->dim() == 3) {
+ partition = static_cast<partitionRegion *>(entity)->getPartition(i);
}
- else if(entity->dim() == 2){
- partition = static_cast<partitionFace*>(entity)->getPartition(i);
+ else if(entity->dim() == 2) {
+ partition = static_cast<partitionFace *>(entity)->getPartition(i);
}
- else if(entity->dim() == 1){
- partition = static_cast<partitionEdge*>(entity)->getPartition(i);
+ else if(entity->dim() == 1) {
+ partition = static_cast<partitionEdge *>(entity)->getPartition(i);
}
- else if(entity->dim() == 0){
- partition = static_cast<partitionVertex*>(entity)->getPartition(i);
+ else if(entity->dim() == 0) {
+ partition = static_cast<partitionVertex *>(entity)->getPartition(i);
}
#if __cplusplus >= 201103L
name += std::to_string(partition);
@@ -2097,13 +2159,13 @@ static void addPhysical(GModel *const model, GEntity *entity,
int number = 0;
hashmap<std::string, int>::iterator it = nameToNumber.find(name);
- if(it == nameToNumber.end()){
+ if(it == nameToNumber.end()) {
number = ++numPhysical;
- iterators[entity->dim()] = model->setPhysicalName
- (iterators[entity->dim()], name, entity->dim(), number);
+ iterators[entity->dim()] = model->setPhysicalName(
+ iterators[entity->dim()], name, entity->dim(), number);
nameToNumber.insert(std::pair<std::string, int>(name, number));
}
- else{
+ else {
number = it->second;
}
entity->addPhysicalEntity(number);
@@ -2118,29 +2180,33 @@ static void AssignPhysicalName(GModel *model)
model->getInnerPhysicalNamesIterators(iterators);
int numPhysical = model->getMaxPhysicalNumber(-1);
// Loop over regions
- for(GModel::const_riter it = model->firstRegion(); it != model->lastRegion(); ++it){
- if((*it)->geomType() == GEntity::PartitionVolume){
+ for(GModel::const_riter it = model->firstRegion(); it != model->lastRegion();
+ ++it) {
+ if((*it)->geomType() == GEntity::PartitionVolume) {
addPhysical(model, *it, nameToNumber, iterators, numPhysical);
}
}
// Loop over faces
- for(GModel::const_fiter it = model->firstFace(); it != model->lastFace(); ++it){
- if((*it)->geomType() == GEntity::PartitionSurface){
+ for(GModel::const_fiter it = model->firstFace(); it != model->lastFace();
+ ++it) {
+ if((*it)->geomType() == GEntity::PartitionSurface) {
addPhysical(model, *it, nameToNumber, iterators, numPhysical);
}
}
// Loop over edges
- for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge(); ++it){
- if((*it)->geomType() == GEntity::PartitionCurve){
+ for(GModel::const_eiter it = model->firstEdge(); it != model->lastEdge();
+ ++it) {
+ if((*it)->geomType() == GEntity::PartitionCurve) {
addPhysical(model, *it, nameToNumber, iterators, numPhysical);
}
}
// Loop over vertices
- for(GModel::const_viter it = model->firstVertex(); it != model->lastVertex(); ++it){
- if((*it)->geomType() == GEntity::PartitionVertex){
+ for(GModel::const_viter it = model->firstVertex(); it != model->lastVertex();
+ ++it) {
+ if((*it)->geomType() == GEntity::PartitionVertex) {
addPhysical(model, *it, nameToNumber, iterators, numPhysical);
}
}
@@ -2160,17 +2226,18 @@ int PartitionMesh(GModel *const model)
if(PartitionGraph(graph)) return 1;
// Assign partitions to elements
- hashmap<MElement*, unsigned int> elmToPartition;
- for(unsigned int i = 0; i < graph.ne(); i++){
- if(graph.element(i)){
- if(graph.nparts() > 1){
- elmToPartition.insert(std::pair<MElement*, unsigned int>(graph.element(i),
- graph.partition(i)+1));
+ hashmap<MElement *, unsigned int> elmToPartition;
+ for(unsigned int i = 0; i < graph.ne(); i++) {
+ if(graph.element(i)) {
+ if(graph.nparts() > 1) {
+ elmToPartition.insert(std::pair<MElement *, unsigned int>(
+ graph.element(i), graph.partition(i) + 1));
// Should be removed
- graph.element(i)->setPartition(graph.partition(i)+1);
+ graph.element(i)->setPartition(graph.partition(i) + 1);
}
- else{
- elmToPartition.insert(std::pair<MElement*, unsigned int>(graph.element(i), 1));
+ else {
+ elmToPartition.insert(
+ std::pair<MElement *, unsigned int>(graph.element(i), 1));
// Should be removed
graph.element(i)->setPartition(1);
}
@@ -2184,9 +2251,10 @@ int PartitionMesh(GModel *const model)
double t2 = Cpu();
Msg::StatusBar(true, "Done partitioning mesh (%g s)", t2 - t1);
- if(CTX::instance()->mesh.partitionCreateTopology){
+ if(CTX::instance()->mesh.partitionCreateTopology) {
Msg::StatusBar(true, "Creating partition topology...");
- std::vector< std::set<MElement*> > boundaryElements = graph.getBoundaryElements();
+ std::vector<std::set<MElement *> > boundaryElements =
+ graph.getBoundaryElements();
CreatePartitionTopology(model, boundaryElements, graph);
boundaryElements.clear();
AssignPhysicalName(model);
@@ -2197,7 +2265,7 @@ int PartitionMesh(GModel *const model)
AssignMeshVertices(model);
- if(CTX::instance()->mesh.partitionCreateGhostCells){
+ if(CTX::instance()->mesh.partitionCreateGhostCells) {
graph.clearDualGraph();
graph.createDualGraph(true);
graph.assignGhostCells();
@@ -2207,16 +2275,16 @@ int PartitionMesh(GModel *const model)
}
template <class ITERATOR, class PART_ENTITY>
-static void assignToParent(std::set<MVertex*> &verts, PART_ENTITY *entity,
+static void assignToParent(std::set<MVertex *> &verts, PART_ENTITY *entity,
ITERATOR it_beg, ITERATOR it_end)
{
- for(ITERATOR it = it_beg; it != it_end; ++it){
+ for(ITERATOR it = it_beg; it != it_end; ++it) {
if(entity->getParentEntity()->dim() == 3)
entity->getParentEntity()->addElement((*it)->getType(), *it);
(*it)->setPartition(0);
- for(std::size_t i = 0; i < (*it)->getNumVertices(); i++){
- if(verts.find((*it)->getVertex(i)) == verts.end()){
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ if(verts.find((*it)->getVertex(i)) == verts.end()) {
(*it)->getVertex(i)->setEntity(entity->getParentEntity());
entity->getParentEntity()->addMeshVertex((*it)->getVertex(i));
verts.insert((*it)->getVertex(i));
@@ -2230,23 +2298,24 @@ static void assignToParent(std::set<MVertex*> &verts, PART_ENTITY *entity,
int UnpartitionMesh(GModel *const model)
{
// make a copy so we can iterate safely (we will remove some entities)
- std::set<GRegion*, GEntityLessThan> regions = model->getRegions();
- std::set<GFace*, GEntityLessThan> faces = model->getFaces();
- std::set<GEdge*, GEntityLessThan> edges = model->getEdges();
- std::set<GVertex*, GEntityLessThan> vertices = model->getVertices();
+ std::set<GRegion *, GEntityLessThan> regions = model->getRegions();
+ std::set<GFace *, GEntityLessThan> faces = model->getFaces();
+ std::set<GEdge *, GEntityLessThan> edges = model->getEdges();
+ std::set<GVertex *, GEntityLessThan> vertices = model->getVertices();
- std::set<MVertex*> verts;
+ std::set<MVertex *> verts;
// Loop over vertices
- for(GModel::viter it = vertices.begin(); it != vertices.end(); ++it){
+ for(GModel::viter it = vertices.begin(); it != vertices.end(); ++it) {
GVertex *vertex = *it;
- if(vertex->geomType() == GEntity::PartitionVertex){
- partitionVertex* pvertex = static_cast<partitionVertex*>(vertex);
- if(pvertex->getParentEntity()){
- assignToParent(verts, pvertex, pvertex->points.begin(), pvertex->points.end());
+ if(vertex->geomType() == GEntity::PartitionVertex) {
+ partitionVertex *pvertex = static_cast<partitionVertex *>(vertex);
+ if(pvertex->getParentEntity()) {
+ assignToParent(verts, pvertex, pvertex->points.begin(),
+ pvertex->points.end());
}
- else{
+ else {
for(unsigned int j = 0; j < pvertex->points.size(); j++)
delete pvertex->points[j];
}
@@ -2259,14 +2328,14 @@ int UnpartitionMesh(GModel *const model)
}
// Loop over edges
- for(GModel::eiter it = edges.begin(); it != edges.end(); ++it){
+ for(GModel::eiter it = edges.begin(); it != edges.end(); ++it) {
GEdge *edge = *it;
- if(edge->geomType() == GEntity::PartitionCurve){
- partitionEdge* pedge = static_cast<partitionEdge*>(edge);
- if(pedge->getParentEntity()){
+ if(edge->geomType() == GEntity::PartitionCurve) {
+ partitionEdge *pedge = static_cast<partitionEdge *>(edge);
+ if(pedge->getParentEntity()) {
assignToParent(verts, pedge, pedge->lines.begin(), pedge->lines.end());
}
- else{
+ else {
for(unsigned int j = 0; j < pedge->lines.size(); j++)
delete pedge->lines[j];
}
@@ -2278,24 +2347,25 @@ int UnpartitionMesh(GModel *const model)
model->remove(pedge);
delete pedge;
}
- else if(edge->geomType() == GEntity::GhostCurve){
+ else if(edge->geomType() == GEntity::GhostCurve) {
model->remove(edge);
delete edge;
}
}
// Loop over faces
- for(GModel::fiter it = faces.begin(); it != faces.end(); ++it)
- {
+ for(GModel::fiter it = faces.begin(); it != faces.end(); ++it) {
GFace *face = *it;
- if(face->geomType() == GEntity::PartitionSurface){
- partitionFace* pface = static_cast<partitionFace*>(face);
- if(pface->getParentEntity()){
- assignToParent(verts, pface, pface->triangles.begin(), pface->triangles.end());
- assignToParent(verts, pface, pface->quadrangles.begin(), pface->quadrangles.end());
+ if(face->geomType() == GEntity::PartitionSurface) {
+ partitionFace *pface = static_cast<partitionFace *>(face);
+ if(pface->getParentEntity()) {
+ assignToParent(verts, pface, pface->triangles.begin(),
+ pface->triangles.end());
+ assignToParent(verts, pface, pface->quadrangles.begin(),
+ pface->quadrangles.end());
}
- else{
+ else {
for(unsigned int j = 0; j < pface->triangles.size(); j++)
delete pface->triangles[j];
for(unsigned int j = 0; j < pface->quadrangles.size(); j++)
@@ -2304,32 +2374,37 @@ int UnpartitionMesh(GModel *const model)
pface->triangles.clear();
pface->quadrangles.clear();
pface->mesh_vertices.clear();
- pface->set(std::vector<GEdge*>());
+ pface->set(std::vector<GEdge *>());
pface->setOrientations(std::vector<int>());
model->remove(pface);
delete pface;
}
- else if(face->geomType() == GEntity::GhostSurface){
+ else if(face->geomType() == GEntity::GhostSurface) {
model->remove(face);
delete face;
}
}
// Loop over regions
- for(GModel::riter it = regions.begin(); it != regions.end(); ++it){
+ for(GModel::riter it = regions.begin(); it != regions.end(); ++it) {
GRegion *region = *it;
- if(region->geomType() == GEntity::PartitionVolume){
- partitionRegion* pregion = static_cast<partitionRegion*>(region);
- if(pregion->getParentEntity()){
- assignToParent(verts, pregion, pregion->tetrahedra.begin(), pregion->tetrahedra.end());
- assignToParent(verts, pregion, pregion->hexahedra.begin(), pregion->hexahedra.end());
- assignToParent(verts, pregion, pregion->prisms.begin(), pregion->prisms.end());
- assignToParent(verts, pregion, pregion->pyramids.begin(), pregion->pyramids.end());
- assignToParent(verts, pregion, pregion->trihedra.begin(), pregion->trihedra.end());
- }
- else{
+ if(region->geomType() == GEntity::PartitionVolume) {
+ partitionRegion *pregion = static_cast<partitionRegion *>(region);
+ if(pregion->getParentEntity()) {
+ assignToParent(verts, pregion, pregion->tetrahedra.begin(),
+ pregion->tetrahedra.end());
+ assignToParent(verts, pregion, pregion->hexahedra.begin(),
+ pregion->hexahedra.end());
+ assignToParent(verts, pregion, pregion->prisms.begin(),
+ pregion->prisms.end());
+ assignToParent(verts, pregion, pregion->pyramids.begin(),
+ pregion->pyramids.end());
+ assignToParent(verts, pregion, pregion->trihedra.begin(),
+ pregion->trihedra.end());
+ }
+ else {
for(unsigned int j = 0; j < pregion->tetrahedra.size(); j++)
delete pregion->tetrahedra[j];
@@ -2351,13 +2426,13 @@ int UnpartitionMesh(GModel *const model)
pregion->pyramids.clear();
pregion->trihedra.clear();
pregion->mesh_vertices.clear();
- pregion->set(std::vector<GFace*>());
+ pregion->set(std::vector<GFace *>());
pregion->setOrientations(std::vector<int>());
model->remove(pregion);
delete pregion;
}
- else if(region->geomType() == GEntity::GhostVolume){
+ else if(region->geomType() == GEntity::GhostVolume) {
model->remove(region);
delete region;
}
@@ -2365,10 +2440,12 @@ int UnpartitionMesh(GModel *const model)
model->setNumPartitions(0);
- std::map<std::pair<int, int>, std::string> physicalNames = model->getPhysicalNames();
- for(GModel::piter it = physicalNames.begin(); it != physicalNames.end(); ++it){
+ std::map<std::pair<int, int>, std::string> physicalNames =
+ model->getPhysicalNames();
+ for(GModel::piter it = physicalNames.begin(); it != physicalNames.end();
+ ++it) {
std::size_t found = it->second.find("_");
- if(found != std::string::npos){
+ if(found != std::string::npos) {
model->removePhysicalGroup(it->first.first, it->first.second);
}
}
@@ -2379,33 +2456,34 @@ int UnpartitionMesh(GModel *const model)
// Create the partition according to the element split given by elmToPartition
// Returns: 0 = success, 1 = no elements found.
int PartitionUsingThisSplit(GModel *const model, unsigned int npart,
- hashmap<MElement*, unsigned int> &elmToPartition)
+ hashmap<MElement *, unsigned int> &elmToPartition)
{
Graph graph(model);
if(MakeGraph(model, graph, -1)) return 1;
graph.createDualGraph(false);
graph.nparts(npart);
- if(elmToPartition.size() != graph.ne()){
+ if(elmToPartition.size() != graph.ne()) {
Msg::Error("All elements are not partitioned.");
return 1;
}
unsigned int *part = new unsigned int[graph.ne()];
- for(unsigned int i = 0; i < graph.ne(); i++){
- if(graph.element(i)){
- part[i] = elmToPartition[graph.element(i)]-1;
+ for(unsigned int i = 0; i < graph.ne(); i++) {
+ if(graph.element(i)) {
+ part[i] = elmToPartition[graph.element(i)] - 1;
}
}
// Check and correct the topology
- for(int i = 1; i < 4; i++){
- for(unsigned int j = 0; j < graph.ne(); j++){
+ for(int i = 1; i < 4; i++) {
+ for(unsigned int j = 0; j < graph.ne(); j++) {
if(graph.element(j)->getDim() == (int)graph.dim()) continue;
- for(unsigned int k = graph.xadj(j); k < graph.xadj(j+1); k++){
- if(graph.element(j)->getDim() == graph.element(graph.adjncy(k))->getDim()-i){
- if(part[j] != part[graph.adjncy(k)]){
+ for(unsigned int k = graph.xadj(j); k < graph.xadj(j + 1); k++) {
+ if(graph.element(j)->getDim() ==
+ graph.element(graph.adjncy(k))->getDim() - i) {
+ if(part[j] != part[graph.adjncy(k)]) {
part[j] = part[graph.adjncy(k)];
break;
}
@@ -2420,9 +2498,10 @@ int PartitionUsingThisSplit(GModel *const model, unsigned int npart,
CreateNewEntities(model, elmToPartition);
elmToPartition.clear();
- if(CTX::instance()->mesh.partitionCreateTopology){
+ if(CTX::instance()->mesh.partitionCreateTopology) {
Msg::StatusBar(true, "Creating partition topology...");
- std::vector< std::set<MElement*> > boundaryElements = graph.getBoundaryElements();
+ std::vector<std::set<MElement *> > boundaryElements =
+ graph.getBoundaryElements();
CreatePartitionTopology(model, boundaryElements, graph);
boundaryElements.clear();
AssignPhysicalName(model);
@@ -2431,7 +2510,7 @@ int PartitionUsingThisSplit(GModel *const model, unsigned int npart,
AssignMeshVertices(model);
- if(CTX::instance()->mesh.partitionCreateGhostCells){
+ if(CTX::instance()->mesh.partitionCreateGhostCells) {
graph.clearDualGraph();
graph.createDualGraph(false);
graph.assignGhostCells();
@@ -2447,14 +2526,15 @@ int ConvertOldPartitioningToNewOne(GModel *const model)
{
Msg::StatusBar(true, "Converting old partitioning...");
- hashmap<MElement*, unsigned int> elmToPartition;
+ hashmap<MElement *, unsigned int> elmToPartition;
std::set<unsigned int> partitions;
- std::vector<GEntity*> entities;
+ std::vector<GEntity *> entities;
model->getEntities(entities);
- for(unsigned int i = 0; i < entities.size(); i++){
- for(unsigned int j = 0; j < entities[i]->getNumMeshElements(); j++){
+ for(unsigned int i = 0; i < entities.size(); i++) {
+ for(unsigned int j = 0; j < entities[i]->getNumMeshElements(); j++) {
MElement *e = entities[i]->getMeshElement(i);
- elmToPartition.insert(std::pair<MElement*, unsigned int>(e, e->getPartition()));
+ elmToPartition.insert(
+ std::pair<MElement *, unsigned int>(e, e->getPartition()));
partitions.insert(e->getPartition());
}
}
@@ -2470,18 +2550,12 @@ int PartitionMesh(GModel *const model)
return 0;
}
-int UnpartitionMesh(GModel *const model)
-{
- return 0;
-}
+int UnpartitionMesh(GModel *const model) { return 0; }
-int ConvertOldPartitioningToNewOne(GModel *const model)
-{
- return 0;
-}
+int ConvertOldPartitioningToNewOne(GModel *const model) { return 0; }
int PartitionUsingThisSplit(GModel *const model, unsigned int npart,
- hashmap<MElement*, unsigned int> &elmToPartition)
+ hashmap<MElement *, unsigned int> &elmToPartition)
{
return 0;
}
diff --git a/Mesh/meshRefine.cpp b/Mesh/meshRefine.cpp
index 6d736154163b717ade1e3f2b5076b3dcff89d7d2..3afeb772abdcd15dde68c2ebf3c98a71fc0206bc 100644
--- a/Mesh/meshRefine.cpp
+++ b/Mesh/meshRefine.cpp
@@ -75,8 +75,8 @@ static bool setBLData(MElement *el)
if(!isBL) return false;
}
// Mark high-order nodes as BL nodes (only works in 2D)
- for(std::size_t i = el->getNumPrimaryVertices();
- i < el->getNumVertices(); i++)
+ for(std::size_t i = el->getNumPrimaryVertices(); i < el->getNumVertices();
+ i++)
setBLData(el->getVertex(i));
return true;
}
@@ -265,7 +265,9 @@ static void Subdivide(GRegion *gr, bool splitIntoHexas,
for(int j = 0; j < t->getNumFaces(); j++) {
MFace face = t->getFace(j);
faceContainer::iterator fIter = faceVertices.find(face);
- if(fIter != faceVertices.end()) { newv.push_back(fIter->second[0]); }
+ if(fIter != faceVertices.end()) {
+ newv.push_back(fIter->second[0]);
+ }
else {
SPoint3 pc = face.barycenter();
newv.push_back(new MVertex(pc.x(), pc.y(), pc.z(), gr));
@@ -307,7 +309,9 @@ static void Subdivide(GRegion *gr, bool splitIntoHexas,
for(int j = 0; j < 2; j++) {
MFace face = p->getFace(j);
faceContainer::iterator fIter = faceVertices.find(face);
- if(fIter != faceVertices.end()) { newv.push_back(fIter->second[0]); }
+ if(fIter != faceVertices.end()) {
+ newv.push_back(fIter->second[0]);
+ }
else {
SPoint3 pc = face.barycenter();
newv.push_back(new MVertex(pc.x(), pc.y(), pc.z(), gr));
@@ -680,7 +684,9 @@ static int schneiders_connect(int i, int j)
69, 67, 73, 71, 73, 96, 97, 3, 100, 101, 29, 103, 100,
4, 5, 100, 103, 86, 86, 30, 35, 0, 94};
- if(i == 0) { return n0[j]; }
+ if(i == 0) {
+ return n0[j];
+ }
else if(i == 1) {
return n1[j];
}
@@ -708,7 +714,7 @@ void subdivide_pyramid(MElement *element, GRegion *gr,
faceContainer &faceVertices,
std::vector<MHexahedron *> &dwarfs88)
{
- std::vector<MVertex *> v(105, (MVertex*)NULL);
+ std::vector<MVertex *> v(105, (MVertex *)NULL);
v[29] = element->getVertex(0);
v[27] = element->getVertex(1);
diff --git a/Mesh/pointInsertion.cpp b/Mesh/pointInsertion.cpp
index b4085b8b1979e4a9ce5826651f98bd785c6a3810..42415db81c21a312d973a99b9b1c741727795140 100644
--- a/Mesh/pointInsertion.cpp
+++ b/Mesh/pointInsertion.cpp
@@ -24,9 +24,7 @@
//#include "google/profiler.h"
-bool old_algo_hexa(){
- return true;
-}
+bool old_algo_hexa() { return true; }
template <typename T>
void print_nodal_info(const std::string &filename,
@@ -35,23 +33,26 @@ void print_nodal_info(const std::string &filename,
std::ofstream out(filename.c_str());
out << "View \"\"{" << std::endl;
- for (typename std::map<MVertex*, T>::const_iterator it = map.begin();it!=map.end();it++){
+ for(typename std::map<MVertex *, T>::const_iterator it = map.begin();
+ it != map.end(); it++) {
MVertex *v = it->first;
- out << "SP( " << v->x() << "," << v->y() << "," << v->z() << "){" << it->second << "};" << std::endl;
+ out << "SP( " << v->x() << "," << v->y() << "," << v->z() << "){"
+ << it->second << "};" << std::endl;
}
out << "};" << std::endl;
out.close();
}
-bool shoot(const SPoint2 &start, const SPoint2 &dir,
- const double &h, SPoint2 &res)
+bool shoot(const SPoint2 &start, const SPoint2 &dir, const double &h,
+ SPoint2 &res)
{
const int RK = 1;
- if (RK==1){
- res = start + (dir*h);
- // std::cout << "(" << start[0] << "," <<start[1] << ") -> (" << res[0] << ","
+ if(RK == 1) {
+ res = start + (dir * h);
+ // std::cout << "(" << start[0] << "," <<start[1] << ") -> (" << res[0]
+ // << ","
// <<res[1] << ") " << std::endl;
return true;
}
@@ -59,36 +60,37 @@ bool shoot(const SPoint2 &start, const SPoint2 &dir,
return false;
}
-bool computeFourNeighbors (frameFieldBackgroundMesh2D *bgm,
- MVertex *v_center, // the vertex for which we want to
- // generate 4 neighbors (real
- // vertex (xyz), not parametric!)
- SPoint2 &midpoint,
- bool goNonLinear, // do we compute the position in
- // the real surface which is
- // nonlinear
- SPoint2 newP[4][NUMDIR], // look into other directions
- SMetric3 &metricField) // the mesh metric
+bool computeFourNeighbors(frameFieldBackgroundMesh2D *bgm,
+ MVertex *v_center, // the vertex for which we want to
+ // generate 4 neighbors (real
+ // vertex (xyz), not parametric!)
+ SPoint2 &midpoint,
+ bool goNonLinear, // do we compute the position in
+ // the real surface which is
+ // nonlinear
+ SPoint2 newP[4][NUMDIR], // look into other directions
+ SMetric3 &metricField) // the mesh metric
{
- // we assume that v is on surface gf, and backgroundMesh2D has been created based on gf
+ // we assume that v is on surface gf, and backgroundMesh2D has been created
+ // based on gf
// get BGM and GFace
- GFace *gf = dynamic_cast<GFace*>(bgm->getBackgroundGEntity());
+ GFace *gf = dynamic_cast<GFace *>(bgm->getBackgroundGEntity());
// get the parametric coordinates of the point on the surface
reparamMeshVertexOnFace(v_center, gf, midpoint);
// get RK info on midpoint (infos in two directions...)
RK_form infos;
- bgm->compute_RK_infos(midpoint[0],midpoint[1],v_center->x(), v_center->y(),
+ bgm->compute_RK_infos(midpoint[0], midpoint[1], v_center->x(), v_center->y(),
v_center->z(), infos);
metricField = infos.metricField;
// shoot in four directions
SPoint2 param_vec;
double h;
- for (int i=0;i<4;i++){// in four directions
- switch (i){
+ for(int i = 0; i < 4; i++) { // in four directions
+ switch(i) {
case 0:
param_vec = infos.paramt1;
h = infos.paramh.first;
@@ -106,68 +108,72 @@ bool computeFourNeighbors (frameFieldBackgroundMesh2D *bgm,
h = infos.paramh.second;
break;
}
- shoot(midpoint,param_vec,h,newP[i][0]);
+ shoot(midpoint, param_vec, h, newP[i][0]);
// std::cout << "(" << midpoint[0] << "," <<midpoint[1] << ") -> (" <<
// newP[i][0][0] << "," << newP[i][0][1] << ") " << std::endl;
}
// the following comes from surfaceFiller.cpp...
const double EPS = 1.e-7;
- for (int j=0;j<2;j++){
- for (int i=0;i<4;i++){
- newP[i][0][j] += (EPS* (double)rand() / RAND_MAX);
+ for(int j = 0; j < 2; j++) {
+ for(int i = 0; i < 4; i++) {
+ newP[i][0][j] += (EPS * (double)rand() / RAND_MAX);
}
}
// We could stop here. Yet, if the metric varies a lot, we can solve a
// nonlinear problem in order to find a better approximation in the real
// surface
- if (1 && goNonLinear){
+ if(1 && goNonLinear) {
double L = infos.localsize;
double newPoint[4][2];
- for (int j=0;j<2;j++){
- for (int i=0;i<4;i++){
+ for(int j = 0; j < 2; j++) {
+ for(int i = 0; i < 4; i++) {
newPoint[i][j] = newP[i][0][j];
}
}
double ERR[4];
- for (int i=0;i<4;i++){ //
+ for(int i = 0; i < 4; i++) { //
// if (newPoint[i][0] < rangeU.low())newPoint[i][0] = rangeU.low();
// if (newPoint[i][0] > rangeU.high())newPoint[i][0] = rangeU.high();
// if (newPoint[i][1] < rangeV.low())newPoint[i][1] = rangeV.low();
// if (newPoint[i][1] > rangeV.high())newPoint[i][1] = rangeV.high();
GPoint pp = gf->point(newP[i][0]);
- double D = sqrt ((pp.x() - v_center->x())*(pp.x() - v_center->x()) +
- (pp.y() - v_center->y())*(pp.y() - v_center->y()) +
- (pp.z() - v_center->z())*(pp.z() - v_center->z()) );
- ERR[i] = 100*fabs(D-L)/(D+L);
- // printf("L = %12.5E D = %12.5E ERR = %12.5E\n",L,D,100*fabs(D-L)/(D+L));
+ double D = sqrt((pp.x() - v_center->x()) * (pp.x() - v_center->x()) +
+ (pp.y() - v_center->y()) * (pp.y() - v_center->y()) +
+ (pp.z() - v_center->z()) * (pp.z() - v_center->z()));
+ ERR[i] = 100 * fabs(D - L) / (D + L);
+ // printf("L = %12.5E D = %12.5E ERR =
+ // %12.5E\n",L,D,100*fabs(D-L)/(D+L));
}
- surfaceFunctorGFace ss (gf);
- SVector3 dirs[4] = {infos.t1*(-1.0),infos.t2*(-1.0),infos.t1*(1.0),infos.t2*(1.0)};
- for (int i=0;i<4;i++){
- if (ERR[i] > 12){
- double uvt[3] = {newPoint[i][0],newPoint[i][1],0.0};
+ surfaceFunctorGFace ss(gf);
+ SVector3 dirs[4] = {infos.t1 * (-1.0), infos.t2 * (-1.0), infos.t1 * (1.0),
+ infos.t2 * (1.0)};
+ for(int i = 0; i < 4; i++) {
+ if(ERR[i] > 12) {
+ double uvt[3] = {newPoint[i][0], newPoint[i][1], 0.0};
// printf("Intersecting with circle N = %g %g %g dir = %g %g %g R
// = %g p = %g %g
// %g\n",n.x(),n.y(),n.z(),dirs[i].x(),dirs[i].y(),dirs[i].z(),L,
// v_center->x(),v_center->y(),v_center->z());
- curveFunctorCircle cf (dirs[i],infos.normal,
- SVector3(v_center->x(),v_center->y(),v_center->z()), L);
- if (intersectCurveSurface (cf,ss,uvt,infos.paramh.first*1.e-3)){
- GPoint pp = gf->point(SPoint2(uvt[0],uvt[1]));
- double D = sqrt ((pp.x() - v_center->x())*(pp.x() - v_center->x()) +
- (pp.y() - v_center->y())*(pp.y() - v_center->y()) +
- (pp.z() - v_center->z())*(pp.z() - v_center->z()) );
- double DP = sqrt ((newPoint[i][0]-uvt[0])*(newPoint[i][0]-uvt[0]) +
- (newPoint[i][1]-uvt[1])*(newPoint[i][1]-uvt[1]));
- double newErr = 100*fabs(D-L)/(D+L);
+ curveFunctorCircle cf(
+ dirs[i], infos.normal,
+ SVector3(v_center->x(), v_center->y(), v_center->z()), L);
+ if(intersectCurveSurface(cf, ss, uvt, infos.paramh.first * 1.e-3)) {
+ GPoint pp = gf->point(SPoint2(uvt[0], uvt[1]));
+ double D = sqrt((pp.x() - v_center->x()) * (pp.x() - v_center->x()) +
+ (pp.y() - v_center->y()) * (pp.y() - v_center->y()) +
+ (pp.z() - v_center->z()) * (pp.z() - v_center->z()));
+ double DP =
+ sqrt((newPoint[i][0] - uvt[0]) * (newPoint[i][0] - uvt[0]) +
+ (newPoint[i][1] - uvt[1]) * (newPoint[i][1] - uvt[1]));
+ double newErr = 100 * fabs(D - L) / (D + L);
// if (v_center->onWhat() != gf && gf->tag() == 3){
// crossField2d::normalizeAngle (uvt[2]);
// printf("INTERSECT angle = %g DP %g\n",uvt[2],DP);
// }
- if (newErr < 1 && DP < .1){
+ if(newErr < 1 && DP < .1) {
// printf("%12.5E vs %12.5E : %12.5E %12.5E vs %12.5E %12.5E
// \n",ERR[i],newErr,newPoint[i][0],newPoint[i][1],uvt[0],uvt[1]);
newPoint[i][0] = uvt[0];
@@ -175,16 +181,16 @@ bool computeFourNeighbors (frameFieldBackgroundMesh2D *bgm,
}
// printf("OK\n");
}
- else{
- Msg::Debug("Cannot put a new point on Surface %d",gf->tag());
+ else {
+ Msg::Debug("Cannot put a new point on Surface %d", gf->tag());
// printf("NOT OK\n");
}
}
}
// return the four new vertices
- for (int i=0;i<4;i++){
- newP[i][0] = SPoint2(newPoint[i][0],newPoint[i][1]);
+ for(int i = 0; i < 4; i++) {
+ newP[i][0] = SPoint2(newPoint[i][0], newPoint[i][1]);
}
}
@@ -192,72 +198,72 @@ bool computeFourNeighbors (frameFieldBackgroundMesh2D *bgm,
}
void computeTwoNeighbors(frameFieldBackgroundMesh3D *bgm, MVertex *parent,
- std::vector<MVertex*> &spawns, SVector3 dir, double h)
+ std::vector<MVertex *> &spawns, SVector3 dir, double h)
{
// using approximate size, RK1...
double x = parent->x();
double y = parent->y();
double z = parent->z();
- double newx,newy,newz;
- GRegion *gr = dynamic_cast<GRegion*>(bgm->getBackgroundGEntity());
+ double newx, newy, newz;
+ GRegion *gr = dynamic_cast<GRegion *>(bgm->getBackgroundGEntity());
newx = x + h * dir(0);
newy = y + h * dir(1);
newz = z + h * dir(2);
- spawns[0] = new MVertex(newx,newy,newz,gr,0);
+ spawns[0] = new MVertex(newx, newy, newz, gr, 0);
newx = x - h * dir(0);
newy = y - h * dir(1);
newz = z - h * dir(2);
- spawns[1] = new MVertex(newx,newy,newz,gr,0);
+ spawns[1] = new MVertex(newx, newy, newz, gr, 0);
}
void computeSixNeighbors(frameFieldBackgroundMesh3D *bgm, MVertex *parent,
- std::vector<MVertex*> &spawns, STensor3 dir, double h)
+ std::vector<MVertex *> &spawns, STensor3 dir, double h)
{
// using approximate size, RK1...
double x = parent->x();
double y = parent->y();
double z = parent->z();
- double newx,newy,newz;
- GRegion *gr = dynamic_cast<GRegion*>(bgm->getBackgroundGEntity());
-
- for (int i=0;i<3;i++){
- newx = x + h * dir(0,i);
- newy = y + h * dir(1,i);
- newz = z + h * dir(2,i);
- spawns[i*2] = new MVertex(newx,newy,newz,gr,0);
-
- newx = x - h * dir(0,i);
- newy = y - h * dir(1,i);
- newz = z - h * dir(2,i);
- spawns[i*2+1] = new MVertex(newx,newy,newz,gr,0);
+ double newx, newy, newz;
+ GRegion *gr = dynamic_cast<GRegion *>(bgm->getBackgroundGEntity());
+
+ for(int i = 0; i < 3; i++) {
+ newx = x + h * dir(0, i);
+ newy = y + h * dir(1, i);
+ newz = z + h * dir(2, i);
+ spawns[i * 2] = new MVertex(newx, newy, newz, gr, 0);
+
+ newx = x - h * dir(0, i);
+ newy = y - h * dir(1, i);
+ newz = z - h * dir(2, i);
+ spawns[i * 2 + 1] = new MVertex(newx, newy, newz, gr, 0);
}
}
double Filler2D::time_bgm_and_smoothing = 0.;
double Filler2D::time_insertion = 0.;
-Filler2D::Filler2D(){}
+Filler2D::Filler2D() {}
Filler2D::~Filler2D()
{
std::cout << "FILLER2D timing:" << std::endl;
std::cout << " ------- CUMULATIVE TIME2D bgm & smoothing : "
- << time_bgm_and_smoothing << " s." << std::endl;
+ << time_bgm_and_smoothing << " s." << std::endl;
std::cout << " ------- CUMULATIVE TIME2D inserting points : "
- << time_insertion << " s." << std::endl;
+ << time_insertion << " s." << std::endl;
std::cout << " ------- TOTAL 2D TIME (new) : "
- << time_bgm_and_smoothing+time_insertion << " s." << std::endl;
+ << time_bgm_and_smoothing + time_insertion << " s." << std::endl;
}
-void Filler2D::pointInsertion2D(GFace* gf, std::vector<MVertex*> &packed,
+void Filler2D::pointInsertion2D(GFace *gf, std::vector<MVertex *> &packed,
std::vector<SMetric3> &metrics)
{
// NB/ do not use the mesh in GFace, use the one in backgroundMesh2D!
- // if(debug) std::cout << " ------------------ OLD -------------------" << std::endl;
- // stringstream ssa;
+ // if(debug) std::cout << " ------------------ OLD -------------------" <<
+ // std::endl; stringstream ssa;
//// ssa << "oldbgm_angles_" << gf->tag() << ".pos";
//// backgroundMesh::current()->print(ssa.str(),gf,1);
// ssa << "oldbgm_sizes_" << gf->tag() << ".pos";
@@ -266,9 +272,9 @@ void Filler2D::pointInsertion2D(GFace* gf, std::vector<MVertex*> &packed,
//
//
//
- // if(debug) std::cout << " ------------------ NEW -------------------" << std::endl;
- // backgroundMesh2D *bgm2 = dynamic_cast<backgroundMesh2D*>(BGMManager::get(gf));
- // stringstream ss2;
+ // if(debug) std::cout << " ------------------ NEW -------------------" <<
+ // std::endl; backgroundMesh2D *bgm2 =
+ // dynamic_cast<backgroundMesh2D*>(BGMManager::get(gf)); stringstream ss2;
// ss2 << "basebg_sizefield_" << gf->tag() << ".pos";
// bgm2->exportSizeField(ss2.str());
//
@@ -280,27 +286,27 @@ void Filler2D::pointInsertion2D(GFace* gf, std::vector<MVertex*> &packed,
BGMManager::set_use_cross_field(true);
const bool goNonLinear = true;
- const bool debug=false;
- const bool export_stuff=true;
+ const bool debug = false;
+ const bool export_stuff = true;
- if (debug) std::cout << "ENTERING POINTINSERTION2D" << std::endl;
+ if(debug) std::cout << "ENTERING POINTINSERTION2D" << std::endl;
double a;
// acquire background mesh
if(debug) std::cout << "pointInsertion2D: recover BGM" << std::endl;
- a=Cpu();
+ a = Cpu();
frameFieldBackgroundMesh2D *bgm =
- dynamic_cast<frameFieldBackgroundMesh2D*>(BGMManager::get(gf));
+ dynamic_cast<frameFieldBackgroundMesh2D *>(BGMManager::get(gf));
time_bgm_and_smoothing += (Cpu() - a);
- if (!bgm){
+ if(!bgm) {
Msg::Error("BGM dynamic cast failed in filler2D::pointInsertion2D");
return;
}
// export BGM size field
- if(export_stuff){
+ if(export_stuff) {
std::cout << "pointInsertion2D: export size field " << std::endl;
std::stringstream ss;
ss << "bg2D_sizefield_" << gf->tag() << ".pos";
@@ -317,113 +323,122 @@ void Filler2D::pointInsertion2D(GFace* gf, std::vector<MVertex*> &packed,
bgm->exportSmoothness(sss.str());
}
-
-
// point insertion algorithm:
- a=Cpu();
+ a = Cpu();
// for debug check...
- int priority_counter=0;
- std::map<MVertex*,int> vert_priority;
+ int priority_counter = 0;
+ std::map<MVertex *, int> vert_priority;
// get all the boundary vertices
if(debug) std::cout << "pointInsertion2D : get bnd vertices " << std::endl;
- std::set<MVertex*> bnd_vertices = bgm->get_vertices_of_maximum_dim(1);
+ std::set<MVertex *> bnd_vertices = bgm->get_vertices_of_maximum_dim(1);
// put boundary vertices in a fifo queue
- std::set<smoothness_point_pair, compareSurfacePointWithExclusionRegionPtr_Smoothness> fifo;
- std::vector<surfacePointWithExclusionRegion*> vertices;
+ std::set<smoothness_point_pair,
+ compareSurfacePointWithExclusionRegionPtr_Smoothness>
+ fifo;
+ std::vector<surfacePointWithExclusionRegion *> vertices;
// initiate the rtree
if(debug) std::cout << "pointInsertion2D : initiate RTree " << std::endl;
- RTree<surfacePointWithExclusionRegion*,double,2,double> rtree;
+ RTree<surfacePointWithExclusionRegion *, double, 2, double> rtree;
SMetric3 metricField(1.0);
SPoint2 newp[4][NUMDIR];
- std::set<MVertex*>::iterator it = bnd_vertices.begin() ;
+ std::set<MVertex *>::iterator it = bnd_vertices.begin();
- for (; it != bnd_vertices.end() ; ++it){
+ for(; it != bnd_vertices.end(); ++it) {
SPoint2 midpoint;
- computeFourNeighbors(bgm,*it, midpoint, goNonLinear, newp, metricField);
- surfacePointWithExclusionRegion *sp = new surfacePointWithExclusionRegion
- (*it, newp, midpoint,metricField);
+ computeFourNeighbors(bgm, *it, midpoint, goNonLinear, newp, metricField);
+ surfacePointWithExclusionRegion *sp =
+ new surfacePointWithExclusionRegion(*it, newp, midpoint, metricField);
smoothness_point_pair mp;
mp.ptr = sp;
- mp.rank=(1.-bgm->get_smoothness(midpoint[0],midpoint[1]));
+ mp.rank = (1. - bgm->get_smoothness(midpoint[0], midpoint[1]));
fifo.insert(mp);
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
- rtree.Insert(_min,_max,sp);
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
+ rtree.Insert(_min, _max, sp);
}
// ---------- main loop -----------------
- while(!fifo.empty()){
- if(debug) std::cout << " -------- fifo.size() = " << fifo.size() << std::endl;
+ while(!fifo.empty()) {
+ if(debug)
+ std::cout << " -------- fifo.size() = " << fifo.size() << std::endl;
int count_nbaddedpt = 0;
- surfacePointWithExclusionRegion * parent = (*fifo.begin()).ptr;
+ surfacePointWithExclusionRegion *parent = (*fifo.begin()).ptr;
fifo.erase(fifo.begin());
- for (int dir=0;dir<NUMDIR;dir++){
- for (int i=0;i<4;i++){
- if (!inExclusionZone (parent->_p[i][dir], rtree, vertices) ){
-
+ for(int dir = 0; dir < NUMDIR; dir++) {
+ for(int i = 0; i < 4; i++) {
+ if(!inExclusionZone(parent->_p[i][dir], rtree, vertices)) {
GPoint gp = gf->point(parent->_p[i][dir]);
- MFaceVertex *v = new MFaceVertex(gp.x(),gp.y(),gp.z(),gf,gp.u(),gp.v());
+ MFaceVertex *v =
+ new MFaceVertex(gp.x(), gp.y(), gp.z(), gf, gp.u(), gp.v());
SPoint2 midpoint;
- computeFourNeighbors(bgm,v, midpoint, goNonLinear, newp, metricField);
- surfacePointWithExclusionRegion *sp = new surfacePointWithExclusionRegion
- (v, newp, midpoint, metricField, parent);
- smoothness_point_pair mp;mp.ptr = sp;mp.rank=(1.-bgm->get_smoothness(gp.u(),gp.v()));
+ computeFourNeighbors(bgm, v, midpoint, goNonLinear, newp,
+ metricField);
+ surfacePointWithExclusionRegion *sp =
+ new surfacePointWithExclusionRegion(v, newp, midpoint, metricField,
+ parent);
+ smoothness_point_pair mp;
+ mp.ptr = sp;
+ mp.rank = (1. - bgm->get_smoothness(gp.u(), gp.v()));
- if (debug) vert_priority[v] = priority_counter++;
+ if(debug) vert_priority[v] = priority_counter++;
fifo.insert(mp);
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
- rtree.Insert(_min,_max,sp);
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
+ rtree.Insert(_min, _max, sp);
- if (debug){
+ if(debug) {
std::cout << " adding node (" << sp->_v->x() << "," << sp->_v->y()
- << "," << sp->_v->z() << ")" << std::endl;
- std::cout << " ----------------------------- sub --- fifo.size() = "
- << fifo.size() << std::endl;
+ << "," << sp->_v->z() << ")" << std::endl;
+ std::cout
+ << " ----------------------------- sub --- fifo.size() = "
+ << fifo.size() << std::endl;
}
count_nbaddedpt++;
}
}
}
- if(debug) std::cout << "////////// nbre of added point: " << count_nbaddedpt << std::endl;
+ if(debug)
+ std::cout << "////////// nbre of added point: " << count_nbaddedpt
+ << std::endl;
}
time_insertion += (Cpu() - a);
- if (debug){
+ if(debug) {
std::stringstream ss;
ss << "priority_" << gf->tag() << ".pos";
- print_nodal_info(ss.str().c_str(),vert_priority);
+ print_nodal_info(ss.str().c_str(), vert_priority);
ss.clear();
}
// add the vertices as additional vertices in the
// surface mesh
- char ccc[256]; sprintf(ccc,"points%d.pos",gf->tag());
- FILE *f = Fopen(ccc,"w");
- if(f){
- fprintf(f,"View \"\"{\n");
- for (unsigned int i=0;i<vertices.size();i++){
- vertices[i]->print(f,i);
+ char ccc[256];
+ sprintf(ccc, "points%d.pos", gf->tag());
+ FILE *f = Fopen(ccc, "w");
+ if(f) {
+ fprintf(f, "View \"\"{\n");
+ for(unsigned int i = 0; i < vertices.size(); i++) {
+ vertices[i]->print(f, i);
if(vertices[i]->_v->onWhat() == gf) {
packed.push_back(vertices[i]->_v);
metrics.push_back(vertices[i]->_meshMetric);
SPoint2 midpoint;
reparamMeshVertexOnFace(vertices[i]->_v, gf, midpoint);
}
- delete vertices[i];
+ delete vertices[i];
}
- fprintf(f,"};");
+ fprintf(f, "};");
fclose(f);
}
}
@@ -439,21 +454,21 @@ bool Filler3D::treat_region(GRegion *gr)
// readValue("param.dat","SMOOTHNESSALGO",algo);
algo.assign("SCALAR");
- if (!algo.compare("SCALAR")){
+ if(!algo.compare("SCALAR")) {
use_vectorial_smoothness = false;
use_fifo = false;
}
- else if (!algo.compare("FIFO")){
+ else if(!algo.compare("FIFO")) {
use_vectorial_smoothness = false;
use_fifo = true;
}
- else{
+ else {
std::cout << "unknown SMOOTHNESSALGO !" << std::endl;
throw;
}
- const bool debug=false;
- const bool export_stuff=true;
+ const bool debug = false;
+ const bool export_stuff = true;
double a;
std::cout << "ENTERING POINTINSERTION3D" << std::endl;
@@ -462,16 +477,16 @@ bool Filler3D::treat_region(GRegion *gr)
std::cout << "pointInsertion3D: recover BGM" << std::endl;
a = Cpu();
frameFieldBackgroundMesh3D *bgm =
- dynamic_cast<frameFieldBackgroundMesh3D*>(BGMManager::get(gr));
+ dynamic_cast<frameFieldBackgroundMesh3D *>(BGMManager::get(gr));
time_smoothing += (Cpu() - a);
- if (!bgm){
+ if(!bgm) {
std::cout << "pointInsertion3D:: BGM dynamic cast failed ! " << std::endl;
throw;
}
// export BGM fields
- if(export_stuff){
+ if(export_stuff) {
std::cout << "pointInsertion3D: export size field " << std::endl;
std::stringstream ss;
ss << "bg3D_sizefield_" << gr->tag() << ".pos";
@@ -487,8 +502,9 @@ bool Filler3D::treat_region(GRegion *gr)
sss << "bg3D_smoothness_" << gr->tag() << ".pos";
bgm->exportSmoothness(sss.str());
- if (use_vectorial_smoothness){
- std::cout << "pointInsertion3D : export vectorial smoothness " << std::endl;
+ if(use_vectorial_smoothness) {
+ std::cout << "pointInsertion3D : export vectorial smoothness "
+ << std::endl;
std::stringstream ssvs;
ssvs << "bg3D_vectorial_smoothness_" << gr->tag() << ".pos";
bgm->exportVectorialSmoothness(ssvs.str());
@@ -496,35 +512,38 @@ bool Filler3D::treat_region(GRegion *gr)
}
// ---------------- START FILLING NEW POINTS ----------------
- std::cout << "pointInsertion3D : inserting points in region " << gr->tag() << std::endl;
+ std::cout << "pointInsertion3D : inserting points in region " << gr->tag()
+ << std::endl;
- //ProfilerStart("/home/bernard/profile");
+ // ProfilerStart("/home/bernard/profile");
a = Cpu();
// ----- initialize fifo list -----
- RTree<MVertex*,double,3,double> rtree;
+ RTree<MVertex *, double, 3, double> rtree;
listOfPoints *fifo;
- if (use_fifo)
+ if(use_fifo)
fifo = new listOfPointsFifo();
- else if (use_vectorial_smoothness)
+ else if(use_vectorial_smoothness)
fifo = new listOfPointsVectorialSmoothness();
else
fifo = new listOfPointsScalarSmoothness();
- std::set<MVertex*> temp;
- std::vector<MVertex*> boundary_vertices;
- std::map<MVertex*,int> vert_priority;
- std::map<MVertex*,double> smoothness_forplot;
+ std::set<MVertex *> temp;
+ std::vector<MVertex *> boundary_vertices;
+ std::map<MVertex *, int> vert_priority;
+ std::map<MVertex *, double> smoothness_forplot;
MElement *element;
MVertex *vertex;
- std::vector<GFace*> faces = gr->faces();
- for(std::vector<GFace*>::iterator it=faces.begin();it!=faces.end();it++){
+ std::vector<GFace *> faces = gr->faces();
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) {
GFace *gf = *it;
// int limit = code_kesskessai(gf->tag());
- for(unsigned int i=0;i<gf->getNumMeshElements();i++){
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
element = gf->getMeshElement(i);
- for(std::size_t j=0;j<element->getNumVertices();j++){// for all vertices
+ for(std::size_t j = 0; j < element->getNumVertices();
+ j++) { // for all vertices
vertex = element->getVertex(j);
temp.insert(vertex);
// limits.insert(make_pair(vertex,limit));
@@ -533,52 +552,53 @@ bool Filler3D::treat_region(GRegion *gr)
}
int geodim;
- for(std::set<MVertex*>::iterator it=temp.begin();it!=temp.end();it++){
+ for(std::set<MVertex *>::iterator it = temp.begin(); it != temp.end(); it++) {
geodim = (*it)->onWhat()->dim();
- if ((geodim==0) || (geodim==1) || (geodim==2)) boundary_vertices.push_back(*it);
+ if((geodim == 0) || (geodim == 1) || (geodim == 2))
+ boundary_vertices.push_back(*it);
}
- double min[3],max[3],x,y,z,h;
- for(unsigned int i=0;i<boundary_vertices.size();i++){
-
+ double min[3], max[3], x, y, z, h;
+ for(unsigned int i = 0; i < boundary_vertices.size(); i++) {
x = boundary_vertices[i]->x();
y = boundary_vertices[i]->y();
z = boundary_vertices[i]->z();
// "on boundary since working on boundary_vertices ...
- MVertex *closest = bgm->get_nearest_neighbor_on_boundary(boundary_vertices[i]);
- h = bgm->size(closest);// get approximate size, closest vertex, faster ?!
+ MVertex *closest =
+ bgm->get_nearest_neighbor_on_boundary(boundary_vertices[i]);
+ h = bgm->size(closest); // get approximate size, closest vertex, faster ?!
- fill_min_max(x,y,z,h,min,max);
+ fill_min_max(x, y, z, h, min, max);
- rtree.Insert(min,max,boundary_vertices[i]);
+ rtree.Insert(min, max, boundary_vertices[i]);
- if (!use_vectorial_smoothness){
+ if(!use_vectorial_smoothness) {
smoothness_vertex_pair *svp = new smoothness_vertex_pair();
svp->v = boundary_vertices[i];
- svp->rank = bgm->get_smoothness(x,y,z);
+ svp->rank = bgm->get_smoothness(x, y, z);
svp->dir = 0;
svp->layer = 0;
svp->size = h;
bgm->eval_approximate_crossfield(closest, svp->cf);
fifo->insert(svp);
- if (debug){
+ if(debug) {
smoothness_forplot[svp->v] = svp->rank;
}
}
- else{
+ else {
STensor3 temp;
bgm->eval_approximate_crossfield(closest, temp);
- for (int idir=0;idir<3;idir++){
+ for(int idir = 0; idir < 3; idir++) {
smoothness_vertex_pair *svp = new smoothness_vertex_pair();
svp->v = boundary_vertices[i];
- svp->rank = bgm->get_vectorial_smoothness(idir,x,y,z);
+ svp->rank = bgm->get_vectorial_smoothness(idir, x, y, z);
svp->dir = idir;
svp->layer = 0;
svp->size = h;
svp->cf = temp;
- for (int k=0;k<3;k++) svp->direction(k) = temp(k,idir);
+ for(int k = 0; k < 3; k++) svp->direction(k) = temp(k, idir);
// std::cout << "fifo size=" << fifo->size() << " inserting " ;
fifo->insert(svp);
@@ -590,16 +610,15 @@ bool Filler3D::treat_region(GRegion *gr)
// TODO: si fifo était list of *PTR -> pas de copies, gain temps ?
Wrapper3D wrapper;
wrapper.set_bgm(bgm);
- MVertex *parent,*individual;
+ MVertex *parent, *individual;
new_vertices.clear();
bool spawn_created;
- int priority_counter=0;
+ int priority_counter = 0;
STensor3 crossfield;
int parent_layer;
- while(!fifo->empty()){
-
- parent = fifo->get_first_vertex();
+ while(!fifo->empty()) {
+ parent = fifo->get_first_vertex();
// parent_limit = fifo->get_first_limit();
parent_layer = fifo->get_first_layer();
@@ -607,15 +626,15 @@ bool Filler3D::treat_region(GRegion *gr)
// continue;
// }
- std::vector<MVertex*> spawns;
- if (!use_vectorial_smoothness){
+ std::vector<MVertex *> spawns;
+ if(!use_vectorial_smoothness) {
spawns.resize(6);
- computeSixNeighbors(bgm,parent,spawns,fifo->get_first_crossfield(),
+ computeSixNeighbors(bgm, parent, spawns, fifo->get_first_crossfield(),
fifo->get_first_size());
}
- else{
+ else {
spawns.resize(2);
- computeTwoNeighbors(bgm,parent,spawns,fifo->get_first_direction(),
+ computeTwoNeighbors(bgm, parent, spawns, fifo->get_first_direction(),
fifo->get_first_size());
}
fifo->erase_first();
@@ -624,23 +643,26 @@ bool Filler3D::treat_region(GRegion *gr)
// parent->x() << "," << parent->y() << "," << parent->z() << ")" <<
// std::endl;
- for(unsigned int i=0;i<spawns.size();i++){
+ for(unsigned int i = 0; i < spawns.size(); i++) {
spawn_created = false;
individual = spawns[i];
x = individual->x();
y = individual->y();
z = individual->z();
- // std::cout << " working on candidate " << "(" << individual->x() << ","
+ // std::cout << " working on candidate " << "(" << individual->x() <<
+ // ","
// << individual->y() << "," << individual->z() << ")" << std::endl;
- if(bgm->inDomain(x,y,z)){
+ if(bgm->inDomain(x, y, z)) {
// std::cout << " spawn " << i << " in domain" << std::endl;
MVertex *closest = bgm->get_nearest_neighbor(individual);
- h = bgm->size(closest);// get approximate size, closest vertex, faster ?!
+ h =
+ bgm->size(closest); // get approximate size, closest vertex, faster ?!
- if(far_from_boundary_3D(bgm,individual,h)){
- // std::cout << " spawn " << i << " far from bnd" << std::endl;
+ if(far_from_boundary_3D(bgm, individual, h)) {
+ // std::cout << " spawn " << i << " far from bnd" <<
+ // std::endl;
bgm->eval_approximate_crossfield(closest, crossfield);
wrapper.set_ok(true);
wrapper.set_individual(individual);
@@ -648,84 +670,85 @@ bool Filler3D::treat_region(GRegion *gr)
wrapper.set_size(&h);
wrapper.set_crossfield(&crossfield);
- fill_min_max(x,y,z,h,min,max);
+ fill_min_max(x, y, z, h, min, max);
- rtree.Search(min,max,rtree_callback_3D,&wrapper);
+ rtree.Search(min, max, rtree_callback_3D, &wrapper);
- if(wrapper.get_ok()){
- // std::cout << " spawn " << i << " wrapper OK" << std::endl;
+ if(wrapper.get_ok()) {
+ // std::cout << " spawn " << i << " wrapper OK" <<
+ // std::endl;
- if (!use_vectorial_smoothness){
+ if(!use_vectorial_smoothness) {
smoothness_vertex_pair *svp = new smoothness_vertex_pair();
svp->v = individual;
- svp->rank=bgm->get_smoothness(individual->x(),individual->y(),individual->z());
+ svp->rank = bgm->get_smoothness(individual->x(), individual->y(),
+ individual->z());
svp->dir = 0;
- svp->layer = parent_layer+1;
+ svp->layer = parent_layer + 1;
svp->size = h;
svp->cf = crossfield;
fifo->insert(svp);
- if (debug){
+ if(debug) {
smoothness_forplot[svp->v] = svp->rank;
vert_priority[individual] = priority_counter++;
}
-
}
- else{
- if (debug) vert_priority[individual] = priority_counter++;
- for (int idir=0;idir<3;idir++){
+ else {
+ if(debug) vert_priority[individual] = priority_counter++;
+ for(int idir = 0; idir < 3; idir++) {
smoothness_vertex_pair *svp = new smoothness_vertex_pair();
svp->v = individual;
- svp->rank = bgm->get_vectorial_smoothness(idir,x,y,z);
+ svp->rank = bgm->get_vectorial_smoothness(idir, x, y, z);
svp->dir = idir;
- svp->layer = parent_layer+1;
+ svp->layer = parent_layer + 1;
svp->size = h;
- for (int k=0;k<3;k++) svp->direction(k) = crossfield(k,idir);
+ for(int k = 0; k < 3; k++)
+ svp->direction(k) = crossfield(k, idir);
svp->cf = crossfield;
fifo->insert(svp);
}
}
- rtree.Insert(min,max,individual);
+ rtree.Insert(min, max, individual);
new_vertices.push_back(individual);
spawn_created = true;
-
}
}
}
- if(!spawn_created){
+ if(!spawn_created) {
delete individual;
}
- }// end loop on spawns
+ } // end loop on spawns
}
- //ProfilerStop();
+ // ProfilerStop();
time_insert_points += (Cpu() - a);
// --- output ---
- if (debug){
+ if(debug) {
std::stringstream ss;
ss << "priority_3D_" << gr->tag() << ".pos";
- print_nodal_info(ss.str().c_str(),vert_priority);
+ print_nodal_info(ss.str().c_str(), vert_priority);
ss.clear();
std::stringstream sss;
sss << "smoothness_3D_" << gr->tag() << ".pos";
- print_nodal_info(sss.str().c_str(),smoothness_forplot);
+ print_nodal_info(sss.str().c_str(), smoothness_forplot);
sss.clear();
}
// ------- meshing using new points
std::cout << "tets in gr before= " << gr->tetrahedra.size() << std::endl;
std::cout << "nb new vertices= " << new_vertices.size() << std::endl;
- a=Cpu();
+ a = Cpu();
int option = CTX::instance()->mesh.algo3d;
CTX::instance()->mesh.algo3d = ALGO_3D_DELAUNAY;
deMeshGRegion deleter;
deleter(gr);
- std::vector<GRegion*> regions;
+ std::vector<GRegion *> regions;
regions.push_back(gr);
meshGRegion mesher(regions); //?
mesher(gr); //?
@@ -738,24 +761,18 @@ bool Filler3D::treat_region(GRegion *gr)
CTX::instance()->mesh.algo3d = option;
delete fifo;
- for(unsigned int i=0;i<new_vertices.size();i++) delete new_vertices[i];
+ for(unsigned int i = 0; i < new_vertices.size(); i++) delete new_vertices[i];
new_vertices.clear();
rtree.RemoveAll();
return true;
}
-int Filler3D::get_nbr_new_vertices()
-{
- return new_vertices.size();
-}
+int Filler3D::get_nbr_new_vertices() { return new_vertices.size(); }
-MVertex* Filler3D::get_new_vertex(int i)
-{
- return new_vertices[i];
-}
+MVertex *Filler3D::get_new_vertex(int i) { return new_vertices[i]; }
-Filler3D::Filler3D(){}
+Filler3D::Filler3D() {}
Filler3D::~Filler3D()
{
@@ -764,13 +781,14 @@ Filler3D::~Filler3D()
<< time_smoothing << " s." << std::endl;
std::cout << " ------- CUMULATIVE TIME3D inserting points : "
<< time_insert_points << " s." << std::endl;
- std::cout << " ------- CUMULATIVE TIME3D meshing region : "
- << time_meshing << " s." << std::endl;
+ std::cout << " ------- CUMULATIVE TIME3D meshing region : " << time_meshing
+ << " s." << std::endl;
std::cout << " ------- CUMULATIVE TOTAL 3D TIME (new) : "
- << time_meshing+time_smoothing+time_insert_points << " s." << std::endl;
+ << time_meshing + time_smoothing + time_insert_points << " s."
+ << std::endl;
}
-std::vector<MVertex*> Filler3D::new_vertices;
+std::vector<MVertex *> Filler3D::new_vertices;
double Filler3D::time_smoothing = 0.;
double Filler3D::time_insert_points = 0.;
diff --git a/Mesh/pointInsertion.h b/Mesh/pointInsertion.h
index 4d91ab679aa9f170ff3f89856c57bdf67fb3a325..dbebddcc86d34e70fb9e05fd2d390fab0c6e3d03 100644
--- a/Mesh/pointInsertion.h
+++ b/Mesh/pointInsertion.h
@@ -19,25 +19,29 @@ class MVertex;
extern bool old_algo_hexa();
-class Filler2D{
- public:
+class Filler2D {
+public:
Filler2D();
~Filler2D();
- void pointInsertion2D(GFace* gf, std::vector<MVertex*> &packed, std::vector<SMetric3> &metrics );
- private:
- static double time_bgm_and_smoothing,time_insertion;
+ void pointInsertion2D(GFace *gf, std::vector<MVertex *> &packed,
+ std::vector<SMetric3> &metrics);
+
+private:
+ static double time_bgm_and_smoothing, time_insertion;
};
-class Filler3D{
- private:
- static std::vector<MVertex*> new_vertices;// these are used in meshGRegion.cpp using static !!!
- static double time_smoothing,time_insert_points, time_meshing;
- public:
+class Filler3D {
+private:
+ static std::vector<MVertex *>
+ new_vertices; // these are used in meshGRegion.cpp using static !!!
+ static double time_smoothing, time_insert_points, time_meshing;
+
+public:
Filler3D();
~Filler3D();
- virtual bool treat_region(GRegion*);
+ virtual bool treat_region(GRegion *);
static int get_nbr_new_vertices();
- static MVertex* get_new_vertex(int);
+ static MVertex *get_new_vertex(int);
};
#endif
diff --git a/Mesh/pointInsertionRTreeTools.cpp b/Mesh/pointInsertionRTreeTools.cpp
index b61a78c22faddd9637df8cb62b670fc23ee58ed9..0d7f8935965c9546527e18328e2c3123c4816384 100644
--- a/Mesh/pointInsertionRTreeTools.cpp
+++ b/Mesh/pointInsertionRTreeTools.cpp
@@ -11,83 +11,83 @@
#include "pointInsertion.h"
#include "GEntity.h"
-surfacePointWithExclusionRegion::surfacePointWithExclusionRegion
- (MVertex *v, SPoint2 p[4][NUMDIR], SPoint2 &_mp, SMetric3 & meshMetric,
- surfacePointWithExclusionRegion *father)
+surfacePointWithExclusionRegion::surfacePointWithExclusionRegion(
+ MVertex *v, SPoint2 p[4][NUMDIR], SPoint2 &_mp, SMetric3 &meshMetric,
+ surfacePointWithExclusionRegion *father)
{
_v = v;
_meshMetric = meshMetric;
_center = _mp;
- for (int i=0;i<4;i++)_q[i] = _center + (p[i][0]+p[(i+1)%4][0]-_center*2)*FACTOR;
- for (int i=0;i<4;i++)for (int j=0;j<NUMDIR;j++)_p[i][j] = p[i][j];
+ for(int i = 0; i < 4; i++)
+ _q[i] = _center + (p[i][0] + p[(i + 1) % 4][0] - _center * 2) * FACTOR;
+ for(int i = 0; i < 4; i++)
+ for(int j = 0; j < NUMDIR; j++) _p[i][j] = p[i][j];
- if (!father){
- fullMatrix<double> V(3,3);
+ if(!father) {
+ fullMatrix<double> V(3, 3);
fullVector<double> S(3);
- meshMetric.eig(V,S);
- double l = std::max(std::max(S(0),S(1)),S(2));
- _distanceSummed = sqrt(1/(l*l));
+ meshMetric.eig(V, S);
+ double l = std::max(std::max(S(0), S(1)), S(2));
+ _distanceSummed = sqrt(1 / (l * l));
}
else {
- _distanceSummed = father->_distanceSummed + distance (father->_v,_v);
+ _distanceSummed = father->_distanceSummed + distance(father->_v, _v);
}
}
-bool surfacePointWithExclusionRegion::inExclusionZone (const SPoint2 &p)
+bool surfacePointWithExclusionRegion::inExclusionZone(const SPoint2 &p)
{
double mat[2][2];
- double b[2] , uv[2];
- mat[0][0]= _q[1].x()-_q[0].x();
- mat[0][1]= _q[2].x()-_q[0].x();
- mat[1][0]= _q[1].y()-_q[0].y();
- mat[1][1]= _q[2].y()-_q[0].y();
+ double b[2], uv[2];
+ mat[0][0] = _q[1].x() - _q[0].x();
+ mat[0][1] = _q[2].x() - _q[0].x();
+ mat[1][0] = _q[1].y() - _q[0].y();
+ mat[1][1] = _q[2].y() - _q[0].y();
b[0] = p.x() - _q[0].x();
b[1] = p.y() - _q[0].y();
sys2x2(mat, b, uv);
// printf("inversion 1 : %g %g \n",uv[0],uv[1]);
- if (uv[0] >= 0 && uv[1] >= 0 && 1.-uv[0] - uv[1] >= 0)return true;
- mat[0][0]= _q[3].x()-_q[2].x();
- mat[0][1]= _q[0].x()-_q[2].x();
- mat[1][0]= _q[3].y()-_q[2].y();
- mat[1][1]= _q[0].y()-_q[2].y();
+ if(uv[0] >= 0 && uv[1] >= 0 && 1. - uv[0] - uv[1] >= 0) return true;
+ mat[0][0] = _q[3].x() - _q[2].x();
+ mat[0][1] = _q[0].x() - _q[2].x();
+ mat[1][0] = _q[3].y() - _q[2].y();
+ mat[1][1] = _q[0].y() - _q[2].y();
b[0] = p.x() - _q[2].x();
b[1] = p.y() - _q[2].y();
sys2x2(mat, b, uv);
// printf("inversion 2 : %g %g \n",uv[0],uv[1]);
- if (uv[0] >= 0 && uv[1] >= 0 && 1.-uv[0] - uv[1] >= 0)return true;
+ if(uv[0] >= 0 && uv[1] >= 0 && 1. - uv[0] - uv[1] >= 0) return true;
return false;
}
-void surfacePointWithExclusionRegion::minmax (double _min[2], double _max[2]) const
+void surfacePointWithExclusionRegion::minmax(double _min[2],
+ double _max[2]) const
{
- _min[0] = std::min(std::min(std::min(_q[0].x(),_q[1].x()),_q[2].x()),_q[3].x());
- _min[1] = std::min(std::min(std::min(_q[0].y(),_q[1].y()),_q[2].y()),_q[3].y());
- _max[0] = std::max(std::max(std::max(_q[0].x(),_q[1].x()),_q[2].x()),_q[3].x());
- _max[1] = std::max(std::max(std::max(_q[0].y(),_q[1].y()),_q[2].y()),_q[3].y());
+ _min[0] =
+ std::min(std::min(std::min(_q[0].x(), _q[1].x()), _q[2].x()), _q[3].x());
+ _min[1] =
+ std::min(std::min(std::min(_q[0].y(), _q[1].y()), _q[2].y()), _q[3].y());
+ _max[0] =
+ std::max(std::max(std::max(_q[0].x(), _q[1].x()), _q[2].x()), _q[3].x());
+ _max[1] =
+ std::max(std::max(std::max(_q[0].y(), _q[1].y()), _q[2].y()), _q[3].y());
}
-void surfacePointWithExclusionRegion::print (FILE *f, int i)
+void surfacePointWithExclusionRegion::print(FILE *f, int i)
{
- fprintf(f,"SP(%g,%g,%g){%d};\n",_center.x(),_center.y(),0.0,i);
- fprintf(f,"SQ(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g){%d,%d,%d,%d};\n",
- _q[0].x(),_q[0].y(),0.0,
- _q[1].x(),_q[1].y(),0.0,
- _q[2].x(),_q[2].y(),0.0,
- _q[3].x(),_q[3].y(),0.0,i,i,i,i);
-
+ fprintf(f, "SP(%g,%g,%g){%d};\n", _center.x(), _center.y(), 0.0, i);
+ fprintf(f, "SQ(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g){%d,%d,%d,%d};\n",
+ _q[0].x(), _q[0].y(), 0.0, _q[1].x(), _q[1].y(), 0.0, _q[2].x(),
+ _q[2].y(), 0.0, _q[3].x(), _q[3].y(), 0.0, i, i, i, i);
}
-my_wrapper::my_wrapper(const SPoint2 &sp)
- : _tooclose(false)
- , _p(sp)
-{
-}
+my_wrapper::my_wrapper(const SPoint2 &sp) : _tooclose(false), _p(sp) {}
-bool rtree_callback(surfacePointWithExclusionRegion *neighbour,void* point)
+bool rtree_callback(surfacePointWithExclusionRegion *neighbour, void *point)
{
- my_wrapper *w = static_cast<my_wrapper*>(point);
+ my_wrapper *w = static_cast<my_wrapper *>(point);
- if (neighbour->inExclusionZone(w->_p)){
+ if(neighbour->inExclusionZone(w->_p)) {
w->_tooclose = true;
return false;
}
@@ -95,29 +95,30 @@ bool rtree_callback(surfacePointWithExclusionRegion *neighbour,void* point)
return true;
}
-bool inExclusionZone
- (SPoint2 &p,
- RTree<surfacePointWithExclusionRegion*,double,2,double> &rtree,
- std::vector<surfacePointWithExclusionRegion*> & all )
+bool inExclusionZone(
+ SPoint2 &p,
+ RTree<surfacePointWithExclusionRegion *, double, 2, double> &rtree,
+ std::vector<surfacePointWithExclusionRegion *> &all)
{
// should assert that the point is inside the domain
// OLD BGM
- if (old_algo_hexa()){
- if (!backgroundMesh::current()->inDomain(p.x(),p.y(),0)) return true;
+ if(old_algo_hexa()) {
+ if(!backgroundMesh::current()->inDomain(p.x(), p.y(), 0)) return true;
}
- else{
+ else {
// NEW BGM
- if (!BGMManager::current2D()->inDomain(p.x(),p.y(),0)) return true;
+ if(!BGMManager::current2D()->inDomain(p.x(), p.y(), 0)) return true;
}
- my_wrapper w (p);
- double _min[2] = {p.x()-1.e-1, p.y()-1.e-1},_max[2] = {p.x()+1.e-1,p.y()+1.e-1};
- rtree.Search(_min,_max,rtree_callback,&w);
+ my_wrapper w(p);
+ double _min[2] = {p.x() - 1.e-1, p.y() - 1.e-1},
+ _max[2] = {p.x() + 1.e-1, p.y() + 1.e-1};
+ rtree.Search(_min, _max, rtree_callback, &w);
return w._tooclose;
- for (unsigned int i=0;i<all.size();++i){
- if (all[i]->inExclusionZone(p)){
+ for(unsigned int i = 0; i < all.size(); ++i) {
+ if(all[i]->inExclusionZone(p)) {
// printf("%g %g is in exclusion zone of %g
// %g\n",p.x(),p.y(),all[i]._center.x(),all[i]._center.y());
return true;
@@ -126,78 +127,81 @@ bool inExclusionZone
return false;
}
-frameFieldBackgroundMesh3D* Wrapper3D::bgmesh = NULL;
+frameFieldBackgroundMesh3D *Wrapper3D::bgmesh = NULL;
-double infinity_distance_3D(const MVertex *v1,const MVertex *v2,STensor3 &cf)
+double infinity_distance_3D(const MVertex *v1, const MVertex *v2, STensor3 &cf)
{
SPoint3 p1 = v1->point();
SPoint3 p2 = v2->point();
- double x1=0.;
- double y1=0.;
- double z1=0.;
- double x2=0.;
- double y2=0.;
- double z2=0.;
- for (int i=0;i<3;i++){
- x1 += cf(i,0) * p1[i];
- y1 += cf(i,1) * p1[i];
- z1 += cf(i,2) * p1[i];
+ double x1 = 0.;
+ double y1 = 0.;
+ double z1 = 0.;
+ double x2 = 0.;
+ double y2 = 0.;
+ double z2 = 0.;
+ for(int i = 0; i < 3; i++) {
+ x1 += cf(i, 0) * p1[i];
+ y1 += cf(i, 1) * p1[i];
+ z1 += cf(i, 2) * p1[i];
}
- for (int i=0;i<3;i++){
- x2 += cf(i,0) * p2[i];
- y2 += cf(i,1) * p2[i];
- z2 += cf(i,2) * p2[i];
+ for(int i = 0; i < 3; i++) {
+ x2 += cf(i, 0) * p2[i];
+ y2 += cf(i, 1) * p2[i];
+ z2 += cf(i, 2) * p2[i];
}
- return std::max(std::max(fabs(x2-x1),fabs(y2-y1)),fabs(z2-z1));// distance
+ return std::max(std::max(fabs(x2 - x1), fabs(y2 - y1)),
+ fabs(z2 - z1)); // distance
};
-void fill_min_max(double x,double y,double z,double h,double *min,double *max)
+void fill_min_max(double x, double y, double z, double h, double *min,
+ double *max)
{
- min[0] = x - sqrt3*h;
- max[0] = x + sqrt3*h;
- min[1] = y - sqrt3*h;
- max[1] = y + sqrt3*h;
- min[2] = z - sqrt3*h;
- max[2] = z + sqrt3*h;
+ min[0] = x - sqrt3 * h;
+ max[0] = x + sqrt3 * h;
+ min[1] = y - sqrt3 * h;
+ max[1] = y + sqrt3 * h;
+ min[2] = z - sqrt3 * h;
+ max[2] = z + sqrt3 * h;
};
-bool rtree_callback_3D(MVertex* neighbour,void* w)
+bool rtree_callback_3D(MVertex *neighbour, void *w)
{
- Wrapper3D* wrapper;
- wrapper = static_cast<Wrapper3D*>(w);
- const MVertex* individual = wrapper->get_individual();
+ Wrapper3D *wrapper;
+ wrapper = static_cast<Wrapper3D *>(w);
+ const MVertex *individual = wrapper->get_individual();
const MVertex *parent = wrapper->get_parent();
- if (parent==neighbour) return true;
+ if(parent == neighbour) return true;
// frameFieldBackgroundMesh3D* bgm = wrapper->bgm();
// const MVertex *closest = bgm->get_nearest_neighbor(individual);
- // const double h = bgm->size(closest);// get approximate size, closest vertex, faster ?!
- // STensor3 crossfield;
+ // const double h = bgm->size(closest);// get approximate size, closest
+ // vertex, faster ?! STensor3 crossfield;
// bgm->eval_approximate_crossfield(closest, crossfield);
double *h = wrapper->get_size();
STensor3 *crossfield = wrapper->get_crossfield();
- const double distance = infinity_distance_3D(individual,neighbour,(*crossfield));
- if(distance<k1*(*h)){
+ const double distance =
+ infinity_distance_3D(individual, neighbour, (*crossfield));
+ if(distance < k1 * (*h)) {
wrapper->set_ok(false);
return false;
}
return true;
};
-bool far_from_boundary_3D(frameFieldBackgroundMesh3D *bgm, MVertex* v, double h)
+bool far_from_boundary_3D(frameFieldBackgroundMesh3D *bgm, MVertex *v, double h)
{
// check if the box (v->point +- k2*h) is in domain
const double x = v->x();
const double y = v->y();
const double z = v->z();
- const double boxsize = k2*h;
- if (!(bgm->inDomain(x+boxsize, y, z))) return false;
- if (!(bgm->inDomain(x-boxsize, y, z))) return false;
- if (!(bgm->inDomain(x, y+boxsize, z))) return false;
- if (!(bgm->inDomain(x, y-boxsize, z))) return false;
- if (!(bgm->inDomain(x, y, z+boxsize))) return false;
- if (!(bgm->inDomain(x, y, z-boxsize))) return false;
+ const double boxsize = k2 * h;
+ if(!(bgm->inDomain(x + boxsize, y, z))) return false;
+ if(!(bgm->inDomain(x - boxsize, y, z))) return false;
+ if(!(bgm->inDomain(x, y + boxsize, z))) return false;
+ if(!(bgm->inDomain(x, y - boxsize, z))) return false;
+ if(!(bgm->inDomain(x, y, z + boxsize))) return false;
+ if(!(bgm->inDomain(x, y, z - boxsize))) return false;
return true;
};
diff --git a/Mesh/pointInsertionRTreeTools.h b/Mesh/pointInsertionRTreeTools.h
index 09b5ae6bb601d435cf3eee732a6fce5b06e3abba..4dc11fa1ea65a46192365d034309d8149567db03 100644
--- a/Mesh/pointInsertionRTreeTools.h
+++ b/Mesh/pointInsertionRTreeTools.h
@@ -16,16 +16,16 @@
#include "GEntity.h"
#include "rtree.h"
-static const double k1 = 0.61; //k1*h is the minimal distance between two nodes
-static const double k2 = 0.5; //k2*h is the minimal distance to the boundary
+static const double k1 = 0.61; // k1*h is the minimal distance between two nodes
+static const double k2 = 0.5; // k2*h is the minimal distance to the boundary
static const double sqrt3 = 1.73205081;
static const double FACTOR = .71;
static const int NUMDIR = 1;
-static const double DIRS [NUMDIR] = {0.0};
+static const double DIRS[NUMDIR] = {0.0};
-//static const int NUMDIR = 3;
-//static const double DIRS [NUMDIR] = {0.0, M_PI/20.,-M_PI/20.};
+// static const int NUMDIR = 3;
+// static const double DIRS [NUMDIR] = {0.0, M_PI/20.,-M_PI/20.};
class surfacePointWithExclusionRegion {
public:
@@ -35,21 +35,21 @@ public:
SPoint2 _q[4];
SMetric3 _meshMetric;
double _distanceSummed;
- /*
- + p3
- p4 |
- +----c-----+ p2
- |
- + p1
+ /*
+ + p3
+ p4 |
+ +----c-----+ p2
+ |
+ + p1
- */
- surfacePointWithExclusionRegion (MVertex *v, SPoint2 p[4][NUMDIR],
- SPoint2 &_mp, SMetric3 & meshMetric,
- surfacePointWithExclusionRegion *father = 0);
+ */
+ surfacePointWithExclusionRegion(MVertex *v, SPoint2 p[4][NUMDIR],
+ SPoint2 &_mp, SMetric3 &meshMetric,
+ surfacePointWithExclusionRegion *father = 0);
- bool inExclusionZone (const SPoint2 &p);
- void minmax (double _min[2], double _max[2]) const;
- void print (FILE *f, int i);
+ bool inExclusionZone(const SPoint2 &p);
+ void minmax(double _min[2], double _max[2]) const;
+ void print(FILE *f, int i);
};
class my_wrapper {
@@ -59,89 +59,90 @@ public:
my_wrapper(const SPoint2 &sp);
};
-struct smoothness_point_pair{
+struct smoothness_point_pair {
double rank;
- surfacePointWithExclusionRegion* ptr;
+ surfacePointWithExclusionRegion *ptr;
};
-class compareSurfacePointWithExclusionRegionPtr_Smoothness
-{
+class compareSurfacePointWithExclusionRegionPtr_Smoothness {
public:
- inline bool operator () (const smoothness_point_pair &a,
- const smoothness_point_pair &b) const
+ inline bool operator()(const smoothness_point_pair &a,
+ const smoothness_point_pair &b) const
{
- if (a.rank == b.rank){
+ if(a.rank == b.rank) {
if(a.ptr->_distanceSummed > b.ptr->_distanceSummed) return false;
if(a.ptr->_distanceSummed < b.ptr->_distanceSummed) return true;
- return a.ptr<b.ptr;
+ return a.ptr < b.ptr;
}
return (a.rank < b.rank);
}
};
-class compareSurfacePointWithExclusionRegionPtr
-{
+class compareSurfacePointWithExclusionRegionPtr {
public:
- inline bool operator () (const surfacePointWithExclusionRegion *a,
- const surfacePointWithExclusionRegion *b) const
+ inline bool operator()(const surfacePointWithExclusionRegion *a,
+ const surfacePointWithExclusionRegion *b) const
{
if(a->_distanceSummed > b->_distanceSummed) return false;
if(a->_distanceSummed < b->_distanceSummed) return true;
- return a<b;
+ return a < b;
}
};
-extern bool rtree_callback(surfacePointWithExclusionRegion *neighbour,void* point);
+extern bool rtree_callback(surfacePointWithExclusionRegion *neighbour,
+ void *point);
-extern bool inExclusionZone (SPoint2 &p,
- RTree<surfacePointWithExclusionRegion*,double,2,double> &rtree,
- std::vector<surfacePointWithExclusionRegion*> & all);
+extern bool inExclusionZone(
+ SPoint2 &p,
+ RTree<surfacePointWithExclusionRegion *, double, 2, double> &rtree,
+ std::vector<surfacePointWithExclusionRegion *> &all);
-class Wrapper3D{
+class Wrapper3D {
private:
- static frameFieldBackgroundMesh3D* bgmesh;
- MVertex *individual,*parent;
+ static frameFieldBackgroundMesh3D *bgmesh;
+ MVertex *individual, *parent;
double *size;
STensor3 *cf;
SVector3 *vec;
bool ok;
+
public:
- Wrapper3D()
- : individual(0), parent(0), size(0), cf(0), vec(0), ok(true)
- {
- }
- Wrapper3D(MVertex* _i,MVertex* _p)
+ Wrapper3D() : individual(0), parent(0), size(0), cf(0), vec(0), ok(true) {}
+ Wrapper3D(MVertex *_i, MVertex *_p)
: individual(_i), parent(_p), size(0), cf(0), vec(0), ok(true)
{
}
- ~Wrapper3D(){}
- void set_ok(bool b){ ok = b; }
- void set_individual(MVertex *vertex){ individual = vertex; }
- void set_parent(MVertex *vertex){ parent = vertex; }
- void set_size(double *h){ size = h; }
- void set_crossfield(STensor3 *_cf){ cf = _cf; }
- void set_direction(SVector3 *_v){ vec = _v; }
- bool get_ok(){ return ok; }
- void set_bgm(frameFieldBackgroundMesh3D *bgm){ bgmesh = bgm; }
- frameFieldBackgroundMesh3D * bgm(){ return bgmesh; }
- MVertex* get_individual(){ return individual; }
- MVertex* get_parent(){ return parent; }
- STensor3* get_crossfield(){ return cf; }
- SVector3* get_direction(){ return vec; }
- double* get_size(){ return size; }
+ ~Wrapper3D() {}
+ void set_ok(bool b) { ok = b; }
+ void set_individual(MVertex *vertex) { individual = vertex; }
+ void set_parent(MVertex *vertex) { parent = vertex; }
+ void set_size(double *h) { size = h; }
+ void set_crossfield(STensor3 *_cf) { cf = _cf; }
+ void set_direction(SVector3 *_v) { vec = _v; }
+ bool get_ok() { return ok; }
+ void set_bgm(frameFieldBackgroundMesh3D *bgm) { bgmesh = bgm; }
+ frameFieldBackgroundMesh3D *bgm() { return bgmesh; }
+ MVertex *get_individual() { return individual; }
+ MVertex *get_parent() { return parent; }
+ STensor3 *get_crossfield() { return cf; }
+ SVector3 *get_direction() { return vec; }
+ double *get_size() { return size; }
};
-extern double infinity_distance_3D(const MVertex *v1,const MVertex *v2,STensor3 &cf);
-extern bool rtree_callback_3D(MVertex* neighbour,void* w);
-extern bool far_from_boundary_3D(frameFieldBackgroundMesh3D *bgm, MVertex* v, double h);
-extern void fill_min_max(double x,double y,double z,double h,double *min,double *max);
+extern double infinity_distance_3D(const MVertex *v1, const MVertex *v2,
+ STensor3 &cf);
+extern bool rtree_callback_3D(MVertex *neighbour, void *w);
+extern bool far_from_boundary_3D(frameFieldBackgroundMesh3D *bgm, MVertex *v,
+ double h);
+extern void fill_min_max(double x, double y, double z, double h, double *min,
+ double *max);
// TODO: this is not a pair anymore, the name has to be changed; this will be in
// listOfPoints AND in RTree: larger memory footprint but less CPU time...
-class smoothness_vertex_pair{
+class smoothness_vertex_pair {
public:
smoothness_vertex_pair() : rank(0.), size(0.), v(0), dir(0), layer(0) {}
- ~smoothness_vertex_pair(){}
+ ~smoothness_vertex_pair() {}
STensor3 cf;
SVector3 direction;
double rank, size;
@@ -149,58 +150,58 @@ public:
int dir, layer;
};
-class compareSmoothnessVertexPairs
-{
+class compareSmoothnessVertexPairs {
private:
const double threshold;
double roundit(const double &d) const
{
- //return (round(d/threshold)*threshold);
- return ((int)(d/threshold + 0.5)*threshold);
+ // return (round(d/threshold)*threshold);
+ return ((int)(d / threshold + 0.5) * threshold);
}
+
public:
- compareSmoothnessVertexPairs():threshold(0.05){};
+ compareSmoothnessVertexPairs() : threshold(0.05){};
- inline bool operator () (const smoothness_vertex_pair *a,
- const smoothness_vertex_pair *b) const
+ inline bool operator()(const smoothness_vertex_pair *a,
+ const smoothness_vertex_pair *b) const
{
- if (a->rank==b->rank) return (a->v<b->v);
+ if(a->rank == b->rank) return (a->v < b->v);
return (a->rank > b->rank);
}
};
-class listOfPoints{
+class listOfPoints {
public:
listOfPoints(){};
virtual ~listOfPoints(){};
- virtual void insert(smoothness_vertex_pair *svp)=0;
- virtual unsigned int size()=0;
- virtual MVertex* get_first_vertex()=0;
- virtual STensor3 get_first_crossfield()=0;
- virtual double get_first_size()=0;
- virtual int get_first_layer()=0;
- virtual SVector3 get_first_direction()=0;
- virtual void erase_first()=0;
- virtual bool empty()=0;
+ virtual void insert(smoothness_vertex_pair *svp) = 0;
+ virtual unsigned int size() = 0;
+ virtual MVertex *get_first_vertex() = 0;
+ virtual STensor3 get_first_crossfield() = 0;
+ virtual double get_first_size() = 0;
+ virtual int get_first_layer() = 0;
+ virtual SVector3 get_first_direction() = 0;
+ virtual void erase_first() = 0;
+ virtual bool empty() = 0;
};
-class listOfPointsScalarSmoothness : public listOfPoints{
+class listOfPointsScalarSmoothness : public listOfPoints {
public:
- listOfPointsScalarSmoothness(){ }
+ listOfPointsScalarSmoothness() {}
virtual ~listOfPointsScalarSmoothness()
{
- while (!empty())
- erase_first();
+ while(!empty()) erase_first();
}
- virtual void insert(smoothness_vertex_pair *svp){ points.insert(svp); }
- virtual unsigned int size(){ return points.size(); }
- virtual MVertex* get_first_vertex(){ return (*points.begin())->v; }
- virtual STensor3 get_first_crossfield(){ return (*points.begin())->cf; }
- virtual double get_first_size(){ return (*points.begin())->size; }
- virtual int get_first_layer(){ return (*points.begin())->layer; }
+ virtual void insert(smoothness_vertex_pair *svp) { points.insert(svp); }
+ virtual unsigned int size() { return points.size(); }
+ virtual MVertex *get_first_vertex() { return (*points.begin())->v; }
+ virtual STensor3 get_first_crossfield() { return (*points.begin())->cf; }
+ virtual double get_first_size() { return (*points.begin())->size; }
+ virtual int get_first_layer() { return (*points.begin())->layer; }
virtual SVector3 get_first_direction()
{
- Msg::Error("listOfPointsScalarSmoothness::get_first_direction NOT applicable");
+ Msg::Error(
+ "listOfPointsScalarSmoothness::get_first_direction NOT applicable");
return SVector3(0.);
}
virtual void erase_first()
@@ -209,37 +210,41 @@ public:
points.erase(points.begin());
delete ptr;
}
- virtual bool empty(){ return points.empty(); }
+ virtual bool empty() { return points.empty(); }
protected:
- std::set<smoothness_vertex_pair*, compareSmoothnessVertexPairs> points;
+ std::set<smoothness_vertex_pair *, compareSmoothnessVertexPairs> points;
};
-class listOfPointsVectorialSmoothness : public listOfPointsScalarSmoothness{
+class listOfPointsVectorialSmoothness : public listOfPointsScalarSmoothness {
public:
- listOfPointsVectorialSmoothness(){}
- virtual ~listOfPointsVectorialSmoothness(){
- while (!empty())
- erase_first();
+ listOfPointsVectorialSmoothness() {}
+ virtual ~listOfPointsVectorialSmoothness()
+ {
+ while(!empty()) erase_first();
}
- virtual SVector3 get_first_direction(){ return (*points.begin())->direction; }
+ virtual SVector3 get_first_direction()
+ {
+ return (*points.begin())->direction;
+ }
+
protected:
- std::set<smoothness_vertex_pair*, compareSmoothnessVertexPairs> points;
+ std::set<smoothness_vertex_pair *, compareSmoothnessVertexPairs> points;
};
-class listOfPointsFifo : public listOfPoints{
+class listOfPointsFifo : public listOfPoints {
public:
listOfPointsFifo(){};
- virtual ~listOfPointsFifo(){
- while (!empty())
- erase_first();
+ virtual ~listOfPointsFifo()
+ {
+ while(!empty()) erase_first();
};
- virtual void insert(smoothness_vertex_pair *svp){ points.push(svp); }
- virtual unsigned int size(){ return points.size(); }
- virtual MVertex* get_first_vertex(){ return (points.front())->v; }
- virtual STensor3 get_first_crossfield(){ return (points.front())->cf; }
- virtual double get_first_size(){ return (points.front())->size; }
- virtual int get_first_layer(){ return (points.front())->layer; }
+ virtual void insert(smoothness_vertex_pair *svp) { points.push(svp); }
+ virtual unsigned int size() { return points.size(); }
+ virtual MVertex *get_first_vertex() { return (points.front())->v; }
+ virtual STensor3 get_first_crossfield() { return (points.front())->cf; }
+ virtual double get_first_size() { return (points.front())->size; }
+ virtual int get_first_layer() { return (points.front())->layer; }
virtual SVector3 get_first_direction()
{
Msg::Error("listOfPointsFifo::get_first_direction NOT applicable");
@@ -251,10 +256,10 @@ public:
points.pop();
delete ptr;
}
- virtual bool empty(){ return points.empty(); }
+ virtual bool empty() { return points.empty(); }
protected:
- std::queue<smoothness_vertex_pair*> points;
+ std::queue<smoothness_vertex_pair *> points;
};
#endif
diff --git a/Mesh/qualityMeasures.cpp b/Mesh/qualityMeasures.cpp
index c560718477f64c36236a1c52341f95c9cc33cc30..75217e05fada76ef793899764b3b3a714c2ff493 100644
--- a/Mesh/qualityMeasures.cpp
+++ b/Mesh/qualityMeasures.cpp
@@ -19,99 +19,123 @@
#include <limits>
#include <string.h>
-
namespace {
+ // Compute unit vector and gradients w.r.t. x0, y0, z0
+ // Remark: gradients w.r.t. x1, y1, z1 not computed as they are just the
+ // opposite
+ inline void unitVecAndGrad(const SPoint3 &p0, const SPoint3 &p1,
+ SVector3 &vec, std::vector<SVector3> &grad)
+ {
+ vec = SVector3(p0, p1);
+ const double n = vec.normalize(), invN = 1 / n;
+ grad[0] = invN * vec[0] * vec;
+ grad[0][0] -= invN; // dv01/dx0
+ grad[1] = invN * vec[1] * vec;
+ grad[1][1] -= invN; // dv01/dy0
+ grad[2] = invN * vec[2] * vec;
+ grad[2][2] -= invN; // dv01/dz0
+ }
-// Compute unit vector and gradients w.r.t. x0, y0, z0
-// Remark: gradients w.r.t. x1, y1, z1 not computed as they are just the opposite
-inline void unitVecAndGrad(const SPoint3 &p0, const SPoint3 &p1,
- SVector3 &vec, std::vector<SVector3> &grad)
-{
- vec = SVector3(p0, p1);
- const double n = vec.normalize(), invN = 1/n;
- grad[0] = invN*vec[0]*vec; grad[0][0] -= invN; // dv01/dx0
- grad[1] = invN*vec[1]*vec; grad[1][1] -= invN; // dv01/dy0
- grad[2] = invN*vec[2]*vec; grad[2][2] -= invN; // dv01/dz0
-}
-
-
-// Given vectors (0, 1) and (0, 2), their gradients and opposite of gradients,
-// and the unit normal vector, compute NCJ from area of triangle defined by both
-// vectors and gradients w.r.t. x0, y0, z0, x1, y1, z1, x2, y2, z2
-inline void NCJAndGrad2D(const SVector3 &v01,
- const std::vector<SVector3> &dv01dp0,
- const std::vector<SVector3> &dv01dp1,
- const SVector3 &v02, const std::vector<SVector3> &dv02dp0,
- const std::vector<SVector3> &dv02dp2,
- const SVector3 &normal,
- double &NCJ, std::vector<double> &dNCJ)
-{
- const SVector3 dvndx0 = crossprod(v01, dv02dp0[0]) + crossprod(dv01dp0[0], v02); // v01 x dv02/dx0 + dv01/dx0 x v02
- const SVector3 dvndy0 = crossprod(v01, dv02dp0[1]) + crossprod(dv01dp0[1], v02); // v01 x dv02/dy0 + dv01/dy0 x v02
- const SVector3 dvndz0 = crossprod(v01, dv02dp0[2]) + crossprod(dv01dp0[2], v02); // v01 x dv02/dz0 + dv01/dz0 x v02
- const SVector3 dvndx1 = crossprod(dv01dp1[0], v02); // dv01/dx1 x v02 (= -dv01/dx0 x v02)
- const SVector3 dvndy1 = crossprod(dv01dp1[1], v02); // dv01/dy1 x v02 (= -dv01/dy0 x v02)
- const SVector3 dvndz1 = crossprod(dv01dp1[2], v02); // dv01/dz1 x v02 (= -dv01/dz0 x v02)
- const SVector3 dvndx2 = crossprod(v01, dv02dp2[0]); // v01 x dv02/dx2 (= v01 x -dv02/dx0)
- const SVector3 dvndy2 = crossprod(v01, dv02dp2[1]); // v01 x dv02/dy2 (= v01 x -dv02/dy0)
- const SVector3 dvndz2 = crossprod(v01, dv02dp2[2]); // v01 x dv02/dz2 (= v01 x -dv02/dz0)
-
- SVector3 vn = crossprod(v01, v02);
- NCJ = dot(vn, normal); // NCJ
- dNCJ[0] = dot(dvndx0, normal); // dNCJ/dx0
- dNCJ[1] = dot(dvndy0, normal); // dNCJ/dy0
- dNCJ[2] = dot(dvndz0, normal); // dNCJ/dz0
- dNCJ[3] = dot(dvndx1, normal); // dNCJ/dx1
- dNCJ[4] = dot(dvndy1, normal); // dNCJ/dy1
- dNCJ[5] = dot(dvndz1, normal); // dNCJ/dz1
- dNCJ[6] = dot(dvndx2, normal); // dNCJ/dx2
- dNCJ[7] = dot(dvndy2, normal); // dNCJ/dy2
- dNCJ[8] = dot(dvndz2, normal); // dNCJ/dz2
-}
-
-
-//// Revert vector and gradients
-//inline void revertVG(const fullMatrix<double> &vg, fullMatrix<double> &res)
-//{
-// res(0, 0) = -vg(0, 3); res(0, 1) = -vg(0, 4); res(0, 2) = -vg(0, 5); res(0, 6) = -vg(0, 6);
-// res(1, 0) = -vg(1, 3); res(1, 1) = -vg(1, 4); res(1, 2) = -vg(1, 5); res(1, 6) = -vg(1, 6);
-// res(2, 0) = -vg(2, 3); res(2, 1) = -vg(2, 4); res(2, 2) = -vg(2, 5); res(2, 6) = -vg(2, 6);
-//}
-
-
-// Scatter the NCJ gradients at vertex iV w.r.t vertices i0, i1 and i2
-// in the vector of gradients for 2D element of nV vertices
-template<int iV, int nV, int i0, int i1, int i2>
-inline void scatterNCJGrad(const std::vector<double> &dNCJi, std::vector<double> &dNCJ)
-{
- dNCJ[(iV*nV+i0)*3] = dNCJi[0]; dNCJ[(iV*nV+i0)*3+1] = dNCJi[1]; dNCJ[(iV*nV+i0)*3+2] = dNCJi[2];
- dNCJ[(iV*nV+i1)*3] = dNCJi[3]; dNCJ[(iV*nV+i1)*3+1] = dNCJi[4]; dNCJ[(iV*nV+i1)*3+2] = dNCJi[5];
- dNCJ[(iV*nV+i2)*3] = dNCJi[6]; dNCJ[(iV*nV+i2)*3+1] = dNCJi[7]; dNCJ[(iV*nV+i2)*3+2] = dNCJi[8];
-}
-
-
-// Scatter the NCJ gradients at vertex iV w.r.t vertices i0, i1, i2 and i3
-// in the vector of gradients for 3D element of nV vertices
-template<int iV, int nV, int i0, int i1, int i2, int i3>
-inline void scatterNCJGrad(const std::vector<double> &dNCJi, std::vector<double> &dNCJ)
-{
- dNCJ[iV*nV+i0*3] = dNCJi[0]; dNCJ[iV*nV+i0*3+1] = dNCJi[1]; dNCJ[iV*nV+i0*3+2] = dNCJi[2];
- dNCJ[iV*nV+i1*3] = dNCJi[3]; dNCJ[iV*nV+i1*3+1] = dNCJi[4]; dNCJ[iV*nV+i1*3+2] = dNCJi[5];
- dNCJ[iV*nV+i2*3] = dNCJi[6]; dNCJ[iV*nV+i2*3+1] = dNCJi[7]; dNCJ[iV*nV+i2*3+2] = dNCJi[8];
- dNCJ[iV*nV+i2*3] = dNCJi[9]; dNCJ[iV*nV+i2*3+1] = dNCJi[10]; dNCJ[iV*nV+i2*3+2] = dNCJi[11];
-}
+ // Given vectors (0, 1) and (0, 2), their gradients and opposite of gradients,
+ // and the unit normal vector, compute NCJ from area of triangle defined by
+ // both vectors and gradients w.r.t. x0, y0, z0, x1, y1, z1, x2, y2, z2
+ inline void
+ NCJAndGrad2D(const SVector3 &v01, const std::vector<SVector3> &dv01dp0,
+ const std::vector<SVector3> &dv01dp1, const SVector3 &v02,
+ const std::vector<SVector3> &dv02dp0,
+ const std::vector<SVector3> &dv02dp2, const SVector3 &normal,
+ double &NCJ, std::vector<double> &dNCJ)
+ {
+ const SVector3 dvndx0 =
+ crossprod(v01, dv02dp0[0]) +
+ crossprod(dv01dp0[0], v02); // v01 x dv02/dx0 + dv01/dx0 x v02
+ const SVector3 dvndy0 =
+ crossprod(v01, dv02dp0[1]) +
+ crossprod(dv01dp0[1], v02); // v01 x dv02/dy0 + dv01/dy0 x v02
+ const SVector3 dvndz0 =
+ crossprod(v01, dv02dp0[2]) +
+ crossprod(dv01dp0[2], v02); // v01 x dv02/dz0 + dv01/dz0 x v02
+ const SVector3 dvndx1 =
+ crossprod(dv01dp1[0], v02); // dv01/dx1 x v02 (= -dv01/dx0 x v02)
+ const SVector3 dvndy1 =
+ crossprod(dv01dp1[1], v02); // dv01/dy1 x v02 (= -dv01/dy0 x v02)
+ const SVector3 dvndz1 =
+ crossprod(dv01dp1[2], v02); // dv01/dz1 x v02 (= -dv01/dz0 x v02)
+ const SVector3 dvndx2 =
+ crossprod(v01, dv02dp2[0]); // v01 x dv02/dx2 (= v01 x -dv02/dx0)
+ const SVector3 dvndy2 =
+ crossprod(v01, dv02dp2[1]); // v01 x dv02/dy2 (= v01 x -dv02/dy0)
+ const SVector3 dvndz2 =
+ crossprod(v01, dv02dp2[2]); // v01 x dv02/dz2 (= v01 x -dv02/dz0)
+
+ SVector3 vn = crossprod(v01, v02);
+ NCJ = dot(vn, normal); // NCJ
+ dNCJ[0] = dot(dvndx0, normal); // dNCJ/dx0
+ dNCJ[1] = dot(dvndy0, normal); // dNCJ/dy0
+ dNCJ[2] = dot(dvndz0, normal); // dNCJ/dz0
+ dNCJ[3] = dot(dvndx1, normal); // dNCJ/dx1
+ dNCJ[4] = dot(dvndy1, normal); // dNCJ/dy1
+ dNCJ[5] = dot(dvndz1, normal); // dNCJ/dz1
+ dNCJ[6] = dot(dvndx2, normal); // dNCJ/dx2
+ dNCJ[7] = dot(dvndy2, normal); // dNCJ/dy2
+ dNCJ[8] = dot(dvndz2, normal); // dNCJ/dz2
+ }
+ //// Revert vector and gradients
+ // inline void revertVG(const fullMatrix<double> &vg, fullMatrix<double> &res)
+ //{
+ // res(0, 0) = -vg(0, 3); res(0, 1) = -vg(0, 4); res(0, 2) = -vg(0, 5);
+ // res(0, 6) = -vg(0, 6); res(1, 0) = -vg(1, 3); res(1, 1) = -vg(1, 4);
+ // res(1, 2) = -vg(1, 5); res(1, 6) = -vg(1, 6); res(2, 0) = -vg(2, 3);
+ // res(2, 1) = -vg(2, 4); res(2, 2) = -vg(2, 5); res(2, 6) = -vg(2, 6);
+ //}
+
+ // Scatter the NCJ gradients at vertex iV w.r.t vertices i0, i1 and i2
+ // in the vector of gradients for 2D element of nV vertices
+ template <int iV, int nV, int i0, int i1, int i2>
+ inline void scatterNCJGrad(const std::vector<double> &dNCJi,
+ std::vector<double> &dNCJ)
+ {
+ dNCJ[(iV * nV + i0) * 3] = dNCJi[0];
+ dNCJ[(iV * nV + i0) * 3 + 1] = dNCJi[1];
+ dNCJ[(iV * nV + i0) * 3 + 2] = dNCJi[2];
+ dNCJ[(iV * nV + i1) * 3] = dNCJi[3];
+ dNCJ[(iV * nV + i1) * 3 + 1] = dNCJi[4];
+ dNCJ[(iV * nV + i1) * 3 + 2] = dNCJi[5];
+ dNCJ[(iV * nV + i2) * 3] = dNCJi[6];
+ dNCJ[(iV * nV + i2) * 3 + 1] = dNCJi[7];
+ dNCJ[(iV * nV + i2) * 3 + 2] = dNCJi[8];
+ }
-}
+ // Scatter the NCJ gradients at vertex iV w.r.t vertices i0, i1, i2 and i3
+ // in the vector of gradients for 3D element of nV vertices
+ template <int iV, int nV, int i0, int i1, int i2, int i3>
+ inline void scatterNCJGrad(const std::vector<double> &dNCJi,
+ std::vector<double> &dNCJ)
+ {
+ dNCJ[iV * nV + i0 * 3] = dNCJi[0];
+ dNCJ[iV * nV + i0 * 3 + 1] = dNCJi[1];
+ dNCJ[iV * nV + i0 * 3 + 2] = dNCJi[2];
+ dNCJ[iV * nV + i1 * 3] = dNCJi[3];
+ dNCJ[iV * nV + i1 * 3 + 1] = dNCJi[4];
+ dNCJ[iV * nV + i1 * 3 + 2] = dNCJi[5];
+ dNCJ[iV * nV + i2 * 3] = dNCJi[6];
+ dNCJ[iV * nV + i2 * 3 + 1] = dNCJi[7];
+ dNCJ[iV * nV + i2 * 3 + 2] = dNCJi[8];
+ dNCJ[iV * nV + i2 * 3] = dNCJi[9];
+ dNCJ[iV * nV + i2 * 3 + 1] = dNCJi[10];
+ dNCJ[iV * nV + i2 * 3 + 2] = dNCJi[11];
+ }
+} // namespace
-double qmTriangle::gamma(const BDS_Point *p1, const BDS_Point *p2, const BDS_Point *p3)
+double qmTriangle::gamma(const BDS_Point *p1, const BDS_Point *p2,
+ const BDS_Point *p3)
{
return gamma(p1->X, p1->Y, p1->Z, p2->X, p2->Y, p2->Z, p3->X, p3->Y, p3->Z);
}
-
double qmTriangle::gamma(BDS_Face *t)
{
BDS_Point *n[4];
@@ -119,41 +143,47 @@ double qmTriangle::gamma(BDS_Face *t)
return gamma(n[0], n[1], n[2]);
}
-
-double qmTriangle::gamma(MTriangle*t)
+double qmTriangle::gamma(MTriangle *t)
{
return gamma(t->getVertex(0), t->getVertex(1), t->getVertex(2));
}
-
-double qmTriangle::gamma(const MVertex *v1, const MVertex *v2, const MVertex *v3)
+double qmTriangle::gamma(const MVertex *v1, const MVertex *v2,
+ const MVertex *v3)
{
- return gamma(v1->x(), v1->y(), v1->z(), v2->x(), v2->y(), v2->z(), v3->x(), v3->y(), v3->z());
+ return gamma(v1->x(), v1->y(), v1->z(), v2->x(), v2->y(), v2->z(), v3->x(),
+ v3->y(), v3->z());
}
-
// Triangle abc
// quality is between 0 and 1
double qmTriangle::gamma(const double &xa, const double &ya, const double &za,
- const double &xb, const double &yb, const double &zb,
- const double &xc, const double &yc, const double &zc)
+ const double &xb, const double &yb, const double &zb,
+ const double &xc, const double &yc, const double &zc)
{
// quality = rho / R = 2 * inscribed radius / circumradius
- double a [3] = {xc - xb, yc - yb, zc - zb};
- double b [3] = {xa - xc, ya - yc, za - zc};
- double c [3] = {xb - xa, yb - ya, zb - za};
+ double a[3] = {xc - xb, yc - yb, zc - zb};
+ double b[3] = {xa - xc, ya - yc, za - zc};
+ double c[3] = {xb - xa, yb - ya, zb - za};
norme(a);
norme(b);
norme(c);
- double pva [3]; prodve(b, c, pva); const double sina = norm3(pva);
- double pvb [3]; prodve(c, a, pvb); const double sinb = norm3(pvb);
- double pvc [3]; prodve(a, b, pvc); const double sinc = norm3(pvc);
-
- if (sina == 0.0 && sinb == 0.0 && sinc == 0.0) return 0.0;
- else return 2 * (2 * sina * sinb * sinc / (sina + sinb + sinc));
+ double pva[3];
+ prodve(b, c, pva);
+ const double sina = norm3(pva);
+ double pvb[3];
+ prodve(c, a, pvb);
+ const double sinb = norm3(pvb);
+ double pvc[3];
+ prodve(a, b, pvc);
+ const double sinc = norm3(pvc);
+
+ if(sina == 0.0 && sinb == 0.0 && sinc == 0.0)
+ return 0.0;
+ else
+ return 2 * (2 * sina * sinb * sinc / (sina + sinb + sinc));
}
-
double qmTriangle::eta(MTriangle *el)
{
MVertex *_v[3] = {el->getVertex(0), el->getVertex(1), el->getVertex(2)};
@@ -162,100 +192,106 @@ double qmTriangle::eta(MTriangle *el)
double a2 = 180 * angle3Vertices(_v[1], _v[2], _v[0]) / M_PI;
double a3 = 180 * angle3Vertices(_v[2], _v[0], _v[1]) / M_PI;
- double amin = std::min(std::min(a1,a2),a3);
+ double amin = std::min(std::min(a1, a2), a3);
double angle = std::abs(60. - amin);
- return 1.-angle/60;
+ return 1. - angle / 60;
}
-
double qmTriangle::angles(MTriangle *e)
{
double a = 500;
double worst_quality = std::numeric_limits<double>::max();
double mat[3][3];
double mat2[3][3];
- double den = atan(a*(M_PI/9)) + atan(a*(M_PI/9));
+ double den = atan(a * (M_PI / 9)) + atan(a * (M_PI / 9));
// This matrix is used to "rotate" the triangle to get each vertex
// as the "origin" of the mapping in turn
double rot[3][3];
- rot[0][0]=-1; rot[0][1]=1; rot[0][2]=0;
- rot[1][0]=-1; rot[1][1]=0; rot[1][2]=0;
- rot[2][0]= 0; rot[2][1]=0; rot[2][2]=1;
+ rot[0][0] = -1;
+ rot[0][1] = 1;
+ rot[0][2] = 0;
+ rot[1][0] = -1;
+ rot[1][1] = 0;
+ rot[1][2] = 0;
+ rot[2][0] = 0;
+ rot[2][1] = 0;
+ rot[2][2] = 1;
double tmp[3][3];
- //double minAngle = 120.0;
- for (int i = 0; i < e->getNumPrimaryVertices(); i++) {
+ // double minAngle = 120.0;
+ for(int i = 0; i < e->getNumPrimaryVertices(); i++) {
const double u = i == 1 ? 1 : 0;
const double v = i == 2 ? 1 : 0;
const double w = 0;
e->getJacobian(u, v, w, mat);
- e->getPrimaryJacobian(u,v,w,mat2);
- for (int j = 0; j < i; j++) {
- matmat(rot,mat,tmp);
+ e->getPrimaryJacobian(u, v, w, mat2);
+ for(int j = 0; j < i; j++) {
+ matmat(rot, mat, tmp);
memcpy(mat, tmp, sizeof(mat));
}
- //get angle
- double v1[3] = {mat[0][0], mat[0][1], mat[0][2] };
- double v2[3] = {mat[1][0], mat[1][1], mat[1][2] };
- double v3[3] = {mat2[0][0], mat2[0][1], mat2[0][2] };
- double v4[3] = {mat2[1][0], mat2[1][1], mat2[1][2] };
+ // get angle
+ double v1[3] = {mat[0][0], mat[0][1], mat[0][2]};
+ double v2[3] = {mat[1][0], mat[1][1], mat[1][2]};
+ double v3[3] = {mat2[0][0], mat2[0][1], mat2[0][2]};
+ double v4[3] = {mat2[1][0], mat2[1][1], mat2[1][2]};
norme(v1);
norme(v2);
norme(v3);
norme(v4);
double v12[3], v34[3];
- prodve(v1,v2,v12);
- prodve(v3,v4,v34);
+ prodve(v1, v2, v12);
+ prodve(v3, v4, v34);
norme(v12);
norme(v34);
double const orientation = prosca(v12, v34);
// If the triangle is "flipped" it's no good
- if (orientation < 0)
- return -std::numeric_limits<double>::max();
+ if(orientation < 0) return -std::numeric_limits<double>::max();
- double const c = prosca(v1,v2);
- double x = std::acos(c)-M_PI/3;
- //double angle = (x+M_PI/3)/M_PI*180;
- double quality = (std::atan(a*(x+M_PI/9)) + std::atan(a*(M_PI/9-x)))/den;
+ double const c = prosca(v1, v2);
+ double x = std::acos(c) - M_PI / 3;
+ // double angle = (x+M_PI/3)/M_PI*180;
+ double quality =
+ (std::atan(a * (x + M_PI / 9)) + std::atan(a * (M_PI / 9 - x))) / den;
worst_quality = std::min(worst_quality, quality);
- //minAngle = std::min(angle, minAngle);
- //printf("Angle %g ", angle);
+ // minAngle = std::min(angle, minAngle);
+ // printf("Angle %g ", angle);
// printf("Quality %g\n",quality);
}
- //printf("MinAngle %g \n", minAngle);
- //return minAngle;
+ // printf("MinAngle %g \n", minAngle);
+ // return minAngle;
return worst_quality;
}
-
void qmTriangle::NCJRange(const MTriangle *el, double &valMin, double &valMax)
{
const JacobianBasis *jac = el->getJacobianFuncSpace();
fullMatrix<double> primNodesXYZ(3, 3);
-// SVector3 geoNorm(0.,0.,0.);
-// std::map<MElement*,GEntity*>::const_iterator itEl2ent = element2entity.find(_el[iEl]);
-// GEntity *ge = (itEl2ent == element2entity.end()) ? 0 : itEl2ent->second;
-// const bool hasGeoNorm = ge && (ge->dim() == 2) && ge->haveParametrization();
- for (int i=0; i<jac->getNumPrimMapNodes(); i++) {
+ // SVector3 geoNorm(0.,0.,0.);
+ // std::map<MElement*,GEntity*>::const_iterator itEl2ent =
+ // element2entity.find(_el[iEl]); GEntity *ge = (itEl2ent ==
+ // element2entity.end()) ? 0 : itEl2ent->second; const bool hasGeoNorm = ge
+ // && (ge->dim() == 2) && ge->haveParametrization();
+ for(int i = 0; i < jac->getNumPrimMapNodes(); i++) {
const MVertex *v = el->getVertex(i);
- primNodesXYZ(i,0) = v->x();
- primNodesXYZ(i,1) = v->y();
- primNodesXYZ(i,2) = v->z();
-// if (hasGeoNorm && (_vert[iV]->onWhat() == ge)) {
-// double u, v;
-// _vert[iV]->getParameter(0,u);
-// _vert[iV]->getParameter(1,v);
-// geoNorm += ((GFace*)ge)->normal(SPoint2(u,v));
-// }
+ primNodesXYZ(i, 0) = v->x();
+ primNodesXYZ(i, 1) = v->y();
+ primNodesXYZ(i, 2) = v->z();
+ // if (hasGeoNorm && (_vert[iV]->onWhat() == ge)) {
+ // double u, v;
+ // _vert[iV]->getParameter(0,u);
+ // _vert[iV]->getParameter(1,v);
+ // geoNorm += ((GFace*)ge)->normal(SPoint2(u,v));
+ // }
}
-// if (hasGeoNorm && (geoNorm.normSq() == 0.)) {
-// SPoint2 param = ((GFace*)ge)->parFromPoint(_el[iEl]->barycenter(true),false);
-// geoNorm = ((GFace*)ge)->normal(param);
-// }
+ // if (hasGeoNorm && (geoNorm.normSq() == 0.)) {
+ // SPoint2 param =
+ // ((GFace*)ge)->parFromPoint(_el[iEl]->barycenter(true),false); geoNorm =
+ // ((GFace*)ge)->normal(param);
+ // }
fullMatrix<double> nM(1, 3);
jac->getPrimNormal2D(primNodesXYZ, nM);
SVector3 normal(nM(0, 0), nM(0, 1), nM(0, 2));
@@ -267,7 +303,6 @@ void qmTriangle::NCJRange(const MTriangle *el, double &valMin, double &valMax)
valMax = *std::max_element(ncj.begin(), ncj.end());
}
-
void qmTriangle::NCJ(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
const SVector3 &normal, std::vector<double> &NCJ)
{
@@ -277,30 +312,31 @@ void qmTriangle::NCJ(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
v12n.normalize();
v20n.normalize();
- // Compute NCJ at vertex from unit vectors a and b as 0.5*||a^b||/A_equilateral
- // Factor = 2./sqrt(3.) = 0.5/A_equilateral
+ // Compute NCJ at vertex from unit vectors a and b as
+ // 0.5*||a^b||/A_equilateral Factor = 2./sqrt(3.) = 0.5/A_equilateral
NCJ[0] = 2.0 / std::sqrt(3.0) * dot(crossprod(v01n, -v20n), normal);
NCJ[1] = 2.0 / std::sqrt(3.0) * dot(crossprod(v12n, -v01n), normal);
NCJ[2] = 2.0 / std::sqrt(3.0) * dot(crossprod(v20n, -v12n), normal);
}
-
// Compute NCJ and its gradients at corners
// Gradients packed in vector: (dNCJ0/dx0, dNCJ0/dy0, dNCJ0/dz0,
-// dNCJ0/dx1, ... dNCJ0/dz3, dNCJ1/dx0, ..., dNCJ3/dz3)
-void qmTriangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
- const SVector3 &normal,
- std::vector<double> &NCJ, std::vector<double> &dNCJ)
+// dNCJ0/dx1, ... dNCJ0/dz3, dNCJ1/dx0, ...,
+// dNCJ3/dz3)
+void qmTriangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1,
+ const SPoint3 &p2, const SVector3 &normal,
+ std::vector<double> &NCJ,
+ std::vector<double> &dNCJ)
{
// Factor = 2./sqrt(3.) = 0.5/A_equilateral
- static const double fact = 2./sqrt(3.);
+ static const double fact = 2. / sqrt(3.);
// Compute unit vector, its gradients and opposite grandients for edge (0, 1)
SVector3 v01n, v10n;
std::vector<SVector3> dv01ndp0(3), dv01ndp1(3);
unitVecAndGrad(p0, p1, v01n, dv01ndp0);
v10n = -v01n;
- for (int i=0; i<3; i++) dv01ndp1[i] = -dv01ndp0[i];
+ for(int i = 0; i < 3; i++) dv01ndp1[i] = -dv01ndp0[i];
const std::vector<SVector3> &dv10ndp1 = dv01ndp0, &dv10ndp0 = dv01ndp1;
// Compute unit vector, its gradients and opposite grandients for edge (1, 2)
@@ -308,7 +344,7 @@ void qmTriangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const SPo
std::vector<SVector3> dv12ndp1(3), dv12ndp2(3);
unitVecAndGrad(p1, p2, v12n, dv12ndp1);
v21n = -v12n;
- for (int i=0; i<3; i++) dv12ndp2[i] = -dv12ndp1[i];
+ for(int i = 0; i < 3; i++) dv12ndp2[i] = -dv12ndp1[i];
const std::vector<SVector3> &dv21ndp2 = dv12ndp1, &dv21ndp1 = dv12ndp2;
// Compute unit vector, its gradients and opposite grandients for edge (2, 0)
@@ -316,70 +352,82 @@ void qmTriangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const SPo
std::vector<SVector3> dv20ndp2(3), dv20ndp0(3);
unitVecAndGrad(p2, p0, v20n, dv20ndp2);
v02n = -v20n;
- for (int i=0; i<3; i++) dv20ndp0[i] = -dv20ndp2[i];
+ for(int i = 0; i < 3; i++) dv20ndp0[i] = -dv20ndp2[i];
const std::vector<SVector3> &dv02ndp0 = dv20ndp2, &dv02ndp2 = dv20ndp0;
// Compute NCJ at vertex 0 as 0.5*||u01^u02||/A_triEqui
// and gradients w.r.t. x0, y0, z0, x1, y1, z1, x2, y2, z2
std::vector<double> dNCJ0(9);
- NCJAndGrad2D(v01n, dv01ndp0, dv01ndp1, v02n, dv02ndp0, dv02ndp2, normal, NCJ[0], dNCJ0);
-// dNCJ[0] = dNCJ0[0]; dNCJ[1] = dNCJ0[1]; dNCJ[2] = dNCJ0[2];
-// dNCJ[3] = dNCJ0[3]; dNCJ[4] = dNCJ0[4]; dNCJ[5] = dNCJ0[5];
-// dNCJ[6] = dNCJ0[6]; dNCJ[7] = dNCJ0[7]; dNCJ[8] = dNCJ0[8];
+ NCJAndGrad2D(v01n, dv01ndp0, dv01ndp1, v02n, dv02ndp0, dv02ndp2, normal,
+ NCJ[0], dNCJ0);
+ // dNCJ[0] = dNCJ0[0]; dNCJ[1] = dNCJ0[1]; dNCJ[2] = dNCJ0[2];
+ // dNCJ[3] = dNCJ0[3]; dNCJ[4] = dNCJ0[4]; dNCJ[5] = dNCJ0[5];
+ // dNCJ[6] = dNCJ0[6]; dNCJ[7] = dNCJ0[7]; dNCJ[8] = dNCJ0[8];
scatterNCJGrad<0, 3, 0, 1, 2>(dNCJ0, dNCJ);
// Compute NCJ at vertex 1 as 0.5*||u12^u10||/A_triEqui
// and gradients w.r.t. x1, y1, z1, x2, y2, z2, x0, y0, z0
std::vector<double> dNCJ1(9);
- NCJAndGrad2D(v12n, dv12ndp1, dv12ndp2, v10n, dv10ndp1, dv10ndp0, normal, NCJ[1], dNCJ1);
-// dNCJ[9] = dNCJ1[6]; dNCJ[10] = dNCJ1[7]; dNCJ[11] = dNCJ1[8];
-// dNCJ[10] = dNCJ1[0]; dNCJ[11] = dNCJ1[1]; dNCJ[12] = dNCJ1[2];
-// dNCJ[13] = dNCJ1[3]; dNCJ[14] = dNCJ1[4]; dNCJ[15] = dNCJ1[5];
+ NCJAndGrad2D(v12n, dv12ndp1, dv12ndp2, v10n, dv10ndp1, dv10ndp0, normal,
+ NCJ[1], dNCJ1);
+ // dNCJ[9] = dNCJ1[6]; dNCJ[10] = dNCJ1[7]; dNCJ[11] = dNCJ1[8];
+ // dNCJ[10] = dNCJ1[0]; dNCJ[11] = dNCJ1[1]; dNCJ[12] = dNCJ1[2];
+ // dNCJ[13] = dNCJ1[3]; dNCJ[14] = dNCJ1[4]; dNCJ[15] = dNCJ1[5];
scatterNCJGrad<1, 3, 1, 2, 0>(dNCJ1, dNCJ);
// Compute NCJ at vertex 2 as 0.5*||u20^u21||/A_triEqui
- // Compute NCJ at vertex 2 and gradients w.r.t. x2, y2, z2, x0, y0, z0, x1, y1, z1
+ // Compute NCJ at vertex 2 and gradients w.r.t. x2, y2, z2, x0, y0, z0, x1,
+ // y1, z1
std::vector<double> dNCJ2(9);
- NCJAndGrad2D(v20n, dv20ndp2, dv20ndp0, v21n, dv21ndp2, dv21ndp1, normal, NCJ[2], dNCJ2);
-// dNCJ[16] = dNCJ2[3]; dNCJ[17] = dNCJ2[4]; dNCJ[18] = dNCJ2[5];
-// dNCJ[19] = dNCJ2[6]; dNCJ[20] = dNCJ2[7]; dNCJ[21] = dNCJ2[8];
-// dNCJ[22] = dNCJ2[0]; dNCJ[23] = dNCJ2[1]; dNCJ[24] = dNCJ2[2];
+ NCJAndGrad2D(v20n, dv20ndp2, dv20ndp0, v21n, dv21ndp2, dv21ndp1, normal,
+ NCJ[2], dNCJ2);
+ // dNCJ[16] = dNCJ2[3]; dNCJ[17] = dNCJ2[4]; dNCJ[18] = dNCJ2[5];
+ // dNCJ[19] = dNCJ2[6]; dNCJ[20] = dNCJ2[7]; dNCJ[21] = dNCJ2[8];
+ // dNCJ[22] = dNCJ2[0]; dNCJ[23] = dNCJ2[1]; dNCJ[24] = dNCJ2[2];
scatterNCJGrad<2, 3, 2, 0, 1>(dNCJ2, dNCJ);
- for (int i=0; i<3; i++) NCJ[i] *= fact;
- for (int i=0; i<27; i++) dNCJ[i] *= fact;
-
-// for (int iV=0; iV<3; iV++) {
-// std::cout << "DBGTT: Vertex " << iV << ":\n";
-// std::cout << "DBGTT: -> NCJ = " << NCJ[iV] << "\n";
-// for (unsigned ig=0; ig<3; ig++) {
-// int ind = iV*9+ig*3;
-// std::cout << "DBGTT: -> dNCJ/dp" << ig << " = (" << dNCJ[ind] << ", " << dNCJ[ind+1] << ", " << dNCJ[ind+2] << ")\n";
-//// int ind2 = ig*3;
-//// std::vector<double> dNCJLoc = (iV == 0) ? dNCJ0 : (iV == 1) ? dNCJ1 : dNCJ2;
-//// std::cout << "DBGTT: -> dNCJ/dp" << ig << " (local) = (" << dNCJLoc[ind2] << ", " << dNCJLoc[ind2+1] << ", " << dNCJLoc[ind2+2] << ")\n";
-// }
-// }
+ for(int i = 0; i < 3; i++) NCJ[i] *= fact;
+ for(int i = 0; i < 27; i++) dNCJ[i] *= fact;
+
+ // for (int iV=0; iV<3; iV++) {
+ // std::cout << "DBGTT: Vertex " << iV << ":\n";
+ // std::cout << "DBGTT: -> NCJ = " << NCJ[iV] << "\n";
+ // for (unsigned ig=0; ig<3; ig++) {
+ // int ind = iV*9+ig*3;
+ // std::cout << "DBGTT: -> dNCJ/dp" << ig << " = (" << dNCJ[ind] <<
+ // ", " << dNCJ[ind+1] << ", " << dNCJ[ind+2] << ")\n";
+ //// int ind2 = ig*3;
+ //// std::vector<double> dNCJLoc = (iV == 0) ? dNCJ0 : (iV == 1) ? dNCJ1
+ ///: dNCJ2; / std::cout << "DBGTT: -> dNCJ/dp" << ig << " (local) =
+ ///(" << dNCJLoc[ind2] << ", " << dNCJLoc[ind2+1] << ", " << dNCJLoc[ind2+2]
+ ///<< ")\n";
+ // }
+ // }
}
+double qmQuadrangle::eta(MQuadrangle *el)
+{
+ double AR = 1; // pow(el->minEdge()/el->maxEdge(),.25);
-double qmQuadrangle::eta(MQuadrangle *el) {
- double AR = 1;//pow(el->minEdge()/el->maxEdge(),.25);
-
- MVertex *_v[4] = {el->getVertex(0), el->getVertex(1), el->getVertex(2), el->getVertex(3)};
+ MVertex *_v[4] = {el->getVertex(0), el->getVertex(1), el->getVertex(2),
+ el->getVertex(3)};
- SVector3 v01 (_v[1]->x()-_v[0]->x(),_v[1]->y()-_v[0]->y(),_v[1]->z()-_v[0]->z());
- SVector3 v12 (_v[2]->x()-_v[1]->x(),_v[2]->y()-_v[1]->y(),_v[2]->z()-_v[1]->z());
- SVector3 v23 (_v[3]->x()-_v[2]->x(),_v[3]->y()-_v[2]->y(),_v[3]->z()-_v[2]->z());
- SVector3 v30 (_v[0]->x()-_v[3]->x(),_v[0]->y()-_v[3]->y(),_v[0]->z()-_v[3]->z());
+ SVector3 v01(_v[1]->x() - _v[0]->x(), _v[1]->y() - _v[0]->y(),
+ _v[1]->z() - _v[0]->z());
+ SVector3 v12(_v[2]->x() - _v[1]->x(), _v[2]->y() - _v[1]->y(),
+ _v[2]->z() - _v[1]->z());
+ SVector3 v23(_v[3]->x() - _v[2]->x(), _v[3]->y() - _v[2]->y(),
+ _v[3]->z() - _v[2]->z());
+ SVector3 v30(_v[0]->x() - _v[3]->x(), _v[0]->y() - _v[3]->y(),
+ _v[0]->z() - _v[3]->z());
- SVector3 a = crossprod(v01,v12);
- SVector3 b = crossprod(v12,v23);
- SVector3 c = crossprod(v23,v30);
- SVector3 d = crossprod(v30,v01);
+ SVector3 a = crossprod(v01, v12);
+ SVector3 b = crossprod(v12, v23);
+ SVector3 c = crossprod(v23, v30);
+ SVector3 d = crossprod(v30, v01);
double sign = 1.0;
- if (dot(a,b) < 0 || dot(a,c) < 0 || dot(a,d) < 0 )sign = -1;
+ if(dot(a, b) < 0 || dot(a, c) < 0 || dot(a, d) < 0) sign = -1;
// FIXME ...
// if (a.z() > 0 || b.z() > 0 || c.z() > 0 || d.z() > 0) sign = -1;
@@ -388,59 +436,57 @@ double qmQuadrangle::eta(MQuadrangle *el) {
double a3 = 180 * angle3Vertices(_v[2], _v[3], _v[0]) / M_PI;
double a4 = 180 * angle3Vertices(_v[3], _v[0], _v[1]) / M_PI;
- a1 = std::min(180.,a1);
- a2 = std::min(180.,a2);
- a3 = std::min(180.,a3);
- a4 = std::min(180.,a4);
+ a1 = std::min(180., a1);
+ a2 = std::min(180., a2);
+ a3 = std::min(180., a3);
+ a4 = std::min(180., a4);
double angle = fabs(90. - a1);
- angle = std::max(fabs(90. - a2),angle);
- angle = std::max(fabs(90. - a3),angle);
- angle = std::max(fabs(90. - a4),angle);
+ angle = std::max(fabs(90. - a2), angle);
+ angle = std::max(fabs(90. - a3), angle);
+ angle = std::max(fabs(90. - a4), angle);
- return sign*(1.-angle/90) * AR;
+ return sign * (1. - angle / 90) * AR;
}
-
double qmQuadrangle::angles(MQuadrangle *e)
{
double a = 100;
double worst_quality = std::numeric_limits<double>::max();
double mat[3][3];
double mat2[3][3];
- double den = atan(a*(M_PI/4)) + atan(a*(2*M_PI/4 - (M_PI/4)));
+ double den = atan(a * (M_PI / 4)) + atan(a * (2 * M_PI / 4 - (M_PI / 4)));
// This matrix is used to "rotate" the triangle to get each vertex
// as the "origin" of the mapping in turn
- //double rot[3][3];
- //rot[0][0]=-1; rot[0][1]=1; rot[0][2]=0;
- //rot[1][0]=-1; rot[1][1]=0; rot[1][2]=0;
- //rot[2][0]= 0; rot[2][1]=0; rot[2][2]=1;
- //double tmp[3][3];
+ // double rot[3][3];
+ // rot[0][0]=-1; rot[0][1]=1; rot[0][2]=0;
+ // rot[1][0]=-1; rot[1][1]=0; rot[1][2]=0;
+ // rot[2][0]= 0; rot[2][1]=0; rot[2][2]=1;
+ // double tmp[3][3];
- const double u[9] = {-1,-1, 1, 1, 0,0,1,-1,0};
- const double v[9] = {-1, 1, 1,-1, -1,1,0,0,0};
-
- for (int i = 0; i < 9; i++) {
+ const double u[9] = {-1, -1, 1, 1, 0, 0, 1, -1, 0};
+ const double v[9] = {-1, 1, 1, -1, -1, 1, 0, 0, 0};
+ for(int i = 0; i < 9; i++) {
e->getJacobian(u[i], v[i], 0, mat);
- e->getPrimaryJacobian(u[i],v[i],0,mat2);
- //for (int j = 0; j < i; j++) {
+ e->getPrimaryJacobian(u[i], v[i], 0, mat2);
+ // for (int j = 0; j < i; j++) {
// matmat(rot,mat,tmp);
// memcpy(mat, tmp, sizeof(mat));
//}
- //get angle
- double v1[3] = {mat[0][0], mat[0][1], mat[0][2] };
- double v2[3] = {mat[1][0], mat[1][1], mat[1][2] };
- double v3[3] = {mat2[0][0], mat2[0][1], mat2[0][2] };
- double v4[3] = {mat2[1][0], mat2[1][1], mat2[1][2] };
+ // get angle
+ double v1[3] = {mat[0][0], mat[0][1], mat[0][2]};
+ double v2[3] = {mat[1][0], mat[1][1], mat[1][2]};
+ double v3[3] = {mat2[0][0], mat2[0][1], mat2[0][2]};
+ double v4[3] = {mat2[1][0], mat2[1][1], mat2[1][2]};
norme(v1);
norme(v2);
norme(v3);
norme(v4);
double v12[3], v34[3];
- prodve(v1,v2,v12);
- prodve(v3,v4,v34);
+ prodve(v1, v2, v12);
+ prodve(v3, v4, v34);
norme(v12);
norme(v34);
@@ -450,54 +496,57 @@ double qmQuadrangle::angles(MQuadrangle *e)
// return -std::numeric_limits<double>::max();
double const c = prosca(v1, v2);
- double const x = std::abs(std::acos(c))-M_PI/2;
- //double angle = std::fabs(std::acos(c))*180/M_PI;
- double const quality = (std::atan(a*(x+M_PI/4)) + std::atan(a*(2*M_PI/4 - (x+M_PI/4))))/den;
+ double const x = std::abs(std::acos(c)) - M_PI / 2;
+ // double angle = std::fabs(std::acos(c))*180/M_PI;
+ double const quality = (std::atan(a * (x + M_PI / 4)) +
+ std::atan(a * (2 * M_PI / 4 - (x + M_PI / 4)))) /
+ den;
worst_quality = std::min(worst_quality, quality);
}
return worst_quality;
}
-
-void qmQuadrangle::NCJRange(const MQuadrangle *el, double &valMin, double &valMax)
+void qmQuadrangle::NCJRange(const MQuadrangle *el, double &valMin,
+ double &valMax)
{
const JacobianBasis *jac = el->getJacobianFuncSpace();
fullMatrix<double> primNodesXYZ(4, 3);
-// SVector3 geoNorm(0.,0.,0.);
-// std::map<MElement*,GEntity*>::const_iterator itEl2ent = element2entity.find(_el[iEl]);
-// GEntity *ge = (itEl2ent == element2entity.end()) ? 0 : itEl2ent->second;
-// const bool hasGeoNorm = ge && (ge->dim() == 2) && ge->haveParametrization();
- for (int i=0; i<jac->getNumPrimMapNodes(); i++) {
+ // SVector3 geoNorm(0.,0.,0.);
+ // std::map<MElement*,GEntity*>::const_iterator itEl2ent =
+ // element2entity.find(_el[iEl]); GEntity *ge = (itEl2ent ==
+ // element2entity.end()) ? 0 : itEl2ent->second; const bool hasGeoNorm = ge
+ // && (ge->dim() == 2) && ge->haveParametrization();
+ for(int i = 0; i < jac->getNumPrimMapNodes(); i++) {
const MVertex *v = el->getVertex(i);
- primNodesXYZ(i,0) = v->x();
- primNodesXYZ(i,1) = v->y();
- primNodesXYZ(i,2) = v->z();
-// if (hasGeoNorm && (_vert[iV]->onWhat() == ge)) {
-// double u, v;
-// _vert[iV]->getParameter(0,u);
-// _vert[iV]->getParameter(1,v);
-// geoNorm += ((GFace*)ge)->normal(SPoint2(u,v));
-// }
+ primNodesXYZ(i, 0) = v->x();
+ primNodesXYZ(i, 1) = v->y();
+ primNodesXYZ(i, 2) = v->z();
+ // if (hasGeoNorm && (_vert[iV]->onWhat() == ge)) {
+ // double u, v;
+ // _vert[iV]->getParameter(0,u);
+ // _vert[iV]->getParameter(1,v);
+ // geoNorm += ((GFace*)ge)->normal(SPoint2(u,v));
+ // }
}
-// if (hasGeoNorm && (geoNorm.normSq() == 0.)) {
-// SPoint2 param = ((GFace*)ge)->parFromPoint(_el[iEl]->barycenter(true),false);
-// geoNorm = ((GFace*)ge)->normal(param);
-// }
+ // if (hasGeoNorm && (geoNorm.normSq() == 0.)) {
+ // SPoint2 param =
+ // ((GFace*)ge)->parFromPoint(_el[iEl]->barycenter(true),false); geoNorm =
+ // ((GFace*)ge)->normal(param);
+ // }
fullMatrix<double> nM(1, 3);
jac->getPrimNormal2D(primNodesXYZ, nM);
SVector3 normal(nM(0, 0), nM(0, 1), nM(0, 2));
std::vector<double> ncj(4);
NCJ(el->getVertex(0)->point(), el->getVertex(1)->point(),
- el->getVertex(2)->point(), el->getVertex(3)->point(),
- normal, ncj);
+ el->getVertex(2)->point(), el->getVertex(3)->point(), normal, ncj);
valMin = *std::min_element(ncj.begin(), ncj.end());
valMax = *std::max_element(ncj.begin(), ncj.end());
}
-
void qmQuadrangle::NCJ(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
- const SPoint3 &p3, const SVector3 &normal, std::vector<double> &ncj)
+ const SPoint3 &p3, const SVector3 &normal,
+ std::vector<double> &ncj)
{
// Compute unit vectors for each edge
SVector3 v01n(p0, p1), v12n(p1, p2), v23n(p2, p3), v30n(p3, p0);
@@ -506,24 +555,26 @@ void qmQuadrangle::NCJ(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
v23n.normalize();
v30n.normalize();
- // Compute NCJ at vertex from unit vectors a and b as 0.5*||a^b||/A_equilateral
+ // Compute NCJ at vertex from unit vectors a and b as
+ // 0.5*||a^b||/A_equilateral
ncj[0] = dot(crossprod(v01n, -v30n), normal);
ncj[1] = dot(crossprod(v12n, -v01n), normal);
ncj[2] = dot(crossprod(v23n, -v12n), normal);
ncj[3] = dot(crossprod(v30n, -v23n), normal);
}
-
-void qmQuadrangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
- const SPoint3 &p3, const SVector3 &normal,
- std::vector<double> &NCJ, std::vector<double> &dNCJ)
+void qmQuadrangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1,
+ const SPoint3 &p2, const SPoint3 &p3,
+ const SVector3 &normal,
+ std::vector<double> &NCJ,
+ std::vector<double> &dNCJ)
{
// Compute unit vector, its gradients and opposite gradients for edge (0,1)
SVector3 v01n, v10n;
std::vector<SVector3> dv01ndp0(3), dv01ndp1(3);
unitVecAndGrad(p0, p1, v01n, dv01ndp0);
v10n = -v01n;
- for (int i=0; i<3; i++) dv01ndp1[i] = -dv01ndp0[i];
+ for(int i = 0; i < 3; i++) dv01ndp1[i] = -dv01ndp0[i];
const std::vector<SVector3> &dv10ndp1 = dv01ndp0, &dv10ndp0 = dv01ndp1;
// Compute unit vector, its gradients and opposite gradients for edge (1,2)
@@ -531,7 +582,7 @@ void qmQuadrangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const S
std::vector<SVector3> dv12ndp1(3), dv12ndp2(3);
unitVecAndGrad(p1, p2, v12n, dv12ndp1);
v21n = -v12n;
- for (int i=0; i<3; i++) dv12ndp2[i] = -dv12ndp1[i];
+ for(int i = 0; i < 3; i++) dv12ndp2[i] = -dv12ndp1[i];
const std::vector<SVector3> &dv21ndp2 = dv12ndp1, &dv21ndp1 = dv12ndp2;
// Compute unit vector, its gradients and opposite gradients for edge (2,3)
@@ -539,7 +590,7 @@ void qmQuadrangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const S
std::vector<SVector3> dv23ndp2(3), dv23ndp3(3);
unitVecAndGrad(p2, p3, v23n, dv23ndp2);
v32n = -v23n;
- for (int i=0; i<3; i++) dv23ndp3[i] = -dv23ndp2[i];
+ for(int i = 0; i < 3; i++) dv23ndp3[i] = -dv23ndp2[i];
const std::vector<SVector3> &dv32ndp3 = dv23ndp2, &dv32ndp2 = dv23ndp3;
// Compute unit vector, its gradients and opposite gradients for edge (3,0)
@@ -547,83 +598,85 @@ void qmQuadrangle::NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const S
std::vector<SVector3> dv30ndp3(3), dv30ndp0(3);
unitVecAndGrad(p3, p0, v30n, dv30ndp3);
v03n = -v30n;
- for (int i=0; i<3; i++) dv30ndp0[i] = -dv30ndp3[i];
+ for(int i = 0; i < 3; i++) dv30ndp0[i] = -dv30ndp3[i];
const std::vector<SVector3> &dv03ndp0 = dv30ndp3, &dv03ndp3 = dv30ndp0;
// Compute NCJ at vertex 0 as 0.5*||u01^u03||/A_triRect
// and gradients w.r.t. x0, y0, z0, x1, y1, z1, x3, y3, z3
std::vector<double> dNCJ0(9);
- NCJAndGrad2D( v01n, dv01ndp0, dv01ndp1, v03n, dv03ndp0, dv03ndp3, normal, NCJ[0], dNCJ0);
+ NCJAndGrad2D(v01n, dv01ndp0, dv01ndp1, v03n, dv03ndp0, dv03ndp3, normal,
+ NCJ[0], dNCJ0);
scatterNCJGrad<0, 4, 0, 1, 3>(dNCJ0, dNCJ);
// Compute NCJ at vertex 1 as 0.5*||u12^u10||/A_triRect
// and gradients w.r.t. x1, y1, z1, x2, y2, z2, x0, y0, z0
std::vector<double> dNCJ1(9);
- NCJAndGrad2D( v12n, dv12ndp1, dv12ndp2, v10n, dv10ndp1, dv10ndp0, normal, NCJ[1], dNCJ1);
+ NCJAndGrad2D(v12n, dv12ndp1, dv12ndp2, v10n, dv10ndp1, dv10ndp0, normal,
+ NCJ[1], dNCJ1);
scatterNCJGrad<1, 4, 1, 2, 0>(dNCJ1, dNCJ);
// Compute NCJ at vertex 2 as 0.5*||u23^u21||/A_triRect
// and gradients w.r.t. x2, y2, z2, x3, y3, z3, x1, y1, z1
std::vector<double> dNCJ2(9);
- NCJAndGrad2D( v23n, dv23ndp2, dv23ndp3, v21n, dv21ndp2, dv21ndp1, normal, NCJ[2], dNCJ2);
+ NCJAndGrad2D(v23n, dv23ndp2, dv23ndp3, v21n, dv21ndp2, dv21ndp1, normal,
+ NCJ[2], dNCJ2);
scatterNCJGrad<2, 4, 2, 3, 1>(dNCJ2, dNCJ);
// Compute NCJ at vertex 3 as 0.5*||u30^u32||/A_triRect
// and gradients w.r.t. x3, y3, z3, x0, y0, z0, x2, y2, z2
std::vector<double> dNCJ3(9);
- NCJAndGrad2D(v30n, dv30ndp3, dv30ndp0, v32n, dv32ndp3, dv32ndp2, normal, NCJ[3], dNCJ3);
+ NCJAndGrad2D(v30n, dv30ndp3, dv30ndp0, v32n, dv32ndp3, dv32ndp2, normal,
+ NCJ[3], dNCJ3);
scatterNCJGrad<3, 4, 3, 0, 2>(dNCJ3, dNCJ);
-// for (int iV=0; iV<4; iV++) {
-// std::cout << "DBGTT: Vertex " << iV << ":\n";
-// std::cout << "DBGTT: -> NCJ = " << NCJ[iV] << "\n";
-// for (unsigned ig=0; ig<4; ig++) {
-// int ind = iV*12+ig*3;
-// std::cout << "DBGTT: -> dNCJ/dp" << ig << " = (" << dNCJ[ind] << ", " << dNCJ[ind+1] << ", " << dNCJ[ind+2] << ")\n";
-//// int ind2 = ig*3;
-//// std::vector<double> dNCJLoc = (iV == 0) ? dNCJ0 : (iV == 1) ? dNCJ1 : dNCJ2;
-//// std::cout << "DBGTT: -> dNCJ/dp" << ig << " (local) = (" << dNCJLoc[ind2] << ", " << dNCJLoc[ind2+1] << ", " << dNCJLoc[ind2+2] << ")\n";
-// }
-// }
+ // for (int iV=0; iV<4; iV++) {
+ // std::cout << "DBGTT: Vertex " << iV << ":\n";
+ // std::cout << "DBGTT: -> NCJ = " << NCJ[iV] << "\n";
+ // for (unsigned ig=0; ig<4; ig++) {
+ // int ind = iV*12+ig*3;
+ // std::cout << "DBGTT: -> dNCJ/dp" << ig << " = (" << dNCJ[ind] <<
+ // ", " << dNCJ[ind+1] << ", " << dNCJ[ind+2] << ")\n";
+ //// int ind2 = ig*3;
+ //// std::vector<double> dNCJLoc = (iV == 0) ? dNCJ0 : (iV == 1) ? dNCJ1
+ ///: dNCJ2; / std::cout << "DBGTT: -> dNCJ/dp" << ig << " (local) =
+ ///(" << dNCJLoc[ind2] << ", " << dNCJLoc[ind2+1] << ", " << dNCJLoc[ind2+2]
+ ///<< ")\n";
+ // }
+ // }
}
-
double qmTetrahedron::qm(MTetrahedron *t, const Measures &cr, double *volume)
{
- return qm(t->getVertex(0), t->getVertex(1), t->getVertex(2), t->getVertex(3), cr, volume);
+ return qm(t->getVertex(0), t->getVertex(1), t->getVertex(2), t->getVertex(3),
+ cr, volume);
}
-
-double qmTetrahedron::qm(const MVertex *v1, const MVertex *v2, const MVertex *v3,
- const MVertex *v4, const Measures &cr, double *volume)
+double qmTetrahedron::qm(const MVertex *v1, const MVertex *v2,
+ const MVertex *v3, const MVertex *v4,
+ const Measures &cr, double *volume)
{
- return qm(v1->x(), v1->y(), v1->z(), v2->x(), v2->y(), v2->z(),
- v3->x(), v3->y(), v3->z(), v4->x(), v4->y(), v4->z(), cr, volume);
+ return qm(v1->x(), v1->y(), v1->z(), v2->x(), v2->y(), v2->z(), v3->x(),
+ v3->y(), v3->z(), v4->x(), v4->y(), v4->z(), cr, volume);
}
-
double qmTetrahedron::qm(const double &x1, const double &y1, const double &z1,
const double &x2, const double &y2, const double &z2,
const double &x3, const double &y3, const double &z3,
const double &x4, const double &y4, const double &z4,
const Measures &cr, double *volume)
{
- switch(cr){
- case QMTET_ONE:
- return 1.0;
+ switch(cr) {
+ case QMTET_ONE: return 1.0;
case QMTET_ETA:
- return eta(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4, volume);
+ return eta(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4, volume);
case QMTET_GAMMA:
- return gamma(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4, volume);
+ return gamma(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4, volume);
case QMTET_COND:
return cond(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4, volume);
- default:
- Msg::Error("Unknown quality measure");
- return 0.;
+ default: Msg::Error("Unknown quality measure"); return 0.;
}
}
-
double qmTetrahedron::eta(const double &x1, const double &y1, const double &z1,
const double &x2, const double &y2, const double &z2,
const double &x3, const double &y3, const double &z3,
@@ -635,11 +688,10 @@ double qmTetrahedron::eta(const double &x1, const double &y1, const double &z1,
double p2[3] = {x3, y3, z3};
double p3[3] = {x4, y4, z4};
- *volume =fabs (robustPredicates::orient3d (p0,p1,p2,p3)) / 6.0;
+ *volume = fabs(robustPredicates::orient3d(p0, p1, p2, p3)) / 6.0;
- double l = ((x2 - x1) * (x2 - x1) +
- (y2 - y1) * (y2 - y1) +
- (z2 - z1) * (z2 - z1));
+ double l =
+ ((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) + (z2 - z1) * (z2 - z1));
l += ((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1) + (z3 - z1) * (z3 - z1));
l += ((x4 - x1) * (x4 - x1) + (y4 - y1) * (y4 - y1) + (z4 - z1) * (z4 - z1));
l += ((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2) + (z3 - z2) * (z3 - z2));
@@ -648,19 +700,19 @@ double qmTetrahedron::eta(const double &x1, const double &y1, const double &z1,
return 12. * pow(3 * fabs(*volume), 2. / 3.) / l;
}
-
-double qmTetrahedron::gamma(const double &x1, const double &y1, const double &z1,
- const double &x2, const double &y2, const double &z2,
- const double &x3, const double &y3, const double &z3,
- const double &x4, const double &y4, const double &z4,
- double *volume)
+double qmTetrahedron::gamma(const double &x1, const double &y1,
+ const double &z1, const double &x2,
+ const double &y2, const double &z2,
+ const double &x3, const double &y3,
+ const double &z3, const double &x4,
+ const double &y4, const double &z4, double *volume)
{
double p0[3] = {x1, y1, z1};
double p1[3] = {x2, y2, z2};
double p2[3] = {x3, y3, z3};
double p3[3] = {x4, y4, z4};
- *volume =fabs (robustPredicates::orient3d (p0,p1,p2,p3)) / 6.0;
+ *volume = fabs(robustPredicates::orient3d(p0, p1, p2, p3)) / 6.0;
// double mat[3][3];
// mat[0][0] = x2 - x1;
@@ -681,23 +733,21 @@ double qmTetrahedron::gamma(const double &x1, const double &y1, const double &z1
double s3 = fabs(triangle_area(p0, p1, p3));
double s4 = fabs(triangle_area(p1, p2, p3));
double rhoin = 3. * fabs(*volume) / (s1 + s2 + s3 + s4);
- double l = (x2 - x1) * (x2 - x1) +
- (y2 - y1) * (y2 - y1) +
- (z2 - z1) * (z2 - z1);
- l = std::max(l, ((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1) +
- (z3 - z1) * (z3 - z1)));
- l = std::max(l, ((x4 - x1) * (x4 - x1) + (y4 - y1) * (y4 - y1) +
- (z4 - z1) * (z4 - z1)));
- l = std::max(l, ((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2) +
- (z3 - z2) * (z3 - z2)));
- l = std::max(l, ((x4 - x2) * (x4 - x2) + (y4 - y2) * (y4 - y2) +
- (z4 - z2) * (z4 - z2)));
- l = std::max(l, ((x3 - x4) * (x3 - x4) + (y3 - y4) * (y3 - y4) +
- (z3 - z4) * (z3 - z4)));
- return sqrt(24./l) * rhoin ;
+ double l =
+ (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) + (z2 - z1) * (z2 - z1);
+ l = std::max(
+ l, ((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1) + (z3 - z1) * (z3 - z1)));
+ l = std::max(
+ l, ((x4 - x1) * (x4 - x1) + (y4 - y1) * (y4 - y1) + (z4 - z1) * (z4 - z1)));
+ l = std::max(
+ l, ((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2) + (z3 - z2) * (z3 - z2)));
+ l = std::max(
+ l, ((x4 - x2) * (x4 - x2) + (y4 - y2) * (y4 - y2) + (z4 - z2) * (z4 - z2)));
+ l = std::max(
+ l, ((x3 - x4) * (x3 - x4) + (y3 - y4) * (y3 - y4) + (z3 - z4) * (z3 - z4)));
+ return sqrt(24. / l) * rhoin;
}
-
double qmTetrahedron::cond(const double &x1, const double &y1, const double &z1,
const double &x2, const double &y2, const double &z2,
const double &x3, const double &y3, const double &z3,
@@ -705,51 +755,55 @@ double qmTetrahedron::cond(const double &x1, const double &y1, const double &z1,
double *volume)
{
/// condition number is defined as (see Knupp & Freitag in IJNME)
- double INVW[3][3] = {{1,-1./sqrt(3.),-1./sqrt(6.)},{0,2/sqrt(3.),-1./sqrt(6.)},{0,0,sqrt(1.5)}};
- double A[3][3] = {{x2-x1,y2-y1,z2-z1},{x3-x1,y3-y1,z3-z1},{x4-x1,y4-y1,z4-z1}};
- double S[3][3],INVS[3][3];
- matmat(A,INVW,S);
- *volume = inv3x3(S,INVS) * 0.70710678118654762;//2/sqrt(2);
- double normS = norm2 (S);
- double normINVS = norm2 (INVS);
+ double INVW[3][3] = {{1, -1. / sqrt(3.), -1. / sqrt(6.)},
+ {0, 2 / sqrt(3.), -1. / sqrt(6.)},
+ {0, 0, sqrt(1.5)}};
+ double A[3][3] = {{x2 - x1, y2 - y1, z2 - z1},
+ {x3 - x1, y3 - y1, z3 - z1},
+ {x4 - x1, y4 - y1, z4 - z1}};
+ double S[3][3], INVS[3][3];
+ matmat(A, INVW, S);
+ *volume = inv3x3(S, INVS) * 0.70710678118654762; // 2/sqrt(2);
+ double normS = norm2(S);
+ double normINVS = norm2(INVS);
return normS * normINVS;
}
-
// TODO: Replace this
-static double prismNCJ(const MVertex* a, const MVertex* b, const MVertex* c, const MVertex* d)
+static double prismNCJ(const MVertex *a, const MVertex *b, const MVertex *c,
+ const MVertex *d)
{
- static const double fact = 2./sqrt(3.);
+ static const double fact = 2. / sqrt(3.);
- const SVector3 vec1 = SVector3(b->x()-a->x(),b->y()-a->y(),b->z()-a->z());
- const SVector3 vec2 = SVector3(c->x()-a->x(),c->y()-a->y(),c->z()-a->z());
- const SVector3 vec3 = SVector3(d->x()-a->x(),d->y()-a->y(),d->z()-a->z());
+ const SVector3 vec1 =
+ SVector3(b->x() - a->x(), b->y() - a->y(), b->z() - a->z());
+ const SVector3 vec2 =
+ SVector3(c->x() - a->x(), c->y() - a->y(), c->z() - a->z());
+ const SVector3 vec3 =
+ SVector3(d->x() - a->x(), d->y() - a->y(), d->z() - a->z());
const double l1 = vec1.norm();
const double l2 = vec2.norm();
const double l3 = vec3.norm();
- const double val = dot(vec1,crossprod(vec2,vec3));
- return fact*fabs(val)/(l1*l2*l3);
+ const double val = dot(vec1, crossprod(vec2, vec3));
+ return fact * fabs(val) / (l1 * l2 * l3);
}
-
-double qmPrism::minNCJ(const MPrism *el) {
- const MVertex *a = el->getVertex(0),*b= el->getVertex(1), *c= el->getVertex(2);
- const MVertex *d = el->getVertex(3),*e= el->getVertex(4), *f= el->getVertex(5);
- const double j[6] = {
- prismNCJ(a,b,c,d),
- prismNCJ(b,a,c,e),
- prismNCJ(c,a,b,f),
- prismNCJ(d,a,e,f),
- prismNCJ(e,b,d,f),
- prismNCJ(f,c,d,e)};
- const double result = *std::min_element(j,j+6);
+double qmPrism::minNCJ(const MPrism *el)
+{
+ const MVertex *a = el->getVertex(0), *b = el->getVertex(1),
+ *c = el->getVertex(2);
+ const MVertex *d = el->getVertex(3), *e = el->getVertex(4),
+ *f = el->getVertex(5);
+ const double j[6] = {prismNCJ(a, b, c, d), prismNCJ(b, a, c, e),
+ prismNCJ(c, a, b, f), prismNCJ(d, a, e, f),
+ prismNCJ(e, b, d, f), prismNCJ(f, c, d, e)};
+ const double result = *std::min_element(j, j + 6);
return result;
}
-
-//void qmPrism::NCJ(const double &x0, const double &y0, const double &z0,
+// void qmPrism::NCJ(const double &x0, const double &y0, const double &z0,
// const double &x1, const double &y1, const double &z1,
// const double &x2, const double &y2, const double &z2,
// const double &x3, const double &y3, const double &z3,
@@ -757,13 +811,13 @@ double qmPrism::minNCJ(const MPrism *el) {
// fullVector<double> &ncj)
//{
// // Compute unit vectors for each edge
-// double x01n, y01n, z01n, x12n, y12n, z12n, x23n, y23n, z23n, x30n, y30n, z30n;
-// unitVec(x0, y0, z0, x1, y1, z1, x01n, y01n, z01n);
-// unitVec(x1, y1, z1, x2, y2, z2, x12n, y12n, z12n);
-// unitVec(x2, y2, z2, x3, y3, z3, x23n, y23n, z23n);
-// unitVec(x3, y3, z3, x0, y0, z0, x30n, y30n, z30n);
+// double x01n, y01n, z01n, x12n, y12n, z12n, x23n, y23n, z23n, x30n, y30n,
+// z30n; unitVec(x0, y0, z0, x1, y1, z1, x01n, y01n, z01n); unitVec(x1, y1, z1,
+// x2, y2, z2, x12n, y12n, z12n); unitVec(x2, y2, z2, x3, y3, z3, x23n, y23n,
+// z23n); unitVec(x3, y3, z3, x0, y0, z0, x30n, y30n, z30n);
//
-// // Compute NCJ at vertex from unit vectors a and b as 0.5*||a^b||/A_equilateral
+// // Compute NCJ at vertex from unit vectors a and b as
+// 0.5*||a^b||/A_equilateral
// // Factor = 2./sqrt(3.) = 0.5/A_equilateral
// static const double fact = 1.1547005383792517;
// ncj(0) = triArea(fact, x01n, y01n, z01n, -x20n, -y20n, -z20n);
@@ -771,15 +825,14 @@ double qmPrism::minNCJ(const MPrism *el) {
// ncj(2) = triArea(fact, x20n, y20n, z20n, -x12n, -y12n, -z12n);
//}
-
// TODO: Remove this (useless as quality measure)
double qmHexahedron::angles(MHexahedron *el)
{
double angleMax = 0.0;
double angleMin = M_PI;
double zeta = 0.0;
- for (int i=0; i<el->getNumFaces(); i++){
- std::vector<MVertex*> vv;
+ for(int i = 0; i < el->getNumFaces(); i++) {
+ std::vector<MVertex *> vv;
vv.push_back(el->getFace(i).getVertex(0));
vv.push_back(el->getFace(i).getVertex(1));
vv.push_back(el->getFace(i).getVertex(2));
@@ -788,15 +841,20 @@ double qmHexahedron::angles(MHexahedron *el)
// MVertex *v1 = new MVertex(1., 0, 0);vv.push_back(v1);
// MVertex *v2 = new MVertex(2., 1., 0);vv.push_back(v2);
// MVertex *v3 = new MVertex(1, 1., 0);vv.push_back(v3);
- for (int j=0; j<4; j++){
- SVector3 a(vv[(j+2)%4]->x()-vv[(j+1)%4]->x(),vv[(j+2)%4]->y()-vv[(j+1)%4]->y(),vv[(j+2)%4]->z()-vv[(j+1)%4]->z() );
- SVector3 b(vv[(j+1)%4]->x()-vv[(j)%4]->x(), vv[(j+1)%4]->y()-vv[(j)%4]->y(), vv[(j+1)%4]->z()-vv[(j)%4]->z() );
- double angle = acos( dot(a,b)/(norm(a)*norm(b))); //*180/M_PI;
+ for(int j = 0; j < 4; j++) {
+ SVector3 a(vv[(j + 2) % 4]->x() - vv[(j + 1) % 4]->x(),
+ vv[(j + 2) % 4]->y() - vv[(j + 1) % 4]->y(),
+ vv[(j + 2) % 4]->z() - vv[(j + 1) % 4]->z());
+ SVector3 b(vv[(j + 1) % 4]->x() - vv[(j) % 4]->x(),
+ vv[(j + 1) % 4]->y() - vv[(j) % 4]->y(),
+ vv[(j + 1) % 4]->z() - vv[(j) % 4]->z());
+ double angle = acos(dot(a, b) / (norm(a) * norm(b))); //*180/M_PI;
angleMax = std::max(angleMax, angle);
angleMin = std::min(angleMin, angle);
}
- //printf("angle max =%g min =%g \n", angleMax*180/M_PI, angleMin*180/M_PI);
+ // printf("angle max =%g min =%g \n", angleMax*180/M_PI, angleMin*180/M_PI);
}
- zeta = 1.-std::max((angleMax-0.5*M_PI)/(0.5*M_PI),(0.5*M_PI-angleMin)/(0.5*M_PI));
+ zeta = 1. - std::max((angleMax - 0.5 * M_PI) / (0.5 * M_PI),
+ (0.5 * M_PI - angleMin) / (0.5 * M_PI));
return zeta;
}
diff --git a/Mesh/qualityMeasures.h b/Mesh/qualityMeasures.h
index 5803d72d0331323aa61aa6018502324a2fb348c2..e7da90254d30eb31f41c2a4c2489e856c696f426 100644
--- a/Mesh/qualityMeasures.h
+++ b/Mesh/qualityMeasures.h
@@ -22,13 +22,12 @@ class MPrism;
class MHexahedron;
class MElement;
-
-class qmTriangle
-{
+class qmTriangle {
public:
static double gamma(MTriangle *f);
static double gamma(BDS_Face *f);
- static double gamma(const BDS_Point *p1, const BDS_Point *p2, const BDS_Point *p3);
+ static double gamma(const BDS_Point *p1, const BDS_Point *p2,
+ const BDS_Point *p3);
static double gamma(const MVertex *v1, const MVertex *v2, const MVertex *v3);
static double gamma(const double *d1, const double *d2, const double *d3);
static double gamma(const double &x1, const double &y1, const double &z1,
@@ -41,14 +40,13 @@ public:
static inline int numNCJVal() { return 3; }
static void NCJ(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
const SVector3 &normal, std::vector<double> &NCJ);
- static void NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
- const SVector3 &normal,
- std::vector<double> &NCJ, std::vector<double> &dNCJ);
+ static void NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1,
+ const SPoint3 &p2, const SVector3 &normal,
+ std::vector<double> &NCJ,
+ std::vector<double> &dNCJ);
};
-
-class qmQuadrangle
-{
+class qmQuadrangle {
public:
static double gamma(MQuadrangle *el) { return eta(el); }
static double eta(MQuadrangle *el);
@@ -57,21 +55,22 @@ public:
static void NCJRange(const MQuadrangle *e, double &valMin, double &valMax);
static inline int numNCJVal() { return 4; }
static void NCJ(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
- const SPoint3 &p3, const SVector3 &normal, std::vector<double> &ncj);
- static void NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1, const SPoint3 &p2,
- const SPoint3 &p3, const SVector3 &normal,
- std::vector<double> &NCJ, std::vector<double> &dNCJ);
+ const SPoint3 &p3, const SVector3 &normal,
+ std::vector<double> &ncj);
+ static void NCJAndGradients(const SPoint3 &p0, const SPoint3 &p1,
+ const SPoint3 &p2, const SPoint3 &p3,
+ const SVector3 &normal, std::vector<double> &NCJ,
+ std::vector<double> &dNCJ);
};
-
-class qmTetrahedron
-{
+class qmTetrahedron {
public:
- enum Measures {QMTET_GAMMA, QMTET_ETA, QMTET_ONE, QMTET_COND};
+ enum Measures { QMTET_GAMMA, QMTET_ETA, QMTET_ONE, QMTET_COND };
static double qm(MTetrahedron *t, const Measures &cr, double *volume = 0);
- static double qm(const BDS_Point *p1, const BDS_Point *p2, const BDS_Point *p3);
+ static double qm(const BDS_Point *p1, const BDS_Point *p2,
+ const BDS_Point *p3);
static double qm(const MVertex *v1, const MVertex *v2, const MVertex *v3,
- const MVertex *v4, const Measures &cr, double *volume = 0);
+ const MVertex *v4, const Measures &cr, double *volume = 0);
static double qm(const double &x1, const double &y1, const double &z1,
const double &x2, const double &y2, const double &z2,
const double &x3, const double &y3, const double &z3,
@@ -93,46 +92,45 @@ public:
const double &x4, const double &y4, const double &z4,
double *volume = 0);
static double minNCJ(const MTetrahedron *e);
-// static void NCJRange(const MTetrahedron *e, double &valMin, double &valMax);
+ // static void NCJRange(const MTetrahedron *e, double &valMin, double
+ // &valMax);
static inline int numNCJVal() { return 4; }
-// static void NCJ(const double &x0, const double &y0, const double &z0,
-// const double &x1, const double &y1, const double &z1,
-// const double &x2, const double &y2, const double &z2,
-// const double &x3, const double &y3, const double &z3,
-// fullVector<double> &ncj);
-// static void NCJAndGradients(const double &x0, const double &y0, const double &z0,
-// const double &x1, const double &y1, const double &z1,
-// const double &x2, const double &y2, const double &z2,
-// const double &x3, const double &y3, const double &z3,
-// fullMatrix<double> &ncj);
+ // static void NCJ(const double &x0, const double &y0, const double &z0,
+ // const double &x1, const double &y1, const double &z1,
+ // const double &x2, const double &y2, const double &z2,
+ // const double &x3, const double &y3, const double &z3,
+ // fullVector<double> &ncj);
+ // static void NCJAndGradients(const double &x0, const double &y0, const
+ // double &z0,
+ // const double &x1, const double &y1, const
+ // double &z1, const double &x2, const double
+ // &y2, const double &z2, const double &x3, const
+ // double &y3, const double &z3,
+ // fullMatrix<double> &ncj);
};
-
-class qmPrism
-{
+class qmPrism {
public:
static double minNCJ(const MPrism *el);
static inline int numNCJVal() { return 6; }
-// static void NCJ(const double &x0, const double &y0, const double &z0,
-// const double &x1, const double &y1, const double &z1,
-// const double &x2, const double &y2, const double &z2,
-// const double &x3, const double &y3, const double &z3,
-// const double &x4, const double &y4, const double &z4,
-// fullVector<double> &ncj);
+ // static void NCJ(const double &x0, const double &y0, const double &z0,
+ // const double &x1, const double &y1, const double &z1,
+ // const double &x2, const double &y2, const double &z2,
+ // const double &x3, const double &y3, const double &z3,
+ // const double &x4, const double &y4, const double &z4,
+ // fullVector<double> &ncj);
};
-
-class qmHexahedron
-{
+class qmHexahedron {
public:
static double angles(MHexahedron *el);
static inline int numNCJVal() { return 8; }
-// static void NCJ(const double &x0, const double &y0, const double &z0,
-// const double &x1, const double &y1, const double &z1,
-// const double &x2, const double &y2, const double &z2,
-// const double &x3, const double &y3, const double &z3,
-// const double &x4, const double &y4, const double &z4,
-// fullVector<double> &ncj);
+ // static void NCJ(const double &x0, const double &y0, const double &z0,
+ // const double &x1, const double &y1, const double &z1,
+ // const double &x2, const double &y2, const double &z2,
+ // const double &x3, const double &y3, const double &z3,
+ // const double &x4, const double &y4, const double &z4,
+ // fullVector<double> &ncj);
};
#endif
diff --git a/Mesh/qualityMeasuresJacobian.cpp b/Mesh/qualityMeasuresJacobian.cpp
index 9a91fdb16f1b2dc0d6e4dd38437877acd34ce920..0c327163a01b87fdf0198a319e6bc246e6db263e 100644
--- a/Mesh/qualityMeasuresJacobian.cpp
+++ b/Mesh/qualityMeasuresJacobian.cpp
@@ -17,9 +17,9 @@
#include "pointsGenerators.h"
#include "OS.h"
-static const double cTri = 2/std::sqrt(3);
+static const double cTri = 2 / std::sqrt(3);
static const double cTet = std::sqrt(2);
-static const double cPyr = 4*std::sqrt(2);
+static const double cPyr = 4 * std::sqrt(2);
static inline void computeCoeffLengthVectors_(const fullMatrix<double> &mat,
fullMatrix<double> &coeff,
@@ -27,1064 +27,1063 @@ static inline void computeCoeffLengthVectors_(const fullMatrix<double> &mat,
{
int sz1 = numCoeff > -1 ? numCoeff : mat.size1();
- switch (type) {
- case TYPE_QUA: coeff.resize(sz1, 2); break;
- case TYPE_TRI: coeff.resize(sz1, 3); break;
- case TYPE_HEX: coeff.resize(sz1, 3); break;
- case TYPE_PRI: coeff.resize(sz1, 4); break;
- case TYPE_TET: coeff.resize(sz1, 6); break;
- case TYPE_PYR: coeff.resize(sz1, 6); break;
- default:
- Msg::Error("Unkown type for IGE computation");
- coeff.resize(0, 0);
- return;
+ switch(type) {
+ case TYPE_QUA: coeff.resize(sz1, 2); break;
+ case TYPE_TRI: coeff.resize(sz1, 3); break;
+ case TYPE_HEX: coeff.resize(sz1, 3); break;
+ case TYPE_PRI: coeff.resize(sz1, 4); break;
+ case TYPE_TET: coeff.resize(sz1, 6); break;
+ case TYPE_PYR: coeff.resize(sz1, 6); break;
+ default:
+ Msg::Error("Unkown type for IGE computation");
+ coeff.resize(0, 0);
+ return;
}
- if (type != TYPE_PYR) {
- for (int i = 0; i < sz1; i++) {
- coeff(i, 0) = std::sqrt(pow_int(mat(i, 0), 2) +
- pow_int(mat(i, 1), 2) +
- pow_int(mat(i, 2), 2) );
- coeff(i, 1) = std::sqrt(pow_int(mat(i, 3), 2) +
- pow_int(mat(i, 4), 2) +
- pow_int(mat(i, 5), 2) );
+ if(type != TYPE_PYR) {
+ for(int i = 0; i < sz1; i++) {
+ coeff(i, 0) = std::sqrt(pow_int(mat(i, 0), 2) + pow_int(mat(i, 1), 2) +
+ pow_int(mat(i, 2), 2));
+ coeff(i, 1) = std::sqrt(pow_int(mat(i, 3), 2) + pow_int(mat(i, 4), 2) +
+ pow_int(mat(i, 5), 2));
}
- if (type == TYPE_TRI) {
- for (int i = 0; i < sz1; i++) {
+ if(type == TYPE_TRI) {
+ for(int i = 0; i < sz1; i++) {
coeff(i, 2) = std::sqrt(pow_int(mat(i, 3) - mat(i, 0), 2) +
pow_int(mat(i, 4) - mat(i, 1), 2) +
- pow_int(mat(i, 5) - mat(i, 2), 2) );
+ pow_int(mat(i, 5) - mat(i, 2), 2));
}
}
- else if (type != TYPE_QUA) { // if 3D
- for (int i = 0; i < sz1; i++) {
- coeff(i, 2) = std::sqrt(pow_int(mat(i, 6), 2) +
- pow_int(mat(i, 7), 2) +
- pow_int(mat(i, 8), 2) );
+ else if(type != TYPE_QUA) { // if 3D
+ for(int i = 0; i < sz1; i++) {
+ coeff(i, 2) = std::sqrt(pow_int(mat(i, 6), 2) + pow_int(mat(i, 7), 2) +
+ pow_int(mat(i, 8), 2));
}
}
- if (type == TYPE_TET || type == TYPE_PRI) {
- for (int i = 0; i < sz1; i++) {
+ if(type == TYPE_TET || type == TYPE_PRI) {
+ for(int i = 0; i < sz1; i++) {
coeff(i, 3) = std::sqrt(pow_int(mat(i, 3) - mat(i, 0), 2) +
pow_int(mat(i, 4) - mat(i, 1), 2) +
- pow_int(mat(i, 5) - mat(i, 2), 2) );
+ pow_int(mat(i, 5) - mat(i, 2), 2));
}
}
- if (type == TYPE_TET) {
- for (int i = 0; i < sz1; i++) {
+ if(type == TYPE_TET) {
+ for(int i = 0; i < sz1; i++) {
coeff(i, 4) = std::sqrt(pow_int(mat(i, 6) - mat(i, 0), 2) +
pow_int(mat(i, 7) - mat(i, 1), 2) +
- pow_int(mat(i, 8) - mat(i, 2), 2) );
+ pow_int(mat(i, 8) - mat(i, 2), 2));
coeff(i, 5) = std::sqrt(pow_int(mat(i, 6) - mat(i, 3), 2) +
pow_int(mat(i, 7) - mat(i, 4), 2) +
- pow_int(mat(i, 8) - mat(i, 5), 2) );
+ pow_int(mat(i, 8) - mat(i, 5), 2));
}
}
}
else {
- for (int i = 0; i < sz1; i++) {
- coeff(i, 0) = std::sqrt(pow_int(2*mat(i, 0), 2) +
- pow_int(2*mat(i, 1), 2) +
- pow_int(2*mat(i, 2), 2) );
- coeff(i, 1) = std::sqrt(pow_int(2*mat(i, 3), 2) +
- pow_int(2*mat(i, 4), 2) +
- pow_int(2*mat(i, 5), 2) );
+ for(int i = 0; i < sz1; i++) {
+ coeff(i, 0) =
+ std::sqrt(pow_int(2 * mat(i, 0), 2) + pow_int(2 * mat(i, 1), 2) +
+ pow_int(2 * mat(i, 2), 2));
+ coeff(i, 1) =
+ std::sqrt(pow_int(2 * mat(i, 3), 2) + pow_int(2 * mat(i, 4), 2) +
+ pow_int(2 * mat(i, 5), 2));
coeff(i, 2) = std::sqrt(pow_int(mat(i, 6) + mat(i, 0) + mat(i, 3), 2) +
pow_int(mat(i, 7) + mat(i, 1) + mat(i, 4), 2) +
- pow_int(mat(i, 8) + mat(i, 2) + mat(i, 5), 2) );
+ pow_int(mat(i, 8) + mat(i, 2) + mat(i, 5), 2));
coeff(i, 3) = std::sqrt(pow_int(mat(i, 6) - mat(i, 0) + mat(i, 3), 2) +
pow_int(mat(i, 7) - mat(i, 1) + mat(i, 4), 2) +
- pow_int(mat(i, 8) - mat(i, 2) + mat(i, 5), 2) );
+ pow_int(mat(i, 8) - mat(i, 2) + mat(i, 5), 2));
coeff(i, 4) = std::sqrt(pow_int(mat(i, 6) - mat(i, 0) - mat(i, 3), 2) +
pow_int(mat(i, 7) - mat(i, 1) - mat(i, 4), 2) +
- pow_int(mat(i, 8) - mat(i, 2) - mat(i, 5), 2) );
+ pow_int(mat(i, 8) - mat(i, 2) - mat(i, 5), 2));
coeff(i, 5) = std::sqrt(pow_int(mat(i, 6) + mat(i, 0) - mat(i, 3), 2) +
pow_int(mat(i, 7) + mat(i, 1) - mat(i, 4), 2) +
- pow_int(mat(i, 8) + mat(i, 2) - mat(i, 5), 2) );
+ pow_int(mat(i, 8) + mat(i, 2) - mat(i, 5), 2));
}
}
}
static inline void computeIGE_(const fullVector<double> &det,
const fullMatrix<double> &v,
- fullVector<double> &ige,
- int type)
+ fullVector<double> &ige, int type)
{
int sz = std::min(det.size(), v.size1());
ige.resize(sz);
switch(type) {
- case TYPE_QUA:
- for (int i = 0; i < sz; i++) {
- ige(i) = det(i)/v(i, 0)/v(i, 1);
- }
- break;
- case TYPE_HEX:
- for (int i = 0; i < sz; i++) {
- ige(i) = det(i)/v(i, 0)/v(i, 1)/v(i, 2);
- }
- break;
- case TYPE_TRI:
- for (int i = 0; i < sz; i++) {
- ige(i) = cTri * det(i) * (1/v(i,0)/v(i,1) +
- 1/v(i,0)/v(i,2) +
- 1/v(i,1)/v(i,2)) / 3;
- }
- break;
- case TYPE_PRI:
- for (int i = 0; i < sz; i++) {
- ige(i) = cTri * det(i) * (1/v(i,0)/v(i,1)/v(i,2) +
- 1/v(i,0)/v(i,3)/v(i,2) +
- 1/v(i,1)/v(i,3)/v(i,2)) / 3;
- }
- break;
- case TYPE_TET:
- for (int i = 0; i < sz; i++) {
- ige(i) = cTet * det(i) * (1/v(i,0)/v(i,5)/v(i,1) +
- 1/v(i,0)/v(i,5)/v(i,2) +
- 1/v(i,0)/v(i,5)/v(i,3) +
- 1/v(i,0)/v(i,5)/v(i,4) +
- 1/v(i,1)/v(i,4)/v(i,0) +
- 1/v(i,1)/v(i,4)/v(i,2) +
- 1/v(i,1)/v(i,4)/v(i,3) +
- 1/v(i,1)/v(i,4)/v(i,5) +
- 1/v(i,2)/v(i,3)/v(i,0) +
- 1/v(i,2)/v(i,3)/v(i,1) +
- 1/v(i,2)/v(i,3)/v(i,4) +
- 1/v(i,2)/v(i,3)/v(i,5))/ 12;
- }
- break;
- case TYPE_PYR:
- for (int i = 0; i < sz; i++) {
- ige(i) = cPyr * det(i) * (1/v(i,0)/v(i,1)/v(i,2) +
- 1/v(i,0)/v(i,1)/v(i,3) +
- 1/v(i,0)/v(i,1)/v(i,4) +
- 1/v(i,0)/v(i,1)/v(i,5) +
- 1/v(i,2)/v(i,3)/v(i,4) +
- 1/v(i,2)/v(i,3)/v(i,5) +
- 1/v(i,4)/v(i,5)/v(i,2) +
- 1/v(i,4)/v(i,5)/v(i,3) ) / 8;
- }
- break;
+ case TYPE_QUA:
+ for(int i = 0; i < sz; i++) {
+ ige(i) = det(i) / v(i, 0) / v(i, 1);
+ }
+ break;
+ case TYPE_HEX:
+ for(int i = 0; i < sz; i++) {
+ ige(i) = det(i) / v(i, 0) / v(i, 1) / v(i, 2);
+ }
+ break;
+ case TYPE_TRI:
+ for(int i = 0; i < sz; i++) {
+ ige(i) = cTri * det(i) *
+ (1 / v(i, 0) / v(i, 1) + 1 / v(i, 0) / v(i, 2) +
+ 1 / v(i, 1) / v(i, 2)) /
+ 3;
+ }
+ break;
+ case TYPE_PRI:
+ for(int i = 0; i < sz; i++) {
+ ige(i) =
+ cTri * det(i) *
+ (1 / v(i, 0) / v(i, 1) / v(i, 2) + 1 / v(i, 0) / v(i, 3) / v(i, 2) +
+ 1 / v(i, 1) / v(i, 3) / v(i, 2)) /
+ 3;
+ }
+ break;
+ case TYPE_TET:
+ for(int i = 0; i < sz; i++) {
+ ige(i) =
+ cTet * det(i) *
+ (1 / v(i, 0) / v(i, 5) / v(i, 1) + 1 / v(i, 0) / v(i, 5) / v(i, 2) +
+ 1 / v(i, 0) / v(i, 5) / v(i, 3) + 1 / v(i, 0) / v(i, 5) / v(i, 4) +
+ 1 / v(i, 1) / v(i, 4) / v(i, 0) + 1 / v(i, 1) / v(i, 4) / v(i, 2) +
+ 1 / v(i, 1) / v(i, 4) / v(i, 3) + 1 / v(i, 1) / v(i, 4) / v(i, 5) +
+ 1 / v(i, 2) / v(i, 3) / v(i, 0) + 1 / v(i, 2) / v(i, 3) / v(i, 1) +
+ 1 / v(i, 2) / v(i, 3) / v(i, 4) + 1 / v(i, 2) / v(i, 3) / v(i, 5)) /
+ 12;
+ }
+ break;
+ case TYPE_PYR:
+ for(int i = 0; i < sz; i++) {
+ ige(i) =
+ cPyr * det(i) *
+ (1 / v(i, 0) / v(i, 1) / v(i, 2) + 1 / v(i, 0) / v(i, 1) / v(i, 3) +
+ 1 / v(i, 0) / v(i, 1) / v(i, 4) + 1 / v(i, 0) / v(i, 1) / v(i, 5) +
+ 1 / v(i, 2) / v(i, 3) / v(i, 4) + 1 / v(i, 2) / v(i, 3) / v(i, 5) +
+ 1 / v(i, 4) / v(i, 5) / v(i, 2) + 1 / v(i, 4) / v(i, 5) / v(i, 3)) /
+ 8;
+ }
+ break;
}
}
namespace jacobianBasedQuality {
-void minMaxJacobianDeterminant(MElement *el, double &min, double &max,
- const fullMatrix<double> *normals)
-{
- const JacobianBasis *jfs = el->getJacobianFuncSpace();
- if (!jfs) {
- Msg::Error("Jacobian function space not implemented for type of element %d", el->getTypeForMSH());
- min = 99;
- max = -99;
- return;
- }
+ void minMaxJacobianDeterminant(MElement *el, double &min, double &max,
+ const fullMatrix<double> *normals)
+ {
+ const JacobianBasis *jfs = el->getJacobianFuncSpace();
+ if(!jfs) {
+ Msg::Error(
+ "Jacobian function space not implemented for type of element %d",
+ el->getTypeForMSH());
+ min = 99;
+ max = -99;
+ return;
+ }
- fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
- el->getNodesCoord(nodesXYZ);
+ fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
+ el->getNodesCoord(nodesXYZ);
- fullVector<double> coeffLag(jfs->getNumJacNodes());
- fullVector<double> coeffBez(jfs->getNumJacNodes());
- jfs->getSignedJacobian(nodesXYZ, coeffLag, normals);
- jfs->lag2Bez(coeffLag, coeffBez);
+ fullVector<double> coeffLag(jfs->getNumJacNodes());
+ fullVector<double> coeffBez(jfs->getNumJacNodes());
+ jfs->getSignedJacobian(nodesXYZ, coeffLag, normals);
+ jfs->lag2Bez(coeffLag, coeffBez);
- std::vector<_CoeffData*> domains;
- domains.push_back(new _CoeffDataJac(coeffBez, jfs->getBezier(), 0));
+ std::vector<_CoeffData *> domains;
+ domains.push_back(new _CoeffDataJac(coeffBez, jfs->getBezier(), 0));
- _subdivideDomains(domains);
+ _subdivideDomains(domains);
- min = domains[0]->minB();
- max = domains[0]->maxB();
- delete domains[0];
- for (unsigned int i = 1; i < domains.size(); ++i) {
- min = std::min(min, domains[i]->minB());
- max = std::max(max, domains[i]->maxB());
- delete domains[i];
+ min = domains[0]->minB();
+ max = domains[0]->maxB();
+ delete domains[0];
+ for(unsigned int i = 1; i < domains.size(); ++i) {
+ min = std::min(min, domains[i]->minB());
+ max = std::max(max, domains[i]->maxB());
+ delete domains[i];
+ }
}
-}
-double minIGEMeasure(MElement *el, bool knownValid, bool reversedOk,
- const fullMatrix<double> *normals)
-{
- bool isReversed = false;
- if (!knownValid) {
- // Computation of the measure should never
- // be performed to invalid elements (for which the measure is 0).
- double jmin, jmax;
- minMaxJacobianDeterminant(el, jmin, jmax, normals);
- if (jmax < 0) {
- if (!reversedOk) return 0;
- isReversed = true;
+ double minIGEMeasure(MElement *el, bool knownValid, bool reversedOk,
+ const fullMatrix<double> *normals)
+ {
+ bool isReversed = false;
+ if(!knownValid) {
+ // Computation of the measure should never
+ // be performed to invalid elements (for which the measure is 0).
+ double jmin, jmax;
+ minMaxJacobianDeterminant(el, jmin, jmax, normals);
+ if(jmax < 0) {
+ if(!reversedOk) return 0;
+ isReversed = true;
+ }
+ else if(jmin <= 0)
+ return 0;
}
- else if (jmin <= 0) return 0;
- }
- fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
- el->getNodesCoord(nodesXYZ);
+ fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
+ el->getNodesCoord(nodesXYZ);
- const JacobianBasis *jacBasis;
- const GradientBasis *gradBasis;
+ const JacobianBasis *jacBasis;
+ const GradientBasis *gradBasis;
- const int type = el->getType();
- const int order = el->getPolynomialOrder();
- const int jacOrder = order * el->getDim();
- const bool serendipFalse = false;
+ const int type = el->getType();
+ const int order = el->getPolynomialOrder();
+ const int jacOrder = order * el->getDim();
+ const bool serendipFalse = false;
- FuncSpaceData jacMatSpace, jacDetSpace;
+ FuncSpaceData jacMatSpace, jacDetSpace;
- switch(type) {
- case TYPE_TRI:
- jacMatSpace = FuncSpaceData(el, order-1, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, jacOrder-2, &serendipFalse);
- break;
- case TYPE_TET:
- jacMatSpace = FuncSpaceData(el, order-1, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, jacOrder-3, &serendipFalse);
- break;
- case TYPE_QUA:
- case TYPE_HEX:
- case TYPE_PRI:
- jacMatSpace = FuncSpaceData(el, order, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, jacOrder, &serendipFalse);
- break;
- case TYPE_PYR:
- jacMatSpace = FuncSpaceData(el, false, order, order-1, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, false, jacOrder, jacOrder-3, &serendipFalse);
- break;
- default:
- Msg::Error("IGE measure not implemented for type of element %d", el->getType());
- return -1;
- }
- gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
- jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
+ switch(type) {
+ case TYPE_TRI:
+ jacMatSpace = FuncSpaceData(el, order - 1, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, jacOrder - 2, &serendipFalse);
+ break;
+ case TYPE_TET:
+ jacMatSpace = FuncSpaceData(el, order - 1, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, jacOrder - 3, &serendipFalse);
+ break;
+ case TYPE_QUA:
+ case TYPE_HEX:
+ case TYPE_PRI:
+ jacMatSpace = FuncSpaceData(el, order, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, jacOrder, &serendipFalse);
+ break;
+ case TYPE_PYR:
+ jacMatSpace = FuncSpaceData(el, false, order, order - 1, &serendipFalse);
+ jacDetSpace =
+ FuncSpaceData(el, false, jacOrder, jacOrder - 3, &serendipFalse);
+ break;
+ default:
+ Msg::Error("IGE measure not implemented for type of element %d",
+ el->getType());
+ return -1;
+ }
+ gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
+ jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
- fullVector<double> coeffDetBez;
- {
- fullVector<double> coeffDetLag(jacBasis->getNumJacNodes());
- jacBasis->getSignedJacobian(nodesXYZ, coeffDetLag, normals);
+ fullVector<double> coeffDetBez;
+ {
+ fullVector<double> coeffDetLag(jacBasis->getNumJacNodes());
+ jacBasis->getSignedJacobian(nodesXYZ, coeffDetLag, normals);
- coeffDetBez.resize(jacBasis->getNumJacNodes());
- jacBasis->lag2Bez(coeffDetLag, coeffDetBez);
+ coeffDetBez.resize(jacBasis->getNumJacNodes());
+ jacBasis->lag2Bez(coeffDetLag, coeffDetBez);
- if (isReversed) coeffDetBez.scale(-1);
+ if(isReversed) coeffDetBez.scale(-1);
+ }
+
+ fullMatrix<double> coeffMatBez;
+ {
+ fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
+ gradBasis->getAllGradientsFromNodes(nodesXYZ, coeffMatLag);
+
+ coeffMatBez.resize(gradBasis->getNumSamplingPoints(), 9);
+ gradBasis->lag2Bez(coeffMatLag, coeffMatBez);
+ if(el->getDim() == 2) coeffMatBez.resize(coeffMatBez.size1(), 6, false);
+ }
+
+ std::vector<_CoeffData *> domains;
+ domains.push_back(
+ new _CoeffDataIGE(coeffDetBez, coeffMatBez, jacBasis->getBezier(),
+ gradBasis->getBezier(), 0, el->getType()));
+
+ _subdivideDomains(domains);
+ // if (domains.size()/7 > 500) {//fordebug
+ // Msg::Info("S too much subdivision: %d (el %d, type %d, tag %d)",
+ // domains.size()/7, el->getNum(), el->getType(),
+ // el->getTypeForMSH());
+ // }
+
+ return _getMinAndDeleteDomains(domains);
}
- fullMatrix<double> coeffMatBez;
+ double minICNMeasure(MElement *el, bool knownValid, bool reversedOk,
+ const fullMatrix<double> *normals)
{
- fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
- gradBasis->getAllGradientsFromNodes(nodesXYZ, coeffMatLag);
+ bool isReversed = false;
+ if(!knownValid) {
+ // Computation of the measure should never
+ // be performed to invalid elements (for which the measure is 0).
+ double jmin, jmax;
+ minMaxJacobianDeterminant(el, jmin, jmax, normals);
+ if(jmax < 0) {
+ if(!reversedOk) return 0;
+ isReversed = true;
+ }
+ else if(jmin <= 0)
+ return 0;
+ }
- coeffMatBez.resize(gradBasis->getNumSamplingPoints(), 9);
- gradBasis->lag2Bez(coeffMatLag, coeffMatBez);
- if (el->getDim() == 2) coeffMatBez.resize(coeffMatBez.size1(), 6, false);
- }
+ fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
+ el->getNodesCoord(nodesXYZ);
- std::vector<_CoeffData*> domains;
- domains.push_back(
- new _CoeffDataIGE(coeffDetBez, coeffMatBez, jacBasis->getBezier(),
- gradBasis->getBezier(), 0, el->getType())
- );
+ const JacobianBasis *jacBasis;
+ const GradientBasis *gradBasis;
- _subdivideDomains(domains);
-// if (domains.size()/7 > 500) {//fordebug
-// Msg::Info("S too much subdivision: %d (el %d, type %d, tag %d)",
-// domains.size()/7, el->getNum(), el->getType(), el->getTypeForMSH());
-// }
+ const int type = el->getType();
+ const int order = el->getPolynomialOrder();
+ const int jacOrder = order * el->getDim();
+ const bool serendipFalse = false;
- return _getMinAndDeleteDomains(domains);
-}
+ FuncSpaceData jacMatSpace, jacDetSpace;
-double minICNMeasure(MElement *el, bool knownValid, bool reversedOk,
- const fullMatrix<double> *normals)
-{
- bool isReversed = false;
- if (!knownValid) {
- // Computation of the measure should never
- // be performed to invalid elements (for which the measure is 0).
- double jmin, jmax;
- minMaxJacobianDeterminant(el, jmin, jmax, normals);
- if (jmax < 0) {
- if (!reversedOk) return 0;
- isReversed = true;
+ switch(type) {
+ case TYPE_TRI:
+ jacMatSpace = FuncSpaceData(el, order - 1, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, jacOrder - 2, &serendipFalse);
+ break;
+ case TYPE_TET:
+ jacMatSpace = FuncSpaceData(el, order - 1, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, jacOrder - 3, &serendipFalse);
+ break;
+ case TYPE_QUA:
+ case TYPE_HEX:
+ case TYPE_PRI:
+ jacMatSpace = FuncSpaceData(el, order, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, jacOrder, &serendipFalse);
+ break;
+ case TYPE_PYR:
+ jacMatSpace = FuncSpaceData(el, false, order, order - 1, &serendipFalse);
+ jacDetSpace =
+ FuncSpaceData(el, false, jacOrder, jacOrder - 3, &serendipFalse);
+ break;
+ default:
+ Msg::Error("ICN not implemented for type of element %d", el->getType());
+ return -1;
}
- else if (jmin <= 0) return 0;
- }
+ gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
+ jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
- fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
- el->getNodesCoord(nodesXYZ);
+ fullVector<double> coeffDetBez;
+ {
+ fullVector<double> coeffDetLag(jacBasis->getNumJacNodes());
+ jacBasis->getSignedIdealJacobian(nodesXYZ, coeffDetLag, normals);
- const JacobianBasis *jacBasis;
- const GradientBasis *gradBasis;
+ coeffDetBez.resize(jacBasis->getNumJacNodes());
+ jacBasis->lag2Bez(coeffDetLag, coeffDetBez);
- const int type = el->getType();
- const int order = el->getPolynomialOrder();
- const int jacOrder = order * el->getDim();
- const bool serendipFalse = false;
+ if(isReversed) coeffDetBez.scale(-1);
+ }
- FuncSpaceData jacMatSpace, jacDetSpace;
+ fullMatrix<double> coeffMatBez;
+ {
+ fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
+ gradBasis->getAllIdealGradientsFromNodes(nodesXYZ, coeffMatLag);
- switch(type) {
- case TYPE_TRI:
- jacMatSpace = FuncSpaceData(el, order-1, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, jacOrder-2, &serendipFalse);
- break;
- case TYPE_TET:
- jacMatSpace = FuncSpaceData(el, order-1, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, jacOrder-3, &serendipFalse);
- break;
- case TYPE_QUA:
- case TYPE_HEX:
- case TYPE_PRI:
- jacMatSpace = FuncSpaceData(el, order, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, jacOrder, &serendipFalse);
- break;
- case TYPE_PYR:
- jacMatSpace = FuncSpaceData(el, false, order, order-1, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, false, jacOrder, jacOrder-3, &serendipFalse);
- break;
- default:
- Msg::Error("ICN not implemented for type of element %d", el->getType());
- return -1;
- }
- gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
- jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
+ coeffMatBez.resize(gradBasis->getNumSamplingPoints(), 9);
+ gradBasis->lag2Bez(coeffMatLag, coeffMatBez);
+ if(el->getDim() == 2) coeffMatBez.resize(coeffMatBez.size1(), 6, false);
+ }
- fullVector<double> coeffDetBez;
- {
- fullVector<double> coeffDetLag(jacBasis->getNumJacNodes());
- jacBasis->getSignedIdealJacobian(nodesXYZ, coeffDetLag, normals);
+ std::vector<_CoeffData *> domains;
+ domains.push_back(new _CoeffDataICN(coeffDetBez, coeffMatBez,
+ jacBasis->getBezier(),
+ gradBasis->getBezier(), 0));
- coeffDetBez.resize(jacBasis->getNumJacNodes());
- jacBasis->lag2Bez(coeffDetLag, coeffDetBez);
+ _subdivideDomains(domains);
+ // if (domains.size()/7 > 500) {//fordebug
+ // Msg::Info("I too much subdivision: %d (el %d, type %d, tag %d)",
+ // domains.size()/7, el->getNum(), el->getType(),
+ // el->getTypeForMSH());
+ // }
- if (isReversed) coeffDetBez.scale(-1);
+ return _getMinAndDeleteDomains(domains);
}
- fullMatrix<double> coeffMatBez;
+ void sampleIGEMeasure(MElement *el, int deg, double &min, double &max)
{
- fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
- gradBasis->getAllIdealGradientsFromNodes(nodesXYZ, coeffMatLag);
-
- coeffMatBez.resize(gradBasis->getNumSamplingPoints(), 9);
- gradBasis->lag2Bez(coeffMatLag, coeffMatBez);
- if (el->getDim() == 2) coeffMatBez.resize(coeffMatBez.size1(), 6, false);
+ fullVector<double> ige;
+ sampleIGEMeasure(el, deg, ige);
+
+ min = std::numeric_limits<double>::infinity();
+ max = -min;
+ for(int i = 0; i < ige.size(); ++i) {
+ min = std::min(min, ige(i));
+ max = std::max(max, ige(i));
+ }
}
- std::vector<_CoeffData*> domains;
- domains.push_back(
- new _CoeffDataICN(coeffDetBez, coeffMatBez, jacBasis->getBezier(),
- gradBasis->getBezier(), 0)
- );
-
- _subdivideDomains(domains);
-// if (domains.size()/7 > 500) {//fordebug
-// Msg::Info("I too much subdivision: %d (el %d, type %d, tag %d)",
-// domains.size()/7, el->getNum(), el->getType(), el->getTypeForMSH());
-// }
+ void sampleJacobian(MElement *el, int deg, fullVector<double> &jac,
+ const fullMatrix<double> *normals)
+ {
+ FuncSpaceData sampleSpace = FuncSpaceData(el, deg);
+ const JacobianBasis *jacBasis = BasisFactory::getJacobianBasis(sampleSpace);
- return _getMinAndDeleteDomains(domains);
-}
+ fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
+ el->getNodesCoord(nodesXYZ);
-void sampleIGEMeasure(MElement *el, int deg, double &min, double &max)
-{
- fullVector<double> ige;
- sampleIGEMeasure(el, deg, ige);
-
- min = std::numeric_limits<double>::infinity();
- max = -min;
- for (int i = 0; i < ige.size(); ++i) {
- min = std::min(min, ige(i));
- max = std::max(max, ige(i));
+ jac.resize(jacBasis->getNumJacNodes());
+ jacBasis->getSignedJacobian(nodesXYZ, jac, normals);
}
-}
-void sampleJacobian(MElement *el, int deg, fullVector<double> &jac,
- const fullMatrix<double> *normals)
-{
- FuncSpaceData sampleSpace = FuncSpaceData(el, deg);
- const JacobianBasis *jacBasis = BasisFactory::getJacobianBasis(sampleSpace);
+ void sampleIGEMeasure(MElement *el, int deg, fullVector<double> &ige)
+ {
+ fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
+ el->getNodesCoord(nodesXYZ);
- fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
- el->getNodesCoord(nodesXYZ);
+ const bool serendipFalse = false;
+ FuncSpaceData jacMatSpace, jacDetSpace;
- jac.resize(jacBasis->getNumJacNodes());
- jacBasis->getSignedJacobian(nodesXYZ, jac, normals);
-}
+ const int type = el->getType();
+ switch(type) {
+ case TYPE_TRI:
+ case TYPE_TET:
+ case TYPE_QUA:
+ case TYPE_HEX:
+ case TYPE_PRI:
+ jacMatSpace = FuncSpaceData(el, deg, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, deg, &serendipFalse);
+ break;
+ case TYPE_PYR:
+ jacMatSpace = FuncSpaceData(el, true, deg - 1, 1, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, true, deg - 1, 1, &serendipFalse);
+ break;
+ default:
+ Msg::Error("IGE not implemented for type of element %d", el->getType());
+ return;
+ }
-void sampleIGEMeasure(MElement *el, int deg, fullVector<double> &ige)
-{
- fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
- el->getNodesCoord(nodesXYZ);
+ const GradientBasis *gradBasis =
+ BasisFactory::getGradientBasis(jacMatSpace);
+ const JacobianBasis *jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
- const bool serendipFalse = false;
- FuncSpaceData jacMatSpace, jacDetSpace;
+ fullVector<double> coeffDeterminant(jacBasis->getNumJacNodes());
+ jacBasis->getSignedJacobian(nodesXYZ, coeffDeterminant);
- const int type = el->getType();
- switch(type) {
- case TYPE_TRI:
- case TYPE_TET:
- case TYPE_QUA:
- case TYPE_HEX:
- case TYPE_PRI:
- jacMatSpace = FuncSpaceData(el, deg, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, deg, &serendipFalse);
- break;
- case TYPE_PYR:
- jacMatSpace = FuncSpaceData(el, true, deg-1, 1, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, true, deg-1, 1, &serendipFalse);
- break;
- default:
- Msg::Error("IGE not implemented for type of element %d", el->getType());
- return;
- }
+ fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
+ gradBasis->getAllGradientsFromNodes(nodesXYZ, coeffMatLag);
+ if(el->getDim() == 2) coeffMatLag.resize(coeffMatLag.size1(), 6, false);
- const GradientBasis *gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
- const JacobianBasis *jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
+ fullMatrix<double> v;
+ computeCoeffLengthVectors_(coeffMatLag, v, type);
- fullVector<double> coeffDeterminant(jacBasis->getNumJacNodes());
- jacBasis->getSignedJacobian(nodesXYZ, coeffDeterminant);
+ computeIGE_(coeffDeterminant, v, ige, type);
+ }
- fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
- gradBasis->getAllGradientsFromNodes(nodesXYZ, coeffMatLag);
- if (el->getDim() == 2) coeffMatLag.resize(coeffMatLag.size1(), 6, false);
+ double minSampledICNMeasure(MElement *el, int deg) // fordebug
+ {
+ fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
+ el->getNodesCoord(nodesXYZ);
- fullMatrix<double> v;
- computeCoeffLengthVectors_(coeffMatLag, v, type);
+ const JacobianBasis *jacBasis;
+ const GradientBasis *gradBasis;
- computeIGE_(coeffDeterminant, v, ige, type);
-}
+ const int type = el->getType();
+ // const int order = el->getPolynomialOrder();
+ // const int jacOrder = order * el->getDim();
+ const bool serendipFalse = false;
-double minSampledICNMeasure(MElement *el, int deg)//fordebug
-{
- fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
- el->getNodesCoord(nodesXYZ);
+ FuncSpaceData jacMatSpace, jacDetSpace;
- const JacobianBasis *jacBasis;
- const GradientBasis *gradBasis;
+ switch(type) {
+ case TYPE_TRI:
+ case TYPE_TET:
+ case TYPE_QUA:
+ case TYPE_HEX:
+ case TYPE_PRI:
+ jacMatSpace = FuncSpaceData(el, deg, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, deg, &serendipFalse);
+ break;
+ case TYPE_PYR:
+ // jacMatSpace = FuncSpaceData(el, false, order, order-1,
+ // &serendipFalse); jacDetSpace = FuncSpaceData(el, false, jacOrder,
+ // jacOrder-3, &serendipFalse);
+ break;
+ default:
+ Msg::Error("ICN not implemented for type of element %d", el->getType());
+ return -1;
+ }
+ gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
+ jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
- const int type = el->getType();
-// const int order = el->getPolynomialOrder();
-// const int jacOrder = order * el->getDim();
- const bool serendipFalse = false;
+ fullVector<double> coeffDetLag(jacBasis->getNumJacNodes());
+ jacBasis->getSignedIdealJacobian(nodesXYZ, coeffDetLag);
- FuncSpaceData jacMatSpace, jacDetSpace;
+ fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
+ gradBasis->getAllIdealGradientsFromNodes(nodesXYZ, coeffMatLag);
- switch(type) {
- case TYPE_TRI:
- case TYPE_TET:
- case TYPE_QUA:
- case TYPE_HEX:
- case TYPE_PRI:
- jacMatSpace = FuncSpaceData(el, deg, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, deg, &serendipFalse);
- break;
- case TYPE_PYR:
-// jacMatSpace = FuncSpaceData(el, false, order, order-1, &serendipFalse);
-// jacDetSpace = FuncSpaceData(el, false, jacOrder, jacOrder-3, &serendipFalse);
- break;
- default:
- Msg::Error("ICN not implemented for type of element %d", el->getType());
- return -1;
- }
- gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
- jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
-
- fullVector<double> coeffDetLag(jacBasis->getNumJacNodes());
- jacBasis->getSignedIdealJacobian(nodesXYZ, coeffDetLag);
-
- fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
- gradBasis->getAllIdealGradientsFromNodes(nodesXYZ, coeffMatLag);
-
- double min = std::numeric_limits<double>::infinity();
- for (int i = 0; i < coeffDetLag.size(); ++i) {
- double frobNorm = 0;
- if (el->getDim() == 2) {
- for (int k = 0; k < 6; ++k)
- frobNorm += coeffMatLag(i, k) * coeffMatLag(i, k);
- min = std::min(min, 2*coeffDetLag(i)/frobNorm);
- }
- else if (el->getDim() == 3) {
- for (int k = 0; k < 9; ++k)
- frobNorm += coeffMatLag(i, k) * coeffMatLag(i, k);
- min = std::min(min, 3*std::pow(coeffDetLag(i), 2/3.)/frobNorm);
+ double min = std::numeric_limits<double>::infinity();
+ for(int i = 0; i < coeffDetLag.size(); ++i) {
+ double frobNorm = 0;
+ if(el->getDim() == 2) {
+ for(int k = 0; k < 6; ++k)
+ frobNorm += coeffMatLag(i, k) * coeffMatLag(i, k);
+ min = std::min(min, 2 * coeffDetLag(i) / frobNorm);
+ }
+ else if(el->getDim() == 3) {
+ for(int k = 0; k < 9; ++k)
+ frobNorm += coeffMatLag(i, k) * coeffMatLag(i, k);
+ min = std::min(min, 3 * std::pow(coeffDetLag(i), 2 / 3.) / frobNorm);
+ }
}
- }
- return min;
-}
+ return min;
+ }
-double minSampledIGEMeasure(MElement *el, int deg)//fordebug
-{
- fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
- el->getNodesCoord(nodesXYZ);
+ double minSampledIGEMeasure(MElement *el, int deg) // fordebug
+ {
+ fullMatrix<double> nodesXYZ(el->getNumVertices(), 3);
+ el->getNodesCoord(nodesXYZ);
- const JacobianBasis *jacBasis;
- const GradientBasis *gradBasis;
+ const JacobianBasis *jacBasis;
+ const GradientBasis *gradBasis;
- const int type = el->getType();
-// const int order = el->getPolynomialOrder();
-// const int jacOrder = order * el->getDim();
- const bool serendipFalse = false;
+ const int type = el->getType();
+ // const int order = el->getPolynomialOrder();
+ // const int jacOrder = order * el->getDim();
+ const bool serendipFalse = false;
- FuncSpaceData jacMatSpace, jacDetSpace;
+ FuncSpaceData jacMatSpace, jacDetSpace;
- switch(type) {
- case TYPE_TRI:
- case TYPE_TET:
- case TYPE_QUA:
- case TYPE_HEX:
- case TYPE_PRI:
- jacMatSpace = FuncSpaceData(el, deg, &serendipFalse);
- jacDetSpace = FuncSpaceData(el, deg, &serendipFalse);
- break;
- case TYPE_PYR:
-// jacMatSpace = FuncSpaceData(el, false, order, order-1, &serendipFalse);
-// jacDetSpace = FuncSpaceData(el, false, jacOrder, jacOrder-3, &serendipFalse);
- break;
- default:
- Msg::Error("ICN not implemented for type of element %d", el->getType());
- return -1;
- }
- gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
- jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
-
- fullVector<double> coeffDetLag(jacBasis->getNumJacNodes());
- jacBasis->getSignedIdealJacobian(nodesXYZ, coeffDetLag);
-
- fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
- gradBasis->getAllIdealGradientsFromNodes(nodesXYZ, coeffMatLag);
-
- double min = std::numeric_limits<double>::infinity();
- for (int i = 0; i < coeffDetLag.size(); ++i) {
- if (el->getDim() == 2) {
- double v[2] = {0, 0};
- for (int k = 0; k < 2; ++k) {
- for (int l = k*3; l < k*3+3; ++l)
- v[k] += coeffMatLag(i, l) * coeffMatLag(i, l);
- }
- min = std::min(min, coeffDetLag(i)/v[0]/v[1]);
- }
- else if (el->getDim() == 3) {
- double v[3] = {0, 0, 0};
- for (int k = 0; k < 3; ++k) {
- for (int l = k*3; l < k*3+3; ++l)
- v[k] += coeffMatLag(i, l) * coeffMatLag(i, l);
- }
- min = std::min(min, coeffDetLag(i)/std::sqrt(v[0]*v[1]*v[2]));
+ switch(type) {
+ case TYPE_TRI:
+ case TYPE_TET:
+ case TYPE_QUA:
+ case TYPE_HEX:
+ case TYPE_PRI:
+ jacMatSpace = FuncSpaceData(el, deg, &serendipFalse);
+ jacDetSpace = FuncSpaceData(el, deg, &serendipFalse);
+ break;
+ case TYPE_PYR:
+ // jacMatSpace = FuncSpaceData(el, false, order, order-1,
+ // &serendipFalse); jacDetSpace = FuncSpaceData(el, false, jacOrder,
+ // jacOrder-3, &serendipFalse);
+ break;
+ default:
+ Msg::Error("ICN not implemented for type of element %d", el->getType());
+ return -1;
}
- }
+ gradBasis = BasisFactory::getGradientBasis(jacMatSpace);
+ jacBasis = BasisFactory::getJacobianBasis(jacDetSpace);
- return min;
-}
+ fullVector<double> coeffDetLag(jacBasis->getNumJacNodes());
+ jacBasis->getSignedIdealJacobian(nodesXYZ, coeffDetLag);
-// Virtual class _CoeffData
-bool _lessMinB::operator()(_CoeffData *cd1, _CoeffData *cd2) const
-{
- return cd1->minB() > cd2->minB();
-}
+ fullMatrix<double> coeffMatLag(gradBasis->getNumSamplingPoints(), 9);
+ gradBasis->getAllIdealGradientsFromNodes(nodesXYZ, coeffMatLag);
-bool _lessMaxB::operator()(_CoeffData *cd1, _CoeffData *cd2) const
-{
- return cd1->maxB() < cd2->maxB();
-}
+ double min = std::numeric_limits<double>::infinity();
+ for(int i = 0; i < coeffDetLag.size(); ++i) {
+ if(el->getDim() == 2) {
+ double v[2] = {0, 0};
+ for(int k = 0; k < 2; ++k) {
+ for(int l = k * 3; l < k * 3 + 3; ++l)
+ v[k] += coeffMatLag(i, l) * coeffMatLag(i, l);
+ }
+ min = std::min(min, coeffDetLag(i) / v[0] / v[1]);
+ }
+ else if(el->getDim() == 3) {
+ double v[3] = {0, 0, 0};
+ for(int k = 0; k < 3; ++k) {
+ for(int l = k * 3; l < k * 3 + 3; ++l)
+ v[k] += coeffMatLag(i, l) * coeffMatLag(i, l);
+ }
+ min = std::min(min, coeffDetLag(i) / std::sqrt(v[0] * v[1] * v[2]));
+ }
+ }
-// Jacobian determinant (for validity of all elements)
-_CoeffDataJac::_CoeffDataJac(fullVector<double> &v,
- const bezierBasis *bfs,
- int depth)
-: _CoeffData(depth), _coeffs(v.getDataPtr(), v.size()), _bfs(bfs)
-{
- if (!v.getOwnData()) {
- Msg::Fatal("Cannot create an instance of _CoeffDataJac from a "
- "fullVector that does not own its data.");
- }
- // _coeffs reuses the data of v, this avoid to allocate a new array and to
- // copy data that are not used outside of this object.
- // It remains to swap ownership:
- v.setOwnData(false);
- const_cast<fullVector<double>&>(_coeffs).setOwnData(true);
-
- _minL = _maxL = v(0);
- int i = 1;
- for (; i < bfs->getNumLagCoeff(); i++) {
- _minL = std::min(_minL, v(i));
- _maxL = std::max(_maxL, v(i));
- }
- _minB = _minL;
- _maxB = _maxL;
- for (; i < v.size(); i++) {
- _minB = std::min(_minB, v(i));
- _maxB = std::max(_maxB, v(i));
+ return min;
}
-}
-bool _CoeffDataJac::boundsOk(double minL, double maxL) const
-{
- double tol = std::max(std::abs(minL), std::abs(maxL)) * 1e-3;
- return (minL <= 0 || _minB > 0) &&
- minL - _minB < tol &&
- _maxB - maxL < tol;
-}
+ // Virtual class _CoeffData
+ bool _lessMinB::operator()(_CoeffData *cd1, _CoeffData *cd2) const
+ {
+ return cd1->minB() > cd2->minB();
+ }
-void _CoeffDataJac::getSubCoeff(std::vector<_CoeffData*> &v) const
-{
- v.clear();
- v.reserve(_bfs->getNumDivision());
- fullVector<double> subCoeff;
- _bfs->subdivideBezCoeff(_coeffs, subCoeff);
-
- int sz = _coeffs.size();
- for (int i = 0; i < _bfs->getNumDivision(); i++) {
- fullVector<double> coeff(sz);
- coeff.copy(subCoeff, i * sz, sz, 0);
- _CoeffDataJac *newData = new _CoeffDataJac(coeff, _bfs, _depth+1);
- v.push_back(newData);
+ bool _lessMaxB::operator()(_CoeffData *cd1, _CoeffData *cd2) const
+ {
+ return cd1->maxB() < cd2->maxB();
}
-}
-// IGE measure (Inverse Gradient Error)
-_CoeffDataIGE::_CoeffDataIGE(fullVector<double> &det,
- fullMatrix<double> &mat,
- const bezierBasis *bfsDet,
- const bezierBasis *bfsMat,
- int depth, int type)
-: _CoeffData(depth), _coeffsJacDet(det.getDataPtr(), det.size()),
- _coeffsJacMat(mat.getDataPtr(), mat.size1(), mat.size2()),
- _bfsDet(bfsDet), _bfsMat(bfsMat), _type(type)
-{
- if (!det.getOwnData() || !mat.getOwnData()) {
- Msg::Fatal("Cannot create an instance of _CoeffDataIGE from a "
- "fullVector or a fullMatrix that does not own its data.");
+ // Jacobian determinant (for validity of all elements)
+ _CoeffDataJac::_CoeffDataJac(fullVector<double> &v, const bezierBasis *bfs,
+ int depth)
+ : _CoeffData(depth), _coeffs(v.getDataPtr(), v.size()), _bfs(bfs)
+ {
+ if(!v.getOwnData()) {
+ Msg::Fatal("Cannot create an instance of _CoeffDataJac from a "
+ "fullVector that does not own its data.");
+ }
+ // _coeffs reuses the data of v, this avoid to allocate a new array and to
+ // copy data that are not used outside of this object.
+ // It remains to swap ownership:
+ v.setOwnData(false);
+ const_cast<fullVector<double> &>(_coeffs).setOwnData(true);
+
+ _minL = _maxL = v(0);
+ int i = 1;
+ for(; i < bfs->getNumLagCoeff(); i++) {
+ _minL = std::min(_minL, v(i));
+ _maxL = std::max(_maxL, v(i));
+ }
+ _minB = _minL;
+ _maxB = _maxL;
+ for(; i < v.size(); i++) {
+ _minB = std::min(_minB, v(i));
+ _maxB = std::max(_maxB, v(i));
+ }
}
- // _coeffsJacDet and _coeffsJacMat reuse data, this avoid to allocate new
- // arrays and to copy data that are not used outside of this object.
- // It remains to swap ownerships:
- det.setOwnData(false);
- mat.setOwnData(false);
- const_cast<fullVector<double>&>(_coeffsJacDet).setOwnData(true);
- const_cast<fullMatrix<double>&>(_coeffsJacMat).setOwnData(true);
-
- _computeAtCorner(_minL, _maxL);
-
- _minB = 0;
- if (boundsOk(_minL, _maxL)) return;
- else _minB = _computeLowerBound();
- // computation of _maxB not implemented for now
-}
-bool _CoeffDataIGE::boundsOk(double minL, double maxL) const
-{
- static const double tolmin = 1e-3;
- static const double tolmax = 1e-2;
- const double tol = tolmin + (tolmax-tolmin) * std::max(_minB, .0);
- return minL - _minB < tol;
-}
+ bool _CoeffDataJac::boundsOk(double minL, double maxL) const
+ {
+ double tol = std::max(std::abs(minL), std::abs(maxL)) * 1e-3;
+ return (minL <= 0 || _minB > 0) && minL - _minB < tol && _maxB - maxL < tol;
+ }
-void _CoeffDataIGE::getSubCoeff(std::vector<_CoeffData*> &v) const
-{
- v.clear();
- v.reserve(_bfsDet->getNumDivision());
- fullVector<double> subCoeffD;
- fullMatrix<double> subCoeffM;
- _bfsDet->subdivideBezCoeff(_coeffsJacDet, subCoeffD);
- _bfsMat->subdivideBezCoeff(_coeffsJacMat, subCoeffM);
-
- int szD = _coeffsJacDet.size();
- int szM1 = _coeffsJacMat.size1();
- int szM2 = _coeffsJacMat.size2();
- for (int i = 0; i < _bfsDet->getNumDivision(); i++) {
- fullVector<double> coeffD(szD);
- fullMatrix<double> coeffM(szM1, szM2);
- coeffD.copy(subCoeffD, i * szD, szD, 0);
- coeffM.copy(subCoeffM, i * szM1, szM1, 0, szM2, 0, 0);
- _CoeffDataIGE *newData;
- newData = new _CoeffDataIGE(coeffD, coeffM, _bfsDet, _bfsMat,
- _depth+1, _type);
- v.push_back(newData);
+ void _CoeffDataJac::getSubCoeff(std::vector<_CoeffData *> &v) const
+ {
+ v.clear();
+ v.reserve(_bfs->getNumDivision());
+ fullVector<double> subCoeff;
+ _bfs->subdivideBezCoeff(_coeffs, subCoeff);
+
+ int sz = _coeffs.size();
+ for(int i = 0; i < _bfs->getNumDivision(); i++) {
+ fullVector<double> coeff(sz);
+ coeff.copy(subCoeff, i * sz, sz, 0);
+ _CoeffDataJac *newData = new _CoeffDataJac(coeff, _bfs, _depth + 1);
+ v.push_back(newData);
+ }
}
-}
-void _CoeffDataIGE::_computeAtCorner(double &min, double &max) const
-{
- fullMatrix<double> v;
- computeCoeffLengthVectors_(_coeffsJacMat, v, _type, _bfsDet->getNumLagCoeff());
+ // IGE measure (Inverse Gradient Error)
+ _CoeffDataIGE::_CoeffDataIGE(fullVector<double> &det, fullMatrix<double> &mat,
+ const bezierBasis *bfsDet,
+ const bezierBasis *bfsMat, int depth, int type)
+ : _CoeffData(depth), _coeffsJacDet(det.getDataPtr(), det.size()),
+ _coeffsJacMat(mat.getDataPtr(), mat.size1(), mat.size2()),
+ _bfsDet(bfsDet), _bfsMat(bfsMat), _type(type)
+ {
+ if(!det.getOwnData() || !mat.getOwnData()) {
+ Msg::Fatal("Cannot create an instance of _CoeffDataIGE from a "
+ "fullVector or a fullMatrix that does not own its data.");
+ }
+ // _coeffsJacDet and _coeffsJacMat reuse data, this avoid to allocate new
+ // arrays and to copy data that are not used outside of this object.
+ // It remains to swap ownerships:
+ det.setOwnData(false);
+ mat.setOwnData(false);
+ const_cast<fullVector<double> &>(_coeffsJacDet).setOwnData(true);
+ const_cast<fullMatrix<double> &>(_coeffsJacMat).setOwnData(true);
+
+ _computeAtCorner(_minL, _maxL);
+
+ _minB = 0;
+ if(boundsOk(_minL, _maxL))
+ return;
+ else
+ _minB = _computeLowerBound();
+ // computation of _maxB not implemented for now
+ }
- fullVector<double> ige;
- computeIGE_(_coeffsJacDet, v, ige, _type);
+ bool _CoeffDataIGE::boundsOk(double minL, double maxL) const
+ {
+ static const double tolmin = 1e-3;
+ static const double tolmax = 1e-2;
+ const double tol = tolmin + (tolmax - tolmin) * std::max(_minB, .0);
+ return minL - _minB < tol;
+ }
- min = std::numeric_limits<double>::infinity();
- max = -min;
- for (int i = 0; i < ige.size(); ++i) {
- min = std::min(min, ige(i));
- max = std::max(max, ige(i));
+ void _CoeffDataIGE::getSubCoeff(std::vector<_CoeffData *> &v) const
+ {
+ v.clear();
+ v.reserve(_bfsDet->getNumDivision());
+ fullVector<double> subCoeffD;
+ fullMatrix<double> subCoeffM;
+ _bfsDet->subdivideBezCoeff(_coeffsJacDet, subCoeffD);
+ _bfsMat->subdivideBezCoeff(_coeffsJacMat, subCoeffM);
+
+ int szD = _coeffsJacDet.size();
+ int szM1 = _coeffsJacMat.size1();
+ int szM2 = _coeffsJacMat.size2();
+ for(int i = 0; i < _bfsDet->getNumDivision(); i++) {
+ fullVector<double> coeffD(szD);
+ fullMatrix<double> coeffM(szM1, szM2);
+ coeffD.copy(subCoeffD, i * szD, szD, 0);
+ coeffM.copy(subCoeffM, i * szM1, szM1, 0, szM2, 0, 0);
+ _CoeffDataIGE *newData;
+ newData =
+ new _CoeffDataIGE(coeffD, coeffM, _bfsDet, _bfsMat, _depth + 1, _type);
+ v.push_back(newData);
+ }
}
-}
-double _CoeffDataIGE::_computeLowerBound() const
-{
- // Speedup: If one coeff _coeffsJacDet is negative, without bounding
- // J^2/(a^2+b^2), we would get with certainty a negative lower bound.
- // For now, returning 0.
- for (int i = 0; i < _coeffsJacDet.size(); ++i) {
- if (_coeffsJacDet(i) < 0) {
- return 0;
+ void _CoeffDataIGE::_computeAtCorner(double &min, double &max) const
+ {
+ fullMatrix<double> v;
+ computeCoeffLengthVectors_(_coeffsJacMat, v, _type,
+ _bfsDet->getNumLagCoeff());
+
+ fullVector<double> ige;
+ computeIGE_(_coeffsJacDet, v, ige, _type);
+
+ min = std::numeric_limits<double>::infinity();
+ max = -min;
+ for(int i = 0; i < ige.size(); ++i) {
+ min = std::min(min, ige(i));
+ max = std::max(max, ige(i));
}
}
- fullMatrix<double> v;
- computeCoeffLengthVectors_(_coeffsJacMat, v, _type);
+ double _CoeffDataIGE::_computeLowerBound() const
+ {
+ // Speedup: If one coeff _coeffsJacDet is negative, without bounding
+ // J^2/(a^2+b^2), we would get with certainty a negative lower bound.
+ // For now, returning 0.
+ for(int i = 0; i < _coeffsJacDet.size(); ++i) {
+ if(_coeffsJacDet(i) < 0) {
+ return 0;
+ }
+ }
- fullVector<double> prox[6];
- for (int i = 0; i < v.size2(); ++i) {
- prox[i].setAsProxy(v, i);
- }
+ fullMatrix<double> v;
+ computeCoeffLengthVectors_(_coeffsJacMat, v, _type);
- bezierBasisRaiser *raiser = _bfsMat->getRaiser();
- fullVector<double> coeffDenominator;
- double result = 0;
+ fullVector<double> prox[6];
+ for(int i = 0; i < v.size2(); ++i) {
+ prox[i].setAsProxy(v, i);
+ }
- switch (_type) {
- case TYPE_QUA:
- raiser->computeCoeff(prox[0], prox[1], coeffDenominator);
- return _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+ bezierBasisRaiser *raiser = _bfsMat->getRaiser();
+ fullVector<double> coeffDenominator;
+ double result = 0;
- case TYPE_TRI:
- raiser->computeCoeff(prox[0], prox[1], coeffDenominator);
- result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
- raiser->computeCoeff(prox[0], prox[2], coeffDenominator);
- result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
- raiser->computeCoeff(prox[1], prox[2], coeffDenominator);
- result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
- return cTri*result/3;
+ switch(_type) {
+ case TYPE_QUA:
+ raiser->computeCoeff(prox[0], prox[1], coeffDenominator);
+ return _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
- case TYPE_HEX:
- raiser->computeCoeff(prox[0], prox[1], prox[2], coeffDenominator);
- return _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+ case TYPE_TRI:
+ raiser->computeCoeff(prox[0], prox[1], coeffDenominator);
+ result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+ raiser->computeCoeff(prox[0], prox[2], coeffDenominator);
+ result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+ raiser->computeCoeff(prox[1], prox[2], coeffDenominator);
+ result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+ return cTri * result / 3;
- case TYPE_PRI:
- raiser->computeCoeff(prox[0], prox[1], prox[2], coeffDenominator);
- result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
- raiser->computeCoeff(prox[0], prox[3], prox[2], coeffDenominator);
- result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
- raiser->computeCoeff(prox[1], prox[3], prox[2], coeffDenominator);
- result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
- return cTri*result/3;
+ case TYPE_HEX:
+ raiser->computeCoeff(prox[0], prox[1], prox[2], coeffDenominator);
+ return _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
- case TYPE_TET:
- {
- fullVector<double> thirdTerm, coeffNum1, tmp;
- thirdTerm = prox[1];
- thirdTerm.axpy(prox[2]);
- thirdTerm.axpy(prox[3]);
- thirdTerm.axpy(prox[4]);
- raiser->computeCoeff(prox[0], prox[5], thirdTerm, coeffNum1);
- thirdTerm = prox[0];
- thirdTerm.axpy(prox[2]);
- thirdTerm.axpy(prox[3]);
- thirdTerm.axpy(prox[5]);
- raiser->computeCoeff(prox[1], prox[4], thirdTerm, tmp);
- coeffNum1.axpy(tmp);
- thirdTerm = prox[0];
- thirdTerm.axpy(prox[1]);
- thirdTerm.axpy(prox[4]);
- thirdTerm.axpy(prox[5]);
- raiser->computeCoeff(prox[2], prox[3], thirdTerm, tmp);
- coeffNum1.axpy(tmp);
-
- fullVector<double> coeffDen1, coeffDen2;
- raiser->computeCoeff(prox[0], prox[1], prox[2], coeffDen1);
- raiser->computeCoeff(prox[3], prox[4], prox[5], coeffDen2);
-
- fullVector<double> &coeffNumerator = tmp;
- bezierBasisRaiser *raiserBis = _bfsDet->getRaiser();
- raiserBis->computeCoeff(coeffNum1, _coeffsJacDet, coeffNumerator);
- raiserBis->computeCoeff(coeffDen1, coeffDen2, coeffDenominator);
-
- result = _computeBoundRational(coeffNumerator, coeffDenominator, true);
- return cTet*result/12;
+ case TYPE_PRI:
+ raiser->computeCoeff(prox[0], prox[1], prox[2], coeffDenominator);
+ result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+ raiser->computeCoeff(prox[0], prox[3], prox[2], coeffDenominator);
+ result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+ raiser->computeCoeff(prox[1], prox[3], prox[2], coeffDenominator);
+ result += _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+ return cTri * result / 3;
+
+ case TYPE_TET: {
+ fullVector<double> thirdTerm, coeffNum1, tmp;
+ thirdTerm = prox[1];
+ thirdTerm.axpy(prox[2]);
+ thirdTerm.axpy(prox[3]);
+ thirdTerm.axpy(prox[4]);
+ raiser->computeCoeff(prox[0], prox[5], thirdTerm, coeffNum1);
+ thirdTerm = prox[0];
+ thirdTerm.axpy(prox[2]);
+ thirdTerm.axpy(prox[3]);
+ thirdTerm.axpy(prox[5]);
+ raiser->computeCoeff(prox[1], prox[4], thirdTerm, tmp);
+ coeffNum1.axpy(tmp);
+ thirdTerm = prox[0];
+ thirdTerm.axpy(prox[1]);
+ thirdTerm.axpy(prox[4]);
+ thirdTerm.axpy(prox[5]);
+ raiser->computeCoeff(prox[2], prox[3], thirdTerm, tmp);
+ coeffNum1.axpy(tmp);
+
+ fullVector<double> coeffDen1, coeffDen2;
+ raiser->computeCoeff(prox[0], prox[1], prox[2], coeffDen1);
+ raiser->computeCoeff(prox[3], prox[4], prox[5], coeffDen2);
+
+ fullVector<double> &coeffNumerator = tmp;
+ bezierBasisRaiser *raiserBis = _bfsDet->getRaiser();
+ raiserBis->computeCoeff(coeffNum1, _coeffsJacDet, coeffNumerator);
+ raiserBis->computeCoeff(coeffDen1, coeffDen2, coeffDenominator);
+
+ result = _computeBoundRational(coeffNumerator, coeffDenominator, true);
+ return cTet * result / 12;
+ }
+
+ case TYPE_PYR: {
+ fullVector<double> thirdTerm, coeffNum1, tmp;
+ thirdTerm = prox[2];
+ thirdTerm.axpy(prox[3]);
+ thirdTerm.axpy(prox[4]);
+ thirdTerm.axpy(prox[5]);
+ raiser->computeCoeff(prox[0], prox[1], thirdTerm, coeffNum1);
+ thirdTerm = prox[4];
+ thirdTerm.axpy(prox[5]);
+ raiser->computeCoeff(prox[2], prox[3], thirdTerm, tmp);
+ coeffNum1.axpy(tmp);
+ thirdTerm = prox[2];
+ thirdTerm.axpy(prox[3]);
+ raiser->computeCoeff(prox[4], prox[5], thirdTerm, tmp);
+ coeffNum1.axpy(tmp);
+
+ fullVector<double> coeffDen1, coeffDen2;
+ raiser->computeCoeff(prox[0], prox[1], prox[2], coeffDen1);
+ raiser->computeCoeff(prox[3], prox[4], prox[5], coeffDen2);
+
+ fullVector<double> &coeffNumerator = tmp;
+ bezierBasisRaiser *raiserBis = _bfsDet->getRaiser();
+ raiserBis->computeCoeff(coeffNum1, _coeffsJacDet, coeffNumerator);
+ raiserBis->computeCoeff(coeffDen1, coeffDen2, coeffDenominator);
+
+ result = _computeBoundRational(coeffNumerator, coeffDenominator, true);
+ return cPyr * result / 8;
+ }
+
+ default: Msg::Info("Unknown type for IGE (%d)", _type); return -1;
+ }
}
- case TYPE_PYR:
+ // ICN measure (Inverse Condition Number)
+ _CoeffDataICN::_CoeffDataICN(fullVector<double> &det, fullMatrix<double> &mat,
+ const bezierBasis *bfsDet,
+ const bezierBasis *bfsMat, int depth)
+ : _CoeffData(depth), _coeffsJacDet(det.getDataPtr(), det.size()),
+ _coeffsJacMat(mat.getDataPtr(), mat.size1(), mat.size2()),
+ _bfsDet(bfsDet), _bfsMat(bfsMat)
{
- fullVector<double> thirdTerm, coeffNum1, tmp;
- thirdTerm = prox[2];
- thirdTerm.axpy(prox[3]);
- thirdTerm.axpy(prox[4]);
- thirdTerm.axpy(prox[5]);
- raiser->computeCoeff(prox[0], prox[1], thirdTerm, coeffNum1);
- thirdTerm = prox[4];
- thirdTerm.axpy(prox[5]);
- raiser->computeCoeff(prox[2], prox[3], thirdTerm, tmp);
- coeffNum1.axpy(tmp);
- thirdTerm = prox[2];
- thirdTerm.axpy(prox[3]);
- raiser->computeCoeff(prox[4], prox[5], thirdTerm, tmp);
- coeffNum1.axpy(tmp);
-
- fullVector<double> coeffDen1, coeffDen2;
- raiser->computeCoeff(prox[0], prox[1], prox[2], coeffDen1);
- raiser->computeCoeff(prox[3], prox[4], prox[5], coeffDen2);
-
- fullVector<double> &coeffNumerator = tmp;
- bezierBasisRaiser *raiserBis = _bfsDet->getRaiser();
- raiserBis->computeCoeff(coeffNum1, _coeffsJacDet, coeffNumerator);
- raiserBis->computeCoeff(coeffDen1, coeffDen2, coeffDenominator);
-
- result = _computeBoundRational(coeffNumerator, coeffDenominator, true);
- return cPyr*result/8;
+ if(!det.getOwnData() || !mat.getOwnData()) {
+ Msg::Fatal("Cannot create an instance of _CoeffDataIGE from a "
+ "fullVector or a fullMatrix that does not own its data.");
+ }
+ // _coeffsJacDet and _coeffsMetric reuse data, this avoid to allocate new
+ // arrays and to copy data that are not used outside of this object.
+ // It remains to swap ownerships:
+ det.setOwnData(false);
+ mat.setOwnData(false);
+ const_cast<fullVector<double> &>(_coeffsJacDet).setOwnData(true);
+ const_cast<fullMatrix<double> &>(_coeffsJacMat).setOwnData(true);
+
+ _computeAtCorner(_minL, _maxL);
+
+ _minB = 0;
+ if(boundsOk(_minL, _maxL))
+ return;
+ else
+ _minB = _computeLowerBound();
+ // _maxB not used for now
}
- default:
- Msg::Info("Unknown type for IGE (%d)", _type);
- return -1;
+ bool _CoeffDataICN::boundsOk(double minL, double maxL) const
+ {
+ static const double tolmin = 1e-3;
+ static const double tolmax = 1e-2;
+ const double tol = tolmin + (tolmax - tolmin) * std::max(_minB, .0);
+ return minL - _minB < tol;
}
-}
-// ICN measure (Inverse Condition Number)
-_CoeffDataICN::_CoeffDataICN(fullVector<double> &det,
- fullMatrix<double> &mat,
- const bezierBasis *bfsDet,
- const bezierBasis *bfsMat,
- int depth)
-: _CoeffData(depth), _coeffsJacDet(det.getDataPtr(), det.size()),
- _coeffsJacMat(mat.getDataPtr(), mat.size1(), mat.size2()),
- _bfsDet(bfsDet), _bfsMat(bfsMat)
-{
- if (!det.getOwnData() || !mat.getOwnData()) {
- Msg::Fatal("Cannot create an instance of _CoeffDataIGE from a "
- "fullVector or a fullMatrix that does not own its data.");
+ void _CoeffDataICN::getSubCoeff(std::vector<_CoeffData *> &v) const
+ {
+ v.clear();
+ v.reserve(_bfsMat->getNumDivision());
+ fullMatrix<double> subCoeffM;
+ fullVector<double> subCoeffD;
+ _bfsMat->subdivideBezCoeff(_coeffsJacMat, subCoeffM);
+ _bfsDet->subdivideBezCoeff(_coeffsJacDet, subCoeffD);
+
+ int szD = _coeffsJacDet.size();
+ int szM1 = _coeffsJacMat.size1();
+ int szM2 = _coeffsJacMat.size2();
+ for(int i = 0; i < _bfsMat->getNumDivision(); i++) {
+ fullVector<double> coeffD(szD);
+ fullMatrix<double> coeffM(szM1, szM2);
+ coeffD.copy(subCoeffD, i * szD, szD, 0);
+ coeffM.copy(subCoeffM, i * szM1, szM1, 0, szM2, 0, 0);
+ _CoeffDataICN *newData =
+ new _CoeffDataICN(coeffD, coeffM, _bfsDet, _bfsMat, _depth + 1);
+ v.push_back(newData);
+ }
}
- // _coeffsJacDet and _coeffsMetric reuse data, this avoid to allocate new
- // arrays and to copy data that are not used outside of this object.
- // It remains to swap ownerships:
- det.setOwnData(false);
- mat.setOwnData(false);
- const_cast<fullVector<double>&>(_coeffsJacDet).setOwnData(true);
- const_cast<fullMatrix<double>&>(_coeffsJacMat).setOwnData(true);
-
- _computeAtCorner(_minL, _maxL);
-
- _minB = 0;
- if (boundsOk(_minL, _maxL)) return;
- else _minB = _computeLowerBound();
- // _maxB not used for now
-}
-bool _CoeffDataICN::boundsOk(double minL, double maxL) const
-{
- static const double tolmin = 1e-3;
- static const double tolmax = 1e-2;
- const double tol = tolmin + (tolmax-tolmin) * std::max(_minB, .0);
- return minL - _minB < tol;
-}
+ void _CoeffDataICN::_computeAtCorner(double &min, double &max) const
+ {
+ min = std::numeric_limits<double>::infinity();
+ max = -min;
-void _CoeffDataICN::getSubCoeff(std::vector<_CoeffData*> &v) const
-{
- v.clear();
- v.reserve(_bfsMat->getNumDivision());
- fullMatrix<double> subCoeffM;
- fullVector<double> subCoeffD;
- _bfsMat->subdivideBezCoeff(_coeffsJacMat, subCoeffM);
- _bfsDet->subdivideBezCoeff(_coeffsJacDet, subCoeffD);
-
- int szD = _coeffsJacDet.size();
- int szM1 = _coeffsJacMat.size1();
- int szM2 = _coeffsJacMat.size2();
- for (int i = 0; i < _bfsMat->getNumDivision(); i++) {
- fullVector<double> coeffD(szD);
- fullMatrix<double> coeffM(szM1, szM2);
- coeffD.copy(subCoeffD, i * szD, szD, 0);
- coeffM.copy(subCoeffM, i * szM1, szM1, 0, szM2, 0, 0);
- _CoeffDataICN *newData
- = new _CoeffDataICN(coeffD, coeffM, _bfsDet, _bfsMat, _depth+1);
- v.push_back(newData);
+ for(int i = 0; i < _bfsMat->getNumLagCoeff(); i++) {
+ double p = 0;
+ for(int k = 0; k < _coeffsJacMat.size2(); ++k) {
+ p += pow_int(_coeffsJacMat(i, k), 2);
+ }
+ double qual;
+ if(_coeffsJacMat.size2() == 6) // if 2D
+ qual = 2 * _coeffsJacDet(i) / p;
+ else // 3D
+ qual = 3 * std::pow(_coeffsJacDet(i), 2 / 3.) / p;
+ min = std::min(min, qual);
+ max = std::max(max, qual);
+ }
}
-}
-void _CoeffDataICN::_computeAtCorner(double &min, double &max) const
-{
- min = std::numeric_limits<double>::infinity();
- max = -min;
-
- for (int i = 0; i < _bfsMat->getNumLagCoeff(); i++) {
- double p = 0;
- for (int k = 0; k < _coeffsJacMat.size2(); ++k) {
- p += pow_int(_coeffsJacMat(i, k), 2);
+ double _CoeffDataICN::_computeLowerBound() const
+ {
+ // Speedup: If one coeff _coeffsJacDet is negative, we would get
+ // a negative lower bound. For now, returning 0.
+ for(int i = 0; i < _coeffsJacDet.size(); ++i) {
+ if(_coeffsJacDet(i) < 0) {
+ return 0;
+ }
}
- double qual;
- if (_coeffsJacMat.size2() == 6) // if 2D
- qual = 2 * _coeffsJacDet(i) / p;
- else // 3D
- qual = 3 * std::pow(_coeffsJacDet(i), 2/3.) / p;
- min = std::min(min, qual);
- max = std::max(max, qual);
- }
-}
-double _CoeffDataICN::_computeLowerBound() const
-{
- // Speedup: If one coeff _coeffsJacDet is negative, we would get
- // a negative lower bound. For now, returning 0.
- for (int i = 0; i < _coeffsJacDet.size(); ++i) {
- if (_coeffsJacDet(i) < 0) {
- return 0;
+ // 2D element
+ if(_coeffsJacMat.size2() == 6) {
+ fullVector<double> coeffDenominator;
+ {
+ bezierBasisRaiser *raiser = _bfsMat->getRaiser();
+ fullVector<double> prox;
+ for(int k = 0; k < _coeffsJacMat.size2(); ++k) {
+ prox.setAsProxy(_coeffsJacMat, k);
+ fullVector<double> tmp;
+ raiser->computeCoeff(prox, prox, tmp);
+ if(k == 0) coeffDenominator.resize(tmp.size());
+ coeffDenominator.axpy(tmp, 1);
+ }
+ }
+ return 2 * _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
}
- }
- // 2D element
- if (_coeffsJacMat.size2() == 6) {
+ // 3D element NEW
fullVector<double> coeffDenominator;
{
- bezierBasisRaiser *raiser = _bfsMat->getRaiser();
- fullVector<double> prox;
- for (int k = 0; k < _coeffsJacMat.size2(); ++k) {
- prox.setAsProxy(_coeffsJacMat, k);
- fullVector<double> tmp;
- raiser->computeCoeff(prox, prox, tmp);
- if (k == 0) coeffDenominator.resize(tmp.size());
- coeffDenominator.axpy(tmp, 1);
+ // P: coefficients of function that bound from above the Frobenius norm of
+ // J element of P are automatically set to 0
+ fullVector<double> P(_coeffsJacMat.size1());
+ for(int i = 0; i < _coeffsJacMat.size1(); ++i) {
+ for(int k = 0; k < _coeffsJacMat.size2(); ++k) {
+ P(i) += _coeffsJacMat(i, k) * _coeffsJacMat(i, k);
+ }
+ P(i) = std::sqrt(P(i));
}
+ _bfsMat->getRaiser()->computeCoeff(P, P, P, coeffDenominator);
}
- return 2*_computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+
+ const double boundFraction =
+ _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
+
+ return 3 * std::pow(boundFraction * boundFraction, 1. / 3);
}
- // 3D element NEW
- fullVector<double> coeffDenominator;
+ // Miscellaneous
+ template <typename Comp>
+ void _subdivideDomainsMinOrMax(std::vector<_CoeffData *> &domains,
+ double &minL, double &maxL)
{
- // P: coefficients of function that bound from above the Frobenius norm of J
- // element of P are automatically set to 0
- fullVector<double> P(_coeffsJacMat.size1());
- for (int i = 0; i < _coeffsJacMat.size1(); ++i) {
- for (int k = 0; k < _coeffsJacMat.size2(); ++k) {
- P(i) += _coeffsJacMat(i, k) * _coeffsJacMat(i, k);
+ std::vector<_CoeffData *> subs;
+ make_heap(domains.begin(), domains.end(), Comp());
+ int k = 0;
+ const int max_subdivision = 1000;
+ while(!domains[0]->boundsOk(minL, maxL) && k++ < max_subdivision) {
+ _CoeffData *cd = domains[0];
+ pop_heap(domains.begin(), domains.end(), Comp());
+ domains.pop_back();
+ cd->getSubCoeff(subs);
+ delete cd;
+
+ for(unsigned int i = 0; i < subs.size(); i++) {
+ minL = std::min(minL, subs[i]->minL());
+ maxL = std::max(maxL, subs[i]->maxL());
+ domains.push_back(subs[i]);
+ push_heap(domains.begin(), domains.end(), Comp());
}
- P(i) = std::sqrt(P(i));
}
- _bfsMat->getRaiser()->computeCoeff(P, P, P, coeffDenominator);
- }
-
- const double boundFraction =
- _computeBoundRational(_coeffsJacDet, coeffDenominator, true);
-
- return 3*std::pow(boundFraction * boundFraction, 1./3);
-}
-
-// Miscellaneous
-template<typename Comp>
-void _subdivideDomainsMinOrMax(std::vector<_CoeffData*> &domains,
- double &minL,
- double &maxL)
-{
- std::vector<_CoeffData*> subs;
- make_heap(domains.begin(), domains.end(), Comp());
- int k = 0;
- const int max_subdivision = 1000;
- while (!domains[0]->boundsOk(minL, maxL) && k++ < max_subdivision) {
- _CoeffData *cd = domains[0];
- pop_heap(domains.begin(), domains.end(), Comp());
- domains.pop_back();
- cd->getSubCoeff(subs);
- delete cd;
-
- for (unsigned int i = 0; i < subs.size(); i++) {
- minL = std::min(minL, subs[i]->minL());
- maxL = std::max(maxL, subs[i]->maxL());
- domains.push_back(subs[i]);
- push_heap(domains.begin(), domains.end(), Comp());
+ if(k > max_subdivision) {
+ Msg::Error("Max subdivision (%d) (size %d)", max_subdivision,
+ domains.size());
}
}
- if (k > max_subdivision) {
- Msg::Error("Max subdivision (%d) (size %d)", max_subdivision, domains.size());
- }
-}
-void _subdivideDomains(std::vector<_CoeffData*> &domains)
-{
- if (domains.empty()) {
- Msg::Warning("empty vector in Bezier subdivision, nothing to do");
- return;
- }
- double minL = domains[0]->minL();
- double maxL = domains[0]->maxL();
- for (unsigned int i = 1; i < domains.size(); ++i) {
- minL = std::min(minL, domains[i]->minL());
- maxL = std::max(maxL, domains[i]->maxL());
- }
-
- _subdivideDomainsMinOrMax<_lessMinB>(domains, minL, maxL);
- _subdivideDomainsMinOrMax<_lessMaxB>(domains, minL, maxL);
-}
+ void _subdivideDomains(std::vector<_CoeffData *> &domains)
+ {
+ if(domains.empty()) {
+ Msg::Warning("empty vector in Bezier subdivision, nothing to do");
+ return;
+ }
+ double minL = domains[0]->minL();
+ double maxL = domains[0]->maxL();
+ for(unsigned int i = 1; i < domains.size(); ++i) {
+ minL = std::min(minL, domains[i]->minL());
+ maxL = std::max(maxL, domains[i]->maxL());
+ }
-double _getMinAndDeleteDomains(std::vector<_CoeffData*> &domains)
-{
- double minB = domains[0]->minB();
- double minL = domains[0]->minL();
- delete domains[0];
- for (unsigned int i = 1; i < domains.size(); ++i) {
- minB = std::min(minB, domains[i]->minB());
- minL = std::min(minL, domains[i]->minL());
- delete domains[i];
+ _subdivideDomainsMinOrMax<_lessMinB>(domains, minL, maxL);
+ _subdivideDomainsMinOrMax<_lessMaxB>(domains, minL, maxL);
}
- double fact = .5 * (minB + minL);
- return fact * minL + (1-fact) * minB;
-}
-double _computeBoundRational(const fullVector<double> &numerator,
- const fullVector<double> &denominator,
- bool lower, bool positiveDenom)
-{
- if (numerator.size() != denominator.size()) {
- Msg::Fatal("In order to compute a bound on a rational function, I need "
- "vectors of the same size! (%d vs %d)", numerator.size(),
- denominator.size());
- return 0;
+ double _getMinAndDeleteDomains(std::vector<_CoeffData *> &domains)
+ {
+ double minB = domains[0]->minB();
+ double minL = domains[0]->minL();
+ delete domains[0];
+ for(unsigned int i = 1; i < domains.size(); ++i) {
+ minB = std::min(minB, domains[i]->minB());
+ minL = std::min(minL, domains[i]->minL());
+ delete domains[i];
+ }
+ double fact = .5 * (minB + minL);
+ return fact * minL + (1 - fact) * minB;
}
- // upper and lower bound of the desired bound:
- const double inf = std::numeric_limits<double>::infinity();
- double upperBound = inf;
- double lowerBound = -inf;
-
- if (!positiveDenom) lower = !lower;
+ double _computeBoundRational(const fullVector<double> &numerator,
+ const fullVector<double> &denominator,
+ bool lower, bool positiveDenom)
+ {
+ if(numerator.size() != denominator.size()) {
+ Msg::Fatal("In order to compute a bound on a rational function, I need "
+ "vectors of the same size! (%d vs %d)",
+ numerator.size(), denominator.size());
+ return 0;
+ }
- if (lower) {
- // if lower is true, we seek: bound * den <= num
- for (int i = 0; i < numerator.size(); ++i) {
- if (denominator(i) == 0) {
- if (numerator(i) < 0) return -inf;
- }
- else if (denominator(i) > 0) {
- upperBound = std::min(upperBound, numerator(i)/denominator(i));
- }
- else {
- lowerBound = std::max(lowerBound, numerator(i)/denominator(i));
+ // upper and lower bound of the desired bound:
+ const double inf = std::numeric_limits<double>::infinity();
+ double upperBound = inf;
+ double lowerBound = -inf;
+
+ if(!positiveDenom) lower = !lower;
+
+ if(lower) {
+ // if lower is true, we seek: bound * den <= num
+ for(int i = 0; i < numerator.size(); ++i) {
+ if(denominator(i) == 0) {
+ if(numerator(i) < 0) return -inf;
+ }
+ else if(denominator(i) > 0) {
+ upperBound = std::min(upperBound, numerator(i) / denominator(i));
+ }
+ else {
+ lowerBound = std::max(lowerBound, numerator(i) / denominator(i));
+ }
}
+ if(lowerBound > upperBound)
+ return -inf;
+ else
+ return upperBound;
}
- if (lowerBound > upperBound)
- return -inf;
- else
- return upperBound;
- }
- else {
- // otherwise, we seek: bound * den >= num
- for (int i = 0; i < numerator.size(); ++i) {
- if (denominator(i) == 0) {
- if (numerator(i) > 0) return inf;
- }
- else if (denominator(i) > 0) {
- lowerBound = std::max(lowerBound, numerator(i)/denominator(i));
- }
- else {
- upperBound = std::min(upperBound, numerator(i)/denominator(i));
+ else {
+ // otherwise, we seek: bound * den >= num
+ for(int i = 0; i < numerator.size(); ++i) {
+ if(denominator(i) == 0) {
+ if(numerator(i) > 0) return inf;
+ }
+ else if(denominator(i) > 0) {
+ lowerBound = std::max(lowerBound, numerator(i) / denominator(i));
+ }
+ else {
+ upperBound = std::min(upperBound, numerator(i) / denominator(i));
+ }
}
+ if(lowerBound > upperBound)
+ return inf;
+ else
+ return lowerBound;
}
- if (lowerBound > upperBound)
- return inf;
- else
- return lowerBound;
}
-}
} // end namespace jacobianBasedQuality
diff --git a/Mesh/qualityMeasuresJacobian.h b/Mesh/qualityMeasuresJacobian.h
index 31f54961d928bb8e230451ae0ed750c623c76a8b..006ee4e3f76e51b9a92873a0f841003bc59e5e1e 100644
--- a/Mesh/qualityMeasuresJacobian.h
+++ b/Mesh/qualityMeasuresJacobian.h
@@ -15,125 +15,117 @@ class MElement;
namespace jacobianBasedQuality {
-void minMaxJacobianDeterminant(MElement *el, double &min, double &max,
- const fullMatrix<double> *normals = NULL);
-double minIGEMeasure(MElement *el,
- bool knownValid = false,
- bool reversedOk = false,
- const fullMatrix<double> *normals = NULL);
-double minICNMeasure(MElement *el,
- bool knownValid = false,
- bool reversedOk = false,
- const fullMatrix<double> *normals = NULL);
-void sampleIGEMeasure(MElement *el, int order, double &min, double &max);
-void sampleJacobian(MElement *el, int order, fullVector<double> &jac,
- const fullMatrix<double> *normals = NULL);
-void sampleIGEMeasure(MElement *el, int order, fullVector<double> &ige);
-void sampleICNMeasure(MElement *el, int order, fullVector<double> &icn);
-double minSampledICNMeasure(MElement *el, int order);//fordebug
-double minSampledIGEMeasure(MElement *el, int order);//fordebug
-
-class _CoeffData
-{
-protected:
- double _minL, _maxL; //Extremum of Jac at corners
- double _minB, _maxB; //Extremum of bezier coefficients
- const int _depth;
-
-public:
- _CoeffData(int depth) : _minL(0), _maxL(0), _minB(0), _maxB(0),
- _depth(depth) {}
- virtual ~_CoeffData() {}
-
- inline double minL() const {return _minL;}
- inline double maxL() const {return _maxL;}
- inline double minB() const {return _minB;}
- inline double maxB() const {return _maxB;}
- inline int depth() const {return _depth;}
-
- virtual bool boundsOk(double minL, double maxL) const = 0;
- virtual void getSubCoeff(std::vector<_CoeffData*>&) const = 0;
- virtual int getNumMeasure() const {return 0;}//fordebug
-};
-
-struct _lessMinB {
- bool operator()(_CoeffData*, _CoeffData*) const;
-};
-struct _lessMaxB {
- bool operator()(_CoeffData*, _CoeffData*) const;
-};
-
-class _CoeffDataJac: public _CoeffData
-{
-private:
- const fullVector<double> _coeffs;
- const bezierBasis *_bfs;
-
-public:
- _CoeffDataJac(fullVector<double> &v, const bezierBasis *bfs, int depth);
- ~_CoeffDataJac() {}
-
- bool boundsOk(double minL, double maxL) const;
- void getSubCoeff(std::vector<_CoeffData*>&) const;
- int getNumMeasure() const {return 1;}//fordebug
-};
-
-class _CoeffDataIGE: public _CoeffData
-{
-private:
- const fullVector<double> _coeffsJacDet;
- const fullMatrix<double> _coeffsJacMat;
- const bezierBasis *_bfsDet, *_bfsMat;
- const int _type;
-
-public:
- _CoeffDataIGE(fullVector<double> &det,
- fullMatrix<double> &mat,
- const bezierBasis *bfsDet,
- const bezierBasis *bfsMat,
- int depth, int type);
- ~_CoeffDataIGE() {}
-
- bool boundsOk(double minL, double maxL) const;
- void getSubCoeff(std::vector<_CoeffData*>&) const;
- int getNumMeasure() const {return 2;}//fordebug
-
-private:
- void _computeAtCorner(double &min, double &max) const;
- double _computeLowerBound() const;
-};
-
-class _CoeffDataICN: public _CoeffData
-{
-private:
- const fullVector<double> _coeffsJacDet;
- const fullMatrix<double> _coeffsJacMat;
- const bezierBasis *_bfsDet, *_bfsMat;
-
-public:
- _CoeffDataICN(fullVector<double> &det,
- fullMatrix<double> &metric,
- const bezierBasis *bfsDet,
- const bezierBasis *bfsMet,
- int depth);
- ~_CoeffDataICN() {}
-
- bool boundsOk(double minL, double maxL) const;
- void getSubCoeff(std::vector<_CoeffData*>&) const;
- int getNumMeasure() const {return 4;}//fordebug
-
-private:
- void _computeAtCorner(double &min, double &max) const;
- double _computeLowerBound() const;
-};
-
-double _computeBoundRational(const fullVector<double> &numerator,
- const fullVector<double> &denominator,
- bool lower, bool positiveDenom = true);
-
-void _subdivideDomains(std::vector<_CoeffData*> &domains);
-double _getMinAndDeleteDomains(std::vector<_CoeffData*> &domains);
-
-}
+ void minMaxJacobianDeterminant(MElement *el, double &min, double &max,
+ const fullMatrix<double> *normals = NULL);
+ double minIGEMeasure(MElement *el, bool knownValid = false,
+ bool reversedOk = false,
+ const fullMatrix<double> *normals = NULL);
+ double minICNMeasure(MElement *el, bool knownValid = false,
+ bool reversedOk = false,
+ const fullMatrix<double> *normals = NULL);
+ void sampleIGEMeasure(MElement *el, int order, double &min, double &max);
+ void sampleJacobian(MElement *el, int order, fullVector<double> &jac,
+ const fullMatrix<double> *normals = NULL);
+ void sampleIGEMeasure(MElement *el, int order, fullVector<double> &ige);
+ void sampleICNMeasure(MElement *el, int order, fullVector<double> &icn);
+ double minSampledICNMeasure(MElement *el, int order); // fordebug
+ double minSampledIGEMeasure(MElement *el, int order); // fordebug
+
+ class _CoeffData {
+ protected:
+ double _minL, _maxL; // Extremum of Jac at corners
+ double _minB, _maxB; // Extremum of bezier coefficients
+ const int _depth;
+
+ public:
+ _CoeffData(int depth)
+ : _minL(0), _maxL(0), _minB(0), _maxB(0), _depth(depth)
+ {
+ }
+ virtual ~_CoeffData() {}
+
+ inline double minL() const { return _minL; }
+ inline double maxL() const { return _maxL; }
+ inline double minB() const { return _minB; }
+ inline double maxB() const { return _maxB; }
+ inline int depth() const { return _depth; }
+
+ virtual bool boundsOk(double minL, double maxL) const = 0;
+ virtual void getSubCoeff(std::vector<_CoeffData *> &) const = 0;
+ virtual int getNumMeasure() const { return 0; } // fordebug
+ };
+
+ struct _lessMinB {
+ bool operator()(_CoeffData *, _CoeffData *) const;
+ };
+ struct _lessMaxB {
+ bool operator()(_CoeffData *, _CoeffData *) const;
+ };
+
+ class _CoeffDataJac : public _CoeffData {
+ private:
+ const fullVector<double> _coeffs;
+ const bezierBasis *_bfs;
+
+ public:
+ _CoeffDataJac(fullVector<double> &v, const bezierBasis *bfs, int depth);
+ ~_CoeffDataJac() {}
+
+ bool boundsOk(double minL, double maxL) const;
+ void getSubCoeff(std::vector<_CoeffData *> &) const;
+ int getNumMeasure() const { return 1; } // fordebug
+ };
+
+ class _CoeffDataIGE : public _CoeffData {
+ private:
+ const fullVector<double> _coeffsJacDet;
+ const fullMatrix<double> _coeffsJacMat;
+ const bezierBasis *_bfsDet, *_bfsMat;
+ const int _type;
+
+ public:
+ _CoeffDataIGE(fullVector<double> &det, fullMatrix<double> &mat,
+ const bezierBasis *bfsDet, const bezierBasis *bfsMat,
+ int depth, int type);
+ ~_CoeffDataIGE() {}
+
+ bool boundsOk(double minL, double maxL) const;
+ void getSubCoeff(std::vector<_CoeffData *> &) const;
+ int getNumMeasure() const { return 2; } // fordebug
+
+ private:
+ void _computeAtCorner(double &min, double &max) const;
+ double _computeLowerBound() const;
+ };
+
+ class _CoeffDataICN : public _CoeffData {
+ private:
+ const fullVector<double> _coeffsJacDet;
+ const fullMatrix<double> _coeffsJacMat;
+ const bezierBasis *_bfsDet, *_bfsMat;
+
+ public:
+ _CoeffDataICN(fullVector<double> &det, fullMatrix<double> &metric,
+ const bezierBasis *bfsDet, const bezierBasis *bfsMet,
+ int depth);
+ ~_CoeffDataICN() {}
+
+ bool boundsOk(double minL, double maxL) const;
+ void getSubCoeff(std::vector<_CoeffData *> &) const;
+ int getNumMeasure() const { return 4; } // fordebug
+
+ private:
+ void _computeAtCorner(double &min, double &max) const;
+ double _computeLowerBound() const;
+ };
+
+ double _computeBoundRational(const fullVector<double> &numerator,
+ const fullVector<double> &denominator,
+ bool lower, bool positiveDenom = true);
+
+ void _subdivideDomains(std::vector<_CoeffData *> &domains);
+ double _getMinAndDeleteDomains(std::vector<_CoeffData *> &domains);
+
+} // namespace jacobianBasedQuality
#endif
diff --git a/Mesh/simple3D.cpp b/Mesh/simple3D.cpp
index 847d64b30e9749f5e16b3d7419433688452f3ca5..fcc9efb73841a56d7c9777e53ac6adb6180d585f 100644
--- a/Mesh/simple3D.cpp
+++ b/Mesh/simple3D.cpp
@@ -22,15 +22,16 @@
#include "rtree.h"
#include "Field.h"
-#define k1 0.7 //k1*h is the minimal distance between two nodes
-#define k2 0.5 //k2*h is the minimal distance to the boundary
+#define k1 0.7 // k1*h is the minimal distance between two nodes
+#define k2 0.5 // k2*h is the minimal distance to the boundary
/*********definitions*********/
-class Metric{
- private:
- double m11,m21,m31,m12,m22,m32,m13,m23,m33;
- public:
+class Metric {
+private:
+ double m11, m21, m31, m12, m22, m32, m13, m23, m33;
+
+public:
Metric();
~Metric();
void set_m11(double);
@@ -53,14 +54,15 @@ class Metric{
double get_m33();
};
-class Node{
- private:
+class Node {
+private:
int layer;
int limit;
double h;
Metric m;
SPoint3 point;
- public:
+
+public:
double min[3];
double max[3];
Node();
@@ -78,21 +80,22 @@ class Node{
SPoint3 get_point();
};
-class Wrapper{
- private:
+class Wrapper {
+private:
bool ok;
- Node* individual;
- Node* parent;
- public:
+ Node *individual;
+ Node *parent;
+
+public:
Wrapper();
- Wrapper(Node*,Node*);
+ Wrapper(Node *, Node *);
~Wrapper();
void set_ok(bool);
- void set_individual(Node*);
- void set_parent(Node*);
+ void set_individual(Node *);
+ void set_parent(Node *);
bool get_ok();
- Node* get_individual();
- Node* get_parent();
+ Node *get_individual();
+ Node *get_parent();
};
/*********functions*********/
@@ -100,9 +103,9 @@ class Wrapper{
double infinity_distance(const SPoint3 &p1, const SPoint3 &p2, Metric m)
{
double distance;
- double x1,y1,z1;
- double x2,y2,z2;
- double a,b,c,d,e,f,g,h,i;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double a, b, c, d, e, f, g, h, i;
a = m.get_m11();
b = m.get_m21();
@@ -114,35 +117,36 @@ double infinity_distance(const SPoint3 &p1, const SPoint3 &p2, Metric m)
h = m.get_m23();
i = m.get_m33();
- x1 = a*p1.x() + b*p1.y() + c*p1.z();
- y1 = d*p1.x() + e*p1.y() + f*p1.z();
- z1 = g*p1.x() + h*p1.y() + i*p1.z();
+ x1 = a * p1.x() + b * p1.y() + c * p1.z();
+ y1 = d * p1.x() + e * p1.y() + f * p1.z();
+ z1 = g * p1.x() + h * p1.y() + i * p1.z();
- x2 = a*p2.x() + b*p2.y() + c*p2.z();
- y2 = d*p2.x() + e*p2.y() + f*p2.z();
- z2 = g*p2.x() + h*p2.y() + i*p2.z();
+ x2 = a * p2.x() + b * p2.y() + c * p2.z();
+ y2 = d * p2.x() + e * p2.y() + f * p2.z();
+ z2 = g * p2.x() + h * p2.y() + i * p2.z();
- distance = std::max(std::max(fabs(x2-x1),fabs(y2-y1)),fabs(z2-z1));
+ distance = std::max(std::max(fabs(x2 - x1), fabs(y2 - y1)), fabs(z2 - z1));
return distance;
}
-bool rtree_callback(Node* neighbour,void* w)
+bool rtree_callback(Node *neighbour, void *w)
{
double h;
double distance;
Metric m;
- Node *individual,*parent;
- Wrapper* wrapper;
+ Node *individual, *parent;
+ Wrapper *wrapper;
- wrapper = static_cast<Wrapper*>(w);
+ wrapper = static_cast<Wrapper *>(w);
individual = wrapper->get_individual();
parent = wrapper->get_parent();
h = individual->get_size();
m = individual->get_metric();
- if(neighbour!=parent){
- distance = infinity_distance(individual->get_point(),neighbour->get_point(),m);
- if(distance<k1*h){
+ if(neighbour != parent) {
+ distance =
+ infinity_distance(individual->get_point(), neighbour->get_point(), m);
+ if(distance < k1 * h) {
wrapper->set_ok(0);
return false;
}
@@ -166,49 +170,47 @@ Metric::Metric()
m33 = 1.0;
}
-Metric::~Metric(){}
+Metric::~Metric() {}
-void Metric::set_m11(double new_m11){ m11 = new_m11; }
+void Metric::set_m11(double new_m11) { m11 = new_m11; }
-void Metric::set_m21(double new_m21){ m21 = new_m21; }
+void Metric::set_m21(double new_m21) { m21 = new_m21; }
-void Metric::set_m31(double new_m31){ m31 = new_m31; }
+void Metric::set_m31(double new_m31) { m31 = new_m31; }
-void Metric::set_m12(double new_m12){ m12 = new_m12; }
+void Metric::set_m12(double new_m12) { m12 = new_m12; }
-void Metric::set_m22(double new_m22){ m22 = new_m22; }
+void Metric::set_m22(double new_m22) { m22 = new_m22; }
-void Metric::set_m32(double new_m32){ m32 = new_m32; }
+void Metric::set_m32(double new_m32) { m32 = new_m32; }
-void Metric::set_m13(double new_m13){ m13 = new_m13; }
+void Metric::set_m13(double new_m13) { m13 = new_m13; }
-void Metric::set_m23(double new_m23){ m23 = new_m23; }
+void Metric::set_m23(double new_m23) { m23 = new_m23; }
-void Metric::set_m33(double new_m33){ m33 = new_m33; }
+void Metric::set_m33(double new_m33) { m33 = new_m33; }
-double Metric::get_m11(){ return m11; }
+double Metric::get_m11() { return m11; }
-double Metric::get_m21(){ return m21; }
+double Metric::get_m21() { return m21; }
-double Metric::get_m31(){ return m31; }
+double Metric::get_m31() { return m31; }
-double Metric::get_m12(){ return m12; }
+double Metric::get_m12() { return m12; }
-double Metric::get_m22(){ return m22; }
+double Metric::get_m22() { return m22; }
-double Metric::get_m32(){ return m32; }
+double Metric::get_m32() { return m32; }
-double Metric::get_m13(){ return m13; }
+double Metric::get_m13() { return m13; }
-double Metric::get_m23(){ return m23; }
+double Metric::get_m23() { return m23; }
-double Metric::get_m33(){ return m33; }
+double Metric::get_m33() { return m33; }
/*********class Node*********/
-Node::Node(){
- limit = -1;
-}
+Node::Node() { limit = -1; }
Node::Node(const SPoint3 &new_point)
{
@@ -216,134 +218,106 @@ Node::Node(const SPoint3 &new_point)
limit = -1;
}
-Node::~Node(){}
+Node::~Node() {}
-void Node::set_layer(int new_layer){
- layer = new_layer;
-}
+void Node::set_layer(int new_layer) { layer = new_layer; }
-void Node::set_limit(int new_limit){
- limit = new_limit;
-}
+void Node::set_limit(int new_limit) { limit = new_limit; }
-void Node::set_size(double new_h){
- h = new_h;
-}
+void Node::set_size(double new_h) { h = new_h; }
void Node::set_metric(const Metric &new_m) { m = new_m; }
void Node::set_point(const SPoint3 &new_point) { point = new_point; }
-int Node::get_layer(){
- return layer;
-}
+int Node::get_layer() { return layer; }
-int Node::get_limit(){
- return limit;
-}
+int Node::get_limit() { return limit; }
-double Node::get_size(){
- return h;
-}
+double Node::get_size() { return h; }
-Metric Node::get_metric(){
- return m;
-}
+Metric Node::get_metric() { return m; }
-SPoint3 Node::get_point(){
- return point;
-}
+SPoint3 Node::get_point() { return point; }
/*********class Wrapper*********/
-Wrapper::Wrapper(){
- ok = 1;
-}
+Wrapper::Wrapper() { ok = 1; }
-Wrapper::Wrapper(Node* new_individual,Node* new_parent){
+Wrapper::Wrapper(Node *new_individual, Node *new_parent)
+{
ok = 1;
individual = new_individual;
parent = new_parent;
}
-Wrapper::~Wrapper(){}
+Wrapper::~Wrapper() {}
-void Wrapper::set_ok(bool new_ok){
- ok = new_ok;
-}
+void Wrapper::set_ok(bool new_ok) { ok = new_ok; }
-void Wrapper::set_individual(Node* new_individual){
+void Wrapper::set_individual(Node *new_individual)
+{
individual = new_individual;
}
-void Wrapper::set_parent(Node* new_parent){
- parent = new_parent;
-}
+void Wrapper::set_parent(Node *new_parent) { parent = new_parent; }
-bool Wrapper::get_ok(){
- return ok;
-}
+bool Wrapper::get_ok() { return ok; }
-Node* Wrapper::get_individual(){
- return individual;
-}
+Node *Wrapper::get_individual() { return individual; }
-Node* Wrapper::get_parent(){
- return parent;
-}
+Node *Wrapper::get_parent() { return parent; }
/*********class Filler*********/
-Filler::Filler(){}
+Filler::Filler() {}
-Filler::~Filler(){}
+Filler::~Filler() {}
void Filler::treat_model()
{
- GRegion* gr;
- GModel* model = GModel::current();
+ GRegion *gr;
+ GModel *model = GModel::current();
GModel::riter it;
- for(it=model->firstRegion();it!=model->lastRegion();it++)
- {
+ for(it = model->firstRegion(); it != model->lastRegion(); it++) {
gr = *it;
- if(gr->getNumMeshElements()>0){
+ if(gr->getNumMeshElements() > 0) {
treat_region(gr);
}
}
}
-void Filler::treat_region(GRegion* gr)
+void Filler::treat_region(GRegion *gr)
{
-
int NumSmooth = CTX::instance()->mesh.smoothCrossField;
- std::cout << "NumSmooth = " << NumSmooth << std::endl ;
- if(NumSmooth && (gr->dim() == 3)){
- double scale = gr->bounds().diag()*1e-2;
- Frame_field::initRegion(gr,NumSmooth);
- Frame_field::saveCrossField("cross0.pos",scale);
-
- Frame_field::smoothRegion(gr,NumSmooth);
- Frame_field::saveCrossField("cross1.pos",scale);
+ std::cout << "NumSmooth = " << NumSmooth << std::endl;
+ if(NumSmooth && (gr->dim() == 3)) {
+ double scale = gr->bounds().diag() * 1e-2;
+ Frame_field::initRegion(gr, NumSmooth);
+ Frame_field::saveCrossField("cross0.pos", scale);
+
+ Frame_field::smoothRegion(gr, NumSmooth);
+ Frame_field::saveCrossField("cross1.pos", scale);
}
int count;
int limit;
bool ok2;
- double x,y,z;
+ double x, y, z;
SPoint3 point;
- Node *node,*individual,*parent;
+ Node *node, *individual, *parent;
- MElementOctree* octree;
+ MElementOctree *octree;
deMeshGRegion deleter;
Wrapper wrapper;
- GFace* gf;
- std::vector<Node*> garbage;
- std::vector<MVertex*> boundary_vertices;
- std::set<MVertex*>::iterator it;
- std::vector<GFace*>::iterator it2;
- std::map<MVertex*,int>::iterator it3;
- RTree<Node*,double,3,double> rtree;
+ GFace *gf;
+ std::vector<Node *> garbage;
+ std::vector<MVertex *> boundary_vertices;
+ std::set<MVertex *>::iterator it;
+ std::vector<GFace *>::iterator it2;
+ std::map<MVertex *, int>::iterator it3;
+ RTree<Node *, double, 3, double> rtree;
Frame_field::init_region(gr);
Size_field::init_region(gr);
@@ -354,78 +328,79 @@ void Filler::treat_region(GRegion* gr)
boundary_vertices.clear();
new_vertices.clear();
- std::vector<GFace*> faces = gr->faces();
- std::map<MVertex*,int> limits;
+ std::vector<GFace *> faces = gr->faces();
+ std::map<MVertex *, int> limits;
- std::set<MVertex*> temp;
+ std::set<MVertex *> temp;
- for(it2=faces.begin();it2!=faces.end();it2++){
+ for(it2 = faces.begin(); it2 != faces.end(); it2++) {
gf = *it2;
limit = code(gf->tag());
- for(GFace::size_type i=0;i<gf->getNumMeshElements();i++){
- MElement* element = gf->getMeshElement(i);
- for(std::size_t j=0;j<element->getNumVertices();j++){
- MVertex* vertex = element->getVertex(j);
+ for(GFace::size_type i = 0; i < gf->getNumMeshElements(); i++) {
+ MElement *element = gf->getMeshElement(i);
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
+ MVertex *vertex = element->getVertex(j);
temp.insert(vertex);
- limits.insert(std::pair<MVertex*,int>(vertex,limit));
+ limits.insert(std::pair<MVertex *, int>(vertex, limit));
}
}
}
- for(it=temp.begin();it!=temp.end();it++){
- if((*it)->onWhat()->dim()==0){
+ for(it = temp.begin(); it != temp.end(); it++) {
+ if((*it)->onWhat()->dim() == 0) {
boundary_vertices.push_back(*it);
}
}
- for(it=temp.begin();it!=temp.end();it++){
- if((*it)->onWhat()->dim()==1){
+ for(it = temp.begin(); it != temp.end(); it++) {
+ if((*it)->onWhat()->dim() == 1) {
boundary_vertices.push_back(*it);
}
}
- for(it=temp.begin();it!=temp.end();it++){
- if((*it)->onWhat()->dim()==2){
+ for(it = temp.begin(); it != temp.end(); it++) {
+ if((*it)->onWhat()->dim() == 2) {
boundary_vertices.push_back(*it);
}
}
- std::queue<Node*> fifo;
+ std::queue<Node *> fifo;
- for(std::size_t i=0;i<boundary_vertices.size();i++){
+ for(std::size_t i = 0; i < boundary_vertices.size(); i++) {
x = boundary_vertices[i]->x();
y = boundary_vertices[i]->y();
z = boundary_vertices[i]->z();
- node = new Node(SPoint3(x,y,z));
- compute_parameters(node,gr);
+ node = new Node(SPoint3(x, y, z));
+ compute_parameters(node, gr);
node->set_layer(0);
it3 = limits.find(boundary_vertices[i]);
node->set_limit(it3->second);
- rtree.Insert(node->min,node->max,node);
+ rtree.Insert(node->min, node->max, node);
fifo.push(node);
}
count = 1;
- while(!fifo.empty()){
+ while(!fifo.empty()) {
parent = fifo.front();
fifo.pop();
garbage.push_back(parent);
- if(parent->get_limit()!=-1 && parent->get_layer()>=parent->get_limit()){
+ if(parent->get_limit() != -1 &&
+ parent->get_layer() >= parent->get_limit()) {
continue;
}
- std::vector<Node*> spawns(6);
- for(int i=0;i<6;i++){
+ std::vector<Node *> spawns(6);
+ for(int i = 0; i < 6; i++) {
spawns[i] = new Node();
}
- create_spawns(gr,octree,parent,spawns);
+ create_spawns(gr, octree, parent, spawns);
- for(int i=0;i<6;i++){
+ for(int i = 0; i < 6; i++) {
ok2 = 0;
individual = spawns[i];
point = individual->get_point();
@@ -433,43 +408,43 @@ void Filler::treat_region(GRegion* gr)
y = point.y();
z = point.z();
- if(inside_domain(octree,x,y,z)){
- compute_parameters(individual,gr);
- individual->set_layer(parent->get_layer()+1);
- individual->set_limit(parent->get_limit());
-
- if(far_from_boundary(octree,individual)){
- wrapper.set_ok(1);
- wrapper.set_individual(individual);
- wrapper.set_parent(parent);
- rtree.Search(individual->min,individual->max,rtree_callback,&wrapper);
-
- if(wrapper.get_ok()){
- fifo.push(individual);
- rtree.Insert(individual->min,individual->max,individual);
- new_vertices.push_back(new MVertex(x,y,z,gr,0));
- ok2 = 1;
- //print_segment(individual->get_point(),parent->get_point(),file);
- }
- }
+ if(inside_domain(octree, x, y, z)) {
+ compute_parameters(individual, gr);
+ individual->set_layer(parent->get_layer() + 1);
+ individual->set_limit(parent->get_limit());
+
+ if(far_from_boundary(octree, individual)) {
+ wrapper.set_ok(1);
+ wrapper.set_individual(individual);
+ wrapper.set_parent(parent);
+ rtree.Search(individual->min, individual->max, rtree_callback,
+ &wrapper);
+
+ if(wrapper.get_ok()) {
+ fifo.push(individual);
+ rtree.Insert(individual->min, individual->max, individual);
+ new_vertices.push_back(new MVertex(x, y, z, gr, 0));
+ ok2 = 1;
+ // print_segment(individual->get_point(),parent->get_point(),file);
+ }
+ }
}
if(!ok2) delete individual;
}
- if(count%100==0){
- printf("%d\n",count);
+ if(count % 100 == 0) {
+ printf("%d\n", count);
}
count++;
}
-
int option = CTX::instance()->mesh.algo3d;
CTX::instance()->mesh.algo3d = ALGO_3D_DELAUNAY;
deleter(gr);
printf("%d vertices to add\n", (int)new_vertices.size());
- std::vector<GRegion*> regions;
+ std::vector<GRegion *> regions;
regions.push_back(gr);
meshGRegion mesher(regions); //?
mesher(gr); //?
@@ -477,8 +452,8 @@ void Filler::treat_region(GRegion* gr)
CTX::instance()->mesh.algo3d = option;
- for(std::size_t i=0;i<garbage.size();i++) delete garbage[i];
- for(std::size_t i=0;i<new_vertices.size();i++) delete new_vertices[i];
+ for(std::size_t i = 0; i < garbage.size(); i++) delete garbage[i];
+ for(std::size_t i = 0; i < new_vertices.size(); i++) delete new_vertices[i];
delete octree;
rtree.RemoveAll();
@@ -486,15 +461,15 @@ void Filler::treat_region(GRegion* gr)
Frame_field::clear();
}
-Metric Filler::get_metric(double x,double y,double z)
+Metric Filler::get_metric(double x, double y, double z)
{
Metric m;
STensor3 m2;
- if(CTX::instance()->mesh.smoothCrossField){
- m2 = Frame_field::findCross(x,y,z);
+ if(CTX::instance()->mesh.smoothCrossField) {
+ m2 = Frame_field::findCross(x, y, z);
}
else
- m2 = Frame_field::search(x,y,z);
+ m2 = Frame_field::search(x, y, z);
m.set_m11(m2.get_m11());
m.set_m21(m2.get_m21());
@@ -511,23 +486,23 @@ Metric Filler::get_metric(double x,double y,double z)
return m;
}
-Metric Filler::get_metric(double x,double y,double z,GEntity* ge)
+Metric Filler::get_metric(double x, double y, double z, GEntity *ge)
{
Metric m;
SMetric3 temp;
- SVector3 v1,v2,v3;
- Field* field;
- FieldManager* manager;
+ SVector3 v1, v2, v3;
+ Field *field;
+ FieldManager *manager;
- v1 = SVector3(1.0,0.0,0.0);
- v2 = SVector3(0.0,1.0,0.0);
- v3 = SVector3(0.0,0.0,1.0);
+ v1 = SVector3(1.0, 0.0, 0.0);
+ v2 = SVector3(0.0, 1.0, 0.0);
+ v3 = SVector3(0.0, 0.0, 1.0);
manager = ge->model()->getFields();
- if(manager->getBackgroundField()>0){
+ if(manager->getBackgroundField() > 0) {
field = manager->get(manager->getBackgroundField());
- if(field){
- (*field)(x,y,z,temp,ge);
+ if(field) {
+ (*field)(x, y, z, temp, ge);
}
}
@@ -546,43 +521,45 @@ Metric Filler::get_metric(double x,double y,double z,GEntity* ge)
return m;
}
-double Filler::get_size(double x,double y,double z){
-
- return Size_field::search(x,y,z);
+double Filler::get_size(double x, double y, double z)
+{
+ return Size_field::search(x, y, z);
}
-double Filler::get_size(double x,double y,double z,GEntity* ge)
+double Filler::get_size(double x, double y, double z, GEntity *ge)
{
double h;
- Field* field;
- FieldManager* manager;
+ Field *field;
+ FieldManager *manager;
h = 1.0;
manager = ge->model()->getFields();
- if(manager->getBackgroundField()>0){
+ if(manager->getBackgroundField() > 0) {
field = manager->get(manager->getBackgroundField());
- if(field){
- h = (*field)(x,y,z,ge);
+ if(field) {
+ h = (*field)(x, y, z, ge);
}
}
return h;
}
-bool Filler::inside_domain(MElementOctree* octree,double x,double y,double z)
+bool Filler::inside_domain(MElementOctree *octree, double x, double y, double z)
{
- MElement* element;
- element = (MElement*)octree->find(x,y,z,3,true);
- if(element!=NULL) return 1;
- else return 0;
+ MElement *element;
+ element = (MElement *)octree->find(x, y, z, 3, true);
+ if(element != NULL)
+ return 1;
+ else
+ return 0;
}
-bool Filler::far_from_boundary(MElementOctree* octree,Node* node)
+bool Filler::far_from_boundary(MElementOctree *octree, Node *node)
{
- double x,y,z;
+ double x, y, z;
double h;
SPoint3 point;
- MElement *e1,*e2,*e3,*e4,*e5,*e6;
+ MElement *e1, *e2, *e3, *e4, *e5, *e6;
point = node->get_point();
x = point.x();
@@ -590,20 +567,23 @@ bool Filler::far_from_boundary(MElementOctree* octree,Node* node)
z = point.z();
h = node->get_size();
- e1 = (MElement*)octree->find(x+k2*h,y,z,3,true);
- e2 = (MElement*)octree->find(x-k2*h,y,z,3,true);
- e3 = (MElement*)octree->find(x,y+k2*h,z,3,true);
- e4 = (MElement*)octree->find(x,y-k2*h,z,3,true);
- e5 = (MElement*)octree->find(x,y,z+k2*h,3,true);
- e6 = (MElement*)octree->find(x,y,z-k2*h,3,true);
+ e1 = (MElement *)octree->find(x + k2 * h, y, z, 3, true);
+ e2 = (MElement *)octree->find(x - k2 * h, y, z, 3, true);
+ e3 = (MElement *)octree->find(x, y + k2 * h, z, 3, true);
+ e4 = (MElement *)octree->find(x, y - k2 * h, z, 3, true);
+ e5 = (MElement *)octree->find(x, y, z + k2 * h, 3, true);
+ e6 = (MElement *)octree->find(x, y, z - k2 * h, 3, true);
- if(e1!=NULL && e2!=NULL && e3!=NULL && e4!=NULL && e5!=NULL && e6!=NULL) return 1;
- else return 0;
+ if(e1 != NULL && e2 != NULL && e3 != NULL && e4 != NULL && e5 != NULL &&
+ e6 != NULL)
+ return 1;
+ else
+ return 0;
}
-void Filler::compute_parameters(Node* node,GEntity* ge)
+void Filler::compute_parameters(Node *node, GEntity *ge)
{
- double x,y,z;
+ double x, y, z;
double h;
Metric m;
SPoint3 point;
@@ -612,8 +592,8 @@ void Filler::compute_parameters(Node* node,GEntity* ge)
x = point.x();
y = point.y();
z = point.z();
- m = get_metric(x,y,z);
- h = get_size(x,y,z);
+ m = get_metric(x, y, z);
+ h = get_size(x, y, z);
node->set_size(h);
node->set_metric(m);
@@ -625,18 +605,18 @@ void Filler::compute_parameters(Node* node,GEntity* ge)
node->max[2] = z + std::sqrt(3.0) * h;
}
-void Filler::create_spawns(GEntity* ge,MElementOctree* octree,
- Node* node,std::vector<Node*>& spawns)
+void Filler::create_spawns(GEntity *ge, MElementOctree *octree, Node *node,
+ std::vector<Node *> &spawns)
{
- double x,y,z;
- double x1,y1,z1;
- double x2,y2,z2;
- double x3,y3,z3;
- double x4,y4,z4;
- double x5,y5,z5;
- double x6,y6,z6;
+ double x, y, z;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double x3, y3, z3;
+ double x4, y4, z4;
+ double x5, y5, z5;
+ double x6, y6, z6;
double h;
- double h1,h2,h3,h4,h5,h6;
+ double h1, h2, h3, h4, h5, h6;
Metric m;
SPoint3 point;
@@ -647,76 +627,84 @@ void Filler::create_spawns(GEntity* ge,MElementOctree* octree,
h = node->get_size();
m = node->get_metric();
- h1 = improvement(ge,octree,point,h,SVector3(m.get_m11(),m.get_m21(),m.get_m31()));
- x1 = x + h1*m.get_m11();
- y1 = y + h1*m.get_m21();
- z1 = z + h1*m.get_m31();
-
- h2 = improvement(ge,octree,point,h,SVector3(-m.get_m11(),-m.get_m21(),-m.get_m31()));
- x2 = x - h2*m.get_m11();
- y2 = y - h2*m.get_m21();
- z2 = z - h2*m.get_m31();
-
- h3 = improvement(ge,octree,point,h,SVector3(m.get_m12(),m.get_m22(),m.get_m32()));
- x3 = x + h3*m.get_m12();
- y3 = y + h3*m.get_m22();
- z3 = z + h3*m.get_m32();
-
- h4 = improvement(ge,octree,point,h,SVector3(-m.get_m12(),-m.get_m22(),-m.get_m32()));
- x4 = x - h4*m.get_m12();
- y4 = y - h4*m.get_m22();
- z4 = z - h4*m.get_m32();
-
- h5 = improvement(ge,octree,point,h,SVector3(m.get_m13(),m.get_m23(),m.get_m33()));
- x5 = x + h5*m.get_m13();
- y5 = y + h5*m.get_m23();
- z5 = z + h5*m.get_m33();
-
- h6 = improvement(ge,octree,point,h,SVector3(-m.get_m13(),-m.get_m23(),-m.get_m33()));
- x6 = x - h6*m.get_m13();
- y6 = y - h6*m.get_m23();
- z6 = z - h6*m.get_m33();
-
- *spawns[0] = Node(SPoint3(x1,y1,z1));
- *spawns[1] = Node(SPoint3(x2,y2,z2));
- *spawns[2] = Node(SPoint3(x3,y3,z3));
- *spawns[3] = Node(SPoint3(x4,y4,z4));
- *spawns[4] = Node(SPoint3(x5,y5,z5));
- *spawns[5] = Node(SPoint3(x6,y6,z6));
+ h1 = improvement(ge, octree, point, h,
+ SVector3(m.get_m11(), m.get_m21(), m.get_m31()));
+ x1 = x + h1 * m.get_m11();
+ y1 = y + h1 * m.get_m21();
+ z1 = z + h1 * m.get_m31();
+
+ h2 = improvement(ge, octree, point, h,
+ SVector3(-m.get_m11(), -m.get_m21(), -m.get_m31()));
+ x2 = x - h2 * m.get_m11();
+ y2 = y - h2 * m.get_m21();
+ z2 = z - h2 * m.get_m31();
+
+ h3 = improvement(ge, octree, point, h,
+ SVector3(m.get_m12(), m.get_m22(), m.get_m32()));
+ x3 = x + h3 * m.get_m12();
+ y3 = y + h3 * m.get_m22();
+ z3 = z + h3 * m.get_m32();
+
+ h4 = improvement(ge, octree, point, h,
+ SVector3(-m.get_m12(), -m.get_m22(), -m.get_m32()));
+ x4 = x - h4 * m.get_m12();
+ y4 = y - h4 * m.get_m22();
+ z4 = z - h4 * m.get_m32();
+
+ h5 = improvement(ge, octree, point, h,
+ SVector3(m.get_m13(), m.get_m23(), m.get_m33()));
+ x5 = x + h5 * m.get_m13();
+ y5 = y + h5 * m.get_m23();
+ z5 = z + h5 * m.get_m33();
+
+ h6 = improvement(ge, octree, point, h,
+ SVector3(-m.get_m13(), -m.get_m23(), -m.get_m33()));
+ x6 = x - h6 * m.get_m13();
+ y6 = y - h6 * m.get_m23();
+ z6 = z - h6 * m.get_m33();
+
+ *spawns[0] = Node(SPoint3(x1, y1, z1));
+ *spawns[1] = Node(SPoint3(x2, y2, z2));
+ *spawns[2] = Node(SPoint3(x3, y3, z3));
+ *spawns[3] = Node(SPoint3(x4, y4, z4));
+ *spawns[4] = Node(SPoint3(x5, y5, z5));
+ *spawns[5] = Node(SPoint3(x6, y6, z6));
}
double Filler::improvement(GEntity *ge, MElementOctree *octree,
const SPoint3 &point, double h1,
const SVector3 &direction)
{
- double x,y,z;
+ double x, y, z;
double average;
double h2;
- double coeffA,coeffB;
+ double coeffA, coeffB;
- x = point.x() + h1*direction.x();
- y = point.y() + h1*direction.y();
- z = point.z() + h1*direction.z();
+ x = point.x() + h1 * direction.x();
+ y = point.y() + h1 * direction.y();
+ z = point.z() + h1 * direction.z();
- if(inside_domain(octree,x,y,z)){
- h2 = get_size(x,y,z);
+ if(inside_domain(octree, x, y, z)) {
+ h2 = get_size(x, y, z);
}
- else h2 = h1;
+ else
+ h2 = h1;
coeffA = 1.0;
coeffB = 0.16;
- if(h2>h1){
- average = coeffA*h1 + (1.0-coeffA)*h2;
+ if(h2 > h1) {
+ average = coeffA * h1 + (1.0 - coeffA) * h2;
}
- else{
- average = coeffB*h1 + (1.0-coeffB)*h2;
+ else {
+ average = coeffB * h1 + (1.0 - coeffB) * h2;
}
return average;
}
-int Filler::code(int tag){
+int Filler::code(int tag)
+{
int limit;
std::string s;
std::stringstream s2;
@@ -725,11 +713,13 @@ int Filler::code(int tag){
s2 << tag;
s = s2.str();
- if(s.length()>=5){
- if(s.at(0)=='1' && s.at(1)=='1' && s.at(2)=='1' && s.at(3)=='1' && s.at(4)=='1'){
+ if(s.length() >= 5) {
+ if(s.at(0) == '1' && s.at(1) == '1' && s.at(2) == '1' && s.at(3) == '1' &&
+ s.at(4) == '1') {
limit = 0;
}
- else if(s.at(0)=='2' && s.at(1)=='2' && s.at(2)=='2' && s.at(3)=='2' && s.at(4)=='2'){
+ else if(s.at(0) == '2' && s.at(1) == '2' && s.at(2) == '2' &&
+ s.at(3) == '2' && s.at(4) == '2') {
limit = 1;
}
}
@@ -737,34 +727,27 @@ int Filler::code(int tag){
return limit;
}
-int Filler::get_nbr_new_vertices()
-{
- return new_vertices.size();
-}
+int Filler::get_nbr_new_vertices() { return new_vertices.size(); }
-MVertex* Filler::get_new_vertex(int i)
-{
- return new_vertices[i];
-}
+MVertex *Filler::get_new_vertex(int i) { return new_vertices[i]; }
void Filler::print_segment(const SPoint3 &p1, const SPoint3 &p2,
std::ofstream &file)
{
- file << "SL ("
- << p1.x() << ", " << p1.y() << ", " << p1.z() << ", "
- << p2.x() << ", " << p2.y() << ", " << p2.z() << ")"
- << "{10, 20};\n";
+ file << "SL (" << p1.x() << ", " << p1.y() << ", " << p1.z() << ", " << p2.x()
+ << ", " << p2.y() << ", " << p2.z() << ")"
+ << "{10, 20};\n";
}
-void Filler::print_node(Node* node,std::ofstream& file)
+void Filler::print_node(Node *node, std::ofstream &file)
{
- double x,y,z;
- double x1,y1,z1;
- double x2,y2,z2;
- double x3,y3,z3;
- double x4,y4,z4;
- double x5,y5,z5;
- double x6,y6,z6;
+ double x, y, z;
+ double x1, y1, z1;
+ double x2, y2, z2;
+ double x3, y3, z3;
+ double x4, y4, z4;
+ double x5, y5, z5;
+ double x6, y6, z6;
double h;
Metric m;
SPoint3 point;
@@ -776,38 +759,38 @@ void Filler::print_node(Node* node,std::ofstream& file)
h = node->get_size();
m = node->get_metric();
- x1 = x + k1*h*m.get_m11();
- y1 = y + k1*h*m.get_m21();
- z1 = z + k1*h*m.get_m31();
+ x1 = x + k1 * h * m.get_m11();
+ y1 = y + k1 * h * m.get_m21();
+ z1 = z + k1 * h * m.get_m31();
- x2 = x - k1*h*m.get_m11();
- y2 = y - k1*h*m.get_m21();
- z2 = z - k1*h*m.get_m31();
+ x2 = x - k1 * h * m.get_m11();
+ y2 = y - k1 * h * m.get_m21();
+ z2 = z - k1 * h * m.get_m31();
- x3 = x + k1*h*m.get_m12();
- y3 = y + k1*h*m.get_m22();
- z3 = z + k1*h*m.get_m32();
+ x3 = x + k1 * h * m.get_m12();
+ y3 = y + k1 * h * m.get_m22();
+ z3 = z + k1 * h * m.get_m32();
- x4 = x - k1*h*m.get_m12();
- y4 = y - k1*h*m.get_m22();
- z4 = z - k1*h*m.get_m32();
+ x4 = x - k1 * h * m.get_m12();
+ y4 = y - k1 * h * m.get_m22();
+ z4 = z - k1 * h * m.get_m32();
- x5 = x + k1*h*m.get_m13();
- y5 = y + k1*h*m.get_m23();
- z5 = z + k1*h*m.get_m33();
+ x5 = x + k1 * h * m.get_m13();
+ y5 = y + k1 * h * m.get_m23();
+ z5 = z + k1 * h * m.get_m33();
- x6 = x - k1*h*m.get_m13();
- y6 = y - k1*h*m.get_m23();
- z6 = z - k1*h*m.get_m33();
+ x6 = x - k1 * h * m.get_m13();
+ y6 = y - k1 * h * m.get_m23();
+ z6 = z - k1 * h * m.get_m33();
- print_segment(SPoint3(x,y,z),SPoint3(x1,y1,z1),file);
- print_segment(SPoint3(x,y,z),SPoint3(x2,y2,z2),file);
- print_segment(SPoint3(x,y,z),SPoint3(x3,y3,z3),file);
- print_segment(SPoint3(x,y,z),SPoint3(x4,y4,z4),file);
- print_segment(SPoint3(x,y,z),SPoint3(x5,y5,z5),file);
- print_segment(SPoint3(x,y,z),SPoint3(x6,y6,z6),file);
+ print_segment(SPoint3(x, y, z), SPoint3(x1, y1, z1), file);
+ print_segment(SPoint3(x, y, z), SPoint3(x2, y2, z2), file);
+ print_segment(SPoint3(x, y, z), SPoint3(x3, y3, z3), file);
+ print_segment(SPoint3(x, y, z), SPoint3(x4, y4, z4), file);
+ print_segment(SPoint3(x, y, z), SPoint3(x5, y5, z5), file);
+ print_segment(SPoint3(x, y, z), SPoint3(x6, y6, z6), file);
}
/*********static declarations*********/
-std::vector<MVertex*> Filler::new_vertices;
+std::vector<MVertex *> Filler::new_vertices;
diff --git a/Mesh/simple3D.h b/Mesh/simple3D.h
index d3c9cc2160ff706e6039808851d6f7c78706a8a1..da85b34c4c5ac0cc9c770798c3c936d1900a8111 100644
--- a/Mesh/simple3D.h
+++ b/Mesh/simple3D.h
@@ -6,11 +6,9 @@
// Contributor(s):
// Tristan Carrier François Henrotte
-
#ifndef _SIMPLE3D_H_
#define _SIMPLE3D_H_
-
#include "SVector3.h"
#include <list>
#include "GRegion.h"
@@ -19,30 +17,31 @@
class Node;
class Metric;
-class Filler{
- private:
- static std::vector<MVertex*> new_vertices;
- Metric get_metric(double,double,double);
- Metric get_metric(double,double,double,GEntity*);
- double get_size(double,double,double);
- double get_size(double,double,double,GEntity*);
- bool inside_domain(MElementOctree*,double,double,double);
- bool far_from_boundary(MElementOctree*,Node*);
- void compute_parameters(Node*,GEntity*);
- void create_spawns(GEntity*,MElementOctree*,Node*,std::vector<Node*>&);
+class Filler {
+private:
+ static std::vector<MVertex *> new_vertices;
+ Metric get_metric(double, double, double);
+ Metric get_metric(double, double, double, GEntity *);
+ double get_size(double, double, double);
+ double get_size(double, double, double, GEntity *);
+ bool inside_domain(MElementOctree *, double, double, double);
+ bool far_from_boundary(MElementOctree *, Node *);
+ void compute_parameters(Node *, GEntity *);
+ void create_spawns(GEntity *, MElementOctree *, Node *,
+ std::vector<Node *> &);
double improvement(GEntity *, MElementOctree *, const SPoint3 &, double,
const SVector3 &);
int code(int);
void print_segment(const SPoint3 &, const SPoint3 &, std::ofstream &);
- void print_node(Node*,std::ofstream&);
- public:
+ void print_node(Node *, std::ofstream &);
+
+public:
Filler();
~Filler();
void treat_model();
- void treat_region(GRegion*);
+ void treat_region(GRegion *);
static int get_nbr_new_vertices();
- static MVertex* get_new_vertex(int);
+ static MVertex *get_new_vertex(int);
};
#endif
-
diff --git a/Mesh/surfaceFiller.cpp b/Mesh/surfaceFiller.cpp
index a78525af8abbab3a2c1c0befe6467ed200c1d286..83e0d3b3a694a7245e0eb6edfbd051867933f0f3 100644
--- a/Mesh/surfaceFiller.cpp
+++ b/Mesh/surfaceFiller.cpp
@@ -6,7 +6,6 @@
// Contributor(s):
// Tristan Carrier Baudoin
-
#include "GmshConfig.h"
#include "surfaceFiller.h"
#include "Field.h"
@@ -44,89 +43,107 @@ using namespace std;
//
// we aim at generating a rectangle with sizes size_1 and size_2 along t1 and t2
-bool compute4neighbors (GFace *gf, // the surface
- MVertex *v_center, // the wertex for which we wnt to generate 4 neighbors
- SPoint2 &midpoint,
- bool goNonLinear, // do we compute the position in the real surface which is nonlinear
- SPoint2 newP[4][NUMDIR], // look into other directions
- SMetric3 &metricField, FILE *crossf = 0) // the mesh metric
+bool compute4neighbors(
+ GFace *gf, // the surface
+ MVertex *v_center, // the wertex for which we wnt to generate 4 neighbors
+ SPoint2 &midpoint,
+ bool goNonLinear, // do we compute the position in the real surface which is
+ // nonlinear
+ SPoint2 newP[4][NUMDIR], // look into other directions
+ SMetric3 &metricField, FILE *crossf = 0) // the mesh metric
{
// we assume that v is on surface gf
// get the parameter of the point on the surface
reparamMeshVertexOnFace(v_center, gf, midpoint);
- double L = backgroundMesh::current()->operator()(midpoint[0],midpoint[1],0.0);
+ double L =
+ backgroundMesh::current()->operator()(midpoint[0], midpoint[1], 0.0);
// printf("L = %12.5E\n",L);
- metricField = SMetric3(1./(L*L));
+ metricField = SMetric3(1. / (L * L));
FieldManager *fields = gf->model()->getFields();
- if(fields->getBackgroundField() > 0){
+ if(fields->getBackgroundField() > 0) {
Field *f = fields->get(fields->getBackgroundField());
- if (!f->isotropic()){
- (*f)(v_center->x(),v_center->y(),v_center->z(), metricField,gf);
- }
- else {
- L = (*f)(v_center->x(),v_center->y(),v_center->z(), gf);
- metricField = SMetric3(1./(L*L));
- }
+ if(!f->isotropic()) {
+ (*f)(v_center->x(), v_center->y(), v_center->z(), metricField, gf);
+ }
+ else {
+ L = (*f)(v_center->x(), v_center->y(), v_center->z(), gf);
+ metricField = SMetric3(1. / (L * L));
+ }
}
-
// get the unit normal at that point
- Pair<SVector3, SVector3> der = gf->firstDer(SPoint2(midpoint[0],midpoint[1]));
+ Pair<SVector3, SVector3> der =
+ gf->firstDer(SPoint2(midpoint[0], midpoint[1]));
SVector3 s1 = der.first();
SVector3 s2 = der.second();
- SVector3 n = crossprod(s1,s2);
+ SVector3 n = crossprod(s1, s2);
n.normalize();
- double M = dot(s1,s1);
- double N = dot(s2,s2);
- double E = dot(s1,s2);
-
+ double M = dot(s1, s1);
+ double N = dot(s2, s2);
+ double E = dot(s1, s2);
// compute the first fundamental form i.e. the metric tensor at the point
// M_{ij} = s_i \cdot s_j
- double metric[2][2] = {{M,E},{E,N}};
+ double metric[2][2] = {{M, E}, {E, N}};
// printf("%d %g %g %g\n",gf->tag(),s1.x(),s1.y(),s1.z());
- SVector3 basis_u = s1; basis_u.normalize();
- SVector3 basis_v = crossprod(n,basis_u);
+ SVector3 basis_u = s1;
+ basis_u.normalize();
+ SVector3 basis_v = crossprod(n, basis_u);
- for (int DIR = 0 ; DIR < NUMDIR ; DIR ++){
- double quadAngle = backgroundMesh::current()->getAngle (midpoint[0],midpoint[1],0) + DIRS[DIR];
+ for(int DIR = 0; DIR < NUMDIR; DIR++) {
+ double quadAngle =
+ backgroundMesh::current()->getAngle(midpoint[0], midpoint[1], 0) +
+ DIRS[DIR];
// normalize vector t1 that is tangent to gf at midpoint
- SVector3 t1 = basis_u * cos (quadAngle) + basis_v * sin (quadAngle) ;
+ SVector3 t1 = basis_u * cos(quadAngle) + basis_v * sin(quadAngle);
t1.normalize();
- // compute the second direction t2 and normalize (t1,t2,n) is the tangent frame
- SVector3 t2 = crossprod(n,t1);
+ // compute the second direction t2 and normalize (t1,t2,n) is the tangent
+ // frame
+ SVector3 t2 = crossprod(n, t1);
t2.normalize();
- if (DIR == 0 && crossf)fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",v_center->x(),v_center->y(),v_center->z(),t1.x(),t1.y(),t1.z());
- if (DIR == 0 && crossf)fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",v_center->x(),v_center->y(),v_center->z(),t2.x(),t2.y(),t2.z());
- if (DIR == 0 && crossf)fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",v_center->x(),v_center->y(),v_center->z(),-t1.x(),-t1.y(),-t1.z());
- if (DIR == 0 && crossf)fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",v_center->x(),v_center->y(),v_center->z(),-t2.x(),-t2.y(),-t2.z());
-
- double size_1 = sqrt(1. / dot(t1,metricField,t1));
- double size_2 = sqrt(1. / dot(t2,metricField,t2));
+ if(DIR == 0 && crossf)
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", v_center->x(),
+ v_center->y(), v_center->z(), t1.x(), t1.y(), t1.z());
+ if(DIR == 0 && crossf)
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", v_center->x(),
+ v_center->y(), v_center->z(), t2.x(), t2.y(), t2.z());
+ if(DIR == 0 && crossf)
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", v_center->x(),
+ v_center->y(), v_center->z(), -t1.x(), -t1.y(), -t1.z());
+ if(DIR == 0 && crossf)
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", v_center->x(),
+ v_center->y(), v_center->z(), -t2.x(), -t2.y(), -t2.z());
+
+ double size_1 = sqrt(1. / dot(t1, metricField, t1));
+ double size_2 = sqrt(1. / dot(t2, metricField, t2));
// compute covariant coordinates of t1 and t2
// t1 = a s1 + b s2 -->
// t1 . s1 = a M + b E
// t1 . s2 = a E + b N --> solve the 2 x 2 system
// and get covariant coordinates a and b
- double rhs1[2] = {dot(t1,s1),dot(t1,s2)}, covar1[2];
+ double rhs1[2] = {dot(t1, s1), dot(t1, s2)}, covar1[2];
bool singular = false;
- if (!sys2x2(metric,rhs1,covar1)){
- Msg::Info("Argh surface %d %g %g %g -- %g %g %g -- %g %g",gf->tag(),s1.x(),s1.y(),s1.z(),s2.x(),s2.y(),s2.z(),size_1,size_2);
- covar1[1] = 1.0; covar1[0] = 0.0;
+ if(!sys2x2(metric, rhs1, covar1)) {
+ Msg::Info("Argh surface %d %g %g %g -- %g %g %g -- %g %g", gf->tag(),
+ s1.x(), s1.y(), s1.z(), s2.x(), s2.y(), s2.z(), size_1, size_2);
+ covar1[1] = 1.0;
+ covar1[0] = 0.0;
singular = true;
}
- double rhs2[2] = {dot(t2,s1),dot(t2,s2)}, covar2[2];
- if (!sys2x2(metric,rhs2,covar2)){
- Msg::Info("Argh surface %d %g %g %g -- %g %g %g",gf->tag(),s1.x(),s1.y(),s1.z(),s2.x(),s2.y(),s2.z());
- covar2[0] = 1.0; covar2[1] = 0.0;
+ double rhs2[2] = {dot(t2, s1), dot(t2, s2)}, covar2[2];
+ if(!sys2x2(metric, rhs2, covar2)) {
+ Msg::Info("Argh surface %d %g %g %g -- %g %g %g", gf->tag(), s1.x(),
+ s1.y(), s1.z(), s2.x(), s2.y(), s2.z());
+ covar2[0] = 1.0;
+ covar2[1] = 0.0;
singular = true;
}
@@ -134,146 +151,165 @@ bool compute4neighbors (GFace *gf, // the surface
// consider a vector v of size 1 in the parameter plane
// its length is sqrt (v^T M v) --> if I want a real size
// of size1 in direction v, it should be sqrt(v^T M v) * size1
- double l1 = sqrt(covar1[0]*covar1[0]+covar1[1]*covar1[1]);
- double l2 = sqrt(covar2[0]*covar2[0]+covar2[1]*covar2[1]);
-
- covar1[0] /= l1;covar1[1] /= l1;
- covar2[0] /= l2;covar2[1] /= l2;
-
- double size_param_1 = size_1 / sqrt ( M*covar1[0]*covar1[0]+
- 2*E*covar1[1]*covar1[0]+
- N*covar1[1]*covar1[1]);
- double size_param_2 = size_2 / sqrt ( M*covar2[0]*covar2[0]+
- 2*E*covar2[1]*covar2[0]+
- N*covar2[1]*covar2[1]);
- if (singular){
- size_param_1 = size_param_2 = std::min (size_param_1,size_param_2);
+ double l1 = sqrt(covar1[0] * covar1[0] + covar1[1] * covar1[1]);
+ double l2 = sqrt(covar2[0] * covar2[0] + covar2[1] * covar2[1]);
+
+ covar1[0] /= l1;
+ covar1[1] /= l1;
+ covar2[0] /= l2;
+ covar2[1] /= l2;
+
+ double size_param_1 =
+ size_1 / sqrt(M * covar1[0] * covar1[0] + 2 * E * covar1[1] * covar1[0] +
+ N * covar1[1] * covar1[1]);
+ double size_param_2 =
+ size_2 / sqrt(M * covar2[0] * covar2[0] + 2 * E * covar2[1] * covar2[0] +
+ N * covar2[1] * covar2[1]);
+ if(singular) {
+ size_param_1 = size_param_2 = std::min(size_param_1, size_param_2);
}
const double EPS = 1.e-7;
- double r1 = EPS*(double)rand() / RAND_MAX;
- double r2 = EPS*(double)rand() / RAND_MAX;
- double r3 = EPS*(double)rand() / RAND_MAX;
- double r4 = EPS*(double)rand() / RAND_MAX;
- double r5 = EPS*(double)rand() / RAND_MAX;
- double r6 = EPS*(double)rand() / RAND_MAX;
- double r7 = EPS* (double)rand() / RAND_MAX;
- double r8 = EPS*(double)rand() / RAND_MAX;
- double newPoint[4][2] = {{midpoint[0] - covar1[0] * size_param_1 +r1,
- midpoint[1] - covar1[1] * size_param_1 +r2},
- {midpoint[0] - covar2[0] * size_param_2 +r3,
- midpoint[1] - covar2[1] * size_param_2 +r4},
- {midpoint[0] + covar1[0] * size_param_1 +r5,
- midpoint[1] + covar1[1] * size_param_1 +r6},
- {midpoint[0] + covar2[0] * size_param_2 +r7,
- midpoint[1] + covar2[1] * size_param_2 +r8 }};
+ double r1 = EPS * (double)rand() / RAND_MAX;
+ double r2 = EPS * (double)rand() / RAND_MAX;
+ double r3 = EPS * (double)rand() / RAND_MAX;
+ double r4 = EPS * (double)rand() / RAND_MAX;
+ double r5 = EPS * (double)rand() / RAND_MAX;
+ double r6 = EPS * (double)rand() / RAND_MAX;
+ double r7 = EPS * (double)rand() / RAND_MAX;
+ double r8 = EPS * (double)rand() / RAND_MAX;
+ double newPoint[4][2] = {{midpoint[0] - covar1[0] * size_param_1 + r1,
+ midpoint[1] - covar1[1] * size_param_1 + r2},
+ {midpoint[0] - covar2[0] * size_param_2 + r3,
+ midpoint[1] - covar2[1] * size_param_2 + r4},
+ {midpoint[0] + covar1[0] * size_param_1 + r5,
+ midpoint[1] + covar1[1] * size_param_1 + r6},
+ {midpoint[0] + covar2[0] * size_param_2 + r7,
+ midpoint[1] + covar2[1] * size_param_2 + r8}};
// We could stop here. Yet, if the metric varies a lot, we can solve
// a nonlinear problem in order to find a better approximation in the real
// surface
double ERR[4];
- for (int i=0;i<4;i++){
+ for(int i = 0; i < 4; i++) {
GPoint pp = gf->point(SPoint2(newPoint[i][0], newPoint[i][1]));
- double D = sqrt ((pp.x() - v_center->x())*(pp.x() - v_center->x()) +
- (pp.y() - v_center->y())*(pp.y() - v_center->y()) +
- (pp.z() - v_center->z())*(pp.z() - v_center->z()) );
- ERR[i] = 100*fabs(D-L)/(D+L);
+ double D = sqrt((pp.x() - v_center->x()) * (pp.x() - v_center->x()) +
+ (pp.y() - v_center->y()) * (pp.y() - v_center->y()) +
+ (pp.z() - v_center->z()) * (pp.z() - v_center->z()));
+ ERR[i] = 100 * fabs(D - L) / (D + L);
}
- if (1 && goNonLinear){
- surfaceFunctorGFace ss (gf); //
- SVector3 dirs[4] = {t1*(-1.0),t2*(-1.0),t1*(1.0),t2*(1.0)}; //
- for (int i=0;i<4;i++){ //
- if (ERR[i] > 12){
- double uvt[3] = {newPoint[i][0],newPoint[i][1],0.0}; //
- // printf("Intersecting with circle N = %g %g %g dir = %g %g %g R = %g p = %g %g %g\n",n.x(),n.y(),n.z(),dirs[i].x(),dirs[i].y(),dirs[i].z(),L,v_center->x(),v_center->y(),v_center->z());
- curveFunctorCircle cf (dirs[i],n,
- SVector3(v_center->x(),v_center->y(),v_center->z()),
- L);
- if (intersectCurveSurface (cf,ss,uvt,size_param_1*1.e-3)){ //
- GPoint pp = gf->point(SPoint2(uvt[0],uvt[1]));
- double D = sqrt ((pp.x() - v_center->x())*(pp.x() - v_center->x()) +
- (pp.y() - v_center->y())*(pp.y() - v_center->y()) +
- (pp.z() - v_center->z())*(pp.z() - v_center->z()) );
- double DP = sqrt ((newPoint[i][0]-uvt[0])*(newPoint[i][0]-uvt[0]) +
- (newPoint[i][1]-uvt[1])*(newPoint[i][1]-uvt[1]));
- double newErr = 100*fabs(D-L)/(D+L);
- // if (v_center->onWhat() != gf && gf->tag() == 3){
- // crossField2d::normalizeAngle (uvt[2]);
- // printf("INTERSECT angle = %g DP %g\n",uvt[2],DP);
- // }
- if (newErr < 1 && DP < .1){
- // printf("%12.5E vs %12.5E : %12.5E %12.5E vs %12.5E %12.5E \n",ERR[i],newErr,newPoint[i][0],newPoint[i][1],uvt[0],uvt[1]);
- newPoint[i][0] = uvt[0]; //
- newPoint[i][1] = uvt[1]; //
- } //
- // printf("OK\n");
- }
- else{
- Msg::Debug("Cannot put a new point on Surface %d",gf->tag());
- // printf("NOT OK\n");
- }
- }
- } //
+ if(1 && goNonLinear) {
+ surfaceFunctorGFace ss(gf); //
+ SVector3 dirs[4] = {t1 * (-1.0), t2 * (-1.0), t1 * (1.0), t2 * (1.0)}; //
+ for(int i = 0; i < 4; i++) { //
+ if(ERR[i] > 12) {
+ double uvt[3] = {newPoint[i][0], newPoint[i][1], 0.0}; //
+ // printf("Intersecting with circle N = %g %g %g dir = %g %g %g R
+ //= %g p = %g %g
+ //%g\n",n.x(),n.y(),n.z(),dirs[i].x(),dirs[i].y(),dirs[i].z(),L,v_center->x(),v_center->y(),v_center->z());
+ curveFunctorCircle cf(
+ dirs[i], n, SVector3(v_center->x(), v_center->y(), v_center->z()),
+ L);
+ if(intersectCurveSurface(cf, ss, uvt, size_param_1 * 1.e-3)) { //
+ GPoint pp = gf->point(SPoint2(uvt[0], uvt[1]));
+ double D =
+ sqrt((pp.x() - v_center->x()) * (pp.x() - v_center->x()) +
+ (pp.y() - v_center->y()) * (pp.y() - v_center->y()) +
+ (pp.z() - v_center->z()) * (pp.z() - v_center->z()));
+ double DP =
+ sqrt((newPoint[i][0] - uvt[0]) * (newPoint[i][0] - uvt[0]) +
+ (newPoint[i][1] - uvt[1]) * (newPoint[i][1] - uvt[1]));
+ double newErr = 100 * fabs(D - L) / (D + L);
+ // if (v_center->onWhat() != gf && gf->tag() == 3){
+ // crossField2d::normalizeAngle (uvt[2]);
+ // printf("INTERSECT angle = %g DP %g\n",uvt[2],DP);
+ // }
+ if(newErr < 1 && DP < .1) {
+ // printf("%12.5E vs %12.5E : %12.5E %12.5E vs %12.5E
+ //%12.5E
+ //\n",ERR[i],newErr,newPoint[i][0],newPoint[i][1],uvt[0],uvt[1]);
+ newPoint[i][0] = uvt[0]; //
+ newPoint[i][1] = uvt[1]; //
+ } //
+ // printf("OK\n");
+ }
+ else {
+ Msg::Debug("Cannot put a new point on Surface %d", gf->tag());
+ // printf("NOT OK\n");
+ }
+ }
+ } //
} /// end non linear -------------------------------------------------//
// return the four new vertices
- for (int i=0;i<4;i++){
- newP[i][DIR] = SPoint2(newPoint[i][0],newPoint[i][1]);
+ for(int i = 0; i < 4; i++) {
+ newP[i][DIR] = SPoint2(newPoint[i][0], newPoint[i][1]);
}
}
return true;
}
-
// recover element around vertex v and interpolate smoothness on this element...
-double get_smoothness(MVertex *v, GFace *gf, const map<MVertex*,double> &vertices2smoothness){
+double get_smoothness(MVertex *v, GFace *gf,
+ const map<MVertex *, double> &vertices2smoothness)
+{
// recover element around MVertex v
- //cout << "Looking for element around point (" << v->x() << "," << v->y() << "," << v->z() << ")" << endl;
+ // cout << "Looking for element around point (" << v->x() << "," << v->y() <<
+ // "," << v->z() << ")" << endl;
SPoint3 sp3(v->x(), v->y(), v->z());
SPoint2 param_point;
reparamMeshVertexOnFace(v, gf, param_point);
- MElement *elem = backgroundMesh::current()->getMeshElementByCoord(param_point[0], param_point[1], 0.);
- if (!elem){
- elem = backgroundMesh::current()->getMeshElementByCoord(param_point[0], param_point[1], 0., false);
- if (!elem)
- cout << " ------ WARNING !!! surfaceFiller : get_smoothness : No element found for coordinate (" << sp3.x() << "," << sp3.y() << "," << sp3.z() << ")" << endl;
+ MElement *elem = backgroundMesh::current()->getMeshElementByCoord(
+ param_point[0], param_point[1], 0.);
+ if(!elem) {
+ elem = backgroundMesh::current()->getMeshElementByCoord(
+ param_point[0], param_point[1], 0., false);
+ if(!elem)
+ cout << " ------ WARNING !!! surfaceFiller : get_smoothness : No element "
+ "found for coordinate ("
+ << sp3.x() << "," << sp3.y() << "," << sp3.z() << ")" << endl;
}
// recover element's vertices:
- vector<MVertex*> localvertices;
+ vector<MVertex *> localvertices;
localvertices.reserve(elem->getNumVertices());
- for (std::size_t ivert=0;ivert<elem->getNumVertices();ivert++){
+ for(std::size_t ivert = 0; ivert < elem->getNumVertices(); ivert++) {
MVertex *temp = elem->getVertex(ivert);
localvertices.push_back(temp);
-// cout << " made of vertex " << temp->x() << "," << temp->y() << "," << temp->z() << endl;
+ // cout << " made of vertex " << temp->x() << "," << temp->y() << "," <<
+ // temp->z() << endl;
}
// recover parametrisation uvw
- double uvw[3],xyz[3];
+ double uvw[3], xyz[3];
xyz[0] = param_point[0];
xyz[1] = param_point[1];
xyz[2] = 0.;
elem->xyz2uvw(xyz, uvw);
-// cout << "xyz is " << xyz[0] << "," << xyz[1] << "," << xyz[2] << endl;
-// cout << "uvw is " << uvw[0] << "," << uvw[1] << "," << uvw[2] << endl;
+ // cout << "xyz is " << xyz[0] << "," << xyz[1] << "," << xyz[2] << endl;
+ // cout << "uvw is " << uvw[0] << "," << uvw[1] << "," << uvw[2] << endl;
// interpolate :
double val[3];
- int i=0;
- for (vector<MVertex*>::iterator it = localvertices.begin();it!=localvertices.end();it++){
+ int i = 0;
+ for(vector<MVertex *>::iterator it = localvertices.begin();
+ it != localvertices.end(); it++) {
MVertex *localv = *it;
- map<MVertex*,double>::const_iterator itfind = vertices2smoothness.find(localv);
- if (itfind==vertices2smoothness.end()){
- cerr << "WARNING: surfaceFiller : get_smoothness : BACKGROUNDMESH VERTEX NOT FOUND IN SMOOTHNESS COMPUTATION !!! ABORTING..." << endl;
+ map<MVertex *, double>::const_iterator itfind =
+ vertices2smoothness.find(localv);
+ if(itfind == vertices2smoothness.end()) {
+ cerr << "WARNING: surfaceFiller : get_smoothness : BACKGROUNDMESH VERTEX "
+ "NOT FOUND IN SMOOTHNESS COMPUTATION !!! ABORTING..."
+ << endl;
throw;
}
-// cout << "nodal value: " << itfind->second << endl;
+ // cout << "nodal value: " << itfind->second << endl;
val[i++] = itfind->second;
}
-// cout << "uvw is " << uvw[0] << " " << uvw[1] << " " << uvw[2] << endl;
+ // cout << "uvw is " << uvw[0] << " " << uvw[1] << " " << uvw[2] << endl;
double res = elem->interpolate(val, uvw[0], uvw[1], uvw[2]);
-// cout << " THE VALUE = " << res << endl;
+ // cout << " THE VALUE = " << res << endl;
return res;
}
@@ -282,9 +318,11 @@ void print_nodal_info_int(const string &filename, map<MVertex *, int> &mapp)
ofstream out(filename.c_str());
out << "View \"\"{" << endl;
- for (map<MVertex*, int>::iterator it = mapp.begin();it!=mapp.end();it++){
+ for(map<MVertex *, int>::iterator it = mapp.begin(); it != mapp.end(); it++) {
MVertex *v = it->first;
- out << "SP( " << v->x() << "," << v->y() << "," << v->z() << "){" << it->second << "};" << endl;;
+ out << "SP( " << v->x() << "," << v->y() << "," << v->z() << "){"
+ << it->second << "};" << endl;
+ ;
}
out << "};" << endl;
@@ -297,155 +335,201 @@ void print_nodal_info_double(const string &filename,
ofstream out(filename.c_str());
out << "View \"\"{" << endl;
- for (map<MVertex*, double>::iterator it = mapp.begin();it!=mapp.end();it++){
+ for(map<MVertex *, double>::iterator it = mapp.begin(); it != mapp.end();
+ it++) {
MVertex *v = it->first;
- out << "SP( " << v->x() << "," << v->y() << "," << v->z() << "){" << it->second << "};" << endl;;
+ out << "SP( " << v->x() << "," << v->y() << "," << v->z() << "){"
+ << it->second << "};" << endl;
+ ;
}
out << "};" << endl;
out.close();
}
-
-void export_point(surfacePointWithExclusionRegion *sp, int DIR, FILE *crossf, GFace *gf){
+void export_point(surfacePointWithExclusionRegion *sp, int DIR, FILE *crossf,
+ GFace *gf)
+{
// get the unit normal at that point
Pair<SVector3, SVector3> der = gf->firstDer(sp->_center);
SVector3 s1 = der.first();
SVector3 s2 = der.second();
- SVector3 n = crossprod(s1,s2);
+ SVector3 n = crossprod(s1, s2);
n.normalize();
- SVector3 basis_u = s1; basis_u.normalize();
- SVector3 basis_v = crossprod(n,basis_u);
+ SVector3 basis_u = s1;
+ basis_u.normalize();
+ SVector3 basis_v = crossprod(n, basis_u);
- double quadAngle = backgroundMesh::current()->getAngle (sp->_center[0],sp->_center[1],0) + DIRS[DIR];
+ double quadAngle =
+ backgroundMesh::current()->getAngle(sp->_center[0], sp->_center[1], 0) +
+ DIRS[DIR];
// normalize vector t1 that is tangent to gf at midpoint
- SVector3 t1 = basis_u * cos (quadAngle) + basis_v * sin (quadAngle) ;
+ SVector3 t1 = basis_u * cos(quadAngle) + basis_v * sin(quadAngle);
t1.normalize();
- // compute the second direction t2 and normalize (t1,t2,n) is the tangent frame
- SVector3 t2 = crossprod(n,t1);
+ // compute the second direction t2 and normalize (t1,t2,n) is the tangent
+ // frame
+ SVector3 t2 = crossprod(n, t1);
t2.normalize();
// double scale = DIR+1.;
SMetric3 metricField;
- double L = backgroundMesh::current()->operator()(sp->_center[0],sp->_center[1],0.0);
- metricField = SMetric3(1./(L*L));
+ double L =
+ backgroundMesh::current()->operator()(sp->_center[0], sp->_center[1], 0.0);
+ metricField = SMetric3(1. / (L * L));
FieldManager *fields = gf->model()->getFields();
- if(fields->getBackgroundField() > 0){
+ if(fields->getBackgroundField() > 0) {
Field *f = fields->get(fields->getBackgroundField());
- if (!f->isotropic()){
- (*f)(sp->_v->x(),sp->_v->y(),sp->_v->z(), metricField,gf);
+ if(!f->isotropic()) {
+ (*f)(sp->_v->x(), sp->_v->y(), sp->_v->z(), metricField, gf);
}
else {
- L = (*f)(sp->_v->x(),sp->_v->y(),sp->_v->z(), gf);
- metricField = SMetric3(1./(L*L));
+ L = (*f)(sp->_v->x(), sp->_v->y(), sp->_v->z(), gf);
+ metricField = SMetric3(1. / (L * L));
}
}
- double size_1 = sqrt(1. / dot(t1,metricField,t1));
- double size_2 = sqrt(1. / dot(t2,metricField,t2));
-
- // fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),t1.x()*scale,t1.y()*scale,t1.z()*scale);
- // fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),t2.x()*scale,t2.y()*scale,t2.z()*scale);
- // fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),-t1.x()*scale,-t1.y()*scale,-t1.z()*scale);
- // fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),-t2.x()*scale,-t2.y()*scale,-t2.z()*scale);
- fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),t1.x()*size_1,t1.y()*size_1,t1.z()*size_1);
- fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),t2.x()*size_2,t2.y()*size_2,t2.z()*size_2);
- fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),-t1.x()*size_1,-t1.y()*size_1,-t1.z()*size_1);
- fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),-t2.x()*size_2,-t2.y()*size_2,-t2.z()*size_2);
+ double size_1 = sqrt(1. / dot(t1, metricField, t1));
+ double size_2 = sqrt(1. / dot(t2, metricField, t2));
+
+ // fprintf(crossf,"VP(%g,%g,%g)
+ // {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),t1.x()*scale,t1.y()*scale,t1.z()*scale);
+ // fprintf(crossf,"VP(%g,%g,%g)
+ // {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),t2.x()*scale,t2.y()*scale,t2.z()*scale);
+ // fprintf(crossf,"VP(%g,%g,%g)
+ // {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),-t1.x()*scale,-t1.y()*scale,-t1.z()*scale);
+ // fprintf(crossf,"VP(%g,%g,%g)
+ // {%g,%g,%g};\n",sp->_v->x(),sp->_v->y(),sp->_v->z(),-t2.x()*scale,-t2.y()*scale,-t2.z()*scale);
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", sp->_v->x(), sp->_v->y(),
+ sp->_v->z(), t1.x() * size_1, t1.y() * size_1, t1.z() * size_1);
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", sp->_v->x(), sp->_v->y(),
+ sp->_v->z(), t2.x() * size_2, t2.y() * size_2, t2.z() * size_2);
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", sp->_v->x(), sp->_v->y(),
+ sp->_v->z(), -t1.x() * size_1, -t1.y() * size_1, -t1.z() * size_1);
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", sp->_v->x(), sp->_v->y(),
+ sp->_v->z(), -t2.x() * size_2, -t2.y() * size_2, -t2.z() * size_2);
}
-
-bool get_local_sizes_and_directions(const MVertex *v_center, const SPoint2 &midpoint, const int DIR, GFace* gf, double (&covar1)[2], double (&covar2)[2], double &size_param_1, double &size_param_2, double &L, SVector3 &t1, SVector3 &t2, SVector3 &n, FILE *crossf=NULL){
-//bool get_RK_stuff(const MVertex *v_center, const SPoint2 &midpoint, const int DIR, GFace* gf, double (&covar1)[2], double (&covar2)[2], double &size_param_1, double &size_param_2, double &L, SVector3 &t1, SVector3 &t2, SVector3 &n, FILE *crossf, const SVector3 &previous_t1, const SVector3 &previous_t2, bool use_previous_basis=false, bool export_cross=true){
+bool get_local_sizes_and_directions(const MVertex *v_center,
+ const SPoint2 &midpoint, const int DIR,
+ GFace *gf, double (&covar1)[2],
+ double (&covar2)[2], double &size_param_1,
+ double &size_param_2, double &L,
+ SVector3 &t1, SVector3 &t2, SVector3 &n,
+ FILE *crossf = NULL)
+{
+ // bool get_RK_stuff(const MVertex *v_center, const SPoint2 &midpoint, const
+ // int DIR, GFace* gf, double (&covar1)[2], double (&covar2)[2], double
+ // &size_param_1, double &size_param_2, double &L, SVector3 &t1, SVector3 &t2,
+ // SVector3 &n, FILE *crossf, const SVector3 &previous_t1, const SVector3
+ // &previous_t2, bool use_previous_basis=false, bool export_cross=true){
// !!!!!!!!!!!! check if point is in domain (for RK !!!)
- if (!backgroundMesh::current()->inDomain(midpoint.x(),midpoint.y(),0)) return false;
+ if(!backgroundMesh::current()->inDomain(midpoint.x(), midpoint.y(), 0))
+ return false;
SMetric3 metricField;
- L = backgroundMesh::current()->operator()(midpoint[0],midpoint[1],0.0);
+ L = backgroundMesh::current()->operator()(midpoint[0], midpoint[1], 0.0);
// printf("L = %12.5E\n",L);
- metricField = SMetric3(1./(L*L));
+ metricField = SMetric3(1. / (L * L));
FieldManager *fields = gf->model()->getFields();
- if(fields->getBackgroundField() > 0){
+ if(fields->getBackgroundField() > 0) {
Field *f = fields->get(fields->getBackgroundField());
- if (!f->isotropic()){
- (*f)(v_center->x(),v_center->y(),v_center->z(), metricField,gf);
+ if(!f->isotropic()) {
+ (*f)(v_center->x(), v_center->y(), v_center->z(), metricField, gf);
}
else {
- L = (*f)(v_center->x(),v_center->y(),v_center->z(), gf);
- metricField = SMetric3(1./(L*L));
+ L = (*f)(v_center->x(), v_center->y(), v_center->z(), gf);
+ metricField = SMetric3(1. / (L * L));
}
}
// get the unit normal at that point
- Pair<SVector3, SVector3> der = gf->firstDer(SPoint2(midpoint[0],midpoint[1]));
+ Pair<SVector3, SVector3> der =
+ gf->firstDer(SPoint2(midpoint[0], midpoint[1]));
SVector3 s1 = der.first();
SVector3 s2 = der.second();
- n = crossprod(s1,s2);
+ n = crossprod(s1, s2);
n.normalize();
- double M = dot(s1,s1);
- double N = dot(s2,s2);
- double E = dot(s1,s2);
+ double M = dot(s1, s1);
+ double N = dot(s2, s2);
+ double E = dot(s1, s2);
// compute the first fundamental form i.e. the metric tensor at the point
// M_{ij} = s_i \cdot s_j
- double metric[2][2] = {{M,E},{E,N}};
+ double metric[2][2] = {{M, E}, {E, N}};
// printf("%d %g %g %g\n",gf->tag(),s1.x(),s1.y(),s1.z());
- SVector3 basis_u = s1; basis_u.normalize();
- SVector3 basis_v = crossprod(n,basis_u);
+ SVector3 basis_u = s1;
+ basis_u.normalize();
+ SVector3 basis_v = crossprod(n, basis_u);
- double quadAngle = backgroundMesh::current()->getAngle (midpoint[0],midpoint[1],0) + DIRS[DIR];
- //double quadAngle = atan2(midpoint[0],midpoint[1]);
+ double quadAngle =
+ backgroundMesh::current()->getAngle(midpoint[0], midpoint[1], 0) +
+ DIRS[DIR];
+ // double quadAngle = atan2(midpoint[0],midpoint[1]);
// normalize vector t1 that is tangent to gf at midpoint
- t1 = basis_u * cos (quadAngle) + basis_v * sin (quadAngle) ;
+ t1 = basis_u * cos(quadAngle) + basis_v * sin(quadAngle);
t1.normalize();
- // compute the second direction t2 and normalize (t1,t2,n) is the tangent frame
- t2 = crossprod(n,t1);
+ // compute the second direction t2 and normalize (t1,t2,n) is the tangent
+ // frame
+ t2 = crossprod(n, t1);
t2.normalize();
-
// std::cout << std::endl;
- // std::cout << "basis uv : (" << basis_u(0) << "," << basis_u(1) << ") (" << basis_v(0) << "," << basis_v(1) << std::endl;
- // std::cout << "t : (" << t1(0) << "," << t1(1) << ") (" << t2(0) << "," << t2(1) << std::endl;
-
-// if (use_previous_basis){
-// std::map<double, double> angles;
-// SVector3 temp = crossprod(previous_t1, t1);
-// double a = atan2(dot(t1, previous_t1), sign(dot(temp,n))*temp.norm() );
-// angles.insert(std::make_pair(abs(a),a));
-// temp = crossprod(previous_t2, t1);
-// a = atan2(dot(t1, previous_t2), sign(dot(temp,n))*temp.norm());
-// angles.insert(std::make_pair(abs(a),a));
-// temp = crossprod(-1.*previous_t1, t1);
-// a = atan2(dot(t1, -1.*previous_t1), sign(dot(temp,n))*temp.norm());
-// angles.insert(std::make_pair(abs(a),a));
-// temp = crossprod(-1.*previous_t2, t1);
-// a = atan2(dot(t1, -1.*previous_t2), sign(dot(temp,n))*temp.norm());
-// angles.insert(std::make_pair(abs(a),a));
-// // std::cout << "angles: " << std::endl;
-// // for (int i=0;i<4;i++) std::cout << angles[i] << " " << std::endl;
-// double min_angle = -(angles.begin()->second);
-// // std::cout << "min angle = " << min_angle << std::endl;
-// t1 = cos(min_angle)*previous_t1 + sin(min_angle)*previous_t2;
-// t2 = -sin(min_angle)*previous_t1 + cos(min_angle)*previous_t2;
-// // std::cout << "new corrected t : (" << t1(0) << "," << t1(1) << ") (" << t2(0) << "," << t2(1) << std::endl;
-// }
-
- double size_1 = sqrt(1. / dot(t1,metricField,t1));
- double size_2 = sqrt(1. / dot(t2,metricField,t2));
-
-
- if (crossf){
- if (DIR == 0 && crossf)fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",v_center->x(),v_center->y(),v_center->z(),t1.x()*size_1,t1.y()*size_1,t1.z()*size_1);
- if (DIR == 0 && crossf)fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",v_center->x(),v_center->y(),v_center->z(),t2.x()*size_2,t2.y()*size_2,t2.z()*size_2);
- if (DIR == 0 && crossf)fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",v_center->x(),v_center->y(),v_center->z(),-t1.x()*size_1,-t1.y()*size_1,-t1.z()*size_1);
- if (DIR == 0 && crossf)fprintf(crossf,"VP(%g,%g,%g) {%g,%g,%g};\n",v_center->x(),v_center->y(),v_center->z(),-t2.x()*size_2,-t2.y()*size_2,-t2.z()*size_2);
+ // std::cout << "basis uv : (" << basis_u(0) << "," << basis_u(1) << ") ("
+ // << basis_v(0) << "," << basis_v(1) << std::endl; std::cout << "t :
+ // (" << t1(0) << "," << t1(1) << ") (" << t2(0) << "," << t2(1) <<
+ // std::endl;
+
+ // if (use_previous_basis){
+ // std::map<double, double> angles;
+ // SVector3 temp = crossprod(previous_t1, t1);
+ // double a = atan2(dot(t1, previous_t1), sign(dot(temp,n))*temp.norm() );
+ // angles.insert(std::make_pair(abs(a),a));
+ // temp = crossprod(previous_t2, t1);
+ // a = atan2(dot(t1, previous_t2), sign(dot(temp,n))*temp.norm());
+ // angles.insert(std::make_pair(abs(a),a));
+ // temp = crossprod(-1.*previous_t1, t1);
+ // a = atan2(dot(t1, -1.*previous_t1), sign(dot(temp,n))*temp.norm());
+ // angles.insert(std::make_pair(abs(a),a));
+ // temp = crossprod(-1.*previous_t2, t1);
+ // a = atan2(dot(t1, -1.*previous_t2), sign(dot(temp,n))*temp.norm());
+ // angles.insert(std::make_pair(abs(a),a));
+ // // std::cout << "angles: " << std::endl;
+ // // for (int i=0;i<4;i++) std::cout << angles[i] << " " <<
+ // std::endl; double min_angle = -(angles.begin()->second);
+ // // std::cout << "min angle = " << min_angle << std::endl;
+ // t1 = cos(min_angle)*previous_t1 + sin(min_angle)*previous_t2;
+ // t2 = -sin(min_angle)*previous_t1 + cos(min_angle)*previous_t2;
+ // // std::cout << "new corrected t : (" << t1(0) << "," <<
+ // t1(1) << ") (" << t2(0) << "," << t2(1) << std::endl;
+ // }
+
+ double size_1 = sqrt(1. / dot(t1, metricField, t1));
+ double size_2 = sqrt(1. / dot(t2, metricField, t2));
+
+ if(crossf) {
+ if(DIR == 0 && crossf)
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", v_center->x(),
+ v_center->y(), v_center->z(), t1.x() * size_1, t1.y() * size_1,
+ t1.z() * size_1);
+ if(DIR == 0 && crossf)
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", v_center->x(),
+ v_center->y(), v_center->z(), t2.x() * size_2, t2.y() * size_2,
+ t2.z() * size_2);
+ if(DIR == 0 && crossf)
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", v_center->x(),
+ v_center->y(), v_center->z(), -t1.x() * size_1, -t1.y() * size_1,
+ -t1.z() * size_1);
+ if(DIR == 0 && crossf)
+ fprintf(crossf, "VP(%g,%g,%g) {%g,%g,%g};\n", v_center->x(),
+ v_center->y(), v_center->z(), -t2.x() * size_2, -t2.y() * size_2,
+ -t2.z() * size_2);
}
// compute covariant coordinates of t1 and t2
@@ -453,17 +537,21 @@ bool get_local_sizes_and_directions(const MVertex *v_center, const SPoint2 &midp
// t1 . s1 = a M + b E
// t1 . s2 = a E + b N --> solve the 2 x 2 system
// and get covariant coordinates a and b
- double rhs1[2] = {dot(t1,s1),dot(t1,s2)};
+ double rhs1[2] = {dot(t1, s1), dot(t1, s2)};
bool singular = false;
- if (!sys2x2(metric,rhs1,covar1)){
- Msg::Info("Argh surface %d %g %g %g -- %g %g %g -- %g %g",gf->tag(),s1.x(),s1.y(),s1.z(),s2.x(),s2.y(),s2.z(),size_1,size_2);
- covar1[1] = 1.0; covar1[0] = 0.0;
+ if(!sys2x2(metric, rhs1, covar1)) {
+ Msg::Info("Argh surface %d %g %g %g -- %g %g %g -- %g %g", gf->tag(),
+ s1.x(), s1.y(), s1.z(), s2.x(), s2.y(), s2.z(), size_1, size_2);
+ covar1[1] = 1.0;
+ covar1[0] = 0.0;
singular = true;
}
- double rhs2[2] = {dot(t2,s1),dot(t2,s2)};
- if (!sys2x2(metric,rhs2,covar2)){
- Msg::Info("Argh surface %d %g %g %g -- %g %g %g",gf->tag(),s1.x(),s1.y(),s1.z(),s2.x(),s2.y(),s2.z());
- covar2[0] = 1.0; covar2[1] = 0.0;
+ double rhs2[2] = {dot(t2, s1), dot(t2, s2)};
+ if(!sys2x2(metric, rhs2, covar2)) {
+ Msg::Info("Argh surface %d %g %g %g -- %g %g %g", gf->tag(), s1.x(), s1.y(),
+ s1.z(), s2.x(), s2.y(), s2.z());
+ covar2[0] = 1.0;
+ covar2[1] = 0.0;
singular = true;
}
@@ -471,233 +559,271 @@ bool get_local_sizes_and_directions(const MVertex *v_center, const SPoint2 &midp
// consider a vector v of size 1 in the parameter plane
// its length is sqrt (v^T M v) --> if I want a real size
// of size1 in direction v, it should be sqrt(v^T M v) * size1
- double l1 = sqrt(covar1[0]*covar1[0]+covar1[1]*covar1[1]);
- double l2 = sqrt(covar2[0]*covar2[0]+covar2[1]*covar2[1]);
-
- covar1[0] /= l1;covar1[1] /= l1;
- covar2[0] /= l2;covar2[1] /= l2;
-
- size_param_1 = size_1 / sqrt ( M*covar1[0]*covar1[0]+
- 2*E*covar1[1]*covar1[0]+
- N*covar1[1]*covar1[1]);
- size_param_2 = size_2 / sqrt ( M*covar2[0]*covar2[0]+
- 2*E*covar2[1]*covar2[0]+
- N*covar2[1]*covar2[1]);
- if (singular){
- size_param_1 = size_param_2 = std::min (size_param_1,size_param_2);
+ double l1 = sqrt(covar1[0] * covar1[0] + covar1[1] * covar1[1]);
+ double l2 = sqrt(covar2[0] * covar2[0] + covar2[1] * covar2[1]);
+
+ covar1[0] /= l1;
+ covar1[1] /= l1;
+ covar2[0] /= l2;
+ covar2[1] /= l2;
+
+ size_param_1 =
+ size_1 / sqrt(M * covar1[0] * covar1[0] + 2 * E * covar1[1] * covar1[0] +
+ N * covar1[1] * covar1[1]);
+ size_param_2 =
+ size_2 / sqrt(M * covar2[0] * covar2[0] + 2 * E * covar2[1] * covar2[0] +
+ N * covar2[1] * covar2[1]);
+ if(singular) {
+ size_param_1 = size_param_2 = std::min(size_param_1, size_param_2);
}
-
return true;
}
-
-
// using fifo based on smoothness criteria
-void packingOfParallelogramsSmoothness(GFace* gf, std::vector<MVertex*> &packed, std::vector<SMetric3> &metrics){
- cout << endl << "------------------------------------------" << endl << " PACKINGOFPARALLELOGRAMS: NEW ALGO BASED ON SMOOTHNESS" << endl << "------------------------------------------" << endl;
+void packingOfParallelogramsSmoothness(GFace *gf,
+ std::vector<MVertex *> &packed,
+ std::vector<SMetric3> &metrics)
+{
+ cout << endl
+ << "------------------------------------------" << endl
+ << " PACKINGOFPARALLELOGRAMS: NEW ALGO BASED ON SMOOTHNESS" << endl
+ << "------------------------------------------" << endl;
const bool goNonLinear = true;
const bool debug = false;
// build vertex -> neighbors table
- multimap<MVertex*,MVertex*> vertex2vertex;
- for (std::vector<MElement*>::iterator it = backgroundMesh::current()->begin_triangles();it!=backgroundMesh::current()->end_triangles();it++){
+ multimap<MVertex *, MVertex *> vertex2vertex;
+ for(std::vector<MElement *>::iterator it =
+ backgroundMesh::current()->begin_triangles();
+ it != backgroundMesh::current()->end_triangles(); it++) {
MElement *e = *it;
- for (std::size_t i=0;i<e->getNumVertices();i++){
+ for(std::size_t i = 0; i < e->getNumVertices(); i++) {
MVertex *current = e->getVertex(i);
- for (std::size_t j=0;j<e->getNumVertices();j++){
- if (i==j) continue;
+ for(std::size_t j = 0; j < e->getNumVertices(); j++) {
+ if(i == j) continue;
MVertex *neighbor = e->getVertex(j);
- vertex2vertex.insert(make_pair(current,neighbor));
+ vertex2vertex.insert(make_pair(current, neighbor));
}
}
}
// build table vertex->smoothness
- map<MVertex*,double> vertices2smoothness;
- map<MVertex*, double> smoothness_essai;
- for (std::vector<MVertex*>::iterator it = backgroundMesh::current()->begin_vertices();it!=backgroundMesh::current()->end_vertices();it++){
+ map<MVertex *, double> vertices2smoothness;
+ map<MVertex *, double> smoothness_essai;
+ for(std::vector<MVertex *>::iterator it =
+ backgroundMesh::current()->begin_vertices();
+ it != backgroundMesh::current()->end_vertices(); it++) {
MVertex *v = *it;
- SPoint2 param_point(v->x(),v->y());GPoint gpt = gf->point(param_point); MVertex v_real(gpt.x(),gpt.y(),gpt.z());
- SVector3 t1,t2,n;double covar1[2],covar2[2],L,size_param_1,size_param_2;
- get_local_sizes_and_directions(&v_real, param_point, 0, gf, covar1, covar2, size_param_1, size_param_2, L, t1, t2, n);
+ SPoint2 param_point(v->x(), v->y());
+ GPoint gpt = gf->point(param_point);
+ MVertex v_real(gpt.x(), gpt.y(), gpt.z());
+ SVector3 t1, t2, n;
+ double covar1[2], covar2[2], L, size_param_1, size_param_2;
+ get_local_sizes_and_directions(&v_real, param_point, 0, gf, covar1, covar2,
+ size_param_1, size_param_2, L, t1, t2, n);
// compare to all neighbors...
- pair<multimap<MVertex*,MVertex*>::iterator, multimap<MVertex*,MVertex*>::iterator> range = vertex2vertex.equal_range(v);
- SVector3 t1_nb,t2_nb,n_nb;double covar1_nb[2],covar2_nb[2],L_nb,size_param_1_nb,size_param_2_nb;
- double maxprod,angle=0.;
- int N=0;
- for (multimap<MVertex*,MVertex*>::iterator itneighbor = range.first;itneighbor!=range.second;itneighbor++){
+ pair<multimap<MVertex *, MVertex *>::iterator,
+ multimap<MVertex *, MVertex *>::iterator>
+ range = vertex2vertex.equal_range(v);
+ SVector3 t1_nb, t2_nb, n_nb;
+ double covar1_nb[2], covar2_nb[2], L_nb, size_param_1_nb, size_param_2_nb;
+ double maxprod, angle = 0.;
+ int N = 0;
+ for(multimap<MVertex *, MVertex *>::iterator itneighbor = range.first;
+ itneighbor != range.second; itneighbor++) {
N++;
- maxprod=0.;
+ maxprod = 0.;
MVertex *v_nb = itneighbor->second;
- SPoint2 param_point_nb(v_nb->x(),v_nb->y());GPoint gpt_nb = gf->point(param_point_nb); MVertex v_real_nb(gpt_nb.x(),gpt_nb.y(),gpt_nb.z());
- get_local_sizes_and_directions(&v_real_nb, param_point_nb, 0, gf, covar1_nb, covar2_nb, size_param_1_nb, size_param_2_nb, L_nb, t1_nb, t2_nb, n_nb);
+ SPoint2 param_point_nb(v_nb->x(), v_nb->y());
+ GPoint gpt_nb = gf->point(param_point_nb);
+ MVertex v_real_nb(gpt_nb.x(), gpt_nb.y(), gpt_nb.z());
+ get_local_sizes_and_directions(&v_real_nb, param_point_nb, 0, gf,
+ covar1_nb, covar2_nb, size_param_1_nb,
+ size_param_2_nb, L_nb, t1_nb, t2_nb, n_nb);
// angle comparison...
- maxprod = std::max(maxprod, fabs(t1[0]*t1_nb[0] + t1[1]*t1_nb[1]));
- maxprod = std::max(maxprod, fabs(t1[0]*t2_nb[0] + t1[1]*t2_nb[1]));
- angle += fabs(acos(max(min(maxprod,1.),-1.)));
+ maxprod = std::max(maxprod, fabs(t1[0] * t1_nb[0] + t1[1] * t1_nb[1]));
+ maxprod = std::max(maxprod, fabs(t1[0] * t2_nb[0] + t1[1] * t2_nb[1]));
+ angle += fabs(acos(max(min(maxprod, 1.), -1.)));
}
angle /= N;
vertices2smoothness[v] = angle;
}
-// if (debug){
-// stringstream ss;
-// ss << "backgroundmesh_smoothness_" << gf->tag() << ".pos";
-// backgroundMesh::current()->print(ss.str().c_str(),gf, vertices2smoothness);
-// }
-
+ // if (debug){
+ // stringstream ss;
+ // ss << "backgroundmesh_smoothness_" << gf->tag() << ".pos";
+ // backgroundMesh::current()->print(ss.str().c_str(),gf,
+ // vertices2smoothness);
+ // }
- // --------------- export de smoothness comme elements.... -----------------------
- if (debug){
+ // --------------- export de smoothness comme elements....
+ // -----------------------
+ if(debug) {
stringstream ss;
ss << "backgroundmesh_element_smoothness_" << gf->tag() << ".pos";
ofstream out(ss.str().c_str());
out << "View \"directions\" {" << endl;
- for (std::vector<MElement*>::iterator it = backgroundMesh::current()->begin_triangles();it!=backgroundMesh::current()->end_triangles();it++){
+ for(std::vector<MElement *>::iterator it =
+ backgroundMesh::current()->begin_triangles();
+ it != backgroundMesh::current()->end_triangles(); it++) {
MElement *e = *it;
vector<MVertex *> nodes;
vector<double> smoothtemp;
- for (int i=0;i<3;i++){
+ for(int i = 0; i < 3; i++) {
MVertex *v = e->getVertex(i);
nodes.push_back(v);
smoothtemp.push_back(vertices2smoothness[v]);
}
out << "ST(";
- for (int i=0;i<3;i++){
- GPoint pp = gf->point(SPoint2(nodes[i]->x(),nodes[i]->y()));
+ for(int i = 0; i < 3; i++) {
+ GPoint pp = gf->point(SPoint2(nodes[i]->x(), nodes[i]->y()));
out << pp.x() << "," << pp.y() << "," << pp.z();
- if (i!=2) out << ",";
+ if(i != 2) out << ",";
}
out << "){";
- for (int i=0;i<3;i++){
- out << (1.-(smoothtemp[i]/M_PI*4.));
- if (i!=2) out << ",";
+ for(int i = 0; i < 3; i++) {
+ out << (1. - (smoothtemp[i] / M_PI * 4.));
+ if(i != 2) out << ",";
}
out << "};" << endl;
-
}
out << "};" << endl;
out.close();
}
// --------------- END ----------------
-
// for debug check...
- int priority_counter=0;
- map<MVertex*,int> vert_priority;
+ int priority_counter = 0;
+ map<MVertex *, int> vert_priority;
// get all the boundary vertices
- std::set<MVertex*> bnd_vertices;
- for(unsigned int i=0;i<gf->getNumMeshElements();i++){
- MElement* element = gf->getMeshElement(i);
- for(std::size_t j=0;j<element->getNumVertices();j++){
+ std::set<MVertex *> bnd_vertices;
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
+ MElement *element = gf->getMeshElement(i);
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
MVertex *vertex = element->getVertex(j);
- if (vertex->onWhat()->dim() < 2)bnd_vertices.insert(vertex);
+ if(vertex->onWhat()->dim() < 2) bnd_vertices.insert(vertex);
}
}
// --------- put boundary vertices in a fifo queue ---------------
- std::set<smoothness_point_pair, compareSurfacePointWithExclusionRegionPtr_Smoothness> fifo;
- std::vector<surfacePointWithExclusionRegion*> vertices;
+ std::set<smoothness_point_pair,
+ compareSurfacePointWithExclusionRegionPtr_Smoothness>
+ fifo;
+ std::vector<surfacePointWithExclusionRegion *> vertices;
// put the RTREE
- RTree<surfacePointWithExclusionRegion*,double,2,double> rtree;
+ RTree<surfacePointWithExclusionRegion *, double, 2, double> rtree;
SMetric3 metricField(1.0);
SPoint2 newp[4][NUMDIR];
- std::set<MVertex*>::iterator it = bnd_vertices.begin() ;
+ std::set<MVertex *>::iterator it = bnd_vertices.begin();
- char NAME[345]; sprintf(NAME,"crossReal%d.pos",gf->tag());
+ char NAME[345];
+ sprintf(NAME, "crossReal%d.pos", gf->tag());
FILE *crossf = NULL;
- if (debug){
- crossf = Fopen (NAME,"w");
+ if(debug) {
+ crossf = Fopen(NAME, "w");
}
- if (crossf) fprintf(crossf,"View \"\"{\n");
- for (; it != bnd_vertices.end() ; ++it){
+ if(crossf) fprintf(crossf, "View \"\"{\n");
+ for(; it != bnd_vertices.end(); ++it) {
SPoint2 midpoint;
- //compute4neighbors_RK2 (gf, *it, midpoint, goNonLinear, newp, metricField,crossf);
- compute4neighbors(gf, *it, midpoint, goNonLinear, newp, metricField,crossf);
+ // compute4neighbors_RK2 (gf, *it, midpoint, goNonLinear, newp,
+ // metricField,crossf);
+ compute4neighbors(gf, *it, midpoint, goNonLinear, newp, metricField,
+ crossf);
surfacePointWithExclusionRegion *sp =
- new surfacePointWithExclusionRegion (*it, newp, midpoint,metricField);
- smoothness_point_pair mp;mp.ptr = sp;mp.rank=get_smoothness(*it,gf,vertices2smoothness);
+ new surfacePointWithExclusionRegion(*it, newp, midpoint, metricField);
+ smoothness_point_pair mp;
+ mp.ptr = sp;
+ mp.rank = get_smoothness(*it, gf, vertices2smoothness);
fifo.insert(mp);
- if (debug){
+ if(debug) {
smoothness_essai[*it] = mp.rank;
}
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
- rtree.Insert(_min,_max,sp);
- if (crossf) export_point(sp, 0, crossf, gf);
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
+ rtree.Insert(_min, _max, sp);
+ if(crossf) export_point(sp, 0, crossf, gf);
}
// ---------- main loop -----------------
- while(!fifo.empty()){
- if (debug) std::cout << " -------- fifo.size() = " << fifo.size() << std::endl;
+ while(!fifo.empty()) {
+ if(debug)
+ std::cout << " -------- fifo.size() = " << fifo.size() << std::endl;
- surfacePointWithExclusionRegion * parent = (*fifo.begin()).ptr;
+ surfacePointWithExclusionRegion *parent = (*fifo.begin()).ptr;
fifo.erase(fifo.begin());
int count_nbaddedpt = 0;
- for (int dir=0;dir<NUMDIR;dir++){
- for (int i=0;i<4;i++){
-
- if (!inExclusionZone (parent->_p[i][dir], rtree, vertices) ){
+ for(int dir = 0; dir < NUMDIR; dir++) {
+ for(int i = 0; i < 4; i++) {
+ if(!inExclusionZone(parent->_p[i][dir], rtree, vertices)) {
GPoint gp = gf->point(parent->_p[i][dir]);
- MFaceVertex *v = new MFaceVertex(gp.x(),gp.y(),gp.z(),gf,gp.u(),gp.v());
+ MFaceVertex *v =
+ new MFaceVertex(gp.x(), gp.y(), gp.z(), gf, gp.u(), gp.v());
SPoint2 midpoint;
- //compute4neighbors_RK2 (gf, v, midpoint, goNonLinear, newp, metricField,crossf);
- compute4neighbors(gf, v, midpoint, goNonLinear, newp, metricField,crossf);
+ // compute4neighbors_RK2 (gf, v, midpoint, goNonLinear, newp,
+ // metricField,crossf);
+ compute4neighbors(gf, v, midpoint, goNonLinear, newp, metricField,
+ crossf);
surfacePointWithExclusionRegion *sp =
- new surfacePointWithExclusionRegion (v, newp, midpoint, metricField, parent);
- smoothness_point_pair mp;mp.ptr = sp;mp.rank=get_smoothness(v,gf,vertices2smoothness);
+ new surfacePointWithExclusionRegion(v, newp, midpoint, metricField,
+ parent);
+ smoothness_point_pair mp;
+ mp.ptr = sp;
+ mp.rank = get_smoothness(v, gf, vertices2smoothness);
- if (debug){
+ if(debug) {
smoothness_essai[v] = mp.rank;
vert_priority[v] = priority_counter++;
}
fifo.insert(mp);
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
- rtree.Insert(_min,_max,sp);
- if (crossf) export_point(sp, dir, crossf, gf);
-
- if (debug){
- std::cout << " adding node (" << sp->_v->x() << "," << sp->_v->y() << "," << sp->_v->z() << ")" << std::endl;
- std::cout << " ----------------------------- sub --- fifo.size() = " << fifo.size() << std::endl;
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
+ rtree.Insert(_min, _max, sp);
+ if(crossf) export_point(sp, dir, crossf, gf);
+
+ if(debug) {
+ std::cout << " adding node (" << sp->_v->x() << "," << sp->_v->y()
+ << "," << sp->_v->z() << ")" << std::endl;
+ std::cout
+ << " ----------------------------- sub --- fifo.size() = "
+ << fifo.size() << std::endl;
}
count_nbaddedpt++;
}
}
}
- if (debug) std::cout << "////////// nbre of added point: " << count_nbaddedpt << std::endl;
+ if(debug)
+ std::cout << "////////// nbre of added point: " << count_nbaddedpt
+ << std::endl;
}
- if (crossf){
- fprintf(crossf,"};\n");
- fclose (crossf);
+ if(crossf) {
+ fprintf(crossf, "};\n");
+ fclose(crossf);
}
-
- if (debug){
+ if(debug) {
stringstream ss;
ss << "priority_" << gf->tag() << ".pos";
- print_nodal_info_int(ss.str().c_str(),vert_priority);
+ print_nodal_info_int(ss.str().c_str(), vert_priority);
ss.clear();
ss << "smoothness_test_" << gf->tag() << ".pos";
- print_nodal_info_double(ss.str().c_str(),smoothness_essai);
+ print_nodal_info_double(ss.str().c_str(), smoothness_essai);
}
-
// add the vertices as additional vertices in the
// surface mesh
// char ccc[256]; sprintf(ccc,"points%d.pos",gf->tag());
// FILE *f = Fopen(ccc,"w");
// if(f) fprintf(f, "View \"\"{\n");
- for (unsigned int i=0;i<vertices.size();i++){
+ for(unsigned int i = 0; i < vertices.size(); i++) {
// if(f) vertices[i]->print(f,i);
if(vertices[i]->_v->onWhat() == gf) {
packed.push_back(vertices[i]->_v);
@@ -705,7 +831,7 @@ void packingOfParallelogramsSmoothness(GFace* gf, std::vector<MVertex*> &packed
SPoint2 midpoint;
reparamMeshVertexOnFace(vertices[i]->_v, gf, midpoint);
}
- delete vertices[i];
+ delete vertices[i];
}
// if(f){
// fprintf(f,"};");
@@ -713,287 +839,308 @@ void packingOfParallelogramsSmoothness(GFace* gf, std::vector<MVertex*> &packed
// }
}
-
-
-
// fills a surface with points in order to build a nice
// quad mesh ------------
-void packingOfParallelograms(GFace* gf, std::vector<MVertex*> &packed, std::vector<SMetric3> &metrics){
- //PE MODIF
-// packingOfParallelogramsSmoothness(gf,packed,metrics);
-// return;
+void packingOfParallelograms(GFace *gf, std::vector<MVertex *> &packed,
+ std::vector<SMetric3> &metrics)
+{
+ // PE MODIF
+ // packingOfParallelogramsSmoothness(gf,packed,metrics);
+ // return;
// END PE MODIF
const bool goNonLinear = true;
// FILE *f = Fopen ("parallelograms.pos","w");
-
// test test test
stringstream ssa;
ssa << "oldbgm_angles_" << gf->tag() << ".pos";
- backgroundMesh::current()->print(ssa.str(),gf,1);
+ backgroundMesh::current()->print(ssa.str(), gf, 1);
// test test test
// get all the boundary vertices
- std::set<MVertex*> bnd_vertices;
- for(unsigned int i=0;i<gf->getNumMeshElements();i++){
- MElement* element = gf->getMeshElement(i);
- for(std::size_t j=0;j<element->getNumVertices();j++){
+ std::set<MVertex *> bnd_vertices;
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
+ MElement *element = gf->getMeshElement(i);
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
MVertex *vertex = element->getVertex(j);
- if (vertex->onWhat()->dim() < 2)bnd_vertices.insert(vertex);
+ if(vertex->onWhat()->dim() < 2) bnd_vertices.insert(vertex);
}
}
// put boundary vertices in a fifo queue
// std::queue<surfacePointWithExclusionRegion*> fifo;
- std::set<surfacePointWithExclusionRegion*, compareSurfacePointWithExclusionRegionPtr> fifo;
- std::vector<surfacePointWithExclusionRegion*> vertices;
+ std::set<surfacePointWithExclusionRegion *,
+ compareSurfacePointWithExclusionRegionPtr>
+ fifo;
+ std::vector<surfacePointWithExclusionRegion *> vertices;
// put the RTREE
- RTree<surfacePointWithExclusionRegion*,double,2,double> rtree;
+ RTree<surfacePointWithExclusionRegion *, double, 2, double> rtree;
SMetric3 metricField(1.0);
SPoint2 newp[4][NUMDIR];
- std::set<MVertex*>::iterator it = bnd_vertices.begin() ;
+ std::set<MVertex *>::iterator it = bnd_vertices.begin();
- char NAME[345]; sprintf(NAME,"crossReal%d.pos",gf->tag());
- FILE *crossf = Fopen (NAME,"w");
- if (crossf) fprintf(crossf,"View \"\"{\n");
- for (; it != bnd_vertices.end() ; ++it){
+ char NAME[345];
+ sprintf(NAME, "crossReal%d.pos", gf->tag());
+ FILE *crossf = Fopen(NAME, "w");
+ if(crossf) fprintf(crossf, "View \"\"{\n");
+ for(; it != bnd_vertices.end(); ++it) {
SPoint2 midpoint;
- compute4neighbors (gf, *it, midpoint, goNonLinear, newp, metricField,crossf);
+ compute4neighbors(gf, *it, midpoint, goNonLinear, newp, metricField,
+ crossf);
surfacePointWithExclusionRegion *sp =
- new surfacePointWithExclusionRegion (*it, newp, midpoint,metricField);
+ new surfacePointWithExclusionRegion(*it, newp, midpoint, metricField);
// fifo.push(sp);
fifo.insert(sp);
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
// printf("%g %g .. %g %g\n",_min[0],_min[1],_max[0],_max[1]);
- rtree.Insert(_min,_max,sp);
+ rtree.Insert(_min, _max, sp);
// sp->print(f);
}
// printf("initially : %d vertices in the domain\n",vertices.size());
-
- while(!fifo.empty()){
- surfacePointWithExclusionRegion * parent = *fifo.begin();
+ while(!fifo.empty()) {
+ surfacePointWithExclusionRegion *parent = *fifo.begin();
fifo.erase(fifo.begin());
- for (int dir=0;dir<NUMDIR;dir++){
+ for(int dir = 0; dir < NUMDIR; dir++) {
int countOK = 0;
- for (int i=0;i<4;i++){
- if (!inExclusionZone (parent->_p[i][dir], rtree, vertices) ){
+ for(int i = 0; i < 4; i++) {
+ if(!inExclusionZone(parent->_p[i][dir], rtree, vertices)) {
countOK++;
GPoint gp = gf->point(parent->_p[i][dir]);
- MFaceVertex *v = new MFaceVertex(gp.x(),gp.y(),gp.z(),gf,gp.u(),gp.v());
+ MFaceVertex *v =
+ new MFaceVertex(gp.x(), gp.y(), gp.z(), gf, gp.u(), gp.v());
SPoint2 midpoint;
- compute4neighbors (gf, v, midpoint, goNonLinear, newp, metricField,crossf);
+ compute4neighbors(gf, v, midpoint, goNonLinear, newp, metricField,
+ crossf);
surfacePointWithExclusionRegion *sp =
- new surfacePointWithExclusionRegion (v, newp, midpoint, metricField, parent);
+ new surfacePointWithExclusionRegion(v, newp, midpoint, metricField,
+ parent);
fifo.insert(sp);
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
- rtree.Insert(_min,_max,sp);
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
+ rtree.Insert(_min, _max, sp);
}
}
- if (countOK)break;
- }
+ if(countOK) break;
+ }
}
- if (crossf){
- fprintf(crossf,"};\n");
- fclose (crossf);
+ if(crossf) {
+ fprintf(crossf, "};\n");
+ fclose(crossf);
}
- // add the vertices as additional vertices in the
- // surface mesh
- char ccc[256]; sprintf(ccc,"points%d.pos",gf->tag());
- FILE *f = Fopen(ccc,"w");
- if(f) fprintf(f,"View \"\"{\n");
- for (unsigned int i=0;i<vertices.size();i++){
+ // add the vertices as additional vertices in the
+ // surface mesh
+ char ccc[256];
+ sprintf(ccc, "points%d.pos", gf->tag());
+ FILE *f = Fopen(ccc, "w");
+ if(f) fprintf(f, "View \"\"{\n");
+ for(unsigned int i = 0; i < vertices.size(); i++) {
// if(vertices[i]->_v->onWhat() != gf)
- if(f) vertices[i]->print(f,i);
+ if(f) vertices[i]->print(f, i);
if(vertices[i]->_v->onWhat() == gf) {
packed.push_back(vertices[i]->_v);
metrics.push_back(vertices[i]->_meshMetric);
SPoint2 midpoint;
reparamMeshVertexOnFace(vertices[i]->_v, gf, midpoint);
}
- delete vertices[i];
+ delete vertices[i];
}
- if(f){
- fprintf(f,"};");
+ if(f) {
+ fprintf(f, "};");
fclose(f);
}
}
-
// fills a surface with points in order to build a nice
// quad mesh ------------
void packingOfParallelogramsConstrained(
GFace *gf, const std::set<MVertex *> &constr_vertices,
std::vector<MVertex *> &packed, std::vector<SMetric3> &metrics)
{
- //PE MODIF
+// PE MODIF
// packingOfParallelogramsSmoothness(gf,packed,metrics);
// return;
- // END PE MODIF
+// END PE MODIF
#if defined(HAVE_RTREE)
- std::cout<<" inside packingOfParallelogramsConstrained"<<std::endl;
+ std::cout << " inside packingOfParallelogramsConstrained" << std::endl;
const bool goNonLinear = true;
// FILE *f = Fopen ("parallelograms.pos","w");
// get all the boundary vertices
- std::set<MVertex*> bnd_vertices;
- for(unsigned int i=0;i<gf->getNumMeshElements();i++){
- MElement* element = gf->getMeshElement(i);
- for(int j=0;j<element->getNumVertices();j++){
+ std::set<MVertex *> bnd_vertices;
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
+ MElement *element = gf->getMeshElement(i);
+ for(int j = 0; j < element->getNumVertices(); j++) {
MVertex *vertex = element->getVertex(j);
- if (vertex->onWhat()->dim() < 2)bnd_vertices.insert(vertex);
+ if(vertex->onWhat()->dim() < 2) bnd_vertices.insert(vertex);
}
}
- std::cout<<" got all the boundary vertices"<<std::endl;
+ std::cout << " got all the boundary vertices" << std::endl;
// put boundary vertices in a fifo queue
// std::queue<surfacePointWithExclusionRegion*> fifo;
- std::set<surfacePointWithExclusionRegion*, compareSurfacePointWithExclusionRegionPtr> fifo;
- std::vector<surfacePointWithExclusionRegion*> vertices;
+ std::set<surfacePointWithExclusionRegion *,
+ compareSurfacePointWithExclusionRegionPtr>
+ fifo;
+ std::vector<surfacePointWithExclusionRegion *> vertices;
// put the RTREE
- RTree<surfacePointWithExclusionRegion*,double,2,double> rtree;
+ RTree<surfacePointWithExclusionRegion *, double, 2, double> rtree;
SMetric3 metricField(1.0);
SPoint2 newp[4][NUMDIR];
- std::set<MVertex*>::iterator it = bnd_vertices.begin() ;
-
- char NAME[345]; sprintf(NAME,"crossReal%d.pos",gf->tag());
- FILE *crossf = Fopen (NAME,"w");
- if (crossf)fprintf(crossf,"View \"\"{\n");
- std::cout<<" entering first for"<<std::endl;
- for (; it != bnd_vertices.end() ; ++it){
+ std::set<MVertex *>::iterator it = bnd_vertices.begin();
+
+ char NAME[345];
+ sprintf(NAME, "crossReal%d.pos", gf->tag());
+ FILE *crossf = Fopen(NAME, "w");
+ if(crossf) fprintf(crossf, "View \"\"{\n");
+ std::cout << " entering first for" << std::endl;
+ for(; it != bnd_vertices.end(); ++it) {
SPoint2 midpoint;
- compute4neighbors (gf, *it, midpoint, goNonLinear, newp, metricField,crossf);
+ compute4neighbors(gf, *it, midpoint, goNonLinear, newp, metricField,
+ crossf);
surfacePointWithExclusionRegion *sp =
- new surfacePointWithExclusionRegion (*it, newp, midpoint,metricField);
+ new surfacePointWithExclusionRegion(*it, newp, midpoint, metricField);
// fifo.push(sp);
fifo.insert(sp);
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
// printf("%g %g .. %g %g\n",_min[0],_min[1],_max[0],_max[1]);
- rtree.Insert(_min,_max,sp);
+ rtree.Insert(_min, _max, sp);
// sp->print(f);
}
- std::set<MVertex*>::iterator it_constr = constr_vertices.begin() ;
- std::cout<<" entering second for"<<std::endl;
- for (; it_constr != constr_vertices.end() ; ++it_constr){
+ std::set<MVertex *>::iterator it_constr = constr_vertices.begin();
+ std::cout << " entering second for" << std::endl;
+ for(; it_constr != constr_vertices.end(); ++it_constr) {
SPoint2 midpoint;
- std::cout<<"going to test out parameterisation of the new point"<<std::endl;
+ std::cout << "going to test out parameterisation of the new point"
+ << std::endl;
double para0, para1;
- (*it_constr)->getParameter(0,para0);
- (*it_constr)->getParameter(1,para1);
- std::cout<<" point tested: para 1 "<<para0<<" and para 2 "<<para1<<std::endl;
- std::cout<<" going to compute4neighbors"<<std::endl;
- compute4neighbors (gf, *it_constr, midpoint, goNonLinear, newp, metricField,crossf);
- std::cout<<" going to surfacePointWithExclusionRegion"<<std::endl;
- surfacePointWithExclusionRegion *sp =
- new surfacePointWithExclusionRegion (*it_constr, newp, midpoint,metricField);
+ (*it_constr)->getParameter(0, para0);
+ (*it_constr)->getParameter(1, para1);
+ std::cout << " point tested: para 1 " << para0 << " and para 2 "
+ << para1 << std::endl;
+ std::cout << " going to compute4neighbors" << std::endl;
+ compute4neighbors(gf, *it_constr, midpoint, goNonLinear, newp, metricField,
+ crossf);
+ std::cout << " going to surfacePointWithExclusionRegion"
+ << std::endl;
+ surfacePointWithExclusionRegion *sp = new surfacePointWithExclusionRegion(
+ *it_constr, newp, midpoint, metricField);
// fifo.push(sp);
- std::cout<<" done surfacePointWithExclusionRegion"<<std::endl;
+ std::cout << " done surfacePointWithExclusionRegion" << std::endl;
fifo.insert(sp);
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
// printf("%g %g .. %g %g\n",_min[0],_min[1],_max[0],_max[1]);
- rtree.Insert(_min,_max,sp);
+ rtree.Insert(_min, _max, sp);
// sp->print(f);
}
// printf("initially : %d vertices in the domain\n",vertices.size());
-
- std::cout<<" entering while"<<std::endl;
- while(!fifo.empty()){
- //surfacePointWithExclusionRegion & parent = fifo.top();
+ std::cout << " entering while" << std::endl;
+ while(!fifo.empty()) {
+ // surfacePointWithExclusionRegion & parent = fifo.top();
// surfacePointWithExclusionRegion * parent = fifo.front();
- surfacePointWithExclusionRegion * parent = *fifo.begin();
+ surfacePointWithExclusionRegion *parent = *fifo.begin();
// fifo.pop();
fifo.erase(fifo.begin());
- for (int dir=0;dir<NUMDIR;dir++){
+ for(int dir = 0; dir < NUMDIR; dir++) {
// printf("dir = %d\n",dir);
int countOK = 0;
- for (int i=0;i<4;i++){
- // printf("i = %d %12.5E %12.5E \n",i,parent._p[i][dir].x(),parent._p[i][dir].y());
+ for(int i = 0; i < 4; i++) {
+ // printf("i = %d %12.5E %12.5E
+ //\n",i,parent._p[i][dir].x(),parent._p[i][dir].y());
// if (!w._tooclose){
- if (!inExclusionZone (parent->_p[i][dir], rtree, vertices) ){
+ if(!inExclusionZone(parent->_p[i][dir], rtree, vertices)) {
countOK++;
GPoint gp = gf->point(parent->_p[i][dir]);
- MFaceVertex *v = new MFaceVertex(gp.x(),gp.y(),gp.z(),gf,gp.u(),gp.v());
- std::cout<<"going to test out parameterisation of the new point"<<std::endl;
+ MFaceVertex *v =
+ new MFaceVertex(gp.x(), gp.y(), gp.z(), gf, gp.u(), gp.v());
+ std::cout << "going to test out parameterisation of the new point"
+ << std::endl;
double para0, para1;
- v->getParameter(0,para0);
- v->getParameter(1,para1);
-// if (v->getNum() == 341){
-// std::cout<<" 341 dans surface filler !!!!"<<std::endl;
-// std::system("pause");
-// getchar();
-// }
- std::cout<<" point tested: para 1 "<<para0<<" and para 2 "<<para1<<std::endl;
- // printf(" %g %g %g %g\n",parent._center.x(),parent._center.y(),gp.u(),gp.v());
+ v->getParameter(0, para0);
+ v->getParameter(1, para1);
+ // if (v->getNum() == 341){
+ // std::cout<<" 341 dans surface filler !!!!"<<std::endl;
+ // std::system("pause");
+ // getchar();
+ // }
+ std::cout << " point tested: para 1 " << para0
+ << " and para 2 " << para1 << std::endl;
+ // printf(" %g %g %g
+ //%g\n",parent._center.x(),parent._center.y(),gp.u(),gp.v());
SPoint2 midpoint;
- compute4neighbors (gf, v, midpoint, goNonLinear, newp, metricField,crossf);
+ compute4neighbors(gf, v, midpoint, goNonLinear, newp, metricField,
+ crossf);
surfacePointWithExclusionRegion *sp =
- new surfacePointWithExclusionRegion (v, newp, midpoint, metricField, parent);
+ new surfacePointWithExclusionRegion(v, newp, midpoint, metricField,
+ parent);
// fifo.push(sp);
fifo.insert(sp);
vertices.push_back(sp);
- double _min[2],_max[2];
- sp->minmax(_min,_max);
- rtree.Insert(_min,_max,sp);
+ double _min[2], _max[2];
+ sp->minmax(_min, _max);
+ rtree.Insert(_min, _max, sp);
}
}
- if (countOK)break;
- }
- // printf("%d\n",vertices.size());
- }
- std::cout<<" entering if"<<std::endl;
- if (crossf){
- fprintf(crossf,"};\n");
- fclose (crossf);
+ if(countOK) break;
}
- // printf("done\n");
-
- // add the vertices as additional vertices in the
- // surface mesh
- char ccc[256]; sprintf(ccc,"points%d.pos",gf->tag());
- FILE *f = Fopen(ccc,"w");
- fprintf(f,"View \"\"{\n");
- std::cout<<" entering another for"<<std::endl;
- for (unsigned int i=0;i<vertices.size();i++){
- // if(vertices[i]->_v->onWhat() != gf)
- vertices[i]->print(f,i);
- if(vertices[i]->_v->onWhat() == gf) {
- packed.push_back(vertices[i]->_v);
- metrics.push_back(vertices[i]->_meshMetric);
- SPoint2 midpoint;
- reparamMeshVertexOnFace(vertices[i]->_v, gf, midpoint);
- std::cout<<"going to test out parameterisation of the REPARAM point"<<std::endl;
- double para0, para1;
- vertices[i]->_v->getParameter(0,para0);
- vertices[i]->_v->getParameter(1,para1);
- std::cout<<" point tested: para 1 "<<para0<<" and para 2 "<<para1<<std::endl;
- // fprintf(f,"TP(%22.15E,%22.15E,%g){%22.15E,%22.15E,%22.15E,%22.15E,%22.15E,%22.15E,%22.15E,%22.15E,%22.15E};\n",vertices[i]->_v->x(),vertices[i]->_v->y(),vertices[i]->_v->z(),
- // vertices[i]->_meshMetric(0,0),vertices[i]->_meshMetric(0,1),vertices[i]->_meshMetric(0,2),
- // vertices[i]->_meshMetric(1,0),vertices[i]->_meshMetric(1,1),vertices[i]->_meshMetric(1,2),
- // vertices[i]->_meshMetric(2,0),vertices[i]->_meshMetric(2,1),vertices[i]->_meshMetric(2,2));
- //fprintf(f,"SP(%22.15E,%22.15E,%g){1};\n",midpoint.x(),midpoint.y(),0.0);
- }
- delete vertices[i];
+ // printf("%d\n",vertices.size());
+ }
+ std::cout << " entering if" << std::endl;
+ if(crossf) {
+ fprintf(crossf, "};\n");
+ fclose(crossf);
+ }
+ // printf("done\n");
+
+ // add the vertices as additional vertices in the
+ // surface mesh
+ char ccc[256];
+ sprintf(ccc, "points%d.pos", gf->tag());
+ FILE *f = Fopen(ccc, "w");
+ fprintf(f, "View \"\"{\n");
+ std::cout << " entering another for" << std::endl;
+ for(unsigned int i = 0; i < vertices.size(); i++) {
+ // if(vertices[i]->_v->onWhat() != gf)
+ vertices[i]->print(f, i);
+ if(vertices[i]->_v->onWhat() == gf) {
+ packed.push_back(vertices[i]->_v);
+ metrics.push_back(vertices[i]->_meshMetric);
+ SPoint2 midpoint;
+ reparamMeshVertexOnFace(vertices[i]->_v, gf, midpoint);
+ std::cout << "going to test out parameterisation of the REPARAM point"
+ << std::endl;
+ double para0, para1;
+ vertices[i]->_v->getParameter(0, para0);
+ vertices[i]->_v->getParameter(1, para1);
+ std::cout << " point tested: para 1 " << para0
+ << " and para 2 " << para1 << std::endl;
+ // fprintf(f,"TP(%22.15E,%22.15E,%g){%22.15E,%22.15E,%22.15E,%22.15E,%22.15E,%22.15E,%22.15E,%22.15E,%22.15E};\n",vertices[i]->_v->x(),vertices[i]->_v->y(),vertices[i]->_v->z(),
+ // vertices[i]->_meshMetric(0,0),vertices[i]->_meshMetric(0,1),vertices[i]->_meshMetric(0,2),
+ // vertices[i]->_meshMetric(1,0),vertices[i]->_meshMetric(1,1),vertices[i]->_meshMetric(1,2),
+ // vertices[i]->_meshMetric(2,0),vertices[i]->_meshMetric(2,1),vertices[i]->_meshMetric(2,2));
+ // fprintf(f,"SP(%22.15E,%22.15E,%g){1};\n",midpoint.x(),midpoint.y(),0.0);
}
- fprintf(f,"};");
- fclose(f);
- // printf("packed.size = %d\n",packed.size());
- // delete rtree;
+ delete vertices[i];
+ }
+ fprintf(f, "};");
+ fclose(f);
+ // printf("packed.size = %d\n",packed.size());
+ // delete rtree;
#endif
}
diff --git a/Mesh/surfaceFiller.h b/Mesh/surfaceFiller.h
index 66ca4f741b99dfd5e7f14b112e8bf6a146ea6aab..5662c14e2a707f825064d71e5f009a0fadb5c5d0 100644
--- a/Mesh/surfaceFiller.h
+++ b/Mesh/surfaceFiller.h
@@ -14,8 +14,11 @@
class GFace;
class MVertex;
-void packingOfParallelogramsSmoothness(GFace* gf, std::vector<MVertex*> &packed, std::vector<SMetric3> &metrics );
-void packingOfParallelograms(GFace* gf, std::vector<MVertex*> &packed, std::vector<SMetric3> &metrics );
+void packingOfParallelogramsSmoothness(GFace *gf,
+ std::vector<MVertex *> &packed,
+ std::vector<SMetric3> &metrics);
+void packingOfParallelograms(GFace *gf, std::vector<MVertex *> &packed,
+ std::vector<SMetric3> &metrics);
void packingOfParallelogramsConstrained(
GFace *gf, const std::set<MVertex *> &constr_vertices,
std::vector<MVertex *> &packed, std::vector<SMetric3> &metrics);
diff --git a/Mesh/tetgenBR.h b/Mesh/tetgenBR.h
index f38471d360c1c45839ea50e4eb82de1cc1956954..86f7ec7d3f26e175f90d742ec6b24087133385b9 100644
--- a/Mesh/tetgenBR.h
+++ b/Mesh/tetgenBR.h
@@ -48,84 +48,82 @@
///////////////////////////////////////////////////////////////////////////////
class tetgenbehavior {
-
public:
-
- // Switches of TetGen.
- int plc; // '-p', 0.
- int psc; // '-s', 0.
- int refine; // '-r', 0.
- int quality; // '-q', 0.
- int nobisect; // '-Y', 0.
- int coarsen; // '-R', 0.
- int weighted; // '-w', 0.
- int brio_hilbert; // '-b', 1.
- int incrflip; // '-l', 0.
- int flipinsert; // '-L', 0.
- int metric; // '-m', 0.
- int varvolume; // '-a', 0.
- int fixedvolume; // '-a', 0.
- int regionattrib; // '-A', 0.
- int cdtrefine; // '-D', 0.
- int insertaddpoints; // '-i', 0.
- int diagnose; // '-d', 0.
- int convex; // '-c', 0.
- int nomergefacet; // '-M', 0.
- int nomergevertex; // '-M', 0.
- int noexact; // '-X', 0.
- int nostaticfilter; // '-X', 0.
- int zeroindex; // '-z', 0.
- int facesout; // '-f', 0.
- int edgesout; // '-e', 0.
- int neighout; // '-n', 0.
- int voroout; // '-v', 0.
- int meditview; // '-g', 0.
- int vtkview; // '-k', 0.
- int nobound; // '-B', 0.
- int nonodewritten; // '-N', 0.
- int noelewritten; // '-E', 0.
- int nofacewritten; // '-F', 0.
- int noiterationnum; // '-I', 0.
- int nojettison; // '-J', 0.
- int docheck; // '-C', 0.
- int quiet; // '-Q', 0.
- int verbose; // '-V', 0.
-
- // Parameters of TetGen.
- int vertexperblock; // '-x', 4092.
- int tetrahedraperblock; // '-x', 8188.
- int shellfaceperblock; // '-x', 2044.
- int nobisect_nomerge; // '-Y', 1.
- int supsteiner_level; // '-Y/', 2.
- int addsteiner_algo; // '-Y//', 1.
- int coarsen_param; // '-R', 0.
- int weighted_param; // '-w', 0.
- int fliplinklevel; // -1.
- int flipstarsize; // -1.
- int fliplinklevelinc; // 1.
- int reflevel; // '-D', 3.
- int optlevel; // '-O', 2.
- int optscheme; // '-O', 7.
- int delmaxfliplevel; // 1.
- int order; // '-o', 1.
- int reversetetori; // '-o/', 0.
- int steinerleft; // '-S', 0.
- int no_sort; // 0.
- int hilbert_order; // '-b///', 52.
- int hilbert_limit; // '-b//' 8.
- int brio_threshold; // '-b' 64.
- REAL brio_ratio; // '-b/' 0.125.
- REAL facet_separate_ang_tol; // '-p', 179.9.
- REAL facet_overlap_ang_tol; // '-p/', 0.1.
- REAL facet_small_ang_tol; // '-p//', 15.0.
- REAL maxvolume; // '-a', -1.0.
- REAL minratio; // '-q', 0.0.
- REAL mindihedral; // '-q', 5.0.
- REAL optmaxdihedral; // 165.0.
- REAL optminsmtdihed; // 179.0.
- REAL optminslidihed; // 179.0.
- REAL epsilon; // '-T', 1.0e-8.
- REAL coarsen_percent; // -R1/#, 1.0.
+ // Switches of TetGen.
+ int plc; // '-p', 0.
+ int psc; // '-s', 0.
+ int refine; // '-r', 0.
+ int quality; // '-q', 0.
+ int nobisect; // '-Y', 0.
+ int coarsen; // '-R', 0.
+ int weighted; // '-w', 0.
+ int brio_hilbert; // '-b', 1.
+ int incrflip; // '-l', 0.
+ int flipinsert; // '-L', 0.
+ int metric; // '-m', 0.
+ int varvolume; // '-a', 0.
+ int fixedvolume; // '-a', 0.
+ int regionattrib; // '-A', 0.
+ int cdtrefine; // '-D', 0.
+ int insertaddpoints; // '-i', 0.
+ int diagnose; // '-d', 0.
+ int convex; // '-c', 0.
+ int nomergefacet; // '-M', 0.
+ int nomergevertex; // '-M', 0.
+ int noexact; // '-X', 0.
+ int nostaticfilter; // '-X', 0.
+ int zeroindex; // '-z', 0.
+ int facesout; // '-f', 0.
+ int edgesout; // '-e', 0.
+ int neighout; // '-n', 0.
+ int voroout; // '-v', 0.
+ int meditview; // '-g', 0.
+ int vtkview; // '-k', 0.
+ int nobound; // '-B', 0.
+ int nonodewritten; // '-N', 0.
+ int noelewritten; // '-E', 0.
+ int nofacewritten; // '-F', 0.
+ int noiterationnum; // '-I', 0.
+ int nojettison; // '-J', 0.
+ int docheck; // '-C', 0.
+ int quiet; // '-Q', 0.
+ int verbose; // '-V', 0.
+
+ // Parameters of TetGen.
+ int vertexperblock; // '-x', 4092.
+ int tetrahedraperblock; // '-x', 8188.
+ int shellfaceperblock; // '-x', 2044.
+ int nobisect_nomerge; // '-Y', 1.
+ int supsteiner_level; // '-Y/', 2.
+ int addsteiner_algo; // '-Y//', 1.
+ int coarsen_param; // '-R', 0.
+ int weighted_param; // '-w', 0.
+ int fliplinklevel; // -1.
+ int flipstarsize; // -1.
+ int fliplinklevelinc; // 1.
+ int reflevel; // '-D', 3.
+ int optlevel; // '-O', 2.
+ int optscheme; // '-O', 7.
+ int delmaxfliplevel; // 1.
+ int order; // '-o', 1.
+ int reversetetori; // '-o/', 0.
+ int steinerleft; // '-S', 0.
+ int no_sort; // 0.
+ int hilbert_order; // '-b///', 52.
+ int hilbert_limit; // '-b//' 8.
+ int brio_threshold; // '-b' 64.
+ REAL brio_ratio; // '-b/' 0.125.
+ REAL facet_separate_ang_tol; // '-p', 179.9.
+ REAL facet_overlap_ang_tol; // '-p/', 0.1.
+ REAL facet_small_ang_tol; // '-p//', 15.0.
+ REAL maxvolume; // '-a', -1.0.
+ REAL minratio; // '-q', 0.0.
+ REAL mindihedral; // '-q', 5.0.
+ REAL optmaxdihedral; // 165.0.
+ REAL optminsmtdihed; // 179.0.
+ REAL optminslidihed; // 179.0.
+ REAL epsilon; // '-T', 1.0e-8.
+ REAL coarsen_percent; // -R1/#, 1.0.
// Strings of command line arguments and input/output file names.
char commandline[1024];
@@ -134,27 +132,27 @@ public:
char addinfilename[1024];
char bgmeshfilename[1024];
- // The input object of TetGen. They are recognized by either the input
- // file extensions or by the specified options.
+ // The input object of TetGen. They are recognized by either the input
+ // file extensions or by the specified options.
// Currently the following objects are supported:
- // - NODES, a list of nodes (.node);
- // - POLY, a piecewise linear complex (.poly or .smesh);
- // - OFF, a polyhedron (.off, Geomview's file format);
+ // - NODES, a list of nodes (.node);
+ // - POLY, a piecewise linear complex (.poly or .smesh);
+ // - OFF, a polyhedron (.off, Geomview's file format);
// - PLY, a polyhedron (.ply, file format from gatech, only ASCII);
// - STL, a surface mesh (.stl, stereolithography format);
- // - MEDIT, a surface mesh (.mesh, Medit's file format);
+ // - MEDIT, a surface mesh (.mesh, Medit's file format);
// - MESH, a tetrahedral mesh (.ele).
// If no extension is available, the imposed command line switch
- // (-p or -r) implies the object.
- enum objecttype {NODES, POLY, OFF, PLY, STL, MEDIT, VTK, MESH} object;
-
+ // (-p or -r) implies the object.
+ enum objecttype { NODES, POLY, OFF, PLY, STL, MEDIT, VTK, MESH } object;
void syntax();
void usage();
// Command line parse routine.
bool parse_commandline(int argc, char **argv);
- bool parse_commandline(char *switches) {
+ bool parse_commandline(char *switches)
+ {
return parse_commandline(0, &switches);
}
@@ -208,11 +206,11 @@ public:
addsteiner_algo = 1;
coarsen_param = 0;
weighted_param = 0;
- fliplinklevel = -1;
- flipstarsize = -1;
+ fliplinklevel = -1;
+ flipstarsize = -1;
fliplinklevelinc = 1;
reflevel = 3;
- optscheme = 7;
+ optscheme = 7;
optlevel = 2;
delmaxfliplevel = 1;
order = 1;
@@ -241,12 +239,10 @@ public:
outfilename[0] = '\0';
addinfilename[0] = '\0';
bgmeshfilename[0] = '\0';
-
}
}; // class tetgenbehavior
-
///////////////////////////////////////////////////////////////////////////////
// //
// tetgenmesh //
@@ -256,39 +252,41 @@ public:
///////////////////////////////////////////////////////////////////////////////
class tetgenmesh {
-
public:
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Mesh data structure //
-// //
-// A tetrahedral mesh T of a 3D piecewise linear complex (PLC) X is a 3D //
-// simplicial complex whose underlying space is equal to the space of X. T //
-// contains a 2D subcomplex S which is a triangular mesh of the boundary of //
-// X. S contains a 1D subcomplex L which is a linear mesh of the boundary of //
-// S. Faces and edges in S and L are respectively called subfaces and segme- //
-// nts to distinguish them from others in T. //
-// //
-// TetGen stores the tetrahedra and vertices of T. The basic structure of a //
-// tetrahedron contains pointers to its vertices and adjacent tetrahedra. A //
-// vertex stores its x-, y-, and z-coordinates, and a pointer to a tetrahed- //
-// ron containing it. Both tetrahedra and vertices may contain user data. //
-// //
-// Each face of T belongs to either two tetrahedra or one tetrahedron. In //
-// the latter case, the face is an exterior boundary face of T. TetGen adds //
-// fictitious tetrahedra (one-to-one) at such faces, and connects them to an //
-// "infinite vertex" (which has no geometric coordinates). One can imagine //
-// such a vertex lies in 4D space and is visible by all exterior boundary //
-// faces. The extended set of tetrahedra (including the infinite vertex) is //
-// a tetrahedralization of a 3-pseudomanifold without boundary. It has the //
-// property that every face is shared by exactly two tetrahedra. //
-// //
-// The current version of TetGen stores explicitly the subfaces and segments //
-// (which are in surface mesh S and the linear mesh L), respectively. Extra //
-// pointers are allocated in tetrahedra and subfaces to point each others. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Mesh data structure //
+ // //
+ // A tetrahedral mesh T of a 3D piecewise linear complex (PLC) X is a 3D //
+ // simplicial complex whose underlying space is equal to the space of X. T //
+ // contains a 2D subcomplex S which is a triangular mesh of the boundary of //
+ // X. S contains a 1D subcomplex L which is a linear mesh of the boundary of
+ // // S. Faces and edges in S and L are respectively called subfaces and
+ // segme- // nts to distinguish them from others in T.
+ // //
+ // //
+ // TetGen stores the tetrahedra and vertices of T. The basic structure of a //
+ // tetrahedron contains pointers to its vertices and adjacent tetrahedra. A //
+ // vertex stores its x-, y-, and z-coordinates, and a pointer to a tetrahed-
+ // // ron containing it. Both tetrahedra and vertices may contain user data.
+ // //
+ // //
+ // Each face of T belongs to either two tetrahedra or one tetrahedron. In //
+ // the latter case, the face is an exterior boundary face of T. TetGen adds
+ // // fictitious tetrahedra (one-to-one) at such faces, and connects them to
+ // an // "infinite vertex" (which has no geometric coordinates). One can
+ // imagine // such a vertex lies in 4D space and is visible by all exterior
+ // boundary // faces. The extended set of tetrahedra (including the
+ // infinite vertex) is // a tetrahedralization of a 3-pseudomanifold without
+ // boundary. It has the // property that every face is shared by exactly two
+ // tetrahedra. //
+ // //
+ // The current version of TetGen stores explicitly the subfaces and segments
+ // // (which are in surface mesh S and the linear mesh L), respectively.
+ // Extra // pointers are allocated in tetrahedra and subfaces to point each
+ // others. //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
// The tetrahedron data structure. It includes the following fields:
// - a list of four adjoining tetrahedra;
@@ -326,67 +324,75 @@ public:
// - an integer for boundary marker (point index);
// - an integer for point type (and flags).
// - an integer for geometry tag (optional, for -s switch).
- // The structure of a point is an array of REALs. Its acutal size is
+ // The structure of a point is an array of REALs. Its acutal size is
// determined at the runtime.
typedef REAL *point;
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Handles //
-// //
-// Navigation and manipulation in a tetrahedralization are accomplished by //
-// operating on structures referred as ``handles". A handle is a pair (t,v), //
-// where t is a pointer to a tetrahedron, and v is a 4-bit integer, in the //
-// range from 0 to 11. v is called the ``version'' of a tetrahedron, it rep- //
-// resents a directed edge of a specific face of the tetrahedron. //
-// //
-// There are 12 even permutations of the four vertices, each of them corres- //
-// ponds to a directed edge (a version) of the tetrahedron. The 12 versions //
-// can be grouped into 4 distinct ``edge rings'' in 4 ``oriented faces'' of //
-// this tetrahedron. One can encode each version (a directed edge) into a //
-// 4-bit integer such that the two upper bits encode the index (from 0 to 2) //
-// of this edge in the edge ring, and the two lower bits encode the index ( //
-// from 0 to 3) of the oriented face which contains this edge. //
-// //
-// The four vertices of a tetrahedron are indexed from 0 to 3 (according to //
-// their storage in the data structure). Give each face the same index as //
-// the node opposite it in the tetrahedron. Denote the edge connecting face //
-// i to face j as i/j. We number the twelve versions as follows: //
-// //
-// | edge 0 edge 1 edge 2 //
-// --------|-------------------------------- //
-// face 0 | 0 (0/1) 4 (0/3) 8 (0/2) //
-// face 1 | 1 (1/2) 5 (1/3) 9 (1/0) //
-// face 2 | 2 (2/3) 6 (2/1) 10 (2/0) //
-// face 3 | 3 (3/0) 7 (3/1) 11 (3/2) //
-// //
-// Similarly, navigation and manipulation in a (boundary) triangulation are //
-// done by using handles of triangles. Each handle is a pair (s, v), where s //
-// is a pointer to a triangle, and v is a version in the range from 0 to 5. //
-// Each version corresponds to a directed edge of this triangle. //
-// //
-// Number the three vertices of a triangle from 0 to 2 (according to their //
-// storage in the data structure). Give each edge the same index as the node //
-// opposite it in the triangle. The six versions of a triangle are: //
-// //
-// | edge 0 edge 1 edge 2 //
-// ---------------|-------------------------- //
-// ccw orieation | 0 2 4 //
-// cw orieation | 1 3 5 //
-// //
-// In the following, a 'triface' is a handle of tetrahedron, and a 'face' is //
-// a handle of a triangle. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Handles //
+ // //
+ // Navigation and manipulation in a tetrahedralization are accomplished by //
+ // operating on structures referred as ``handles". A handle is a pair (t,v),
+ // // where t is a pointer to a tetrahedron, and v is a 4-bit integer, in the
+ // // range from 0 to 11. v is called the ``version'' of a tetrahedron, it
+ // rep- // resents a directed edge of a specific face of the tetrahedron.
+ // //
+ // //
+ // There are 12 even permutations of the four vertices, each of them corres-
+ // // ponds to a directed edge (a version) of the tetrahedron. The 12
+ // versions // can be grouped into 4 distinct ``edge rings'' in 4 ``oriented
+ // faces'' of // this tetrahedron. One can encode each version (a directed
+ // edge) into a // 4-bit integer such that the two upper bits encode the
+ // index (from 0 to 2) // of this edge in the edge ring, and the two lower
+ // bits encode the index ( // from 0 to 3) of the oriented face which
+ // contains this edge. //
+ // //
+ // The four vertices of a tetrahedron are indexed from 0 to 3 (according to //
+ // their storage in the data structure). Give each face the same index as //
+ // the node opposite it in the tetrahedron. Denote the edge connecting face
+ // // i to face j as i/j. We number the twelve versions as follows:
+ // //
+ // //
+ // | edge 0 edge 1 edge 2 //
+ // --------|-------------------------------- //
+ // face 0 | 0 (0/1) 4 (0/3) 8 (0/2) // face 1 | 1 (1/2) 5
+ // (1/3) 9 (1/0) // face 2 | 2 (2/3)
+ // 6 (2/1) 10 (2/0) // face 3 | 3 (3/0)
+ // 7 (3/1) 11 (3/2) //
+ // //
+ // Similarly, navigation and manipulation in a (boundary) triangulation are //
+ // done by using handles of triangles. Each handle is a pair (s, v), where s
+ // // is a pointer to a triangle, and v is a version in the range from 0 to 5.
+ // // Each version corresponds to a directed edge of this triangle.
+ // //
+ // //
+ // Number the three vertices of a triangle from 0 to 2 (according to their //
+ // storage in the data structure). Give each edge the same index as the node
+ // // opposite it in the triangle. The six versions of a triangle are:
+ // //
+ // //
+ // | edge 0 edge 1 edge 2 //
+ // ---------------|-------------------------- //
+ // ccw orieation | 0 2 4 //
+ // cw orieation | 1 3 5 //
+ // //
+ // In the following, a 'triface' is a handle of tetrahedron, and a 'face' is
+ // // a handle of a triangle.
+ // //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
class triface {
public:
tetrahedron *tet;
int ver; // Range from 0 to 11.
triface() : tet(0), ver(0) {}
- triface& operator=(const triface& t) {
- tet = t.tet; ver = t.ver;
+ triface &operator=(const triface &t)
+ {
+ tet = t.tet;
+ ver = t.ver;
return *this;
}
};
@@ -396,34 +402,36 @@ public:
shellface *sh;
int shver; // Range from 0 to 5.
face() : sh(0), shver(0) {}
- face& operator=(const face& s) {
- sh = s.sh; shver = s.shver;
+ face &operator=(const face &s)
+ {
+ sh = s.sh;
+ shver = s.shver;
return *this;
}
};
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Arraypool //
-// //
-// A dynamic linear array. (It is written by J. Shewchuk) //
-// //
-// Each arraypool contains an array of pointers to a number of blocks. Each //
-// block contains the same fixed number of objects. Each index of the array //
-// addresses a particular object in the pool. The most significant bits add- //
-// ress the index of the block containing the object. The less significant //
-// bits address this object within the block. //
-// //
-// 'objectbytes' is the size of one object in blocks; 'log2objectsperblock' //
-// is the base-2 logarithm of 'objectsperblock'; 'objects' counts the number //
-// of allocated objects; 'totalmemory' is the total memory in bytes. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Arraypool //
+ // //
+ // A dynamic linear array. (It is written by J. Shewchuk) //
+ // //
+ // Each arraypool contains an array of pointers to a number of blocks. Each
+ // // block contains the same fixed number of objects. Each index of the
+ // array // addresses a particular object in the pool. The most significant
+ // bits add- // ress the index of the block containing the object. The less
+ // significant // bits address this object within the block.
+ // //
+ // //
+ // 'objectbytes' is the size of one object in blocks; 'log2objectsperblock' //
+ // is the base-2 logarithm of 'objectsperblock'; 'objects' counts the number
+ // // of allocated objects; 'totalmemory' is the total memory in bytes.
+ // //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
class arraypool {
-
public:
-
int objectbytes;
int objectsperblock;
int log2objectsperblock;
@@ -435,109 +443,110 @@ public:
void restart();
void poolinit(int sizeofobject, int log2objperblk);
- char* getblock(int objectindex);
- void* lookup(int objectindex);
+ char *getblock(int objectindex);
+ void *lookup(int objectindex);
int newindex(void **newptr);
arraypool(int sizeofobject, int log2objperblk);
~arraypool();
};
-// fastlookup() -- A fast, unsafe operation. Return the pointer to the object
-// with a given index. Note: The object's block must have been allocated,
-// i.e., by the function newindex().
-
-#define fastlookup(pool, index) \
- (void *) ((pool)->toparray[(index) >> (pool)->log2objectsperblock] + \
- ((index) & (pool)->objectsperblockmark) * (pool)->objectbytes)
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Memorypool //
-// //
-// A structure for memory allocation. (It is written by J. Shewchuk) //
-// //
-// firstblock is the first block of items. nowblock is the block from which //
-// items are currently being allocated. nextitem points to the next slab //
-// of free memory for an item. deaditemstack is the head of a linked list //
-// (stack) of deallocated items that can be recycled. unallocateditems is //
-// the number of items that remain to be allocated from nowblock. //
-// //
-// Traversal is the process of walking through the entire list of items, and //
-// is separate from allocation. Note that a traversal will visit items on //
-// the "deaditemstack" stack as well as live items. pathblock points to //
-// the block currently being traversed. pathitem points to the next item //
-// to be traversed. pathitemsleft is the number of items that remain to //
-// be traversed in pathblock. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ // fastlookup() -- A fast, unsafe operation. Return the pointer to the object
+ // with a given index. Note: The object's block must have been allocated,
+ // i.e., by the function newindex().
+
+#define fastlookup(pool, index) \
+ (void *)((pool)->toparray[(index) >> (pool)->log2objectsperblock] + \
+ ((index) & (pool)->objectsperblockmark) * (pool)->objectbytes)
+
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Memorypool //
+ // //
+ // A structure for memory allocation. (It is written by J. Shewchuk) //
+ // //
+ // firstblock is the first block of items. nowblock is the block from which //
+ // items are currently being allocated. nextitem points to the next slab //
+ // of free memory for an item. deaditemstack is the head of a linked list //
+ // (stack) of deallocated items that can be recycled. unallocateditems is
+ // // the number of items that remain to be allocated from nowblock.
+ // //
+ // //
+ // Traversal is the process of walking through the entire list of items, and
+ // //
+ // is separate from allocation. Note that a traversal will visit items on
+ // // the "deaditemstack" stack as well as live items. pathblock points to
+ // // the block currently being traversed. pathitem points to the next item
+ // // to be traversed. pathitemsleft is the number of items that remain to
+ // // be traversed in pathblock.
+ // //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
class memorypool {
-
public:
-
void **firstblock, **nowblock;
void *nextitem;
void *deaditemstack;
void **pathblock;
void *pathitem;
- int alignbytes;
- int itembytes, itemwords;
- int itemsperblock;
+ int alignbytes;
+ int itembytes, itemwords;
+ int itemsperblock;
long items, maxitems;
- int unallocateditems;
- int pathitemsleft;
+ int unallocateditems;
+ int pathitemsleft;
memorypool();
memorypool(int, int, int, int);
~memorypool();
-
+
void poolinit(int, int, int, int);
void restart();
void *alloc();
- void dealloc(void*);
+ void dealloc(void *);
void traversalinit();
void *traverse();
- };
+ };
-///////////////////////////////////////////////////////////////////////////////
-// //
-// badface //
-// //
-// Despite of its name, a 'badface' can be used to represent one of the //
-// following objects: //
-// - a face of a tetrahedron which is (possibly) non-Delaunay; //
-// - an encroached subsegment or subface; //
-// - a bad-quality tetrahedron, i.e, has too large radius-edge ratio; //
-// - a sliver, i.e., has good radius-edge ratio but nearly zero volume; //
-// - a recently flipped face (saved for undoing the flip later). //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // badface //
+ // //
+ // Despite of its name, a 'badface' can be used to represent one of the //
+ // following objects: //
+ // - a face of a tetrahedron which is (possibly) non-Delaunay; //
+ // - an encroached subsegment or subface; //
+ // - a bad-quality tetrahedron, i.e, has too large radius-edge ratio; //
+ // - a sliver, i.e., has good radius-edge ratio but nearly zero volume; //
+ // - a recently flipped face (saved for undoing the flip later). //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
class badface {
public:
- triface tt;
+ triface tt;
face ss;
- REAL key, cent[6]; // circumcenter or cos(dihedral angles) at 6 edges.
+ REAL key, cent[6]; // circumcenter or cos(dihedral angles) at 6 edges.
point forg, fdest, fapex, foppo, noppo;
- badface *nextitem;
- badface() : key(0), forg(0), fdest(0), fapex(0), foppo(0), noppo(0),
- nextitem(0) {}
+ badface *nextitem;
+ badface()
+ : key(0), forg(0), fdest(0), fapex(0), foppo(0), noppo(0), nextitem(0)
+ {
+ }
};
-///////////////////////////////////////////////////////////////////////////////
-// //
-// insertvertexflags //
-// //
-// A collection of flags that pass to the routine insertvertex(). //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // insertvertexflags //
+ // //
+ // A collection of flags that pass to the routine insertvertex(). //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
class insertvertexflags {
-
public:
-
- int iloc; // input/output.
+ int iloc; // input/output.
int bowywat, lawson;
int splitbdflag, validflag, respectbdflag;
int rejflag, chkencflag, cdtflag;
@@ -552,7 +561,8 @@ public:
REAL smlen; // for useinsertradius.
point parentpt;
- insertvertexflags() {
+ insertvertexflags()
+ {
iloc = bowywat = lawson = 0;
splitbdflag = validflag = respectbdflag = 0;
rejflag = chkencflag = cdtflag = 0;
@@ -567,25 +577,23 @@ public:
}
};
-///////////////////////////////////////////////////////////////////////////////
-// //
-// flipconstraints //
-// //
-// A structure of a collection of data (options and parameters) which pass //
-// to the edge flip function flipnm(). //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // flipconstraints //
+ // //
+ // A structure of a collection of data (options and parameters) which pass //
+ // to the edge flip function flipnm(). //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
class flipconstraints {
-
public:
-
// Elementary flip flags.
int enqflag; // (= flipflag)
int chkencflag;
// Control flags
- int unflip; // Undo the performed flips.
+ int unflip; // Undo the performed flips.
int collectnewtets; // Collect the new tets created by flips.
int collectencsegflag;
@@ -599,13 +607,13 @@ public:
// Boundary recovery flags.
int checkflipeligibility;
- point seg[2]; // A constraining edge to be recovered.
- point fac[3]; // A constraining face to be recovered.
+ point seg[2]; // A constraining edge to be recovered.
+ point fac[3]; // A constraining face to be recovered.
point remvert; // A vertex to be removed.
-
- flipconstraints() {
- enqflag = 0;
+ flipconstraints()
+ {
+ enqflag = 0;
chkencflag = 0;
unflip = 0;
@@ -626,33 +634,31 @@ public:
}
};
-///////////////////////////////////////////////////////////////////////////////
-// //
-// optparameters //
-// //
-// Optimization options and parameters. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // optparameters //
+ // //
+ // Optimization options and parameters. //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
class optparameters {
-
public:
-
// The one of goals of optimization.
- int max_min_volume; // Maximize the minimum volume.
- int min_max_aspectratio; // Minimize the maximum aspect ratio.
- int min_max_dihedangle; // Minimize the maximum dihedral angle.
+ int max_min_volume; // Maximize the minimum volume.
+ int min_max_aspectratio; // Minimize the maximum aspect ratio.
+ int min_max_dihedangle; // Minimize the maximum dihedral angle.
// The initial and improved value.
REAL initval, imprval;
int numofsearchdirs;
REAL searchstep;
- int maxiter; // Maximum smoothing iterations (disabled by -1).
+ int maxiter; // Maximum smoothing iterations (disabled by -1).
int smthiter; // Performed iterations.
-
- optparameters() {
+ optparameters()
+ {
max_min_volume = 0;
min_max_aspectratio = 0;
min_max_dihedangle = 0;
@@ -661,38 +667,68 @@ public:
numofsearchdirs = 10;
searchstep = 0.01;
- maxiter = -1; // Unlimited smoothing iterations.
+ maxiter = -1; // Unlimited smoothing iterations.
smthiter = 0;
-
}
};
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Labels (enumeration declarations) used by TetGen. //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ // Labels that signify the type of a vertex.
+ enum verttype {
+ UNUSEDVERTEX,
+ DUPLICATEDVERTEX,
+ RIDGEVERTEX,
+ ACUTEVERTEX,
+ FACETVERTEX,
+ VOLVERTEX,
+ FREESEGVERTEX,
+ FREEFACETVERTEX,
+ FREEVOLVERTEX,
+ NREGULARVERTEX,
+ DEADVERTEX
+ };
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Labels (enumeration declarations) used by TetGen. //
-// //
-///////////////////////////////////////////////////////////////////////////////
-
- // Labels that signify the type of a vertex.
- enum verttype {UNUSEDVERTEX, DUPLICATEDVERTEX, RIDGEVERTEX, ACUTEVERTEX,
- FACETVERTEX, VOLVERTEX, FREESEGVERTEX, FREEFACETVERTEX,
- FREEVOLVERTEX, NREGULARVERTEX, DEADVERTEX};
-
// Labels that signify the result of triangle-triangle intersection test.
- enum interresult {DISJOINT, INTERSECT, SHAREVERT, SHAREEDGE, SHAREFACE,
- TOUCHEDGE, TOUCHFACE, ACROSSVERT, ACROSSEDGE, ACROSSFACE};
+ enum interresult {
+ DISJOINT,
+ INTERSECT,
+ SHAREVERT,
+ SHAREEDGE,
+ SHAREFACE,
+ TOUCHEDGE,
+ TOUCHFACE,
+ ACROSSVERT,
+ ACROSSEDGE,
+ ACROSSFACE
+ };
// Labels that signify the result of point location.
- enum locateresult {UNKNOWN, OUTSIDE, INTETRAHEDRON, ONFACE, ONEDGE, ONVERTEX,
- ENCVERTEX, ENCSEGMENT, ENCSUBFACE, NEARVERTEX, NONREGULAR,
- INSTAR, BADELEMENT};
+ enum locateresult {
+ UNKNOWN,
+ OUTSIDE,
+ INTETRAHEDRON,
+ ONFACE,
+ ONEDGE,
+ ONVERTEX,
+ ENCVERTEX,
+ ENCSEGMENT,
+ ENCSUBFACE,
+ NEARVERTEX,
+ NONREGULAR,
+ INSTAR,
+ BADELEMENT
+ };
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Variables of TetGen //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Variables of TetGen //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
// Pointer to the input data (a set of nodes, a PLC, or a mesh).
tetgenio *in, *addin;
@@ -714,7 +750,7 @@ public:
// A memorypool to store faces to be flipped.
memorypool *flippool;
arraypool *unflipqueue;
- badface *flipstack;
+ badface *flipstack;
// Arrays used for point insertion (the Bowyer-Watson algorithm).
arraypool *cavetetlist, *cavebdrylist, *caveoldtetlist;
@@ -749,203 +785,202 @@ public:
point *highordertable;
// Various variables.
- int numpointattrib; // Number of point attributes.
- int numelemattrib; // Number of tetrahedron attributes.
- int sizeoftensor; // Number of REALs per metric tensor.
- int pointmtrindex; // Index to find the metric tensor of a point.
- int pointparamindex; // Index to find the u,v coordinates of a point.
- int point2simindex; // Index to find a simplex adjacent to a point.
- int pointmarkindex; // Index to find boundary marker of a point.
- int pointinsradiusindex; // Index to find the insertion radius of a point.
- int elemattribindex; // Index to find attributes of a tetrahedron.
- int volumeboundindex; // Index to find volume bound of a tetrahedron.
- int elemmarkerindex; // Index to find marker of a tetrahedron.
- int shmarkindex; // Index to find boundary marker of a subface.
- int areaboundindex; // Index to find area bound of a subface.
- int checksubsegflag; // Are there segments in the tetrahedralization yet?
- int checksubfaceflag; // Are there subfaces in the tetrahedralization yet?
- int checkconstraints; // Are there variant (node, seg, facet) constraints?
- int nonconvex; // Is current mesh non-convex?
- int autofliplinklevel; // The increase of link levels, default is 1.
- int useinsertradius; // Save the insertion radius for Steiner points.
- long samples; // Number of random samples for point location.
- unsigned long randomseed; // Current random number seed.
- REAL cosmaxdihed, cosmindihed; // The cosine values of max/min dihedral.
- REAL cossmtdihed; // The cosine value of a bad dihedral to be smoothed.
- REAL cosslidihed; // The cosine value of the max dihedral of a sliver.
- REAL minfaceang, minfacetdihed; // The minimum input (dihedral) angles.
- REAL tetprism_vol_sum; // The total volume of tetrahedral-prisms (in 4D).
- REAL longest; // The longest possible edge length.
- REAL minedgelength; // = longest * b->epsion.
- REAL xmax, xmin, ymax, ymin, zmax, zmin; // Bounding box of points.
+ int numpointattrib; // Number of point attributes.
+ int numelemattrib; // Number of tetrahedron attributes.
+ int sizeoftensor; // Number of REALs per metric tensor.
+ int pointmtrindex; // Index to find the metric tensor of a point.
+ int pointparamindex; // Index to find the u,v coordinates of a point.
+ int point2simindex; // Index to find a simplex adjacent to a point.
+ int pointmarkindex; // Index to find boundary marker of a point.
+ int pointinsradiusindex; // Index to find the insertion radius of a point.
+ int elemattribindex; // Index to find attributes of a tetrahedron.
+ int volumeboundindex; // Index to find volume bound of a tetrahedron.
+ int elemmarkerindex; // Index to find marker of a tetrahedron.
+ int shmarkindex; // Index to find boundary marker of a subface.
+ int areaboundindex; // Index to find area bound of a subface.
+ int checksubsegflag; // Are there segments in the tetrahedralization yet?
+ int checksubfaceflag; // Are there subfaces in the tetrahedralization yet?
+ int checkconstraints; // Are there variant (node, seg, facet) constraints?
+ int nonconvex; // Is current mesh non-convex?
+ int autofliplinklevel; // The increase of link levels, default is 1.
+ int useinsertradius; // Save the insertion radius for Steiner points.
+ long samples; // Number of random samples for point location.
+ unsigned long randomseed; // Current random number seed.
+ REAL cosmaxdihed, cosmindihed; // The cosine values of max/min dihedral.
+ REAL cossmtdihed; // The cosine value of a bad dihedral to be smoothed.
+ REAL cosslidihed; // The cosine value of the max dihedral of a sliver.
+ REAL minfaceang, minfacetdihed; // The minimum input (dihedral) angles.
+ REAL tetprism_vol_sum; // The total volume of tetrahedral-prisms (in 4D).
+ REAL longest; // The longest possible edge length.
+ REAL minedgelength; // = longest * b->epsion.
+ REAL xmax, xmin, ymax, ymin, zmax, zmin; // Bounding box of points.
// Counters.
- long insegments; // Number of input segments.
- long hullsize; // Number of exterior boundary faces.
- long meshedges; // Number of mesh edges.
- long meshhulledges; // Number of boundary mesh edges.
- long steinerleft; // Number of Steiner points not yet used.
- long dupverts; // Are there duplicated vertices?
- long unuverts; // Are there unused vertices?
- long nonregularcount; // Are there non-regular vertices?
- long st_segref_count, st_facref_count, st_volref_count; // Steiner points.
+ long insegments; // Number of input segments.
+ long hullsize; // Number of exterior boundary faces.
+ long meshedges; // Number of mesh edges.
+ long meshhulledges; // Number of boundary mesh edges.
+ long steinerleft; // Number of Steiner points not yet used.
+ long dupverts; // Are there duplicated vertices?
+ long unuverts; // Are there unused vertices?
+ long nonregularcount; // Are there non-regular vertices?
+ long st_segref_count, st_facref_count, st_volref_count; // Steiner points.
long fillregioncount, cavitycount, cavityexpcount;
long flip14count, flip26count, flipn2ncount;
long flip23count, flip32count, flip44count, flip41count;
long flip31count, flip22count;
- unsigned long totalworkmemory; // Total memory used by working arrays.
+ unsigned long totalworkmemory; // Total memory used by working arrays.
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Mesh manipulation primitives //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Mesh manipulation primitives //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
// Fast lookup tables for mesh manipulation primitives.
static int bondtbl[12][12], fsymtbl[12][12];
static int esymtbl[12], enexttbl[12], eprevtbl[12];
- static int enextesymtbl[12], eprevesymtbl[12];
+ static int enextesymtbl[12], eprevesymtbl[12];
static int eorgoppotbl[12], edestoppotbl[12];
static int facepivot1[12], facepivot2[12][12];
static int orgpivot[12], destpivot[12], apexpivot[12], oppopivot[12];
static int tsbondtbl[12][6], stbondtbl[12][6];
static int tspivottbl[12][6], stpivottbl[12][6];
static int ver2edge[12], edge2ver[6], epivot[12];
- static int sorgpivot [6], sdestpivot[6], sapexpivot[6];
+ static int sorgpivot[6], sdestpivot[6], sapexpivot[6];
static int snextpivot[6];
void inittables();
// Primitives for tetrahedra.
- inline tetrahedron encode(triface& t);
- inline tetrahedron encode2(tetrahedron* ptr, int ver);
- inline void decode(tetrahedron ptr, triface& t);
- inline void bond(triface& t1, triface& t2);
- inline void dissolve(triface& t);
- inline void esym(triface& t1, triface& t2);
- inline void esymself(triface& t);
- inline void enext(triface& t1, triface& t2);
- inline void enextself(triface& t);
- inline void eprev(triface& t1, triface& t2);
- inline void eprevself(triface& t);
- inline void enextesym(triface& t1, triface& t2);
- inline void enextesymself(triface& t);
- inline void eprevesym(triface& t1, triface& t2);
- inline void eprevesymself(triface& t);
- inline void eorgoppo(triface& t1, triface& t2);
- inline void eorgoppoself(triface& t);
- inline void edestoppo(triface& t1, triface& t2);
- inline void edestoppoself(triface& t);
- inline void fsym(triface& t1, triface& t2);
- inline void fsymself(triface& t);
- inline void fnext(triface& t1, triface& t2);
- inline void fnextself(triface& t);
- inline point org (triface& t);
- inline point dest(triface& t);
- inline point apex(triface& t);
- inline point oppo(triface& t);
- inline void setorg (triface& t, point p);
- inline void setdest(triface& t, point p);
- inline void setapex(triface& t, point p);
- inline void setoppo(triface& t, point p);
- inline REAL elemattribute(tetrahedron* ptr, int attnum);
- inline void setelemattribute(tetrahedron* ptr, int attnum, REAL value);
- inline REAL volumebound(tetrahedron* ptr);
- inline void setvolumebound(tetrahedron* ptr, REAL value);
- inline int elemindex(tetrahedron* ptr);
- inline void setelemindex(tetrahedron* ptr, int value);
- inline int elemmarker(tetrahedron* ptr);
- inline void setelemmarker(tetrahedron* ptr, int value);
- inline void infect(triface& t);
- inline void uninfect(triface& t);
- inline bool infected(triface& t);
- inline void marktest(triface& t);
- inline void unmarktest(triface& t);
- inline bool marktested(triface& t);
- inline void markface(triface& t);
- inline void unmarkface(triface& t);
- inline bool facemarked(triface& t);
- inline void markedge(triface& t);
- inline void unmarkedge(triface& t);
- inline bool edgemarked(triface& t);
- inline void marktest2(triface& t);
- inline void unmarktest2(triface& t);
- inline bool marktest2ed(triface& t);
- inline int elemcounter(triface& t);
- inline void setelemcounter(triface& t, int value);
- inline void increaseelemcounter(triface& t);
- inline void decreaseelemcounter(triface& t);
- inline bool ishulltet(triface& t);
- inline bool isdeadtet(triface& t);
-
+ inline tetrahedron encode(triface &t);
+ inline tetrahedron encode2(tetrahedron *ptr, int ver);
+ inline void decode(tetrahedron ptr, triface &t);
+ inline void bond(triface &t1, triface &t2);
+ inline void dissolve(triface &t);
+ inline void esym(triface &t1, triface &t2);
+ inline void esymself(triface &t);
+ inline void enext(triface &t1, triface &t2);
+ inline void enextself(triface &t);
+ inline void eprev(triface &t1, triface &t2);
+ inline void eprevself(triface &t);
+ inline void enextesym(triface &t1, triface &t2);
+ inline void enextesymself(triface &t);
+ inline void eprevesym(triface &t1, triface &t2);
+ inline void eprevesymself(triface &t);
+ inline void eorgoppo(triface &t1, triface &t2);
+ inline void eorgoppoself(triface &t);
+ inline void edestoppo(triface &t1, triface &t2);
+ inline void edestoppoself(triface &t);
+ inline void fsym(triface &t1, triface &t2);
+ inline void fsymself(triface &t);
+ inline void fnext(triface &t1, triface &t2);
+ inline void fnextself(triface &t);
+ inline point org(triface &t);
+ inline point dest(triface &t);
+ inline point apex(triface &t);
+ inline point oppo(triface &t);
+ inline void setorg(triface &t, point p);
+ inline void setdest(triface &t, point p);
+ inline void setapex(triface &t, point p);
+ inline void setoppo(triface &t, point p);
+ inline REAL elemattribute(tetrahedron *ptr, int attnum);
+ inline void setelemattribute(tetrahedron *ptr, int attnum, REAL value);
+ inline REAL volumebound(tetrahedron *ptr);
+ inline void setvolumebound(tetrahedron *ptr, REAL value);
+ inline int elemindex(tetrahedron *ptr);
+ inline void setelemindex(tetrahedron *ptr, int value);
+ inline int elemmarker(tetrahedron *ptr);
+ inline void setelemmarker(tetrahedron *ptr, int value);
+ inline void infect(triface &t);
+ inline void uninfect(triface &t);
+ inline bool infected(triface &t);
+ inline void marktest(triface &t);
+ inline void unmarktest(triface &t);
+ inline bool marktested(triface &t);
+ inline void markface(triface &t);
+ inline void unmarkface(triface &t);
+ inline bool facemarked(triface &t);
+ inline void markedge(triface &t);
+ inline void unmarkedge(triface &t);
+ inline bool edgemarked(triface &t);
+ inline void marktest2(triface &t);
+ inline void unmarktest2(triface &t);
+ inline bool marktest2ed(triface &t);
+ inline int elemcounter(triface &t);
+ inline void setelemcounter(triface &t, int value);
+ inline void increaseelemcounter(triface &t);
+ inline void decreaseelemcounter(triface &t);
+ inline bool ishulltet(triface &t);
+ inline bool isdeadtet(triface &t);
+
// Primitives for subfaces and subsegments.
- inline void sdecode(shellface sptr, face& s);
- inline shellface sencode(face& s);
+ inline void sdecode(shellface sptr, face &s);
+ inline shellface sencode(face &s);
inline shellface sencode2(shellface *sh, int shver);
- inline void spivot(face& s1, face& s2);
- inline void spivotself(face& s);
- inline void sbond(face& s1, face& s2);
- inline void sbond1(face& s1, face& s2);
- inline void sdissolve(face& s);
- inline point sorg(face& s);
- inline point sdest(face& s);
- inline point sapex(face& s);
- inline void setsorg(face& s, point pointptr);
- inline void setsdest(face& s, point pointptr);
- inline void setsapex(face& s, point pointptr);
- inline void sesym(face& s1, face& s2);
- inline void sesymself(face& s);
- inline void senext(face& s1, face& s2);
- inline void senextself(face& s);
- inline void senext2(face& s1, face& s2);
- inline void senext2self(face& s);
- inline REAL areabound(face& s);
- inline void setareabound(face& s, REAL value);
- inline int shellmark(face& s);
- inline void setshellmark(face& s, int value);
- inline void sinfect(face& s);
- inline void suninfect(face& s);
- inline bool sinfected(face& s);
- inline void smarktest(face& s);
- inline void sunmarktest(face& s);
- inline bool smarktested(face& s);
- inline void smarktest2(face& s);
- inline void sunmarktest2(face& s);
- inline bool smarktest2ed(face& s);
- inline void smarktest3(face& s);
- inline void sunmarktest3(face& s);
- inline bool smarktest3ed(face& s);
- inline void setfacetindex(face& f, int value);
- inline int getfacetindex(face& f);
+ inline void spivot(face &s1, face &s2);
+ inline void spivotself(face &s);
+ inline void sbond(face &s1, face &s2);
+ inline void sbond1(face &s1, face &s2);
+ inline void sdissolve(face &s);
+ inline point sorg(face &s);
+ inline point sdest(face &s);
+ inline point sapex(face &s);
+ inline void setsorg(face &s, point pointptr);
+ inline void setsdest(face &s, point pointptr);
+ inline void setsapex(face &s, point pointptr);
+ inline void sesym(face &s1, face &s2);
+ inline void sesymself(face &s);
+ inline void senext(face &s1, face &s2);
+ inline void senextself(face &s);
+ inline void senext2(face &s1, face &s2);
+ inline void senext2self(face &s);
+ inline REAL areabound(face &s);
+ inline void setareabound(face &s, REAL value);
+ inline int shellmark(face &s);
+ inline void setshellmark(face &s, int value);
+ inline void sinfect(face &s);
+ inline void suninfect(face &s);
+ inline bool sinfected(face &s);
+ inline void smarktest(face &s);
+ inline void sunmarktest(face &s);
+ inline bool smarktested(face &s);
+ inline void smarktest2(face &s);
+ inline void sunmarktest2(face &s);
+ inline bool smarktest2ed(face &s);
+ inline void smarktest3(face &s);
+ inline void sunmarktest3(face &s);
+ inline bool smarktest3ed(face &s);
+ inline void setfacetindex(face &f, int value);
+ inline int getfacetindex(face &f);
// Primitives for interacting tetrahedra and subfaces.
- inline void tsbond(triface& t, face& s);
- inline void tsdissolve(triface& t);
- inline void stdissolve(face& s);
- inline void tspivot(triface& t, face& s);
- inline void stpivot(face& s, triface& t);
+ inline void tsbond(triface &t, face &s);
+ inline void tsdissolve(triface &t);
+ inline void stdissolve(face &s);
+ inline void tspivot(triface &t, face &s);
+ inline void stpivot(face &s, triface &t);
// Primitives for interacting tetrahedra and segments.
- inline void tssbond1(triface& t, face& seg);
- inline void sstbond1(face& s, triface& t);
- inline void tssdissolve1(triface& t);
- inline void sstdissolve1(face& s);
- inline void tsspivot1(triface& t, face& s);
- inline void sstpivot1(face& s, triface& t);
+ inline void tssbond1(triface &t, face &seg);
+ inline void sstbond1(face &s, triface &t);
+ inline void tssdissolve1(triface &t);
+ inline void sstdissolve1(face &s);
+ inline void tsspivot1(triface &t, face &s);
+ inline void sstpivot1(face &s, triface &t);
// Primitives for interacting subfaces and segments.
- inline void ssbond(face& s, face& edge);
- inline void ssbond1(face& s, face& edge);
- inline void ssdissolve(face& s);
- inline void sspivot(face& s, face& edge);
+ inline void ssbond(face &s, face &edge);
+ inline void ssbond1(face &s, face &edge);
+ inline void ssdissolve(face &s);
+ inline void sspivot(face &s, face &edge);
// Primitives for points.
- inline int pointmark(point pt);
+ inline int pointmark(point pt);
inline void setpointmark(point pt, int value);
inline enum verttype pointtype(point pt);
inline void setpointtype(point pt, enum verttype value);
- inline int pointgeomtag(point pt);
+ inline int pointgeomtag(point pt);
inline void setpointgeomtag(point pt, int value);
inline REAL pointgeomuv(point pt, int i);
inline void setpointgeomuv(point pt, int i, REAL value);
@@ -974,77 +1009,80 @@ public:
inline bool issteinerpoint(point pt);
// Advanced primitives.
- inline void point2tetorg(point pt, triface& t);
- inline void point2shorg(point pa, face& s);
- inline point farsorg(face& seg);
- inline point farsdest(face& seg);
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Memory managment //
-// //
-///////////////////////////////////////////////////////////////////////////////
-
- void tetrahedrondealloc(tetrahedron*);
+ inline void point2tetorg(point pt, triface &t);
+ inline void point2shorg(point pa, face &s);
+ inline point farsorg(face &seg);
+ inline point farsdest(face &seg);
+
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Memory managment //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ void tetrahedrondealloc(tetrahedron *);
tetrahedron *tetrahedrontraverse();
tetrahedron *alltetrahedrontraverse();
- void shellfacedealloc(memorypool*, shellface*);
- shellface *shellfacetraverse(memorypool*);
+ void shellfacedealloc(memorypool *, shellface *);
+ shellface *shellfacetraverse(memorypool *);
void pointdealloc(point);
point pointtraverse();
- void makeindex2pointmap(point*&);
- void makepoint2submap(memorypool*, int*&, face*&);
- void maketetrahedron(triface*);
- void makeshellface(memorypool*, face*);
- void makepoint(point*, enum verttype);
+ void makeindex2pointmap(point *&);
+ void makepoint2submap(memorypool *, int *&, face *&);
+ void maketetrahedron(triface *);
+ void makeshellface(memorypool *, face *);
+ void makepoint(point *, enum verttype);
void initializepools();
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Advanced geometric predicates and calculations //
-// //
-// TetGen uses a simplified symbolic perturbation scheme from Edelsbrunner, //
-// et al [*]. Hence the point-in-sphere test never returns a zero. The idea //
-// is to perturb the weights of vertices in the fourth dimension. TetGen //
-// uses the indices of the vertices decide the amount of perturbation. It is //
-// implemented in the routine insphere_s().
-// //
-// The routine tri_edge_test() determines whether or not a triangle and an //
-// edge intersect in 3D. If they intersect, their intersection type is also //
-// reported. This test is a combination of n 3D orientation tests (n is bet- //
-// ween 3 and 9). It uses the robust orient3d() test to make the branch dec- //
-// isions. The routine tri_tri_test() determines whether or not two triang- //
-// les intersect in 3D. It also uses the robust orient3d() test. //
-// //
-// There are a number of routines to calculate geometrical quantities, e.g., //
-// circumcenters, angles, dihedral angles, face normals, face areas, etc. //
-// They are so far done by the default floating-point arithmetics which are //
-// non-robust. They should be improved in the future. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Advanced geometric predicates and calculations //
+ // //
+ // TetGen uses a simplified symbolic perturbation scheme from Edelsbrunner, //
+ // et al [*]. Hence the point-in-sphere test never returns a zero. The idea
+ // // is to perturb the weights of vertices in the fourth dimension. TetGen
+ // // uses the indices of the vertices decide the amount of perturbation. It
+ // is // implemented in the routine insphere_s().
+ // //
+ // The routine tri_edge_test() determines whether or not a triangle and an //
+ // edge intersect in 3D. If they intersect, their intersection type is also //
+ // reported. This test is a combination of n 3D orientation tests (n is bet-
+ // // ween 3 and 9). It uses the robust orient3d() test to make the branch
+ // dec- // isions. The routine tri_tri_test() determines whether or not two
+ // triang- // les intersect in 3D. It also uses the robust orient3d() test.
+ // //
+ // //
+ // There are a number of routines to calculate geometrical quantities, e.g.,
+ // // circumcenters, angles, dihedral angles, face normals, face areas, etc.
+ // // They are so far done by the default floating-point arithmetics which are
+ // // non-robust. They should be improved in the future.
+ // //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
// Symbolic perturbations (robust)
- REAL insphere_s(REAL*, REAL*, REAL*, REAL*, REAL*);
- REAL orient4d_s(REAL*, REAL*, REAL*, REAL*, REAL*,
- REAL, REAL, REAL, REAL, REAL);
+ REAL insphere_s(REAL *, REAL *, REAL *, REAL *, REAL *);
+ REAL orient4d_s(REAL *, REAL *, REAL *, REAL *, REAL *, REAL, REAL, REAL,
+ REAL, REAL);
// Triangle-edge intersection test (robust)
- int tri_edge_2d(point, point, point, point, point, point, int, int*, int*);
+ int tri_edge_2d(point, point, point, point, point, point, int, int *, int *);
int tri_edge_tail(point, point, point, point, point, point, REAL, REAL, int,
- int*, int*);
- int tri_edge_test(point, point, point, point, point, point, int, int*, int*);
+ int *, int *);
+ int tri_edge_test(point, point, point, point, point, point, int, int *,
+ int *);
// Triangle-triangle intersection test (robust)
int tri_edge_inter_tail(point, point, point, point, point, REAL, REAL);
int tri_tri_inter(point, point, point, point, point, point);
// Linear algebra functions
- inline REAL dot(REAL* v1, REAL* v2);
- inline void cross(REAL* v1, REAL* v2, REAL* n);
- bool lu_decmp(REAL lu[4][4], int n, int* ps, REAL* d, int N);
- void lu_solve(REAL lu[4][4], int n, int* ps, REAL* b, int N);
+ inline REAL dot(REAL *v1, REAL *v2);
+ inline void cross(REAL *v1, REAL *v2, REAL *n);
+ bool lu_decmp(REAL lu[4][4], int n, int *ps, REAL *d, int N);
+ void lu_solve(REAL lu[4][4], int n, int *ps, REAL *b, int N);
// An embedded 2-dimensional geometric predicate (non-robust)
REAL incircle3d(point pa, point pb, point pc, point pd);
@@ -1052,262 +1090,278 @@ public:
// Geometric calculations (non-robust)
REAL orient3dfast(REAL *pa, REAL *pb, REAL *pc, REAL *pd);
inline REAL norm2(REAL x, REAL y, REAL z);
- inline REAL distance(REAL* p1, REAL* p2);
+ inline REAL distance(REAL *p1, REAL *p2);
void facenormal(point pa, point pb, point pc, REAL *n, int pivot, REAL *lav);
- REAL shortdistance(REAL* p, REAL* e1, REAL* e2);
- REAL triarea(REAL* pa, REAL* pb, REAL* pc);
- REAL interiorangle(REAL* o, REAL* p1, REAL* p2, REAL* n);
- void projpt2edge(REAL* p, REAL* e1, REAL* e2, REAL* prj);
- void projpt2face(REAL* p, REAL* f1, REAL* f2, REAL* f3, REAL* prj);
- bool tetalldihedral(point, point, point, point, REAL*, REAL*, REAL*);
- void tetallnormal(point, point, point, point, REAL N[4][3], REAL* volume);
+ REAL shortdistance(REAL *p, REAL *e1, REAL *e2);
+ REAL triarea(REAL *pa, REAL *pb, REAL *pc);
+ REAL interiorangle(REAL *o, REAL *p1, REAL *p2, REAL *n);
+ void projpt2edge(REAL *p, REAL *e1, REAL *e2, REAL *prj);
+ void projpt2face(REAL *p, REAL *f1, REAL *f2, REAL *f3, REAL *prj);
+ bool tetalldihedral(point, point, point, point, REAL *, REAL *, REAL *);
+ void tetallnormal(point, point, point, point, REAL N[4][3], REAL *volume);
REAL tetaspectratio(point, point, point, point);
- bool circumsphere(REAL*, REAL*, REAL*, REAL*, REAL* cent, REAL* radius);
- bool orthosphere(REAL*,REAL*,REAL*,REAL*,REAL,REAL,REAL,REAL,REAL*,REAL*);
- void planelineint(REAL*, REAL*, REAL*, REAL*, REAL*, REAL*, REAL*);
- int linelineint(REAL*, REAL*, REAL*, REAL*, REAL*, REAL*, REAL*, REAL*);
- REAL tetprismvol(REAL* pa, REAL* pb, REAL* pc, REAL* pd);
- bool calculateabovepoint(arraypool*, point*, point*, point*);
+ bool circumsphere(REAL *, REAL *, REAL *, REAL *, REAL *cent, REAL *radius);
+ bool orthosphere(REAL *, REAL *, REAL *, REAL *, REAL, REAL, REAL, REAL,
+ REAL *, REAL *);
+ void planelineint(REAL *, REAL *, REAL *, REAL *, REAL *, REAL *, REAL *);
+ int linelineint(REAL *, REAL *, REAL *, REAL *, REAL *, REAL *, REAL *,
+ REAL *);
+ REAL tetprismvol(REAL *pa, REAL *pb, REAL *pc, REAL *pd);
+ bool calculateabovepoint(arraypool *, point *, point *, point *);
void calculateabovepoint4(point, point, point, point);
// PLC error reports.
- void report_overlapping_facets(face*, face*, REAL dihedang = 0.0);
- int report_selfint_edge(point, point, face* sedge, triface* searchtet,
+ void report_overlapping_facets(face *, face *, REAL dihedang = 0.0);
+ int report_selfint_edge(point, point, face *sedge, triface *searchtet,
enum interresult);
- int report_selfint_face(point, point, point, face* sface, triface* iedge,
- int intflag, int* types, int* poss);
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Local mesh transformations //
-// //
-// A local transformation replaces a small set of tetrahedra with another //
-// set of tetrahedra which fills the same space and the same boundaries. //
-// In 3D, the most simplest local transformations are the elementary flips //
-// performed within the convex hull of five vertices: 2-to-3, 3-to-2, 1-to-4,//
-// and 4-to-1 flips, where the numbers indicate the number of tetrahedra //
-// before and after each flip. The 1-to-4 and 4-to-1 flip involve inserting //
-// or deleting a vertex, respectively. //
-// There are complex local transformations which can be decomposed as a //
-// combination of elementary flips. For example,a 4-to-4 flip which replaces //
-// two coplanar edges can be regarded by a 2-to-3 flip and a 3-to-2 flip. //
-// Note that the first 2-to-3 flip will temporarily create a degenerate tet- //
-// rahedron which is removed immediately by the followed 3-to-2 flip. More //
-// generally, a n-to-m flip, where n > 3, m = (n - 2) * 2, which removes an //
-// edge can be done by first performing a sequence of (n - 3) 2-to-3 flips //
-// followed by a 3-to-2 flip. //
-// //
-// The routines flip23(), flip32(), and flip41() perform the three element- //
-// ray flips. The flip14() is available inside the routine insertpoint(). //
-// //
-// The routines flipnm() and flipnm_post() implement a generalized edge flip //
-// algorithm which uses a combination of elementary flips. //
-// //
-// The routine insertpoint() implements a variant of Bowyer-Watson's cavity //
-// algorithm to insert a vertex. It works for arbitrary tetrahedralization, //
-// either Delaunay, or constrained Delaunay, or non-Delaunay. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ int report_selfint_face(point, point, point, face *sface, triface *iedge,
+ int intflag, int *types, int *poss);
+
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Local mesh transformations //
+ // //
+ // A local transformation replaces a small set of tetrahedra with another //
+ // set of tetrahedra which fills the same space and the same boundaries. //
+ // In 3D, the most simplest local transformations are the elementary flips
+ // //
+ // performed within the convex hull of five vertices: 2-to-3, 3-to-2,
+ // 1-to-4,// and 4-to-1 flips, where the numbers indicate the number of
+ // tetrahedra // before and after each flip. The 1-to-4 and 4-to-1 flip
+ // involve inserting // or deleting a vertex, respectively.
+ // //
+ // There are complex local transformations which can be decomposed as a //
+ // combination of elementary flips. For example,a 4-to-4 flip which replaces
+ // // two coplanar edges can be regarded by a 2-to-3 flip and a 3-to-2 flip.
+ // // Note that the first 2-to-3 flip will temporarily create a degenerate
+ // tet- // rahedron which is removed immediately by the followed 3-to-2 flip.
+ // More // generally, a n-to-m flip, where n > 3, m = (n - 2) * 2, which
+ // removes an // edge can be done by first performing a sequence of (n - 3)
+ // 2-to-3 flips // followed by a 3-to-2 flip.
+ // //
+ // //
+ // The routines flip23(), flip32(), and flip41() perform the three element- //
+ // ray flips. The flip14() is available inside the routine insertpoint(). //
+ // //
+ // The routines flipnm() and flipnm_post() implement a generalized edge flip
+ // // algorithm which uses a combination of elementary flips.
+ // //
+ // //
+ // The routine insertpoint() implements a variant of Bowyer-Watson's cavity //
+ // algorithm to insert a vertex. It works for arbitrary tetrahedralization, //
+ // either Delaunay, or constrained Delaunay, or non-Delaunay. //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
// The elementary flips.
- void flip23(triface*, int, flipconstraints* fc);
- void flip32(triface*, int, flipconstraints* fc);
- void flip41(triface*, int, flipconstraints* fc);
+ void flip23(triface *, int, flipconstraints *fc);
+ void flip32(triface *, int, flipconstraints *fc);
+ void flip41(triface *, int, flipconstraints *fc);
// A generalized edge flip.
- int flipnm(triface*, int n, int level, int, flipconstraints* fc);
- int flipnm_post(triface*, int n, int nn, int, flipconstraints* fc);
+ int flipnm(triface *, int n, int level, int, flipconstraints *fc);
+ int flipnm_post(triface *, int n, int nn, int, flipconstraints *fc);
// Point insertion.
- int insertpoint(point, triface*, face*, face*, insertvertexflags*);
- void insertpoint_abort(face*, insertvertexflags*);
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Delaunay tetrahedralization //
-// //
-// The routine incrementaldelaunay() implemented two incremental algorithms //
-// for constructing Delaunay tetrahedralizations (DTs): the Bowyer-Watson //
-// (B-W) algorithm and the incremental flip algorithm of Edelsbrunner and //
-// Shah, "Incremental topological flipping works for regular triangulation," //
-// Algorithmica, 15:233-241, 1996. //
-// //
-// The routine incrementalflip() implements the flip algorithm of [Edelsbru- //
-// nner and Shah, 1996]. It flips a queue of locally non-Delaunay faces (in //
-// an arbitrary order). The success is guaranteed when the Delaunay tetrah- //
-// edralization is constructed incrementally by adding one vertex at a time. //
-// //
-// The routine locate() finds a tetrahedron contains a new point in current //
-// DT. It uses a simple stochastic walk algorithm: starting from an arbitr- //
-// ary tetrahedron in DT, it finds the destination by visit one tetrahedron //
-// at a time, randomly chooses a tetrahedron if there are more than one //
-// choices. This algorithm terminates due to Edelsbrunner's acyclic theorem. //
-// Choose a good starting tetrahedron is crucial to the speed of the walk. //
-// TetGen originally uses the "jump-and-walk" algorithm of Muecke, E.P., //
-// Saias, I., and Zhu, B. "Fast Randomized Point Location Without Preproces- //
-// sing." In Proceedings of the 12th ACM Symposium on Computational Geometry,//
-// 274-283, 1996. It first randomly samples several tetrahedra in the DT //
-// and then choosing the closet one to start walking. //
-// The above algorithm slows download dramatically as the number of points //
-// grows -- reported in Amenta, N., Choi, S. and Rote, G., "Incremental //
-// construction con {BRIO}," In Proceedings of 19th ACM Symposium on //
-// Computational Geometry, 211-219, 2003. On the other hand, Liu and //
-// Snoeyink showed that the point location can be made in constant time if //
-// the points are pre-sorted so that the nearby points in space have nearby //
-// indices, then adding the points in this order. They sorted the points //
-// along the 3D Hilbert curve. //
-// //
-// The routine hilbert_sort3() sorts a set of 3D points along the 3D Hilbert //
-// curve. It recursively splits a point set according to the Hilbert indices //
-// mapped to the subboxes of the bounding box of the point set. //
-// The Hilbert indices is calculated by Butz's algorithm in 1971. A nice //
-// exposition of this algorithm can be found in the paper of Hamilton, C., //
-// "Compact Hilbert Indices", Technical Report CS-2006-07, Computer Science, //
-// Dalhousie University, 2006 (the Section 2). My implementation also refer- //
-// enced Steven Witham's implementation of "Hilbert walk" (hopefully, it is //
-// still available at: http://www.tiac.net/~sw/2008/10/Hilbert/). //
-// //
-// TetGen sorts the points using the method in the paper of Boissonnat,J.-D.,//
-// Devillers, O. and Hornus, S. "Incremental Construction of the Delaunay //
-// Triangulation and the Delaunay Graph in Medium Dimension," In Proceedings //
-// of the 25th ACM Symposium on Computational Geometry, 2009. //
-// It first randomly sorts the points into subgroups using the Biased Rand-//
-// omized Insertion Ordering (BRIO) of Amenta et al 2003, then sorts the //
-// points in each subgroup along the 3D Hilbert curve. Inserting points in //
-// this order ensures a randomized "sprinkling" of the points over the //
-// domain, while sorting of each subset ensures locality. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ int insertpoint(point, triface *, face *, face *, insertvertexflags *);
+ void insertpoint_abort(face *, insertvertexflags *);
+
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Delaunay tetrahedralization //
+ // //
+ // The routine incrementaldelaunay() implemented two incremental algorithms //
+ // for constructing Delaunay tetrahedralizations (DTs): the Bowyer-Watson //
+ // (B-W) algorithm and the incremental flip algorithm of Edelsbrunner and //
+ // Shah, "Incremental topological flipping works for regular triangulation,"
+ // // Algorithmica, 15:233-241, 1996.
+ // //
+ // //
+ // The routine incrementalflip() implements the flip algorithm of [Edelsbru-
+ // // nner and Shah, 1996]. It flips a queue of locally non-Delaunay faces
+ // (in // an arbitrary order). The success is guaranteed when the Delaunay
+ // tetrah- // edralization is constructed incrementally by adding one vertex
+ // at a time. //
+ // //
+ // The routine locate() finds a tetrahedron contains a new point in current //
+ // DT. It uses a simple stochastic walk algorithm: starting from an arbitr-
+ // // ary tetrahedron in DT, it finds the destination by visit one tetrahedron
+ // // at a time, randomly chooses a tetrahedron if there are more than one
+ // // choices. This algorithm terminates due to Edelsbrunner's acyclic
+ // theorem. //
+ // Choose a good starting tetrahedron is crucial to the speed of the walk.
+ // //
+ // TetGen originally uses the "jump-and-walk" algorithm of Muecke, E.P., //
+ // Saias, I., and Zhu, B. "Fast Randomized Point Location Without Preproces-
+ // // sing." In Proceedings of the 12th ACM Symposium on Computational
+ // Geometry,// 274-283, 1996. It first randomly samples several tetrahedra in
+ // the DT // and then choosing the closet one to start walking.
+ // //
+ // The above algorithm slows download dramatically as the number of points
+ // //
+ // grows -- reported in Amenta, N., Choi, S. and Rote, G., "Incremental //
+ // construction con {BRIO}," In Proceedings of 19th ACM Symposium on //
+ // Computational Geometry, 211-219, 2003. On the other hand, Liu and //
+ // Snoeyink showed that the point location can be made in constant time if //
+ // the points are pre-sorted so that the nearby points in space have nearby //
+ // indices, then adding the points in this order. They sorted the points //
+ // along the 3D Hilbert curve. //
+ // //
+ // The routine hilbert_sort3() sorts a set of 3D points along the 3D Hilbert
+ // // curve. It recursively splits a point set according to the Hilbert
+ // indices // mapped to the subboxes of the bounding box of the point set.
+ // //
+ // The Hilbert indices is calculated by Butz's algorithm in 1971. A nice //
+ // exposition of this algorithm can be found in the paper of Hamilton, C., //
+ // "Compact Hilbert Indices", Technical Report CS-2006-07, Computer Science,
+ // // Dalhousie University, 2006 (the Section 2). My implementation also
+ // refer- // enced Steven Witham's implementation of "Hilbert walk"
+ // (hopefully, it is // still available at:
+ // http://www.tiac.net/~sw/2008/10/Hilbert/). //
+ // //
+ // TetGen sorts the points using the method in the paper of
+ // Boissonnat,J.-D.,// Devillers, O. and Hornus, S. "Incremental Construction
+ // of the Delaunay // Triangulation and the Delaunay Graph in Medium
+ // Dimension," In Proceedings // of the 25th ACM Symposium on Computational
+ // Geometry, 2009. //
+ // It first randomly sorts the points into subgroups using the Biased
+ // Rand-//
+ // omized Insertion Ordering (BRIO) of Amenta et al 2003, then sorts the //
+ // points in each subgroup along the 3D Hilbert curve. Inserting points in //
+ // this order ensures a randomized "sprinkling" of the points over the //
+ // domain, while sorting of each subset ensures locality. //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
void transfernodes();
// Point sorting.
- int transgc[8][3][8], tsb1mod3[8];
+ int transgc[8][3][8], tsb1mod3[8];
void hilbert_init(int n);
- int hilbert_split(point* vertexarray, int arraysize, int gc0, int gc1,
- REAL, REAL, REAL, REAL, REAL, REAL);
- void hilbert_sort3(point* vertexarray, int arraysize, int e, int d,
- REAL, REAL, REAL, REAL, REAL, REAL, int depth);
- void brio_multiscale_sort(point*,int,int threshold,REAL ratio,int* depth);
+ int hilbert_split(point *vertexarray, int arraysize, int gc0, int gc1, REAL,
+ REAL, REAL, REAL, REAL, REAL);
+ void hilbert_sort3(point *vertexarray, int arraysize, int e, int d, REAL,
+ REAL, REAL, REAL, REAL, REAL, int depth);
+ void brio_multiscale_sort(point *, int, int threshold, REAL ratio,
+ int *depth);
// Point location.
unsigned long randomnation(unsigned int choices);
void randomsample(point searchpt, triface *searchtet);
- enum locateresult locate(point searchpt, triface *searchtet,
+ enum locateresult locate(point searchpt, triface *searchtet,
int chkencflag = 0);
// Incremental flips.
- void flippush(badface*&, triface*);
- int incrementalflip(point newpt, int, flipconstraints *fc);
+ void flippush(badface *&, triface *);
+ int incrementalflip(point newpt, int, flipconstraints *fc);
// Incremental Delaunay construction.
void initialdelaunay(point pa, point pb, point pc, point pd);
- void incrementaldelaunay(clock_t&);
+ void incrementaldelaunay(clock_t &);
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Surface triangulation //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Surface triangulation //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
- void flipshpush(face*);
- void flip22(face*, int, int);
- void flip31(face*, int);
+ void flipshpush(face *);
+ void flip22(face *, int, int);
+ void flip31(face *, int);
long lawsonflip();
- int sinsertvertex(point newpt, face*, face*, int iloc, int bowywat, int);
- int sremovevertex(point delpt, face*, face*, int lawson);
+ int sinsertvertex(point newpt, face *, face *, int iloc, int bowywat, int);
+ int sremovevertex(point delpt, face *, face *, int lawson);
- enum locateresult slocate(point, face*, int, int, int);
- enum interresult sscoutsegment(face*, point, int, int, int);
- void scarveholes(int, REAL*);
+ enum locateresult slocate(point, face *, int, int, int);
+ enum interresult sscoutsegment(face *, point, int, int, int);
+ void scarveholes(int, REAL *);
void unifysegments();
- void identifyinputedges(point*);
+ void identifyinputedges(point *);
void mergefacets();
- enum interresult finddirection(triface* searchtet, point endpt);
+ enum interresult finddirection(triface *searchtet, point endpt);
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Constrained tetrahedralizations. //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Constrained tetrahedralizations. //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
int checkflipeligibility(int fliptype, point, point, point, point, point,
- int level, int edgepivot, flipconstraints* fc);
+ int level, int edgepivot, flipconstraints *fc);
- int removeedgebyflips(triface*, flipconstraints*);
- int removefacebyflips(triface*, flipconstraints*);
+ int removeedgebyflips(triface *, flipconstraints *);
+ int removefacebyflips(triface *, flipconstraints *);
- int recoveredgebyflips(point, point, face*, triface*, int fullsearch);
- int add_steinerpt_in_schoenhardtpoly(triface*, int, int chkencflag);
- int add_steinerpt_in_segment(face*, int searchlevel);
- int addsteiner4recoversegment(face*, int);
- int recoversegments(arraypool*, int fullsearch, int steinerflag);
+ int recoveredgebyflips(point, point, face *, triface *, int fullsearch);
+ int add_steinerpt_in_schoenhardtpoly(triface *, int, int chkencflag);
+ int add_steinerpt_in_segment(face *, int searchlevel);
+ int addsteiner4recoversegment(face *, int);
+ int recoversegments(arraypool *, int fullsearch, int steinerflag);
- int recoverfacebyflips(point, point, point, face*, triface*);
- int recoversubfaces(arraypool*, int steinerflag);
+ int recoverfacebyflips(point, point, point, face *, triface *);
+ int recoversubfaces(arraypool *, int steinerflag);
- int getvertexstar(int, point searchpt, arraypool*, arraypool*, arraypool*);
- int getedge(point, point, triface*);
- int reduceedgesatvertex(point startpt, arraypool* endptlist);
+ int getvertexstar(int, point searchpt, arraypool *, arraypool *, arraypool *);
+ int getedge(point, point, triface *);
+ int reduceedgesatvertex(point startpt, arraypool *endptlist);
int removevertexbyflips(point steinerpt);
int suppressbdrysteinerpoint(point steinerpt);
int suppresssteinerpoints();
- void recoverboundary(clock_t&);
+ void recoverboundary(clock_t &);
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Mesh reconstruction //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Mesh reconstruction //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
void carveholes();
// Comment: These three functions are implemented directly in:
// gmsh_wrk/Mesh/meshGRegionBoundaryRecovery.cpp
bool reconstructmesh(void *);
- void outsurfacemesh(const char* mfilename);
- void outmesh2medit(const char* mfilename);
+ void outsurfacemesh(const char *mfilename);
+ void outmesh2medit(const char *mfilename);
- void enqueuesubface(memorypool*, face*);
- void enqueuetetrahedron(triface*);
+ void enqueuesubface(memorypool *, face *);
+ void enqueuetetrahedron(triface *);
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Mesh optimization //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Mesh optimization //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
long lawsonflip3d(flipconstraints *fc);
void recoverdelaunay();
- int gettetrahedron(point, point, point, point, triface *);
+ int gettetrahedron(point, point, point, point, triface *);
long improvequalitybyflips();
- int smoothpoint(point smtpt, arraypool*, int ccw, optparameters *opm);
+ int smoothpoint(point smtpt, arraypool *, int ccw, optparameters *opm);
long improvequalitybysmoothing(optparameters *opm);
- int splitsliver(triface *, REAL, int);
+ int splitsliver(triface *, REAL, int);
long removeslivers(int);
void optimizemesh();
void jettisonnodes();
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Constructor & destructor //
-// //
-///////////////////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////////////////
+ // //
+ // Constructor & destructor //
+ // //
+ ///////////////////////////////////////////////////////////////////////////////
void initializetetgenmesh()
{
- in = addin = NULL;
- b = NULL;
+ in = addin = NULL;
+ b = NULL;
bgm = NULL;
tetrahedrons = subfaces = subsegs = points = NULL;
@@ -1354,7 +1408,7 @@ public:
minfaceang = minfacetdihed = PI;
tetprism_vol_sum = 0.0;
longest = minedgelength = 0.0;
- xmax = xmin = ymax = ymin = zmax = zmin = 0.0;
+ xmax = xmin = ymax = ymin = zmax = zmin = 0.0;
insegments = 0l;
hullsize = 0l;
@@ -1370,60 +1424,59 @@ public:
flip22count = flip31count = 0l;
totalworkmemory = 0l;
-
} // tetgenmesh()
void freememory()
{
- if (bgm != NULL) {
+ if(bgm != NULL) {
delete bgm;
}
- if (points != (memorypool *) NULL) {
+ if(points != (memorypool *)NULL) {
delete points;
- delete [] dummypoint;
+ delete[] dummypoint;
}
- if (tetrahedrons != (memorypool *) NULL) {
+ if(tetrahedrons != (memorypool *)NULL) {
delete tetrahedrons;
}
- if (subfaces != (memorypool *) NULL) {
+ if(subfaces != (memorypool *)NULL) {
delete subfaces;
delete subsegs;
}
- if (tet2segpool != NULL) {
+ if(tet2segpool != NULL) {
delete tet2segpool;
delete tet2subpool;
}
- if (badtetrahedrons) {
+ if(badtetrahedrons) {
delete badtetrahedrons;
}
- if (badsubfacs) {
+ if(badsubfacs) {
delete badsubfacs;
}
- if (badsubsegs) {
+ if(badsubsegs) {
delete badsubsegs;
}
- if (encseglist) {
+ if(encseglist) {
delete encseglist;
}
- if (encshlist) {
+ if(encshlist) {
delete encshlist;
}
- if (flippool != NULL) {
+ if(flippool != NULL) {
delete flippool;
delete unflipqueue;
}
- if (cavetetlist != NULL) {
+ if(cavetetlist != NULL) {
delete cavetetlist;
delete cavebdrylist;
delete caveoldtetlist;
delete cavetetvertlist;
}
- if (caveshlist != NULL) {
+ if(caveshlist != NULL) {
delete caveshlist;
delete caveshbdlist;
delete cavesegshlist;
@@ -1433,40 +1486,33 @@ public:
delete caveencseglist;
}
- if (subsegstack != NULL) {
+ if(subsegstack != NULL) {
delete subsegstack;
delete subfacstack;
delete subvertstack;
}
- if (idx2facetlist != NULL) {
- delete [] idx2facetlist;
- delete [] facetverticeslist;
+ if(idx2facetlist != NULL) {
+ delete[] idx2facetlist;
+ delete[] facetverticeslist;
}
- if (segmentendpointslist != NULL) {
- delete [] segmentendpointslist;
+ if(segmentendpointslist != NULL) {
+ delete[] segmentendpointslist;
}
- if (highordertable != NULL) {
- delete [] highordertable;
+ if(highordertable != NULL) {
+ delete[] highordertable;
}
initializetetgenmesh();
}
- tetgenmesh()
- {
- initializetetgenmesh();
- }
+ tetgenmesh() { initializetetgenmesh(); }
- ~tetgenmesh()
- {
- freememory();
- } // ~tetgenmesh()
-
-}; // End of class tetgenmesh.
+ ~tetgenmesh() { freememory(); } // ~tetgenmesh()
+}; // End of class tetgenmesh.
///////////////////////////////////////////////////////////////////////////////
// //
@@ -1476,7 +1522,7 @@ public:
// selfint_event, a structure to report self-intersections.
//
-// - e_type, report the type of self-intersections,
+// - e_type, report the type of self-intersections,
// it may be one of:
// 0, reserved.
// 1, two edges intersect,
@@ -1486,7 +1532,7 @@ public:
// 5, an edge and a triangle are overlapping,
// 6, two triangles are overlapping,
// 7, a vertex lies in an edge,
-// 8, a vertex lies in a facet,
+// 8, a vertex lies in a facet,
class selfint_event {
public:
@@ -1498,9 +1544,10 @@ public:
int s_marker2; // Tag of the 2nd segment.
int f_vertices2[3];
REAL int_point[3];
- selfint_event() {
+ selfint_event()
+ {
e_type = 0;
- f_marker1 = f_marker2 = 0;
+ f_marker1 = f_marker2 = 0;
s_marker1 = s_marker2 = 0;
}
};
@@ -1512,9 +1559,9 @@ inline void terminatetetgen(tetgenmesh *m, int x)
#ifdef TETLIBRARY
throw x;
#else
- switch (x) {
+ switch(x) {
case 1: // Out of memory.
- printf("Error: Out of memory.\n");
+ printf("Error: Out of memory.\n");
break;
case 2: // Encounter an internal error.
printf("Please report this bug to Hang.Si@wias-berlin.de. Include\n");
@@ -1523,11 +1570,11 @@ inline void terminatetetgen(tetgenmesh *m, int x)
break;
case 3:
printf("A self-intersection was detected. Program stopped.\n");
- printf("Hint: use -d option to detect all self-intersections.\n");
+ printf("Hint: use -d option to detect all self-intersections.\n");
break;
case 4:
printf("A very small input feature size was detected. Program stopped.\n");
- if (m) {
+ if(m) {
printf("Hint: use -T option to set a smaller tolerance. Current is %g\n",
m->b->epsilon);
}
@@ -1536,9 +1583,7 @@ inline void terminatetetgen(tetgenmesh *m, int x)
printf("Two very close input facets were detected. Program stopped.\n");
printf("Hint: use -Y option to avoid adding Steiner points in boundary.\n");
break;
- case 10:
- printf("An input error was detected. Program stopped.\n");
- break;
+ case 10: printf("An input error was detected. Program stopped.\n"); break;
} // switch (x)
exit(x);
#endif // #ifdef TETLIBRARY
@@ -1550,352 +1595,391 @@ inline void terminatetetgen(tetgenmesh *m, int x)
// //
///////////////////////////////////////////////////////////////////////////////
-// encode() compress a handle into a single pointer. It relies on the
+// encode() compress a handle into a single pointer. It relies on the
// assumption that all addresses of tetrahedra are aligned to sixteen-
// byte boundaries, so that the last four significant bits are zero.
-inline tetgenmesh::tetrahedron tetgenmesh::encode(triface& t) {
- return (tetrahedron) ((uintptr_t) (t).tet | (uintptr_t) (t).ver);
+inline tetgenmesh::tetrahedron tetgenmesh::encode(triface &t)
+{
+ return (tetrahedron)((uintptr_t)(t).tet | (uintptr_t)(t).ver);
}
-inline tetgenmesh::tetrahedron tetgenmesh::encode2(tetrahedron* ptr, int ver) {
- return (tetrahedron) ((uintptr_t) (ptr) | (uintptr_t) (ver));
+inline tetgenmesh::tetrahedron tetgenmesh::encode2(tetrahedron *ptr, int ver)
+{
+ return (tetrahedron)((uintptr_t)(ptr) | (uintptr_t)(ver));
}
// decode() converts a pointer to a handle. The version is extracted from
// the four least significant bits of the pointer.
-inline void tetgenmesh::decode(tetrahedron ptr, triface& t) {
- (t).ver = (int) ((uintptr_t) (ptr) & (uintptr_t) 15);
- (t).tet = (tetrahedron *) ((uintptr_t) (ptr) ^ (uintptr_t) (t).ver);
+inline void tetgenmesh::decode(tetrahedron ptr, triface &t)
+{
+ (t).ver = (int)((uintptr_t)(ptr) & (uintptr_t)15);
+ (t).tet = (tetrahedron *)((uintptr_t)(ptr) ^ (uintptr_t)(t).ver);
}
-// bond() connects two tetrahedra together. (t1,v1) and (t2,v2) must
-// refer to the same face and the same edge.
+// bond() connects two tetrahedra together. (t1,v1) and (t2,v2) must
+// refer to the same face and the same edge.
-inline void tetgenmesh::bond(triface& t1, triface& t2) {
+inline void tetgenmesh::bond(triface &t1, triface &t2)
+{
t1.tet[t1.ver & 3] = encode2(t2.tet, bondtbl[t1.ver][t2.ver]);
t2.tet[t2.ver & 3] = encode2(t1.tet, bondtbl[t2.ver][t1.ver]);
}
-
// dissolve() a bond (from one side).
-inline void tetgenmesh::dissolve(triface& t) {
- t.tet[t.ver & 3] = NULL;
-}
+inline void tetgenmesh::dissolve(triface &t) { t.tet[t.ver & 3] = NULL; }
// enext() finds the next edge (counterclockwise) in the same face.
-inline void tetgenmesh::enext(triface& t1, triface& t2) {
+inline void tetgenmesh::enext(triface &t1, triface &t2)
+{
t2.tet = t1.tet;
t2.ver = enexttbl[t1.ver];
}
-inline void tetgenmesh::enextself(triface& t) {
- t.ver = enexttbl[t.ver];
-}
+inline void tetgenmesh::enextself(triface &t) { t.ver = enexttbl[t.ver]; }
// eprev() finds the next edge (clockwise) in the same face.
-inline void tetgenmesh::eprev(triface& t1, triface& t2) {
+inline void tetgenmesh::eprev(triface &t1, triface &t2)
+{
t2.tet = t1.tet;
t2.ver = eprevtbl[t1.ver];
}
-inline void tetgenmesh::eprevself(triface& t) {
- t.ver = eprevtbl[t.ver];
-}
+inline void tetgenmesh::eprevself(triface &t) { t.ver = eprevtbl[t.ver]; }
// esym() finds the reversed edge. It is in the other face of the
// same tetrahedron.
-inline void tetgenmesh::esym(triface& t1, triface& t2) {
+inline void tetgenmesh::esym(triface &t1, triface &t2)
+{
(t2).tet = (t1).tet;
(t2).ver = esymtbl[(t1).ver];
}
-inline void tetgenmesh::esymself(triface& t) {
- (t).ver = esymtbl[(t).ver];
-}
+inline void tetgenmesh::esymself(triface &t) { (t).ver = esymtbl[(t).ver]; }
// enextesym() finds the reversed edge of the next edge. It is in the other
-// face of the same tetrahedron. It is the combination esym() * enext().
+// face of the same tetrahedron. It is the combination esym() * enext().
-inline void tetgenmesh::enextesym(triface& t1, triface& t2) {
+inline void tetgenmesh::enextesym(triface &t1, triface &t2)
+{
t2.tet = t1.tet;
t2.ver = enextesymtbl[t1.ver];
}
-inline void tetgenmesh::enextesymself(triface& t) {
+inline void tetgenmesh::enextesymself(triface &t)
+{
t.ver = enextesymtbl[t.ver];
}
// eprevesym() finds the reversed edge of the previous edge.
-inline void tetgenmesh::eprevesym(triface& t1, triface& t2) {
+inline void tetgenmesh::eprevesym(triface &t1, triface &t2)
+{
t2.tet = t1.tet;
t2.ver = eprevesymtbl[t1.ver];
}
-inline void tetgenmesh::eprevesymself(triface& t) {
+inline void tetgenmesh::eprevesymself(triface &t)
+{
t.ver = eprevesymtbl[t.ver];
}
// eorgoppo() Finds the opposite face of the origin of the current edge.
// Return the opposite edge of the current edge.
-inline void tetgenmesh::eorgoppo(triface& t1, triface& t2) {
+inline void tetgenmesh::eorgoppo(triface &t1, triface &t2)
+{
t2.tet = t1.tet;
t2.ver = eorgoppotbl[t1.ver];
}
-inline void tetgenmesh::eorgoppoself(triface& t) {
- t.ver = eorgoppotbl[t.ver];
-}
+inline void tetgenmesh::eorgoppoself(triface &t) { t.ver = eorgoppotbl[t.ver]; }
-// edestoppo() Finds the opposite face of the destination of the current
+// edestoppo() Finds the opposite face of the destination of the current
// edge. Return the opposite edge of the current edge.
-inline void tetgenmesh::edestoppo(triface& t1, triface& t2) {
+inline void tetgenmesh::edestoppo(triface &t1, triface &t2)
+{
t2.tet = t1.tet;
t2.ver = edestoppotbl[t1.ver];
}
-inline void tetgenmesh::edestoppoself(triface& t) {
+inline void tetgenmesh::edestoppoself(triface &t)
+{
t.ver = edestoppotbl[t.ver];
}
// fsym() finds the adjacent tetrahedron at the same face and the same edge.
-inline void tetgenmesh::fsym(triface& t1, triface& t2) {
+inline void tetgenmesh::fsym(triface &t1, triface &t2)
+{
decode((t1).tet[(t1).ver & 3], t2);
t2.ver = fsymtbl[t1.ver][t2.ver];
}
-
-#define fsymself(t) \
- t1ver = (t).ver; \
- decode((t).tet[(t).ver & 3], (t));\
+#define fsymself(t) \
+ t1ver = (t).ver; \
+ decode((t).tet[(t).ver & 3], (t)); \
(t).ver = fsymtbl[t1ver][(t).ver]
// fnext() finds the next face while rotating about an edge according to
// a right-hand rule. The face is in the adjacent tetrahedron. It is
// the combination: fsym() * esym().
-inline void tetgenmesh::fnext(triface& t1, triface& t2) {
+inline void tetgenmesh::fnext(triface &t1, triface &t2)
+{
decode(t1.tet[facepivot1[t1.ver]], t2);
t2.ver = facepivot2[t1.ver][t2.ver];
}
-
-#define fnextself(t) \
- t1ver = (t).ver; \
- decode((t).tet[facepivot1[(t).ver]], (t)); \
+#define fnextself(t) \
+ t1ver = (t).ver; \
+ decode((t).tet[facepivot1[(t).ver]], (t)); \
(t).ver = facepivot2[t1ver][(t).ver]
-
// The following primtives get or set the origin, destination, face apex,
// or face opposite of an ordered tetrahedron.
-inline tetgenmesh::point tetgenmesh::org(triface& t) {
- return (point) (t).tet[orgpivot[(t).ver]];
+inline tetgenmesh::point tetgenmesh::org(triface &t)
+{
+ return (point)(t).tet[orgpivot[(t).ver]];
}
-inline tetgenmesh::point tetgenmesh:: dest(triface& t) {
- return (point) (t).tet[destpivot[(t).ver]];
+inline tetgenmesh::point tetgenmesh::dest(triface &t)
+{
+ return (point)(t).tet[destpivot[(t).ver]];
}
-inline tetgenmesh::point tetgenmesh:: apex(triface& t) {
- return (point) (t).tet[apexpivot[(t).ver]];
+inline tetgenmesh::point tetgenmesh::apex(triface &t)
+{
+ return (point)(t).tet[apexpivot[(t).ver]];
}
-inline tetgenmesh::point tetgenmesh:: oppo(triface& t) {
- return (point) (t).tet[oppopivot[(t).ver]];
+inline tetgenmesh::point tetgenmesh::oppo(triface &t)
+{
+ return (point)(t).tet[oppopivot[(t).ver]];
}
-inline void tetgenmesh:: setorg(triface& t, point p) {
- (t).tet[orgpivot[(t).ver]] = (tetrahedron) (p);
+inline void tetgenmesh::setorg(triface &t, point p)
+{
+ (t).tet[orgpivot[(t).ver]] = (tetrahedron)(p);
}
-inline void tetgenmesh:: setdest(triface& t, point p) {
- (t).tet[destpivot[(t).ver]] = (tetrahedron) (p);
+inline void tetgenmesh::setdest(triface &t, point p)
+{
+ (t).tet[destpivot[(t).ver]] = (tetrahedron)(p);
}
-inline void tetgenmesh:: setapex(triface& t, point p) {
- (t).tet[apexpivot[(t).ver]] = (tetrahedron) (p);
+inline void tetgenmesh::setapex(triface &t, point p)
+{
+ (t).tet[apexpivot[(t).ver]] = (tetrahedron)(p);
}
-inline void tetgenmesh:: setoppo(triface& t, point p) {
- (t).tet[oppopivot[(t).ver]] = (tetrahedron) (p);
+inline void tetgenmesh::setoppo(triface &t, point p)
+{
+ (t).tet[oppopivot[(t).ver]] = (tetrahedron)(p);
}
-#define setvertices(t, torg, tdest, tapex, toppo) \
- (t).tet[orgpivot[(t).ver]] = (tetrahedron) (torg);\
- (t).tet[destpivot[(t).ver]] = (tetrahedron) (tdest); \
- (t).tet[apexpivot[(t).ver]] = (tetrahedron) (tapex); \
- (t).tet[oppopivot[(t).ver]] = (tetrahedron) (toppo)
+#define setvertices(t, torg, tdest, tapex, toppo) \
+ (t).tet[orgpivot[(t).ver]] = (tetrahedron)(torg); \
+ (t).tet[destpivot[(t).ver]] = (tetrahedron)(tdest); \
+ (t).tet[apexpivot[(t).ver]] = (tetrahedron)(tapex); \
+ (t).tet[oppopivot[(t).ver]] = (tetrahedron)(toppo)
// Check or set a tetrahedron's attributes.
-inline REAL tetgenmesh::elemattribute(tetrahedron* ptr, int attnum) {
- return ((REAL *) (ptr))[elemattribindex + attnum];
+inline REAL tetgenmesh::elemattribute(tetrahedron *ptr, int attnum)
+{
+ return ((REAL *)(ptr))[elemattribindex + attnum];
}
-inline void tetgenmesh::setelemattribute(tetrahedron* ptr, int attnum,
- REAL value) {
- ((REAL *) (ptr))[elemattribindex + attnum] = value;
+inline void tetgenmesh::setelemattribute(tetrahedron *ptr, int attnum,
+ REAL value)
+{
+ ((REAL *)(ptr))[elemattribindex + attnum] = value;
}
// Check or set a tetrahedron's maximum volume bound.
-inline REAL tetgenmesh::volumebound(tetrahedron* ptr) {
- return ((REAL *) (ptr))[volumeboundindex];
+inline REAL tetgenmesh::volumebound(tetrahedron *ptr)
+{
+ return ((REAL *)(ptr))[volumeboundindex];
}
-inline void tetgenmesh::setvolumebound(tetrahedron* ptr, REAL value) {
- ((REAL *) (ptr))[volumeboundindex] = value;
+inline void tetgenmesh::setvolumebound(tetrahedron *ptr, REAL value)
+{
+ ((REAL *)(ptr))[volumeboundindex] = value;
}
// Get or set a tetrahedron's index (only used for output).
// These two routines use the reserved slot ptr[10].
-inline int tetgenmesh::elemindex(tetrahedron* ptr) {
- int *iptr = (int *) &(ptr[10]);
+inline int tetgenmesh::elemindex(tetrahedron *ptr)
+{
+ int *iptr = (int *)&(ptr[10]);
return iptr[0];
}
-inline void tetgenmesh::setelemindex(tetrahedron* ptr, int value) {
- int *iptr = (int *) &(ptr[10]);
+inline void tetgenmesh::setelemindex(tetrahedron *ptr, int value)
+{
+ int *iptr = (int *)&(ptr[10]);
iptr[0] = value;
}
-// Get or set a tetrahedron's marker.
+// Get or set a tetrahedron's marker.
// Set 'value = 0' cleans all the face/edge flags.
-inline int tetgenmesh::elemmarker(tetrahedron* ptr) {
- return ((int *) (ptr))[elemmarkerindex];
+inline int tetgenmesh::elemmarker(tetrahedron *ptr)
+{
+ return ((int *)(ptr))[elemmarkerindex];
}
-inline void tetgenmesh::setelemmarker(tetrahedron* ptr, int value) {
- ((int *) (ptr))[elemmarkerindex] = value;
+inline void tetgenmesh::setelemmarker(tetrahedron *ptr, int value)
+{
+ ((int *)(ptr))[elemmarkerindex] = value;
}
// infect(), infected(), uninfect() -- primitives to flag or unflag a
// tetrahedron. The last bit of the element marker is flagged (1)
// or unflagged (0).
-inline void tetgenmesh::infect(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] |= 1;
+inline void tetgenmesh::infect(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] |= 1;
}
-inline void tetgenmesh::uninfect(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] &= ~1;
+inline void tetgenmesh::uninfect(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] &= ~1;
}
-inline bool tetgenmesh::infected(triface& t) {
- return (((int *) (t.tet))[elemmarkerindex] & 1) != 0;
+inline bool tetgenmesh::infected(triface &t)
+{
+ return (((int *)(t.tet))[elemmarkerindex] & 1) != 0;
}
// marktest(), marktested(), unmarktest() -- primitives to flag or unflag a
// tetrahedron. Use the second lowerest bit of the element marker.
-inline void tetgenmesh::marktest(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] |= 2;
+inline void tetgenmesh::marktest(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] |= 2;
}
-inline void tetgenmesh::unmarktest(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] &= ~2;
+inline void tetgenmesh::unmarktest(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] &= ~2;
}
-
-inline bool tetgenmesh::marktested(triface& t) {
- return (((int *) (t.tet))[elemmarkerindex] & 2) != 0;
+
+inline bool tetgenmesh::marktested(triface &t)
+{
+ return (((int *)(t.tet))[elemmarkerindex] & 2) != 0;
}
// markface(), unmarkface(), facemarked() -- primitives to flag or unflag a
// face of a tetrahedron. From the last 3rd to 6th bits are used for
-// face markers, e.g., the last third bit corresponds to loc = 0.
+// face markers, e.g., the last third bit corresponds to loc = 0.
-inline void tetgenmesh::markface(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] |= (4 << (t.ver & 3));
+inline void tetgenmesh::markface(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] |= (4 << (t.ver & 3));
}
-inline void tetgenmesh::unmarkface(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] &= ~(4 << (t.ver & 3));
+inline void tetgenmesh::unmarkface(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] &= ~(4 << (t.ver & 3));
}
-inline bool tetgenmesh::facemarked(triface& t) {
- return (((int *) (t.tet))[elemmarkerindex] & (4 << (t.ver & 3))) != 0;
+inline bool tetgenmesh::facemarked(triface &t)
+{
+ return (((int *)(t.tet))[elemmarkerindex] & (4 << (t.ver & 3))) != 0;
}
// markedge(), unmarkedge(), edgemarked() -- primitives to flag or unflag an
// edge of a tetrahedron. From the last 7th to 12th bits are used for
-// edge markers, e.g., the last 7th bit corresponds to the 0th edge, etc.
+// edge markers, e.g., the last 7th bit corresponds to the 0th edge, etc.
// Remark: The last 7th bit is marked by 2^6 = 64.
-inline void tetgenmesh::markedge(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] |= (int) (64 << ver2edge[(t).ver]);
+inline void tetgenmesh::markedge(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] |= (int)(64 << ver2edge[(t).ver]);
}
-inline void tetgenmesh::unmarkedge(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] &= ~(int) (64 << ver2edge[(t).ver]);
+inline void tetgenmesh::unmarkedge(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] &= ~(int)(64 << ver2edge[(t).ver]);
}
-inline bool tetgenmesh::edgemarked(triface& t) {
- return (((int *) (t.tet))[elemmarkerindex] &
- (int) (64 << ver2edge[(t).ver])) != 0;
+inline bool tetgenmesh::edgemarked(triface &t)
+{
+ return (((int *)(t.tet))[elemmarkerindex] & (int)(64 << ver2edge[(t).ver])) !=
+ 0;
}
// marktest2(), unmarktest2(), marktest2ed() -- primitives to flag and unflag
// a tetrahedron. The 13th bit (2^12 = 4096) is used for this flag.
-inline void tetgenmesh::marktest2(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] |= (int) (4096);
+inline void tetgenmesh::marktest2(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] |= (int)(4096);
}
-inline void tetgenmesh::unmarktest2(triface& t) {
- ((int *) (t.tet))[elemmarkerindex] &= ~(int) (4096);
+inline void tetgenmesh::unmarktest2(triface &t)
+{
+ ((int *)(t.tet))[elemmarkerindex] &= ~(int)(4096);
}
-inline bool tetgenmesh::marktest2ed(triface& t) {
- return (((int *) (t.tet))[elemmarkerindex] & (int) (4096)) != 0;
+inline bool tetgenmesh::marktest2ed(triface &t)
+{
+ return (((int *)(t.tet))[elemmarkerindex] & (int)(4096)) != 0;
}
// elemcounter(), setelemcounter() -- primitives to read or ser a (small)
// integer counter in this tet. It is saved from the 16th bit. On 32 bit
-// system, the range of the counter is [0, 2^15 = 32768].
+// system, the range of the counter is [0, 2^15 = 32768].
-inline int tetgenmesh::elemcounter(triface& t) {
- return (((int *) (t.tet))[elemmarkerindex]) >> 16;
+inline int tetgenmesh::elemcounter(triface &t)
+{
+ return (((int *)(t.tet))[elemmarkerindex]) >> 16;
}
-inline void tetgenmesh::setelemcounter(triface& t, int value) {
- int c = ((int *) (t.tet))[elemmarkerindex];
+inline void tetgenmesh::setelemcounter(triface &t, int value)
+{
+ int c = ((int *)(t.tet))[elemmarkerindex];
// Clear the old counter while keep the other flags.
c &= 65535; // sum_{i=0^15} 2^i
c |= (value << 16);
- ((int *) (t.tet))[elemmarkerindex] = c;
+ ((int *)(t.tet))[elemmarkerindex] = c;
}
-inline void tetgenmesh::increaseelemcounter(triface& t) {
+inline void tetgenmesh::increaseelemcounter(triface &t)
+{
int c = elemcounter(t);
setelemcounter(t, c + 1);
}
-inline void tetgenmesh::decreaseelemcounter(triface& t) {
+inline void tetgenmesh::decreaseelemcounter(triface &t)
+{
int c = elemcounter(t);
setelemcounter(t, c - 1);
}
// ishulltet() tests if t is a hull tetrahedron.
-inline bool tetgenmesh::ishulltet(triface& t) {
- return (point) (t).tet[7] == dummypoint;
+inline bool tetgenmesh::ishulltet(triface &t)
+{
+ return (point)(t).tet[7] == dummypoint;
}
// isdeadtet() tests if t is a tetrahedron is dead.
-inline bool tetgenmesh::isdeadtet(triface& t) {
+inline bool tetgenmesh::isdeadtet(triface &t)
+{
return ((t.tet == NULL) || (t.tet[4] == NULL));
}
@@ -1913,23 +1997,26 @@ inline bool tetgenmesh::isdeadtet(triface& t) {
// bits of each pointer by 'sencode()'. 'sdecode()' decodes a pointer,
// extracting an edge version and a pointer to the beginning of a subface.
-inline void tetgenmesh::sdecode(shellface sptr, face& s) {
- s.shver = (int) ((uintptr_t) (sptr) & (uintptr_t) 7);
- s.sh = (shellface *) ((uintptr_t) (sptr) ^ (uintptr_t) (s.shver));
+inline void tetgenmesh::sdecode(shellface sptr, face &s)
+{
+ s.shver = (int)((uintptr_t)(sptr) & (uintptr_t)7);
+ s.sh = (shellface *)((uintptr_t)(sptr) ^ (uintptr_t)(s.shver));
}
-inline tetgenmesh::shellface tetgenmesh::sencode(face& s) {
- return (shellface) ((uintptr_t) s.sh | (uintptr_t) s.shver);
+inline tetgenmesh::shellface tetgenmesh::sencode(face &s)
+{
+ return (shellface)((uintptr_t)s.sh | (uintptr_t)s.shver);
}
-inline tetgenmesh::shellface tetgenmesh::sencode2(shellface *sh, int shver) {
- return (shellface) ((uintptr_t) sh | (uintptr_t) shver);
+inline tetgenmesh::shellface tetgenmesh::sencode2(shellface *sh, int shver)
+{
+ return (shellface)((uintptr_t)sh | (uintptr_t)shver);
}
// sbond() bonds two subfaces (s1) and (s2) together. s1 and s2 must refer
// to the same edge. No requirement is needed on their orientations.
-inline void tetgenmesh::sbond(face& s1, face& s2)
+inline void tetgenmesh::sbond(face &s1, face &s2)
{
s1.sh[s1.shver >> 1] = sencode(s2);
s2.sh[s2.shver >> 1] = sencode(s1);
@@ -1939,7 +2026,7 @@ inline void tetgenmesh::sbond(face& s1, face& s2)
// but s2 is not pointing to s1. s1 and s2 must refer to the same edge.
// No requirement is needed on their orientations.
-inline void tetgenmesh::sbond1(face& s1, face& s2)
+inline void tetgenmesh::sbond1(face &s1, face &s2)
{
s1.sh[s1.shver >> 1] = sencode(s2);
}
@@ -1947,21 +2034,18 @@ inline void tetgenmesh::sbond1(face& s1, face& s2)
// Dissolve a subface bond (from one side). Note that the other subface
// will still think it's connected to this subface.
-inline void tetgenmesh::sdissolve(face& s)
-{
- s.sh[s.shver >> 1] = NULL;
-}
+inline void tetgenmesh::sdissolve(face &s) { s.sh[s.shver >> 1] = NULL; }
// spivot() finds the adjacent subface (s2) for a given subface (s1).
// s1 and s2 share at the same edge.
-inline void tetgenmesh::spivot(face& s1, face& s2)
+inline void tetgenmesh::spivot(face &s1, face &s2)
{
shellface sptr = s1.sh[s1.shver >> 1];
sdecode(sptr, s2);
}
-inline void tetgenmesh::spivotself(face& s)
+inline void tetgenmesh::spivotself(face &s)
{
shellface sptr = s.sh[s.shver >> 1];
sdecode(sptr, s);
@@ -1970,200 +2054,190 @@ inline void tetgenmesh::spivotself(face& s)
// These primitives determine or set the origin, destination, or apex
// of a subface with respect to the edge version.
-inline tetgenmesh::point tetgenmesh::sorg(face& s)
+inline tetgenmesh::point tetgenmesh::sorg(face &s)
{
- return (point) s.sh[sorgpivot[s.shver]];
+ return (point)s.sh[sorgpivot[s.shver]];
}
-inline tetgenmesh::point tetgenmesh::sdest(face& s)
+inline tetgenmesh::point tetgenmesh::sdest(face &s)
{
- return (point) s.sh[sdestpivot[s.shver]];
+ return (point)s.sh[sdestpivot[s.shver]];
}
-inline tetgenmesh::point tetgenmesh::sapex(face& s)
+inline tetgenmesh::point tetgenmesh::sapex(face &s)
{
- return (point) s.sh[sapexpivot[s.shver]];
+ return (point)s.sh[sapexpivot[s.shver]];
}
-inline void tetgenmesh::setsorg(face& s, point pointptr)
+inline void tetgenmesh::setsorg(face &s, point pointptr)
{
- s.sh[sorgpivot[s.shver]] = (shellface) pointptr;
+ s.sh[sorgpivot[s.shver]] = (shellface)pointptr;
}
-inline void tetgenmesh::setsdest(face& s, point pointptr)
+inline void tetgenmesh::setsdest(face &s, point pointptr)
{
- s.sh[sdestpivot[s.shver]] = (shellface) pointptr;
+ s.sh[sdestpivot[s.shver]] = (shellface)pointptr;
}
-inline void tetgenmesh::setsapex(face& s, point pointptr)
+inline void tetgenmesh::setsapex(face &s, point pointptr)
{
- s.sh[sapexpivot[s.shver]] = (shellface) pointptr;
+ s.sh[sapexpivot[s.shver]] = (shellface)pointptr;
}
-#define setshvertices(s, pa, pb, pc)\
- setsorg(s, pa);\
- setsdest(s, pb);\
+#define setshvertices(s, pa, pb, pc) \
+ setsorg(s, pa); \
+ setsdest(s, pb); \
setsapex(s, pc)
// sesym() reserves the direction of the lead edge.
-inline void tetgenmesh::sesym(face& s1, face& s2)
+inline void tetgenmesh::sesym(face &s1, face &s2)
{
s2.sh = s1.sh;
- s2.shver = (s1.shver ^ 1); // Inverse the last bit.
+ s2.shver = (s1.shver ^ 1); // Inverse the last bit.
}
-inline void tetgenmesh::sesymself(face& s)
-{
- s.shver ^= 1;
-}
+inline void tetgenmesh::sesymself(face &s) { s.shver ^= 1; }
// senext() finds the next edge (counterclockwise) in the same orientation
// of this face.
-inline void tetgenmesh::senext(face& s1, face& s2)
+inline void tetgenmesh::senext(face &s1, face &s2)
{
s2.sh = s1.sh;
s2.shver = snextpivot[s1.shver];
}
-inline void tetgenmesh::senextself(face& s)
-{
- s.shver = snextpivot[s.shver];
-}
+inline void tetgenmesh::senextself(face &s) { s.shver = snextpivot[s.shver]; }
-inline void tetgenmesh::senext2(face& s1, face& s2)
+inline void tetgenmesh::senext2(face &s1, face &s2)
{
s2.sh = s1.sh;
s2.shver = snextpivot[snextpivot[s1.shver]];
}
-inline void tetgenmesh::senext2self(face& s)
+inline void tetgenmesh::senext2self(face &s)
{
s.shver = snextpivot[snextpivot[s.shver]];
}
-
// Check or set a subface's maximum area bound.
-inline REAL tetgenmesh::areabound(face& s)
+inline REAL tetgenmesh::areabound(face &s)
{
- return ((REAL *) (s.sh))[areaboundindex];
+ return ((REAL *)(s.sh))[areaboundindex];
}
-inline void tetgenmesh::setareabound(face& s, REAL value)
+inline void tetgenmesh::setareabound(face &s, REAL value)
{
- ((REAL *) (s.sh))[areaboundindex] = value;
+ ((REAL *)(s.sh))[areaboundindex] = value;
}
// These two primitives read or set a shell marker. Shell markers are used
// to hold user boundary information.
-inline int tetgenmesh::shellmark(face& s)
+inline int tetgenmesh::shellmark(face &s)
{
- return ((int *) (s.sh))[shmarkindex];
+ return ((int *)(s.sh))[shmarkindex];
}
-inline void tetgenmesh::setshellmark(face& s, int value)
+inline void tetgenmesh::setshellmark(face &s, int value)
{
- ((int *) (s.sh))[shmarkindex] = value;
+ ((int *)(s.sh))[shmarkindex] = value;
}
-
-
// sinfect(), sinfected(), suninfect() -- primitives to flag or unflag a
// subface. The last bit of ((int *) ((s).sh))[shmarkindex+1] is flagged.
-inline void tetgenmesh::sinfect(face& s)
+inline void tetgenmesh::sinfect(face &s)
{
- ((int *) ((s).sh))[shmarkindex+1] =
- (((int *) ((s).sh))[shmarkindex+1] | (int) 1);
+ ((int *)((s).sh))[shmarkindex + 1] =
+ (((int *)((s).sh))[shmarkindex + 1] | (int)1);
}
-inline void tetgenmesh::suninfect(face& s)
+inline void tetgenmesh::suninfect(face &s)
{
- ((int *) ((s).sh))[shmarkindex+1] =
- (((int *) ((s).sh))[shmarkindex+1] & ~(int) 1);
+ ((int *)((s).sh))[shmarkindex + 1] =
+ (((int *)((s).sh))[shmarkindex + 1] & ~(int)1);
}
// Test a subface for viral infection.
-inline bool tetgenmesh::sinfected(face& s)
+inline bool tetgenmesh::sinfected(face &s)
{
- return (((int *) ((s).sh))[shmarkindex+1] & (int) 1) != 0;
+ return (((int *)((s).sh))[shmarkindex + 1] & (int)1) != 0;
}
// smarktest(), smarktested(), sunmarktest() -- primitives to flag or unflag
// a subface. The last 2nd bit of the integer is flagged.
-inline void tetgenmesh::smarktest(face& s)
+inline void tetgenmesh::smarktest(face &s)
{
- ((int *) ((s).sh))[shmarkindex+1] =
- (((int *)((s).sh))[shmarkindex+1] | (int) 2);
+ ((int *)((s).sh))[shmarkindex + 1] =
+ (((int *)((s).sh))[shmarkindex + 1] | (int)2);
}
-inline void tetgenmesh::sunmarktest(face& s)
+inline void tetgenmesh::sunmarktest(face &s)
{
- ((int *) ((s).sh))[shmarkindex+1] =
- (((int *)((s).sh))[shmarkindex+1] & ~(int)2);
+ ((int *)((s).sh))[shmarkindex + 1] =
+ (((int *)((s).sh))[shmarkindex + 1] & ~(int)2);
}
-inline bool tetgenmesh::smarktested(face& s)
+inline bool tetgenmesh::smarktested(face &s)
{
- return ((((int *) ((s).sh))[shmarkindex+1] & (int) 2) != 0);
+ return ((((int *)((s).sh))[shmarkindex + 1] & (int)2) != 0);
}
-// smarktest2(), smarktest2ed(), sunmarktest2() -- primitives to flag or
+// smarktest2(), smarktest2ed(), sunmarktest2() -- primitives to flag or
// unflag a subface. The last 3rd bit of the integer is flagged.
-inline void tetgenmesh::smarktest2(face& s)
+inline void tetgenmesh::smarktest2(face &s)
{
- ((int *) ((s).sh))[shmarkindex+1] =
- (((int *)((s).sh))[shmarkindex+1] | (int) 4);
+ ((int *)((s).sh))[shmarkindex + 1] =
+ (((int *)((s).sh))[shmarkindex + 1] | (int)4);
}
-inline void tetgenmesh::sunmarktest2(face& s)
+inline void tetgenmesh::sunmarktest2(face &s)
{
- ((int *) ((s).sh))[shmarkindex+1] =
- (((int *)((s).sh))[shmarkindex+1] & ~(int)4);
+ ((int *)((s).sh))[shmarkindex + 1] =
+ (((int *)((s).sh))[shmarkindex + 1] & ~(int)4);
}
-inline bool tetgenmesh::smarktest2ed(face& s)
+inline bool tetgenmesh::smarktest2ed(face &s)
{
- return ((((int *) ((s).sh))[shmarkindex+1] & (int) 4) != 0);
+ return ((((int *)((s).sh))[shmarkindex + 1] & (int)4) != 0);
}
// The last 4th bit of ((int *) ((s).sh))[shmarkindex+1] is flagged.
-inline void tetgenmesh::smarktest3(face& s)
+inline void tetgenmesh::smarktest3(face &s)
{
- ((int *) ((s).sh))[shmarkindex+1] =
- (((int *)((s).sh))[shmarkindex+1] | (int) 8);
+ ((int *)((s).sh))[shmarkindex + 1] =
+ (((int *)((s).sh))[shmarkindex + 1] | (int)8);
}
-inline void tetgenmesh::sunmarktest3(face& s)
+inline void tetgenmesh::sunmarktest3(face &s)
{
- ((int *) ((s).sh))[shmarkindex+1] =
- (((int *)((s).sh))[shmarkindex+1] & ~(int)8);
+ ((int *)((s).sh))[shmarkindex + 1] =
+ (((int *)((s).sh))[shmarkindex + 1] & ~(int)8);
}
-inline bool tetgenmesh::smarktest3ed(face& s)
+inline bool tetgenmesh::smarktest3ed(face &s)
{
- return ((((int *) ((s).sh))[shmarkindex+1] & (int) 8) != 0);
+ return ((((int *)((s).sh))[shmarkindex + 1] & (int)8) != 0);
}
-
// Each facet has a unique index (automatically indexed). Starting from '0'.
-// We save this index in the same field of the shell type.
+// We save this index in the same field of the shell type.
-inline void tetgenmesh::setfacetindex(face& s, int value)
+inline void tetgenmesh::setfacetindex(face &s, int value)
{
- ((int *) (s.sh))[shmarkindex + 2] = value;
+ ((int *)(s.sh))[shmarkindex + 2] = value;
}
-inline int tetgenmesh::getfacetindex(face& s)
+inline int tetgenmesh::getfacetindex(face &s)
{
- return ((int *) (s.sh))[shmarkindex + 2];
+ return ((int *)(s.sh))[shmarkindex + 2];
}
///////////////////////////////////////////////////////////////////////////////
@@ -2174,26 +2248,26 @@ inline int tetgenmesh::getfacetindex(face& s)
// tsbond() bond a tetrahedron (t) and a subface (s) together.
// Note that t and s must be the same face and the same edge. Moreover,
-// t and s have the same orientation.
+// t and s have the same orientation.
// Since the edge number in t and in s can be any number in {0,1,2}. We bond
// the edge in s which corresponds to t's 0th edge, and vice versa.
-inline void tetgenmesh::tsbond(triface& t, face& s)
+inline void tetgenmesh::tsbond(triface &t, face &s)
{
- if ((t).tet[9] == NULL) {
+ if((t).tet[9] == NULL) {
// Allocate space for this tet.
- (t).tet[9] = (tetrahedron) tet2subpool->alloc();
+ (t).tet[9] = (tetrahedron)tet2subpool->alloc();
// Initialize.
- for (int i = 0; i < 4; i++) {
- ((shellface *) (t).tet[9])[i] = NULL;
+ for(int i = 0; i < 4; i++) {
+ ((shellface *)(t).tet[9])[i] = NULL;
}
}
// Bond t <== s.
- ((shellface *) (t).tet[9])[(t).ver & 3] =
+ ((shellface *)(t).tet[9])[(t).ver & 3] =
sencode2((s).sh, tsbondtbl[t.ver][s.shver]);
// Bond s <== t.
- s.sh[9 + ((s).shver & 1)] =
- (shellface) encode2((t).tet, stbondtbl[t.ver][s.shver]);
+ s.sh[9 + ((s).shver & 1)] =
+ (shellface)encode2((t).tet, stbondtbl[t.ver][s.shver]);
}
// tspivot() finds a subface (s) abutting on the given tetrahdera (t).
@@ -2201,51 +2275,49 @@ inline void tetgenmesh::tsbond(triface& t, face& s)
// the subface s, and s and t must be at the same edge wth the same
// orientation.
-inline void tetgenmesh::tspivot(triface& t, face& s)
+inline void tetgenmesh::tspivot(triface &t, face &s)
{
- if ((t).tet[9] == NULL) {
+ if((t).tet[9] == NULL) {
(s).sh = NULL;
return;
}
// Get the attached subface s.
- sdecode(((shellface *) (t).tet[9])[(t).ver & 3], (s));
+ sdecode(((shellface *)(t).tet[9])[(t).ver & 3], (s));
(s).shver = tspivottbl[t.ver][s.shver];
}
// Quickly check if the handle (t, v) is a subface.
-#define issubface(t) \
- ((t).tet[9] && ((t).tet[9])[(t).ver & 3])
+#define issubface(t) ((t).tet[9] && ((t).tet[9])[(t).ver & 3])
// stpivot() finds a tetrahedron (t) abutting a given subface (s).
// Return the t (if it exists) with the same edge and the same
// orientation of s.
-inline void tetgenmesh::stpivot(face& s, triface& t)
+inline void tetgenmesh::stpivot(face &s, triface &t)
{
- decode((tetrahedron) s.sh[9 + (s.shver & 1)], t);
- if ((t).tet == NULL) {
+ decode((tetrahedron)s.sh[9 + (s.shver & 1)], t);
+ if((t).tet == NULL) {
return;
}
(t).ver = stpivottbl[t.ver][s.shver];
}
-// Quickly check if this subface is attached to a tetrahedron.
+ // Quickly check if this subface is attached to a tetrahedron.
-#define isshtet(s) \
- ((s).sh[9 + ((s).shver & 1)])
+#define isshtet(s) ((s).sh[9 + ((s).shver & 1)])
// tsdissolve() dissolve a bond (from the tetrahedron side).
-inline void tetgenmesh::tsdissolve(triface& t)
+inline void tetgenmesh::tsdissolve(triface &t)
{
- if ((t).tet[9] != NULL) {
- ((shellface *) (t).tet[9])[(t).ver & 3] = NULL;
+ if((t).tet[9] != NULL) {
+ ((shellface *)(t).tet[9])[(t).ver & 3] = NULL;
}
}
// stdissolve() dissolve a bond (from the subface side).
-inline void tetgenmesh::stdissolve(face& s)
+inline void tetgenmesh::stdissolve(face &s)
{
(s).sh[9] = NULL;
(s).sh[10] = NULL;
@@ -2259,36 +2331,32 @@ inline void tetgenmesh::stdissolve(face& s)
// ssbond() bond a subface to a subsegment.
-inline void tetgenmesh::ssbond(face& s, face& edge)
+inline void tetgenmesh::ssbond(face &s, face &edge)
{
s.sh[6 + (s.shver >> 1)] = sencode(edge);
edge.sh[0] = sencode(s);
}
-inline void tetgenmesh::ssbond1(face& s, face& edge)
+inline void tetgenmesh::ssbond1(face &s, face &edge)
{
s.sh[6 + (s.shver >> 1)] = sencode(edge);
- //edge.sh[0] = sencode(s);
+ // edge.sh[0] = sencode(s);
}
// ssdisolve() dissolve a bond (from the subface side)
-inline void tetgenmesh::ssdissolve(face& s)
-{
- s.sh[6 + (s.shver >> 1)] = NULL;
-}
+inline void tetgenmesh::ssdissolve(face &s) { s.sh[6 + (s.shver >> 1)] = NULL; }
// sspivot() finds a subsegment abutting a subface.
-inline void tetgenmesh::sspivot(face& s, face& edge)
+inline void tetgenmesh::sspivot(face &s, face &edge)
{
- sdecode((shellface) s.sh[6 + (s.shver >> 1)], edge);
+ sdecode((shellface)s.sh[6 + (s.shver >> 1)], edge);
}
-// Quickly check if the edge is a subsegment.
+ // Quickly check if the edge is a subsegment.
-#define isshsubseg(s) \
- ((s).sh[6 + ((s).shver >> 1)])
+#define isshsubseg(s) ((s).sh[6 + ((s).shver >> 1)])
///////////////////////////////////////////////////////////////////////////////
// //
@@ -2296,53 +2364,53 @@ inline void tetgenmesh::sspivot(face& s, face& edge)
// //
///////////////////////////////////////////////////////////////////////////////
-inline void tetgenmesh::tssbond1(triface& t, face& s)
+inline void tetgenmesh::tssbond1(triface &t, face &s)
{
- if ((t).tet[8] == NULL) {
+ if((t).tet[8] == NULL) {
// Allocate space for this tet.
- (t).tet[8] = (tetrahedron) tet2segpool->alloc();
+ (t).tet[8] = (tetrahedron)tet2segpool->alloc();
// Initialization.
- for (int i = 0; i < 6; i++) {
- ((shellface *) (t).tet[8])[i] = NULL;
+ for(int i = 0; i < 6; i++) {
+ ((shellface *)(t).tet[8])[i] = NULL;
}
}
- ((shellface *) (t).tet[8])[ver2edge[(t).ver]] = sencode((s));
+ ((shellface *)(t).tet[8])[ver2edge[(t).ver]] = sencode((s));
}
-inline void tetgenmesh::sstbond1(face& s, triface& t)
+inline void tetgenmesh::sstbond1(face &s, triface &t)
{
- ((tetrahedron *) (s).sh)[9] = encode(t);
+ ((tetrahedron *)(s).sh)[9] = encode(t);
}
-inline void tetgenmesh::tssdissolve1(triface& t)
+inline void tetgenmesh::tssdissolve1(triface &t)
{
- if ((t).tet[8] != NULL) {
- ((shellface *) (t).tet[8])[ver2edge[(t).ver]] = NULL;
+ if((t).tet[8] != NULL) {
+ ((shellface *)(t).tet[8])[ver2edge[(t).ver]] = NULL;
}
}
-inline void tetgenmesh::sstdissolve1(face& s)
+inline void tetgenmesh::sstdissolve1(face &s)
{
- ((tetrahedron *) (s).sh)[9] = NULL;
+ ((tetrahedron *)(s).sh)[9] = NULL;
}
-inline void tetgenmesh::tsspivot1(triface& t, face& s)
+inline void tetgenmesh::tsspivot1(triface &t, face &s)
{
- if ((t).tet[8] != NULL) {
- sdecode(((shellface *) (t).tet[8])[ver2edge[(t).ver]], s);
- } else {
+ if((t).tet[8] != NULL) {
+ sdecode(((shellface *)(t).tet[8])[ver2edge[(t).ver]], s);
+ }
+ else {
(s).sh = NULL;
}
}
-// Quickly check whether 't' is a segment or not.
+ // Quickly check whether 't' is a segment or not.
-#define issubseg(t) \
- ((t).tet[8] && ((t).tet[8])[ver2edge[(t).ver]])
+#define issubseg(t) ((t).tet[8] && ((t).tet[8])[ver2edge[(t).ver]])
-inline void tetgenmesh::sstpivot1(face& s, triface& t)
+inline void tetgenmesh::sstpivot1(face &s, triface &t)
{
- decode((tetrahedron) s.sh[9], t);
+ decode((tetrahedron)s.sh[9], t);
}
///////////////////////////////////////////////////////////////////////////////
@@ -2351,137 +2419,162 @@ inline void tetgenmesh::sstpivot1(face& s, triface& t)
// //
///////////////////////////////////////////////////////////////////////////////
-inline int tetgenmesh::pointmark(point pt) {
- return ((int *) (pt))[pointmarkindex];
+inline int tetgenmesh::pointmark(point pt)
+{
+ return ((int *)(pt))[pointmarkindex];
}
-inline void tetgenmesh::setpointmark(point pt, int value) {
- ((int *) (pt))[pointmarkindex] = value;
+inline void tetgenmesh::setpointmark(point pt, int value)
+{
+ ((int *)(pt))[pointmarkindex] = value;
}
-
// These two primitives set and read the type of the point.
-inline enum tetgenmesh::verttype tetgenmesh::pointtype(point pt) {
- return (enum verttype) (((int *) (pt))[pointmarkindex + 1] >> (int) 8);
+inline enum tetgenmesh::verttype tetgenmesh::pointtype(point pt)
+{
+ return (enum verttype)(((int *)(pt))[pointmarkindex + 1] >> (int)8);
}
-inline void tetgenmesh::setpointtype(point pt, enum verttype value) {
- ((int *) (pt))[pointmarkindex + 1] =
- ((int) value << 8) + (((int *) (pt))[pointmarkindex + 1] & (int) 255);
+inline void tetgenmesh::setpointtype(point pt, enum verttype value)
+{
+ ((int *)(pt))[pointmarkindex + 1] =
+ ((int)value << 8) + (((int *)(pt))[pointmarkindex + 1] & (int)255);
}
// Read and set the geometry tag of the point (used by -s option).
-inline int tetgenmesh::pointgeomtag(point pt) {
- return ((int *) (pt))[pointmarkindex + 2];
+inline int tetgenmesh::pointgeomtag(point pt)
+{
+ return ((int *)(pt))[pointmarkindex + 2];
}
-inline void tetgenmesh::setpointgeomtag(point pt, int value) {
- ((int *) (pt))[pointmarkindex + 2] = value;
+inline void tetgenmesh::setpointgeomtag(point pt, int value)
+{
+ ((int *)(pt))[pointmarkindex + 2] = value;
}
// Read and set the u,v coordinates of the point (used by -s option).
-inline REAL tetgenmesh::pointgeomuv(point pt, int i) {
+inline REAL tetgenmesh::pointgeomuv(point pt, int i)
+{
return pt[pointparamindex + i];
}
-inline void tetgenmesh::setpointgeomuv(point pt, int i, REAL value) {
+inline void tetgenmesh::setpointgeomuv(point pt, int i, REAL value)
+{
pt[pointparamindex + i] = value;
}
// pinfect(), puninfect(), pinfected() -- primitives to flag or unflag
// a point. The last bit of the integer '[pointindex+1]' is flagged.
-inline void tetgenmesh::pinfect(point pt) {
- ((int *) (pt))[pointmarkindex + 1] |= (int) 1;
+inline void tetgenmesh::pinfect(point pt)
+{
+ ((int *)(pt))[pointmarkindex + 1] |= (int)1;
}
-inline void tetgenmesh::puninfect(point pt) {
- ((int *) (pt))[pointmarkindex + 1] &= ~(int) 1;
+inline void tetgenmesh::puninfect(point pt)
+{
+ ((int *)(pt))[pointmarkindex + 1] &= ~(int)1;
}
-inline bool tetgenmesh::pinfected(point pt) {
- return (((int *) (pt))[pointmarkindex + 1] & (int) 1) != 0;
+inline bool tetgenmesh::pinfected(point pt)
+{
+ return (((int *)(pt))[pointmarkindex + 1] & (int)1) != 0;
}
-// pmarktest(), punmarktest(), pmarktested() -- more primitives to
-// flag or unflag a point.
+// pmarktest(), punmarktest(), pmarktested() -- more primitives to
+// flag or unflag a point.
-inline void tetgenmesh::pmarktest(point pt) {
- ((int *) (pt))[pointmarkindex + 1] |= (int) 2;
+inline void tetgenmesh::pmarktest(point pt)
+{
+ ((int *)(pt))[pointmarkindex + 1] |= (int)2;
}
-inline void tetgenmesh::punmarktest(point pt) {
- ((int *) (pt))[pointmarkindex + 1] &= ~(int) 2;
+inline void tetgenmesh::punmarktest(point pt)
+{
+ ((int *)(pt))[pointmarkindex + 1] &= ~(int)2;
}
-inline bool tetgenmesh::pmarktested(point pt) {
- return (((int *) (pt))[pointmarkindex + 1] & (int) 2) != 0;
+inline bool tetgenmesh::pmarktested(point pt)
+{
+ return (((int *)(pt))[pointmarkindex + 1] & (int)2) != 0;
}
-inline void tetgenmesh::pmarktest2(point pt) {
- ((int *) (pt))[pointmarkindex + 1] |= (int) 4;
+inline void tetgenmesh::pmarktest2(point pt)
+{
+ ((int *)(pt))[pointmarkindex + 1] |= (int)4;
}
-inline void tetgenmesh::punmarktest2(point pt) {
- ((int *) (pt))[pointmarkindex + 1] &= ~(int) 4;
+inline void tetgenmesh::punmarktest2(point pt)
+{
+ ((int *)(pt))[pointmarkindex + 1] &= ~(int)4;
}
-inline bool tetgenmesh::pmarktest2ed(point pt) {
- return (((int *) (pt))[pointmarkindex + 1] & (int) 4) != 0;
+inline bool tetgenmesh::pmarktest2ed(point pt)
+{
+ return (((int *)(pt))[pointmarkindex + 1] & (int)4) != 0;
}
-inline void tetgenmesh::pmarktest3(point pt) {
- ((int *) (pt))[pointmarkindex + 1] |= (int) 8;
+inline void tetgenmesh::pmarktest3(point pt)
+{
+ ((int *)(pt))[pointmarkindex + 1] |= (int)8;
}
-inline void tetgenmesh::punmarktest3(point pt) {
- ((int *) (pt))[pointmarkindex + 1] &= ~(int) 8;
+inline void tetgenmesh::punmarktest3(point pt)
+{
+ ((int *)(pt))[pointmarkindex + 1] &= ~(int)8;
}
-inline bool tetgenmesh::pmarktest3ed(point pt) {
- return (((int *) (pt))[pointmarkindex + 1] & (int) 8) != 0;
+inline bool tetgenmesh::pmarktest3ed(point pt)
+{
+ return (((int *)(pt))[pointmarkindex + 1] & (int)8) != 0;
}
// These following primitives set and read a pointer to a tetrahedron
// a subface/subsegment, a point, or a tet of background mesh.
-inline tetgenmesh::tetrahedron tetgenmesh::point2tet(point pt) {
- return ((tetrahedron *) (pt))[point2simindex];
+inline tetgenmesh::tetrahedron tetgenmesh::point2tet(point pt)
+{
+ return ((tetrahedron *)(pt))[point2simindex];
}
-inline void tetgenmesh::setpoint2tet(point pt, tetrahedron value) {
- ((tetrahedron *) (pt))[point2simindex] = value;
+inline void tetgenmesh::setpoint2tet(point pt, tetrahedron value)
+{
+ ((tetrahedron *)(pt))[point2simindex] = value;
}
-inline tetgenmesh::point tetgenmesh::point2ppt(point pt) {
- return (point) ((tetrahedron *) (pt))[point2simindex + 1];
+inline tetgenmesh::point tetgenmesh::point2ppt(point pt)
+{
+ return (point)((tetrahedron *)(pt))[point2simindex + 1];
}
-inline void tetgenmesh::setpoint2ppt(point pt, point value) {
- ((tetrahedron *) (pt))[point2simindex + 1] = (tetrahedron) value;
+inline void tetgenmesh::setpoint2ppt(point pt, point value)
+{
+ ((tetrahedron *)(pt))[point2simindex + 1] = (tetrahedron)value;
}
-inline tetgenmesh::shellface tetgenmesh::point2sh(point pt) {
- return (shellface) ((tetrahedron *) (pt))[point2simindex + 2];
+inline tetgenmesh::shellface tetgenmesh::point2sh(point pt)
+{
+ return (shellface)((tetrahedron *)(pt))[point2simindex + 2];
}
-inline void tetgenmesh::setpoint2sh(point pt, shellface value) {
- ((tetrahedron *) (pt))[point2simindex + 2] = (tetrahedron) value;
+inline void tetgenmesh::setpoint2sh(point pt, shellface value)
+{
+ ((tetrahedron *)(pt))[point2simindex + 2] = (tetrahedron)value;
}
-
-inline tetgenmesh::tetrahedron tetgenmesh::point2bgmtet(point pt) {
- return ((tetrahedron *) (pt))[point2simindex + 3];
+inline tetgenmesh::tetrahedron tetgenmesh::point2bgmtet(point pt)
+{
+ return ((tetrahedron *)(pt))[point2simindex + 3];
}
-inline void tetgenmesh::setpoint2bgmtet(point pt, tetrahedron value) {
- ((tetrahedron *) (pt))[point2simindex + 3] = value;
+inline void tetgenmesh::setpoint2bgmtet(point pt, tetrahedron value)
+{
+ ((tetrahedron *)(pt))[point2simindex + 3] = value;
}
-
// The primitives for saving and getting the insertion radius.
inline void tetgenmesh::setpointinsradius(point pt, REAL value)
{
@@ -2493,37 +2586,43 @@ inline REAL tetgenmesh::getpointinsradius(point pt)
return pt[pointinsradiusindex];
}
-inline bool tetgenmesh::issteinerpoint(point pt) {
- return (pointtype(pt) == FREESEGVERTEX) || (pointtype(pt) == FREEFACETVERTEX)
- || (pointtype(pt) == FREEVOLVERTEX);
+inline bool tetgenmesh::issteinerpoint(point pt)
+{
+ return (pointtype(pt) == FREESEGVERTEX) ||
+ (pointtype(pt) == FREEFACETVERTEX) || (pointtype(pt) == FREEVOLVERTEX);
}
// point2tetorg() Get the tetrahedron whose origin is the point.
-inline void tetgenmesh::point2tetorg(point pa, triface& searchtet)
+inline void tetgenmesh::point2tetorg(point pa, triface &searchtet)
{
decode(point2tet(pa), searchtet);
- if ((point) searchtet.tet[4] == pa) {
+ if((point)searchtet.tet[4] == pa) {
searchtet.ver = 11;
- } else if ((point) searchtet.tet[5] == pa) {
+ }
+ else if((point)searchtet.tet[5] == pa) {
searchtet.ver = 3;
- } else if ((point) searchtet.tet[6] == pa) {
+ }
+ else if((point)searchtet.tet[6] == pa) {
searchtet.ver = 7;
- } else {
+ }
+ else {
searchtet.ver = 0;
}
}
// point2shorg() Get the subface/segment whose origin is the point.
-inline void tetgenmesh::point2shorg(point pa, face& searchsh)
+inline void tetgenmesh::point2shorg(point pa, face &searchsh)
{
sdecode(point2sh(pa), searchsh);
- if ((point) searchsh.sh[3] == pa) {
+ if((point)searchsh.sh[3] == pa) {
searchsh.shver = 0;
- } else if ((point) searchsh.sh[4] == pa) {
- searchsh.shver = (searchsh.sh[5] != NULL ? 2 : 1);
- } else {
+ }
+ else if((point)searchsh.sh[4] == pa) {
+ searchsh.shver = (searchsh.sh[5] != NULL ? 2 : 1);
+ }
+ else {
searchsh.shver = 4;
}
}
@@ -2531,32 +2630,32 @@ inline void tetgenmesh::point2shorg(point pa, face& searchsh)
// farsorg() Return the origin of the subsegment.
// farsdest() Return the destination of the subsegment.
-inline tetgenmesh::point tetgenmesh::farsorg(face& s)
+inline tetgenmesh::point tetgenmesh::farsorg(face &s)
{
face travesh, neighsh;
travesh = s;
- while (1) {
+ while(1) {
senext2(travesh, neighsh);
- spivotself(neighsh);
- if (neighsh.sh == NULL) break;
- if (sorg(neighsh) != sorg(travesh)) sesymself(neighsh);
- senext2(neighsh, travesh);
+ spivotself(neighsh);
+ if(neighsh.sh == NULL) break;
+ if(sorg(neighsh) != sorg(travesh)) sesymself(neighsh);
+ senext2(neighsh, travesh);
}
return sorg(travesh);
}
-inline tetgenmesh::point tetgenmesh::farsdest(face& s)
+inline tetgenmesh::point tetgenmesh::farsdest(face &s)
{
face travesh, neighsh;
travesh = s;
- while (1) {
+ while(1) {
senext(travesh, neighsh);
- spivotself(neighsh);
- if (neighsh.sh == NULL) break;
- if (sdest(neighsh) != sdest(travesh)) sesymself(neighsh);
- senext(neighsh, travesh);
+ spivotself(neighsh);
+ if(neighsh.sh == NULL) break;
+ if(sdest(neighsh) != sdest(travesh)) sesymself(neighsh);
+ senext(neighsh, travesh);
}
return sdest(travesh);
}
@@ -2568,21 +2667,21 @@ inline tetgenmesh::point tetgenmesh::farsdest(face& s)
///////////////////////////////////////////////////////////////////////////////
// dot() returns the dot product: v1 dot v2.
-inline REAL tetgenmesh::dot(REAL* v1, REAL* v2)
+inline REAL tetgenmesh::dot(REAL *v1, REAL *v2)
{
return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
}
// cross() computes the cross product: n = v1 cross v2.
-inline void tetgenmesh::cross(REAL* v1, REAL* v2, REAL* n)
+inline void tetgenmesh::cross(REAL *v1, REAL *v2, REAL *n)
{
- n[0] = v1[1] * v2[2] - v2[1] * v1[2];
+ n[0] = v1[1] * v2[2] - v2[1] * v1[2];
n[1] = -(v1[0] * v2[2] - v2[0] * v1[2]);
- n[2] = v1[0] * v2[1] - v2[0] * v1[1];
+ n[2] = v1[0] * v2[1] - v2[0] * v1[1];
}
// distance() computes the Euclidean distance between two points.
-inline REAL tetgenmesh::distance(REAL* p1, REAL* p2)
+inline REAL tetgenmesh::distance(REAL *p1, REAL *p2)
{
return sqrt((p2[0] - p1[0]) * (p2[0] - p1[0]) +
(p2[1] - p1[1]) * (p2[1] - p1[1]) +
diff --git a/Mesh/yamakawa.cpp b/Mesh/yamakawa.cpp
index 85f2ba10b46d5417f91ec817adad1fc634b8ff72..63b676db0973dd45912954245608f0ae937f6afa 100644
--- a/Mesh/yamakawa.cpp
+++ b/Mesh/yamakawa.cpp
@@ -30,7 +30,6 @@
#include <cassert>
-
#ifdef EXTERNAL_MIN_WEIGHTED_SET_SEARCH
#include "mwis.hpp"
#endif
@@ -39,7 +38,7 @@ namespace {
// Helper functions for the recombination of hex into hexes
// No reason to put them in the already huge Recombinator class
- typedef std::map<MVertex*, std::set<MElement*> > Vertex2Elements;
+ typedef std::map<MVertex *, std::set<MElement *> > Vertex2Elements;
// Hex facet to hex vertex mapping
// Previously explicitely built each time
@@ -50,48 +49,54 @@ namespace {
// d, c, g, h
// d, a, e, h
// WARNING: Looks like it is not the same used in other places in gmsh
- static unsigned int hex_facet_to_vertex[6][4] = {
- { 0,1,2,3 },{ 4,5,6,7 },{ 0,1,5,4 },{ 1,2,6,5 },{ 3,2,6,7 },{ 3,0,4,7 } };
+ static unsigned int hex_facet_to_vertex[6][4] = {{0, 1, 2, 3}, {4, 5, 6, 7},
+ {0, 1, 5, 4}, {1, 2, 6, 5},
+ {3, 2, 6, 7}, {3, 0, 4, 7}};
// Not ordered
static unsigned int hex_edge_to_vertex[12][2] = {
- {0,1}, {0,3}, {0,4}, {1,2}, {1,5}, {2,3}, {2,6}, {3,7}, {4,5}, {4,7}, {5,6}, {6,7} };
+ {0, 1}, {0, 3}, {0, 4}, {1, 2}, {1, 5}, {2, 3},
+ {2, 6}, {3, 7}, {4, 5}, {4, 7}, {5, 6}, {6, 7}};
// Possible triangles in a quad facet - 2 pairs of conformal triangles
static unsigned int quad_facet_triangulation[4][3] = {
- { 0, 1, 2 },{ 0, 2, 3 },{ 0, 1, 3 },{ 1, 2, 3 } };
+ {0, 1, 2}, {0, 2, 3}, {0, 1, 3}, {1, 2, 3}};
static unsigned int hex_facet_diagonal[12][2] = {
- { 0,2 },{ 0,5 },{ 0,7 },
- { 1,3 },{ 1,4 },{ 1,6 },
- { 2,5 },{ 2,7 },{ 3,4 },
- { 3,6 },{ 4,6 },{ 5,7 } };
-
- // Returns the vertex index in the hex for a vertex index in a triangle taken on a facet
- static unsigned int hex_facet_triangulation(unsigned int f, unsigned int triangle, unsigned int vtriangle) {
+ {0, 2}, {0, 5}, {0, 7}, {1, 3}, {1, 4}, {1, 6},
+ {2, 5}, {2, 7}, {3, 4}, {3, 6}, {4, 6}, {5, 7}};
+
+ // Returns the vertex index in the hex for a vertex index in a triangle taken
+ // on a facet
+ static unsigned int hex_facet_triangulation(unsigned int f,
+ unsigned int triangle,
+ unsigned int vtriangle)
+ {
unsigned int vfacet = quad_facet_triangulation[triangle][vtriangle];
return hex_facet_to_vertex[f][vfacet];
}
// Is this vertex in that hex?
- //bool inclusion(MVertex* vertex, const Hex& hex) {
+ // bool inclusion(MVertex* vertex, const Hex& hex) {
// return hex.contains(vertex);
//}
// Is that vertex in that tet?
- bool tet_contains_vertex(MElement* tet, MVertex* v) {
- return tet->getVertex(0) == v
- || tet->getVertex(1) == v
- || tet->getVertex(2) == v
- || tet->getVertex(3) == v;
+ bool tet_contains_vertex(MElement *tet, MVertex *v)
+ {
+ return tet->getVertex(0) == v || tet->getVertex(1) == v ||
+ tet->getVertex(2) == v || tet->getVertex(3) == v;
}
// Check the given 3 vertices are vertices of one of the tets given in
// the input set
- bool inclusion(MVertex* v1, MVertex* v2, MVertex* v3, const std::set<MElement*>& tets) {
- for (std::set<MElement*>::const_iterator it = tets.begin(); it != tets.end(); it++) {
- if (tet_contains_vertex(*it, v1) && tet_contains_vertex(*it, v2)
- && tet_contains_vertex(*it, v3)) {
+ bool inclusion(MVertex *v1, MVertex *v2, MVertex *v3,
+ const std::set<MElement *> &tets)
+ {
+ for(std::set<MElement *>::const_iterator it = tets.begin();
+ it != tets.end(); it++) {
+ if(tet_contains_vertex(*it, v1) && tet_contains_vertex(*it, v2) &&
+ tet_contains_vertex(*it, v3)) {
return true;
}
}
@@ -100,24 +105,25 @@ namespace {
// Return true if the 4 tet vertices are points of one
// of the 6 hex facets
- bool is_combinatorially_sliver(MElement* tet, const Hex& hex) {
- for (unsigned int f = 0; f < 6; ++f) {
+ bool is_combinatorially_sliver(MElement *tet, const Hex &hex)
+ {
+ for(unsigned int f = 0; f < 6; ++f) {
bool tet_in_facet = true;
- for (unsigned int v = 0; v < 4; ++v) {
- MVertex* tet_vertex = tet->getVertex(v);
+ for(unsigned int v = 0; v < 4; ++v) {
+ MVertex *tet_vertex = tet->getVertex(v);
bool vertex_found = false;
- for (unsigned int vface = 0; vface < 4; ++vface) {
+ for(unsigned int vface = 0; vface < 4; ++vface) {
unsigned int v_hex = hex_facet_to_vertex[f][vface];
- if (hex.getVertex(v_hex) == tet_vertex) {
+ if(hex.getVertex(v_hex) == tet_vertex) {
vertex_found = true;
}
}
- if (!vertex_found) {
+ if(!vertex_found) {
tet_in_facet = false;
break;
}
}
- if (tet_in_facet) {
+ if(tet_in_facet) {
return true;
}
}
@@ -127,7 +133,8 @@ namespace {
// Return true if the input tet is combinatorially a sliver of
// the input hex, i.e. its vertices are the same than those of
// one of the hex facets
- bool sliver(MElement* tet, const Hex &hex) {
+ bool sliver(MElement *tet, const Hex &hex)
+ {
return is_combinatorially_sliver(tet, hex);
}
@@ -145,28 +152,30 @@ namespace {
}
*/
- double distance(MVertex* v, MVertex* v1, MVertex* v2) {
+ double distance(MVertex *v, MVertex *v1, MVertex *v2)
+ {
double val;
double x, y, z;
- x = 0.5*(v2->x() + v1->x()) - v->x();
- y = 0.5*(v2->y() + v1->y()) - v->y();
- z = 0.5*(v2->z() + v1->z()) - v->z();
+ x = 0.5 * (v2->x() + v1->x()) - v->x();
+ y = 0.5 * (v2->y() + v1->y()) - v->y();
+ z = 0.5 * (v2->z() + v1->z()) - v->z();
- val = sqrt(x*x + y*y + z*z);
+ val = sqrt(x * x + y * y + z * z);
return val;
}
// Compute the longest edge of the tetrahedra
// and get the indices (0 to 3) of its 2 extremities
- double diagonal(MElement* tet, int& index1, int& index2) {
+ double diagonal(MElement *tet, int &index1, int &index2)
+ {
double max;
double l1, l2, l3, l4, l5, l6;
- MVertex* a = tet->getVertex(0);
- MVertex* b = tet->getVertex(1);
- MVertex* c = tet->getVertex(2);
- MVertex* d = tet->getVertex(3);
+ MVertex *a = tet->getVertex(0);
+ MVertex *b = tet->getVertex(1);
+ MVertex *c = tet->getVertex(2);
+ MVertex *d = tet->getVertex(3);
max = 1000000.0;
l1 = ::distance(a, b);
@@ -176,32 +185,32 @@ namespace {
l5 = ::distance(c, d);
l6 = ::distance(d, b);
- if (l1 >= l2 && l1 >= l3 && l1 >= l4 && l1 >= l5 && l1 >= l6) {
+ if(l1 >= l2 && l1 >= l3 && l1 >= l4 && l1 >= l5 && l1 >= l6) {
index1 = 0;
index2 = 1;
max = l1;
}
- else if (l2 >= l1 && l2 >= l3 && l2 >= l4 && l2 >= l5 && l2 >= l6) {
+ else if(l2 >= l1 && l2 >= l3 && l2 >= l4 && l2 >= l5 && l2 >= l6) {
index1 = 0;
index2 = 2;
max = l2;
}
- else if (l3 >= l1 && l3 >= l2 && l3 >= l4 && l3 >= l5 && l3 >= l6) {
+ else if(l3 >= l1 && l3 >= l2 && l3 >= l4 && l3 >= l5 && l3 >= l6) {
index1 = 0;
index2 = 3;
max = l3;
}
- else if (l4 >= l1 && l4 >= l2 && l4 >= l3 && l4 >= l5 && l4 >= l6) {
+ else if(l4 >= l1 && l4 >= l2 && l4 >= l3 && l4 >= l5 && l4 >= l6) {
index1 = 1;
index2 = 2;
max = l4;
}
- else if (l5 >= l1 && l5 >= l2 && l5 >= l3 && l5 >= l4 && l5 >= l6) {
+ else if(l5 >= l1 && l5 >= l2 && l5 >= l3 && l5 >= l4 && l5 >= l6) {
index1 = 2;
index2 = 3;
max = l5;
}
- else if (l6 >= l1 && l6 >= l2 && l6 >= l3 && l6 >= l4 && l6 >= l5) {
+ else if(l6 >= l1 && l6 >= l2 && l6 >= l3 && l6 >= l4 && l6 >= l5) {
index1 = 3;
index2 = 1;
max = l6;
@@ -209,7 +218,8 @@ namespace {
return max;
}
- double scalar(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4) {
+ double scalar(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4)
+ {
SVector3 vec1(v1->point(), v2->point());
SVector3 vec2(v3->point(), v4->point());
@@ -217,22 +227,24 @@ namespace {
double l2 = vec2.norm();
double val = dot(vec1, vec2);
- return fabs(val) / (l1*l2);
+ return fabs(val) / (l1 * l2);
}
// TODO remove this stupid
- void two_others(int index1, int index2, int& index3, int& index4) {
+ void two_others(int index1, int index2, int &index3, int &index4)
+ {
index3 = -1;
index4 = -1;
- for (int i = 0; i < 4; i++) {
- if (i != index1 && i != index2) {
- if (index3 == -1) index3 = i;
- else index4 = i;
+ for(int i = 0; i < 4; i++) {
+ if(i != index1 && i != index2) {
+ if(index3 == -1)
+ index3 = i;
+ else
+ index4 = i;
}
}
}
-
// Check that all the cube facets corresponds to facets
// of the tests contitutive of that hex.
// Apparently it might not always be the case, when a tet
@@ -243,20 +255,21 @@ namespace {
// triangulation of the quad in the input tets
// TODO - Strange - Check that this test is really useful -
// It does look more like a bug to me. JP
- bool valid(const Hex &hex, const std::set<MElement*>& tets) {
- for (unsigned int f = 0; f < 6; f++) {
+ bool valid(const Hex &hex, const std::set<MElement *> &tets)
+ {
+ for(unsigned int f = 0; f < 6; f++) {
std::vector<bool> triangle_found(4);
- for (unsigned int triangle = 0; triangle < 4; triangle++) {
- MVertex* v0 = hex.getVertex(hex_facet_triangulation(f, triangle, 0));
- MVertex* v1 = hex.getVertex(hex_facet_triangulation(f, triangle, 1));
- MVertex* v2 = hex.getVertex(hex_facet_triangulation(f, triangle, 2));
+ for(unsigned int triangle = 0; triangle < 4; triangle++) {
+ MVertex *v0 = hex.getVertex(hex_facet_triangulation(f, triangle, 0));
+ MVertex *v1 = hex.getVertex(hex_facet_triangulation(f, triangle, 1));
+ MVertex *v2 = hex.getVertex(hex_facet_triangulation(f, triangle, 2));
triangle_found[triangle] = inclusion(v0, v1, v2, tets);
}
- bool cur_facet_ok = (triangle_found[0] && triangle_found[1])
- || (triangle_found[2] && triangle_found[3]);
+ bool cur_facet_ok = (triangle_found[0] && triangle_found[1]) ||
+ (triangle_found[2] && triangle_found[3]);
- if (!cur_facet_ok) {
+ if(!cur_facet_ok) {
return false;
}
}
@@ -282,11 +295,10 @@ namespace {
}
*/
/*
- bool is_hex_facet_planar(const Hex& hex, unsigned int facet_id, double max_angle = 15.) {
- std::vector<SPoint3> points(4);
- for (unsigned int v = 0; v < 4; ++v) {
- unsigned int v_id = hex_facet_to_vertex[facet_id][v];
- points[v] = hex.getVertex(v_id)->point();
+ bool is_hex_facet_planar(const Hex& hex, unsigned int facet_id, double
+ max_angle = 15.) { std::vector<SPoint3> points(4); for (unsigned int v = 0; v
+ < 4; ++v) { unsigned int v_id = hex_facet_to_vertex[facet_id][v]; points[v] =
+ hex.getVertex(v_id)->point();
}
SVector3 vec1 = SVector3(points[0], points[1]).unit();
SVector3 vec2 = SVector3(points[0], points[2]).unit();
@@ -302,8 +314,8 @@ namespace {
}
}
*/
- unsigned int nb_tets_sharing_vertices(MVertex* v1, MVertex* v2, MVertex* v3,
- TetMeshConnectivity& tet_mesh)
+ unsigned int nb_tets_sharing_vertices(MVertex *v1, MVertex *v2, MVertex *v3,
+ TetMeshConnectivity &tet_mesh)
{
TetMeshConnectivity::TetSet tets;
tet_mesh.tets_around_vertices(v1, v2, v3, tets);
@@ -313,40 +325,46 @@ namespace {
// Check that the given facet of the input hex
// can be combinatorially built from two tet facets
// i.e. we check that for either of the subdivision of the facet into
- // two triangles we can find at least one tet that have this triangle as a facet
- // The two triangles of the subdivided quad facet must be adjacent to
- // the same number of tets -- a face partly on the boundary and party inside is invalid.
- bool validFace(const Hex& hex, unsigned int facet_id, TetMeshConnectivity& tet_mesh) {
- int nb_tets_adjacent[4] = { 0,0,0,0 };
+ // two triangles we can find at least one tet that have this triangle as a
+ // facet The two triangles of the subdivided quad facet must be adjacent to
+ // the same number of tets -- a face partly on the boundary and party inside
+ // is invalid.
+ bool validFace(const Hex &hex, unsigned int facet_id,
+ TetMeshConnectivity &tet_mesh)
+ {
+ int nb_tets_adjacent[4] = {0, 0, 0, 0};
// Possible de ne pas faire tous les calculs, mais bon
- for (unsigned int t = 0; t < 4; ++t) {
+ for(unsigned int t = 0; t < 4; ++t) {
unsigned int nb = nb_tets_sharing_vertices(
hex.getVertex(hex_facet_triangulation(facet_id, t, 0)),
hex.getVertex(hex_facet_triangulation(facet_id, t, 1)),
- hex.getVertex(hex_facet_triangulation(facet_id, t, 2)),
- tet_mesh);
+ hex.getVertex(hex_facet_triangulation(facet_id, t, 2)), tet_mesh);
nb_tets_adjacent[t] = nb;
}
- bool valid_facet = (nb_tets_adjacent[0] > 0 && nb_tets_adjacent[1] == nb_tets_adjacent[0])
- || (nb_tets_adjacent[2] > 0 && nb_tets_adjacent[3] == nb_tets_adjacent[2]);
+ bool valid_facet =
+ (nb_tets_adjacent[0] > 0 && nb_tets_adjacent[1] == nb_tets_adjacent[0]) ||
+ (nb_tets_adjacent[2] > 0 && nb_tets_adjacent[3] == nb_tets_adjacent[2]);
return valid_facet;
}
// Check that the 6 facets of the hexahedra are valid
// A facet is valid if
- // TODO Change the code to have const TetMeshConnectivity& -- pb is [] operator on the maps
- bool validFaces(const Hex &hex, TetMeshConnectivity& tet_mesh) {
- for (unsigned int f = 0; f < 6; ++f) {
+ // TODO Change the code to have const TetMeshConnectivity& -- pb is []
+ // operator on the maps
+ bool validFaces(const Hex &hex, TetMeshConnectivity &tet_mesh)
+ {
+ for(unsigned int f = 0; f < 6; ++f) {
bool valid_facet = validFace(hex, f, tet_mesh);
- if (!valid_facet) {
+ if(!valid_facet) {
return false;
}
}
return true;
}
- double eta(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+ double eta(MVertex *a, MVertex *b, MVertex *c, MVertex *d)
+ {
MQuadrangle quad(a, b, c, d);
return quad.etaShapeMeasure();
}
@@ -354,14 +372,14 @@ namespace {
// If all etaShapeMeasure for the 6 hex facets are above the required min_eta
// return the result of validFaces
// otherwise return false
- bool valid(const Hex &hex, TetMeshConnectivity& tet_mesh, double min_eta = 0.000001) {
- for (unsigned int f = 0; f < 6; ++f) {
- double eta_value = eta(
- hex.vertex_in_facet(f, 0),
- hex.vertex_in_facet(f, 1),
- hex.vertex_in_facet(f, 2),
- hex.vertex_in_facet(f, 3));
- if (eta_value < min_eta) {
+ bool valid(const Hex &hex, TetMeshConnectivity &tet_mesh,
+ double min_eta = 0.000001)
+ {
+ for(unsigned int f = 0; f < 6; ++f) {
+ double eta_value =
+ eta(hex.vertex_in_facet(f, 0), hex.vertex_in_facet(f, 1),
+ hex.vertex_in_facet(f, 2), hex.vertex_in_facet(f, 3));
+ if(eta_value < min_eta) {
return false;
}
}
@@ -369,67 +387,75 @@ namespace {
}
// Returns true if the hex contains all the tet vertices
- bool hex_contains_tet(const Hex& hex, MElement* tet) {
- return hex.contains((tet)->getVertex(0))
- && hex.contains((tet)->getVertex(1))
- && hex.contains((tet)->getVertex(2))
- && hex.contains((tet)->getVertex(3));
+ bool hex_contains_tet(const Hex &hex, MElement *tet)
+ {
+ return hex.contains((tet)->getVertex(0)) &&
+ hex.contains((tet)->getVertex(1)) &&
+ hex.contains((tet)->getVertex(2)) &&
+ hex.contains((tet)->getVertex(3));
}
-
// For all tets around the input vertex
// Check if its 4 vertices are vertices of the input hex
// Insert the tet in the final set if they are
- void find(MVertex* vertex, const Hex& hex, std::set<MElement*>& result, TetMeshConnectivity& tet_mesh) {
- TetMeshConnectivity::TetSet tets_around_v = tet_mesh.tets_around_vertex(vertex);
- for (TetMeshConnectivity::TetSet::const_iterator tet = tets_around_v.begin();
- tet != tets_around_v.end(); ++tet)
- {
- if (hex_contains_tet( hex, *tet)) {
+ void find(MVertex *vertex, const Hex &hex, std::set<MElement *> &result,
+ TetMeshConnectivity &tet_mesh)
+ {
+ TetMeshConnectivity::TetSet tets_around_v =
+ tet_mesh.tets_around_vertex(vertex);
+ for(TetMeshConnectivity::TetSet::const_iterator tet = tets_around_v.begin();
+ tet != tets_around_v.end(); ++tet) {
+ if(hex_contains_tet(hex, *tet)) {
result.insert(*tet);
}
}
}
- void find(const Hex& hex, std::set<MElement*>& result, TetMeshConnectivity& tet_mesh) {
- for (unsigned int v = 0; v < 8; ++v) {
+ void find(const Hex &hex, std::set<MElement *> &result,
+ TetMeshConnectivity &tet_mesh)
+ {
+ for(unsigned int v = 0; v < 8; ++v) {
find(hex.getVertex(v), hex, result, tet_mesh);
}
}
- MVertex* last_tet_vertex(MElement* tet, MVertex* v1, MVertex* v2, MVertex* v3) {
- for (unsigned int i = 0; i < 4; ++i) {
- MVertex* v = tet->getVertex(i);
- if (v != v1 && v != v2 && v != v3) {
+ MVertex *last_tet_vertex(MElement *tet, MVertex *v1, MVertex *v2, MVertex *v3)
+ {
+ for(unsigned int i = 0; i < 4; ++i) {
+ MVertex *v = tet->getVertex(i);
+ if(v != v1 && v != v2 && v != v3) {
return v;
}
}
return NULL;
}
- // Among the input tetrahedra find the first tet that contains v1, v2, and v3 BUT not v4
- // and return the vertex of tet that is neither v1, v2, or v3
+ // Among the input tetrahedra find the first tet that contains v1, v2, and v3
+ // BUT not v4 and return the vertex of tet that is neither v1, v2, or v3
// Dis-donc c'est vraiment tordu !!
- // Tout ca pour avoir le voisin d'un tet la face opposée à v4 et prendre le point
- // opposé dans le tet voisin.
- MVertex* find(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4, const std::set<MElement*>& tets) {
- for (std::set<MElement*>::const_iterator it = tets.begin(); it != tets.end(); it++) {
- MElement* tet = *it;
- if (tet_contains_vertex(tet, v1) && tet_contains_vertex(tet, v2)
- && tet_contains_vertex(tet, v3) && !tet_contains_vertex(tet, v4)
- ) {
+ // Tout ca pour avoir le voisin d'un tet la face opposée à v4 et prendre le
+ // point opposé dans le tet voisin.
+ MVertex *find(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ const std::set<MElement *> &tets)
+ {
+ for(std::set<MElement *>::const_iterator it = tets.begin();
+ it != tets.end(); it++) {
+ MElement *tet = *it;
+ if(tet_contains_vertex(tet, v1) && tet_contains_vertex(tet, v2) &&
+ tet_contains_vertex(tet, v3) && !tet_contains_vertex(tet, v4)) {
return last_tet_vertex(tet, v1, v2, v3);
}
}
return NULL;
}
-
template <class T>
- bool find_value_in_multiset(const std::multiset<T>& set, const T& value, T& value_in_set) {
+ bool find_value_in_multiset(const std::multiset<T> &set, const T &value,
+ T &value_in_set)
+ {
typename std::multiset<T>::const_iterator it = set.find(value);
- for (; it != set.end() && it->get_hash() == value.get_hash(); ++it) {
- if (value.same_vertices(*it)) {
+ for(; it != set.end() && it->get_hash() == value.get_hash(); ++it) {
+ if(value.same_vertices(*it)) {
value_in_set = *it;
return true;
}
@@ -439,10 +465,11 @@ namespace {
// Check if one value exist in a multiset hash table of Recombinator
template <class T>
- bool find_value_in_multiset(const std::multiset<T>& set, const T& value) {
+ bool find_value_in_multiset(const std::multiset<T> &set, const T &value)
+ {
typename std::multiset<T>::const_iterator it = set.find(value);
- for (; it != set.end() && it->get_hash() == value.get_hash(); ++it) {
- if (value.same_vertices(*it)) {
+ for(; it != set.end() && it->get_hash() == value.get_hash(); ++it) {
+ if(value.same_vertices(*it)) {
return true;
}
}
@@ -451,33 +478,30 @@ namespace {
// To insert values in multiset hash table of Recombinator
template <class T>
- void add_value_to_multiset(std::multiset<T>& set, const T& value) {
- if (!find_value_in_multiset(set, value)) {
+ void add_value_to_multiset(std::multiset<T> &set, const T &value)
+ {
+ if(!find_value_in_multiset(set, value)) {
set.insert(value);
}
}
-
-
// Compute the intersection of bin1 and bin2
// And add to final the elements that are not in the already vector
- // void Recombinator::intersection(const std::set<MVertex*>& bin1, const std::set<MVertex*>& bin2,
+ // void Recombinator::intersection(const std::set<MVertex*>& bin1, const
+ // std::set<MVertex*>& bin2,
-
- std::ostream& operator<<(std::ostream& os, const Hex& hex){
+ std::ostream &operator<<(std::ostream &os, const Hex &hex)
+ {
os << " vertices "
- << " A " << hex.getVertex(0)->getNum()
- << " B " << hex.getVertex(1)->getNum()
- << " C " << hex.getVertex(2)->getNum()
- << " D " << hex.getVertex(3)->getNum()
- << " E " << hex.getVertex(4)->getNum()
- << " F " << hex.getVertex(5)->getNum()
- << " G " << hex.getVertex(6)->getNum()
- << " H " << hex.getVertex(7)->getNum();
+ << " A " << hex.getVertex(0)->getNum() << " B "
+ << hex.getVertex(1)->getNum() << " C " << hex.getVertex(2)->getNum()
+ << " D " << hex.getVertex(3)->getNum() << " E "
+ << hex.getVertex(4)->getNum() << " F " << hex.getVertex(5)->getNum()
+ << " G " << hex.getVertex(6)->getNum() << " H "
+ << hex.getVertex(7)->getNum();
return os;
}
-
} // anonymous namespace
void export_gregion_mesh(GRegion *gr, const string &filename)
@@ -485,33 +509,33 @@ void export_gregion_mesh(GRegion *gr, const string &filename)
// FIXME: use MElement::writeMSH
// create set of all tets
- map<MVertex*, int> vertices;
+ map<MVertex *, int> vertices;
int counterv = 1;
- for (vector<MTetrahedron*>::iterator it = gr->tetrahedra.begin();
- it != gr->tetrahedra.end(); it++) {
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(vector<MTetrahedron *>::iterator it = gr->tetrahedra.begin();
+ it != gr->tetrahedra.end(); it++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
vertices.insert(make_pair((*it)->getVertex(i), counterv));
counterv++;
}
}
- for (vector<MHexahedron*>::iterator it = gr->hexahedra.begin();
- it != gr->hexahedra.end(); it++) {
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(vector<MHexahedron *>::iterator it = gr->hexahedra.begin();
+ it != gr->hexahedra.end(); it++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
vertices.insert(make_pair((*it)->getVertex(i), counterv));
counterv++;
}
}
- for (vector<MPrism*>::iterator it = gr->prisms.begin();
- it != gr->prisms.end(); it++) {
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(vector<MPrism *>::iterator it = gr->prisms.begin();
+ it != gr->prisms.end(); it++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
vertices.insert(make_pair((*it)->getVertex(i), counterv));
counterv++;
}
}
- for (vector<MPyramid*>::iterator it = gr->pyramids.begin();
- it != gr->pyramids.end(); it++) {
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(vector<MPyramid *>::iterator it = gr->pyramids.begin();
+ it != gr->pyramids.end(); it++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
vertices.insert(make_pair((*it)->getVertex(i), counterv));
counterv++;
}
@@ -519,53 +543,58 @@ void export_gregion_mesh(GRegion *gr, const string &filename)
// export mesh
ofstream out(filename.c_str());
- out << "$MeshFormat" << endl << "2.2 0 8" << endl << "$EndMeshFormat"
- << endl << "$Nodes" << endl << vertices.size() << endl;
+ out << "$MeshFormat" << endl
+ << "2.2 0 8" << endl
+ << "$EndMeshFormat" << endl
+ << "$Nodes" << endl
+ << vertices.size() << endl;
// write vertices
- for (map<MVertex*, int>::iterator it = vertices.begin();
- it != vertices.end(); it++)
- out << it->second << " " << it->first->x() << " " << it->first->y()
- << " " << it->first->z() << endl;
- out << "$EndNodes" << endl << "$Elements" << endl
- << (gr->tetrahedra.size() + gr->hexahedra.size() +
- gr->prisms.size() + gr->pyramids.size()) << endl;
+ for(map<MVertex *, int>::iterator it = vertices.begin(); it != vertices.end();
+ it++)
+ out << it->second << " " << it->first->x() << " " << it->first->y() << " "
+ << it->first->z() << endl;
+ out << "$EndNodes" << endl
+ << "$Elements" << endl
+ << (gr->tetrahedra.size() + gr->hexahedra.size() + gr->prisms.size() +
+ gr->pyramids.size())
+ << endl;
// write elems
int counter = 1;
- for (vector<MTetrahedron*>::iterator it = gr->tetrahedra.begin();
- it != gr->tetrahedra.end(); it++) {
+ for(vector<MTetrahedron *>::iterator it = gr->tetrahedra.begin();
+ it != gr->tetrahedra.end(); it++) {
out << counter << " 4 2 0 26";
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
MVertex *v = (*it)->getVertex(i);
out << " " << vertices[v];
}
out << endl;
counter++;
}
- for (vector<MHexahedron*>::iterator it = gr->hexahedra.begin();
- it != gr->hexahedra.end(); it++) {
+ for(vector<MHexahedron *>::iterator it = gr->hexahedra.begin();
+ it != gr->hexahedra.end(); it++) {
out << counter << " 5 2 0 26";
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
MVertex *v = (*it)->getVertex(i);
out << " " << vertices[v];
}
out << endl;
counter++;
}
- for (vector<MPrism*>::iterator it = gr->prisms.begin();
- it != gr->prisms.end(); it++) {
+ for(vector<MPrism *>::iterator it = gr->prisms.begin();
+ it != gr->prisms.end(); it++) {
out << counter << " 6 2 0 26";
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
MVertex *v = (*it)->getVertex(i);
out << " " << vertices[v];
}
out << endl;
counter++;
}
- for (vector<MPyramid*>::iterator it = gr->pyramids.begin();
- it != gr->pyramids.end(); it++) {
+ for(vector<MPyramid *>::iterator it = gr->pyramids.begin();
+ it != gr->pyramids.end(); it++) {
out << counter << " 7 2 0 26";
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
MVertex *v = (*it)->getVertex(i);
out << " " << vertices[v];
}
@@ -577,45 +606,47 @@ void export_gregion_mesh(GRegion *gr, const string &filename)
out.close();
}
-
/**************************************************/
/****************class Recombinator****************/
/**************************************************/
-
-MVertex* Hex::vertex_in_facet(unsigned int facet, unsigned int v_in_facet) const {
+MVertex *Hex::vertex_in_facet(unsigned int facet, unsigned int v_in_facet) const
+{
unsigned int v = hex_facet_to_vertex[facet][v_in_facet];
return getVertex(v);
}
-
bool compare_hex_ptr_by_quality(Hex *a, Hex *b)
{
return (a->get_quality() > (b->get_quality()));
}
-Recombinator::~Recombinator() {
- for (std::vector<Hex*>::iterator it = potential.begin(); it != potential.end(); it++) {
+Recombinator::~Recombinator()
+{
+ for(std::vector<Hex *>::iterator it = potential.begin();
+ it != potential.end(); it++) {
delete *it;
}
}
-void Recombinator::execute() {
- GModel* model = GModel::current();
+void Recombinator::execute()
+{
+ GModel *model = GModel::current();
// Backup the current mesh
model->writeMSH("beforeyamakawa.msh");
- for (GModel::riter region_itr = model->firstRegion();
- region_itr != model->lastRegion(); region_itr++) {
- GRegion* region = *region_itr;
+ for(GModel::riter region_itr = model->firstRegion();
+ region_itr != model->lastRegion(); region_itr++) {
+ GRegion *region = *region_itr;
- if (region->getNumMeshElements() > 0) {
+ if(region->getNumMeshElements() > 0) {
execute(region);
}
}
}
-void Recombinator::execute(GRegion* gr) {
+void Recombinator::execute(GRegion *gr)
+{
Msg::Info(" ................HEXAHEDRA.... RECOMBINATOR................\n");
initialize_structures(gr);
@@ -628,35 +659,42 @@ void Recombinator::execute(GRegion* gr) {
create_quads_on_boundary();
print_statistics();
-
}
-void Recombinator::print_all_potential_hex() const {
+void Recombinator::print_all_potential_hex() const
+{
// SORTIE TOUS HEX POT
- std::cout << "__________________________ START POT HEX LISTING ____________________ " << endl;
- for (std::vector<Hex*>::const_iterator it = potential.begin();it!=potential.end();it++){
- cout << "--- Potential hex : " << *(*it) << " " << (*it)->get_quality() << endl;
- }
- std::cout << "__________________________ END POT HEX LISTING ____________________ " << endl;
+ std::cout
+ << "__________________________ START POT HEX LISTING ____________________ "
+ << endl;
+ for(std::vector<Hex *>::const_iterator it = potential.begin();
+ it != potential.end(); it++) {
+ cout << "--- Potential hex : " << *(*it) << " " << (*it)->get_quality()
+ << endl;
+ }
+ std::cout
+ << "__________________________ END POT HEX LISTING ____________________ "
+ << endl;
// END
}
-
-
// This way to flag the tets already included in
// one hex of the final mesh is probably quite pricy. JP
// TODO Replace by a big vector of booleans
-void Recombinator::init_markings() {
+void Recombinator::init_markings()
+{
markings.clear();
- for (unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
- MElement* element = current_region->getMeshElement(i);
- markings.insert(std::pair<MElement*, bool>(element, false));
+ for(unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
+ MElement *element = current_region->getMeshElement(i);
+ markings.insert(std::pair<MElement *, bool>(element, false));
}
}
template <class T>
-void remove_values_from_set(std::set<T>& input_set, const std::vector<T>& values) {
- for (unsigned int i = 0; i < values.size(); ++i) {
+void remove_values_from_set(std::set<T> &input_set,
+ const std::vector<T> &values)
+{
+ for(unsigned int i = 0; i < values.size(); ++i) {
input_set.erase(values[i]);
}
}
@@ -669,28 +707,30 @@ void remove_values_from_set(std::set<T>& input_set, const std::vector<T>& values
// store only the neighbos whose index is superior JP
// TODO - Do not add potential hexes with a very bad quality
// TODO - Change the storage for the potential hexes - We need a big vector
-// and a way to compare - sort them - lower getVertex index shoudl always be first
-void Recombinator::pattern1() {
+// and a way to compare - sort them - lower getVertex index shoudl always be
+// first
+void Recombinator::pattern1()
+{
Msg::Info("Hex-merging pattern nb. 1...");
- for (unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
- MElement* tet = current_region->getMeshElement(i);
+ for(unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
+ MElement *tet = current_region->getMeshElement(i);
- for (int index = 0; index < 4; index++) {
- //max_scaled_jacobian(element,index);
+ for(int index = 0; index < 4; index++) {
+ // max_scaled_jacobian(element,index);
MVertex *a = tet->getVertex(index);
MVertex *b = tet->getVertex((index + 1) % 4);
MVertex *c = tet->getVertex((index + 2) % 4);
MVertex *d = tet->getVertex((index + 3) % 4);
- std::vector<MVertex*> added(4);
+ std::vector<MVertex *> added(4);
added[0] = a;
added[1] = b;
added[2] = c;
added[3] = d;
- std::set<MVertex*> bin1;
- std::set<MVertex*> bin2;
- std::set<MVertex*> bin3;
+ std::set<MVertex *> bin1;
+ std::set<MVertex *> bin2;
+ std::set<MVertex *> bin3;
tet_mesh.vertices_around_vertices(b, d, bin1); // candidates for F - p
tet_mesh.vertices_around_vertices(b, c, bin2); // candidates for C - q
@@ -702,23 +742,25 @@ void Recombinator::pattern1() {
remove_values_from_set(bin3, added);
added.resize(7);
- for (vertex_set_itr it1 = bin1.begin(); it1 != bin1.end(); it1++) {
- MVertex* p = *it1;
+ for(vertex_set_itr it1 = bin1.begin(); it1 != bin1.end(); it1++) {
+ MVertex *p = *it1;
added[4] = p;
- for (vertex_set_itr it2 = bin2.begin(); it2 != bin2.end(); it2++) {
- MVertex* q = *it2;
+ for(vertex_set_itr it2 = bin2.begin(); it2 != bin2.end(); it2++) {
+ MVertex *q = *it2;
added[5] = q;
- for (vertex_set_itr it3 = bin3.begin(); it3 != bin3.end(); it3++) {
- MVertex* r = *it3;
+ for(vertex_set_itr it3 = bin3.begin(); it3 != bin3.end(); it3++) {
+ MVertex *r = *it3;
added[6] = r;
- if (p != q && p != r && q != r) {
- std::set<MVertex*> bin4; // candidates for G - s vertices linked to p,q and r
+ if(p != q && p != r && q != r) {
+ std::set<MVertex *>
+ bin4; // candidates for G - s vertices linked to p,q and r
tet_mesh.vertices_around_vertices(p, q, r, bin4);
remove_values_from_set(bin4, added);
- for (std::set<MVertex*>::iterator it4 = bin4.begin(); it4 != bin4.end(); it4++) {
- MVertex* s = *it4;
- Hex* hex = new Hex(a, b, q, c, d, p, s, r);
+ for(std::set<MVertex *>::iterator it4 = bin4.begin();
+ it4 != bin4.end(); it4++) {
+ MVertex *s = *it4;
+ Hex *hex = new Hex(a, b, q, c, d, p, s, r);
add_or_free_potential_hex(hex);
}
@@ -730,11 +772,12 @@ void Recombinator::pattern1() {
}
}
-void Recombinator::pattern2() {
+void Recombinator::pattern2()
+{
Msg::Info("Hex-merging pattern nb. 2...");
- for (unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
- MElement* tet = current_region->getMeshElement(i);
+ for(unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
+ MElement *tet = current_region->getMeshElement(i);
// Only the longest edges is tested - to avoid looping on all the tet edges
int index1 = -1;
int index2 = -1;
@@ -746,30 +789,31 @@ void Recombinator::pattern2() {
diagonal(tet, index1, index2);
two_others(index1, index2, index3, index4);
- MVertex* b = tet->getVertex(index1); // b and d are the vertices of the longest edge
- MVertex* d = tet->getVertex(index2);
- MVertex* a = tet->getVertex(index3); // a and c are the other two vertices
- MVertex* c = tet->getVertex(index4);
+ MVertex *b =
+ tet->getVertex(index1); // b and d are the vertices of the longest edge
+ MVertex *d = tet->getVertex(index2);
+ MVertex *a = tet->getVertex(index3); // a and c are the other two vertices
+ MVertex *c = tet->getVertex(index4);
- std::set<MElement*> verif;
+ std::set<MElement *> verif;
tet_mesh.tets_around_vertices(b, d, verif);
// If there are 6 tets sharing the longest edge
// of the input tet - proceed
// And get the other 4 vertices of the hex
- if (verif.size() == 6) {
- MVertex* s = find(a, b, d, c, verif);
- MVertex* p = find(b, c, d, a, verif);
-
- if (s != NULL && p != NULL) {
- MVertex* r = find(s, b, d, a, verif);
- MVertex* q = find(p, b, d, c, verif);
- if (r != 0 && q != 0) {
+ if(verif.size() == 6) {
+ MVertex *s = find(a, b, d, c, verif);
+ MVertex *p = find(b, c, d, a, verif);
+
+ if(s != NULL && p != NULL) {
+ MVertex *r = find(s, b, d, a, verif);
+ MVertex *q = find(p, b, d, c, verif);
+ if(r != 0 && q != 0) {
// 2 possible hexes
- Hex* hex = new Hex(a, s, b, c, d, r, q, p);
+ Hex *hex = new Hex(a, s, b, c, d, r, q, p);
add_or_free_potential_hex(hex);
- Hex* hex2 = new Hex(a, c, d, s, b, p, q, r);
+ Hex *hex2 = new Hex(a, c, d, s, b, p, q, r);
add_or_free_potential_hex(hex2);
}
}
@@ -777,11 +821,12 @@ void Recombinator::pattern2() {
}
}
-void Recombinator::pattern3() {
+void Recombinator::pattern3()
+{
Msg::Info("Hex-merging pattern nb. 3...");
- for (unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
- MElement* tet = current_region->getMeshElement(i);
+ for(unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
+ MElement *tet = current_region->getMeshElement(i);
int index1 = -1;
int index2 = -1;
@@ -791,27 +836,28 @@ void Recombinator::pattern3() {
diagonal(tet, index1, index2);
two_others(index1, index2, index3, index4);
- MVertex* b = tet->getVertex(index1);
- MVertex* d = tet->getVertex(index2);
- MVertex* a = tet->getVertex(index3);
- MVertex* c = tet->getVertex(index4);
+ MVertex *b = tet->getVertex(index1);
+ MVertex *d = tet->getVertex(index2);
+ MVertex *a = tet->getVertex(index3);
+ MVertex *c = tet->getVertex(index4);
- std::set<MElement*> verif1;
- std::set<MElement*> verif2;
+ std::set<MElement *> verif1;
+ std::set<MElement *> verif2;
tet_mesh.tets_around_vertices(b, d, verif1);
tet_mesh.tets_around_vertices(a, c, verif2);
- if (verif1.size() == 4 && verif2.size() == 4) {
- MVertex* fA = find(b, d, a, c, verif1);
- MVertex* fB = find(b, d, c, a, verif1);
- MVertex* bA = find(a, c, b, d, verif2);
- MVertex* bB = find(a, c, d, b, verif2);
-
- if (fA != 0 && fB != 0 && bA != 0 && bB != 0 && fA != fB && bA != bB) {
- if (scalar(fA, fB, a, b) > scalar(fA, fB, b, c) && scalar(bA, bB, a, b) > scalar(bA, bB, b, c)) {
- MVertex* p = NULL;
- MVertex* q = NULL;
- if (distance(fA, b, c) < distance(fB, b, c)) {
+ if(verif1.size() == 4 && verif2.size() == 4) {
+ MVertex *fA = find(b, d, a, c, verif1);
+ MVertex *fB = find(b, d, c, a, verif1);
+ MVertex *bA = find(a, c, b, d, verif2);
+ MVertex *bB = find(a, c, d, b, verif2);
+
+ if(fA != 0 && fB != 0 && bA != 0 && bB != 0 && fA != fB && bA != bB) {
+ if(scalar(fA, fB, a, b) > scalar(fA, fB, b, c) &&
+ scalar(bA, bB, a, b) > scalar(bA, bB, b, c)) {
+ MVertex *p = NULL;
+ MVertex *q = NULL;
+ if(distance(fA, b, c) < distance(fB, b, c)) {
p = fA;
q = fB;
}
@@ -820,9 +866,9 @@ void Recombinator::pattern3() {
q = fA;
}
- MVertex* r = NULL;
- MVertex* s = NULL;
- if (distance(bA, b, c) < distance(bB, b, c)) {
+ MVertex *r = NULL;
+ MVertex *s = NULL;
+ if(distance(bA, b, c) < distance(bB, b, c)) {
r = bA;
s = bB;
}
@@ -843,15 +889,16 @@ void Recombinator::pattern3() {
bool c9 = tet_mesh.are_vertex_neighbors(a, s);
bool c10 = tet_mesh.are_vertex_neighbors(d, s);
- if (c1 && c2 && c3 && c4 && c5 && c6 && c7 && c8 && c9 && c10) {
- Hex* hex = new Hex(p, c, r, b, q, d, s, a);
+ if(c1 && c2 && c3 && c4 && c5 && c6 && c7 && c8 && c9 && c10) {
+ Hex *hex = new Hex(p, c, r, b, q, d, s, a);
add_or_free_potential_hex(hex);
}
} // copy paste alert
- else if (scalar(fA, fB, a, b) <= scalar(fA, fB, b, c) && scalar(bA, bB, a, b) <= scalar(bA, bB, b, c)) {
- MVertex* p = NULL;
- MVertex* q = NULL;
- if (distance(fA, a, b) < distance(fB, a, b)) {
+ else if(scalar(fA, fB, a, b) <= scalar(fA, fB, b, c) &&
+ scalar(bA, bB, a, b) <= scalar(bA, bB, b, c)) {
+ MVertex *p = NULL;
+ MVertex *q = NULL;
+ if(distance(fA, a, b) < distance(fB, a, b)) {
p = fA;
q = fB;
}
@@ -859,9 +906,9 @@ void Recombinator::pattern3() {
p = fB;
q = fA;
}
- MVertex* r = NULL;
- MVertex* s = NULL;
- if (distance(bA, a, b) < distance(bB, a, b)) {
+ MVertex *r = NULL;
+ MVertex *s = NULL;
+ if(distance(bA, a, b) < distance(bB, a, b)) {
r = bA;
s = bB;
}
@@ -882,8 +929,8 @@ void Recombinator::pattern3() {
bool c9 = tet_mesh.are_vertex_neighbors(c, s);
bool c10 = tet_mesh.are_vertex_neighbors(d, s);
- if (c1 && c2 && c3 && c4 && c5 && c6 && c7 && c8 && c9 && c10) {
- Hex* hex = new Hex(p, b, r, a, q, c, s, d);
+ if(c1 && c2 && c3 && c4 && c5 && c6 && c7 && c8 && c9 && c10) {
+ Hex *hex = new Hex(p, b, r, a, q, c, s, d);
add_or_free_potential_hex(hex);
}
@@ -893,9 +940,9 @@ void Recombinator::pattern3() {
}
}
-void Recombinator::add_or_free_potential_hex(Hex * candidate)
+void Recombinator::add_or_free_potential_hex(Hex *candidate)
{
- if (valid(*candidate, tet_mesh)) {
+ if(valid(*candidate, tet_mesh)) {
potential.push_back(candidate);
}
else {
@@ -903,34 +950,39 @@ void Recombinator::add_or_free_potential_hex(Hex * candidate)
}
}
-void add_hex_to_region(GRegion* region, const Hex& hex) {
+void add_hex_to_region(GRegion *region, const Hex &hex)
+{
region->addHexahedron(new MHexahedron(hex.vertices()));
}
-
-bool Recombinator::are_all_tets_free(const std::set<MElement*>& tets) const {
- for (std::set<MElement*>::const_iterator it = tets.begin(); it != tets.end(); it++) {
- MElement* tet = *it;
- std::map<MElement*, bool>::const_iterator it2 = markings.find(tet);
- if (it2->second == true) {
+bool Recombinator::are_all_tets_free(const std::set<MElement *> &tets) const
+{
+ for(std::set<MElement *>::const_iterator it = tets.begin(); it != tets.end();
+ it++) {
+ MElement *tet = *it;
+ std::map<MElement *, bool>::const_iterator it2 = markings.find(tet);
+ if(it2->second == true) {
return false;
}
}
return true;
}
-void Recombinator::mark_tets(const std::set<MElement*>& tets)
+void Recombinator::mark_tets(const std::set<MElement *> &tets)
{
- for (std::set<MElement*>::const_iterator it = tets.begin(); it != tets.end(); ++it) {
- std::map<MElement*, bool>::iterator it2 = markings.find(*it);
+ for(std::set<MElement *>::const_iterator it = tets.begin(); it != tets.end();
+ ++it) {
+ std::map<MElement *, bool>::iterator it2 = markings.find(*it);
it2->second = true;
}
}
-
-void remove_slivers(std::set<MElement*>& tets, const Hex& hex, std::set<MElement*>& slivers) {
- for (std::set<MElement*>::iterator it = tets.begin(); it != tets.end(); ++it) {
- if (is_combinatorially_sliver(*it, hex)) {
+void remove_slivers(std::set<MElement *> &tets, const Hex &hex,
+ std::set<MElement *> &slivers)
+{
+ for(std::set<MElement *>::iterator it = tets.begin(); it != tets.end();
+ ++it) {
+ if(is_combinatorially_sliver(*it, hex)) {
slivers.insert(*it);
tets.erase(it);
break;
@@ -940,13 +992,14 @@ void remove_slivers(std::set<MElement*>& tets, const Hex& hex, std::set<MElement
// Delete the region tets and put back those which are not marked
// as being part of an hex
-void Recombinator::delete_marked_tets_in_region() const {
- std::vector<MTetrahedron*> copy_tets = current_region->tetrahedra;
+void Recombinator::delete_marked_tets_in_region() const
+{
+ std::vector<MTetrahedron *> copy_tets = current_region->tetrahedra;
current_region->tetrahedra.clear();
- for (unsigned int i = 0; i < copy_tets.size(); i++) {
- MElement* element = (MElement*)(copy_tets[i]);
- std::map<MElement*, bool>::const_iterator it2 = markings.find(element);
- if (it2->second == false) {
+ for(unsigned int i = 0; i < copy_tets.size(); i++) {
+ MElement *element = (MElement *)(copy_tets[i]);
+ std::map<MElement *, bool>::const_iterator it2 = markings.find(element);
+ if(it2->second == false) {
current_region->tetrahedra.push_back(copy_tets[i]);
}
else {
@@ -955,21 +1008,21 @@ void Recombinator::delete_marked_tets_in_region() const {
}
}
-bool Recombinator::add_hex_to_region_if_valid(const Hex& hex)
+bool Recombinator::add_hex_to_region_if_valid(const Hex &hex)
{
// Get the tets constituting that hex
- std::set<MElement*> hex_tets;
+ std::set<MElement *> hex_tets;
find(hex, hex_tets, tet_mesh);
- std::set<MElement*> slivers;
+ std::set<MElement *> slivers;
remove_slivers(hex_tets, hex, slivers);
// Sanity checks
assert(hex_tets.size() > 4 && hex_tets.size() < 7);
assert(slivers.size() < 8);
- bool valid_hex = are_all_tets_free(hex_tets) && valid(hex, hex_tets)
- && is_potential_hex_conform(hex);
+ bool valid_hex = are_all_tets_free(hex_tets) && valid(hex, hex_tets) &&
+ is_potential_hex_conform(hex);
- if( valid_hex){
+ if(valid_hex) {
add_hex_to_region(current_region, hex);
mark_tets(hex_tets);
mark_tets(slivers);
@@ -980,28 +1033,29 @@ bool Recombinator::add_hex_to_region_if_valid(const Hex& hex)
return valid_hex;
}
-void Recombinator::merge() {
+void Recombinator::merge()
+{
clear_hash_tables();
int nb_final_hex = 0;
double total_quality = 0.0;
std::sort(potential.begin(), potential.end(), compare_hex_ptr_by_quality);
- for (unsigned int i = 0; i < potential.size(); i++) {
- const Hex& hex = *potential[i];
+ for(unsigned int i = 0; i < potential.size(); i++) {
+ const Hex &hex = *potential[i];
// TODO - Not storing low quality tets in the first place would be cheaper
- if (hex.get_quality() < hex_threshold_quality) {
+ if(hex.get_quality() < hex_threshold_quality) {
break;
}
bool hex_added = add_hex_to_region_if_valid(hex);
// Compute tet quality statistics
- if (hex_added) {
+ if(hex_added) {
total_quality += hex.get_quality();
nb_final_hex++;
}
}
- if (nb_final_hex > 0) {
+ if(nb_final_hex > 0) {
delete_marked_tets_in_region();
}
@@ -1011,52 +1065,57 @@ void Recombinator::merge() {
Msg::Info("hexahedra average quality (0->1) : %f\n", average_quality);
}
-
-void Recombinator::set_region_elements_positive(){
- for (unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
- MElement* element = current_region->getMeshElement(i);
+void Recombinator::set_region_elements_positive()
+{
+ for(unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
+ MElement *element = current_region->getMeshElement(i);
element->setVolumePositive();
}
}
-void Recombinator::print_statistics() {
+void Recombinator::print_statistics()
+{
unsigned int nb_hex = 0;
double total_volume = 0.0;
double hex_volume = 0.0;
- for (unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
- MElement* element = current_region->getMeshElement(i);
+ for(unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
+ MElement *element = current_region->getMeshElement(i);
double volume = element->getVolume();
- if (element->getNumVertices() == 8) {
+ if(element->getNumVertices() == 8) {
nb_hex++;
hex_volume += volume;
}
total_volume += volume;
}
- printf("percentage of hexahedra (number) : %.2f\n", nb_hex*100.0 / current_region->getNumMeshElements());
- printf("percentage of hexahedra (volume) : %.2f\n", hex_volume*100.0 / total_volume);
+ printf("percentage of hexahedra (number) : %.2f\n",
+ nb_hex * 100.0 / current_region->getNumMeshElements());
+ printf("percentage of hexahedra (volume) : %.2f\n",
+ hex_volume * 100.0 / total_volume);
}
// Get all the triangle facets defining the boundary of the input region
// Each Tuple stores its 3 vertices, the triangle, and the GFace
// to which it belongs
-void Recombinator::build_tuples() {
+void Recombinator::build_tuples()
+{
tuples.clear();
triangles.clear();
- std::vector<GFace*> faces = current_region->faces();
+ std::vector<GFace *> faces = current_region->faces();
- for (std::vector<GFace*>::iterator it = faces.begin(); it != faces.end(); it++) {
- GFace* gf = *it;
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) {
+ GFace *gf = *it;
- for (unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
- MElement* element = gf->getMeshElement(i);
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
+ MElement *element = gf->getMeshElement(i);
- if (element->getNumVertices() == 3) {
- MVertex* a = element->getVertex(0);
- MVertex* b = element->getVertex(1);
- MVertex* c = element->getVertex(2);
+ if(element->getNumVertices() == 3) {
+ MVertex *a = element->getVertex(0);
+ MVertex *b = element->getVertex(1);
+ MVertex *c = element->getVertex(2);
tuples.insert(Tuple(a, b, c, element, gf));
}
@@ -1064,22 +1123,21 @@ void Recombinator::build_tuples() {
}
}
-
-
-void Recombinator::create_quads_on_boundary() {
- for (unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
- MElement* element = current_region->getMeshElement(i);
-
- if (element->getNumVertices() == 8) {
- MVertex* a = element->getVertex(0);
- MVertex* b = element->getVertex(1);
- MVertex* c = element->getVertex(2);
- MVertex* d = element->getVertex(3);
- MVertex* e = element->getVertex(4);
- MVertex* f = element->getVertex(5);
- MVertex* g = element->getVertex(6);
- MVertex* h = element->getVertex(7);
- // WARNING: not the same facets than those used to build the hex !!
+void Recombinator::create_quads_on_boundary()
+{
+ for(unsigned int i = 0; i < current_region->getNumMeshElements(); i++) {
+ MElement *element = current_region->getMeshElement(i);
+
+ if(element->getNumVertices() == 8) {
+ MVertex *a = element->getVertex(0);
+ MVertex *b = element->getVertex(1);
+ MVertex *c = element->getVertex(2);
+ MVertex *d = element->getVertex(3);
+ MVertex *e = element->getVertex(4);
+ MVertex *f = element->getVertex(5);
+ MVertex *g = element->getVertex(6);
+ MVertex *h = element->getVertex(7);
+ // WARNING: not the same facets than those used to build the hex !!
create_quads_on_boundary(a, b, c, d);
create_quads_on_boundary(e, f, g, h);
create_quads_on_boundary(a, e, h, d);
@@ -1091,39 +1149,42 @@ void Recombinator::create_quads_on_boundary() {
delete_quad_triangles_in_boundary();
}
-void Recombinator::delete_quad_triangles_in_boundary() const {
- std::vector<GFace*> faces = current_region->faces();
- for (std::vector<GFace*>::iterator it = faces.begin(); it != faces.end(); it++) {
- GFace* gf = *it;
- std::vector<MElement*> triangles_to_keep;
+void Recombinator::delete_quad_triangles_in_boundary() const
+{
+ std::vector<GFace *> faces = current_region->faces();
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) {
+ GFace *gf = *it;
+ std::vector<MElement *> triangles_to_keep;
triangles_to_keep.reserve(gf->triangles.size());
// Why not directly iterate on the triangle list??
- for (unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
- MElement* element = gf->getMeshElement(i);
+ for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) {
+ MElement *element = gf->getMeshElement(i);
bool is_triangle = element->getNumVertices() == 3;
- if( is_triangle ) {
+ if(is_triangle) {
bool is_in_quad = triangles.find(element) != triangles.end();
- if( !is_in_quad ){
+ if(!is_in_quad) {
triangles_to_keep.push_back(element);
}
}
}
gf->triangles.clear();
- for (unsigned int i = 0; i < triangles_to_keep.size(); i++) {
- gf->triangles.push_back((MTriangle*)triangles_to_keep[i]);
+ for(unsigned int i = 0; i < triangles_to_keep.size(); i++) {
+ gf->triangles.push_back((MTriangle *)triangles_to_keep[i]);
}
}
}
-
-
// For the two possible triangulations
// of these 4 points - check if they are part of the input
// boundary of the region
// If they are, create the corrsponding quad in the GFace mesh.
-// TODO - check and get out fast if the vertices are not on the boundary of the region
-void Recombinator::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+// TODO - check and get out fast if the vertices are not on the boundary of the
+// region
+void Recombinator::create_quads_on_boundary(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
Tuple tuple0(a, b, c);
Tuple tuple1(c, d, a);
@@ -1134,11 +1195,11 @@ void Recombinator::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c,
bool tuple1_found = find_value_in_multiset(tuples, tuple1, stored_tuple1);
bool quad_added = false;
- if (tuple0_found && tuple1_found) {
+ if(tuple0_found && tuple1_found) {
triangles.insert(stored_tuple0.get_element());
triangles.insert(stored_tuple1.get_element());
- GFace* face = stored_tuple0.get_gf();
+ GFace *face = stored_tuple0.get_gf();
assert(stored_tuple1.get_gf() == face);
face->addQuadrangle(new MQuadrangle(a, b, c, d));
quad_added = true;
@@ -1154,13 +1215,13 @@ void Recombinator::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c,
bool tuple2_found = find_value_in_multiset(tuples, tuple2, stored_tuple2);
bool tuple3_found = find_value_in_multiset(tuples, tuple3, stored_tuple3);
- if (tuple2_found && tuple3_found) {
+ if(tuple2_found && tuple3_found) {
triangles.insert(stored_tuple2.get_element());
triangles.insert(stored_tuple3.get_element());
- GFace* face = stored_tuple2.get_gf();
+ GFace *face = stored_tuple2.get_gf();
assert(stored_tuple3.get_gf() == face);
- if (!quad_added) {
+ if(!quad_added) {
face->addQuadrangle(new MQuadrangle(a, b, c, d));
}
else {
@@ -1171,55 +1232,57 @@ void Recombinator::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c,
}
}
-
// Tet is not compatible with previsouly built tets
// No need to check the slivers, they belong potentially to several hex.
-bool Recombinator::is_potential_hex_conform(const Hex & hex) {
- return conformityA(hex) && conformityB(hex)
- && conformityC(hex) && faces_statuquo(hex);
+bool Recombinator::is_potential_hex_conform(const Hex &hex)
+{
+ return conformityA(hex) && conformityB(hex) && conformityC(hex) &&
+ faces_statuquo(hex);
}
-
// Return true if all the facets of the potential hex are conformA
// A facet is conformA if all or none of the 4 possible triangles are in TableA
-bool Recombinator::conformityA(const Hex &hex) {
- for (unsigned int f = 0; f < 6; ++f) {
+bool Recombinator::conformityA(const Hex &hex)
+{
+ for(unsigned int f = 0; f < 6; ++f) {
std::vector<bool> triangle_inA(4, false);
- for (unsigned int t = 0; t < 4; ++t) {
+ for(unsigned int t = 0; t < 4; ++t) {
Facet hex_facet_triangle(hex.getVertex(hex_facet_triangulation(f, t, 0)),
- hex.getVertex(hex_facet_triangulation(f, t, 1)),
- hex.getVertex(hex_facet_triangulation(f, t, 2)));
+ hex.getVertex(hex_facet_triangulation(f, t, 1)),
+ hex.getVertex(hex_facet_triangulation(f, t, 2)));
triangle_inA[t] = find_value_in_multiset(hash_tableA, hex_facet_triangle);
}
- unsigned int nb_triangles_inA = std::count(triangle_inA.begin(), triangle_inA.end(), true);
- if (nb_triangles_inA != 0 && nb_triangles_inA != 4) {
+ unsigned int nb_triangles_inA =
+ std::count(triangle_inA.begin(), triangle_inA.end(), true);
+ if(nb_triangles_inA != 0 && nb_triangles_inA != 4) {
return false;
}
}
return true;
}
-bool Recombinator::conformityB(const Hex &hex) {
+bool Recombinator::conformityB(const Hex &hex)
+{
// Check if one of the 12 hex edges is in tableB
- for (unsigned int edge = 0; edge < 12; ++edge) {
- Diagonal hex_edge( hex.getVertex(hex_edge_to_vertex[edge][0]),
- hex.getVertex(hex_edge_to_vertex[edge][1]));
+ for(unsigned int edge = 0; edge < 12; ++edge) {
+ Diagonal hex_edge(hex.getVertex(hex_edge_to_vertex[edge][0]),
+ hex.getVertex(hex_edge_to_vertex[edge][1]));
bool is_already_diagonal = find_value_in_multiset(hash_tableB, hex_edge);
- if (is_already_diagonal) {
+ if(is_already_diagonal) {
return false;
}
}
// And check that for each hex facet only one of the 2 diagonals is in tableB
// Isn't it redondant with conformity A ???
- for (unsigned int facet = 0; facet < 6; ++facet) {
+ for(unsigned int facet = 0; facet < 6; ++facet) {
Diagonal d0(hex.vertex_in_facet(facet, 0), hex.vertex_in_facet(facet, 2));
Diagonal d1(hex.vertex_in_facet(facet, 1), hex.vertex_in_facet(facet, 3));
bool is_already_diagonal0 = find_value_in_multiset(hash_tableB, d0);
bool is_already_diagonal1 = find_value_in_multiset(hash_tableB, d1);
- if (is_already_diagonal0 != is_already_diagonal1) {
+ if(is_already_diagonal0 != is_already_diagonal1) {
return false;
}
}
@@ -1228,12 +1291,14 @@ bool Recombinator::conformityB(const Hex &hex) {
// Return true if one of the 12 facet diagonals of the hex is in tableC
// meaning that it was used as an hex edge.
-bool Recombinator::conformityC(const Hex &hex) {
- for (unsigned int i = 0; i < 12; ++i) {
+bool Recombinator::conformityC(const Hex &hex)
+{
+ for(unsigned int i = 0; i < 12; ++i) {
Diagonal facet_diagonal(hex.getVertex(hex_facet_diagonal[i][0]),
- hex.getVertex(hex_facet_diagonal[i][1]));
- bool is_already_hex_edge = find_value_in_multiset(hash_tableC, facet_diagonal);
- if (is_already_hex_edge) {
+ hex.getVertex(hex_facet_diagonal[i][1]));
+ bool is_already_hex_edge =
+ find_value_in_multiset(hash_tableC, facet_diagonal);
+ if(is_already_hex_edge) {
return false;
}
}
@@ -1242,14 +1307,13 @@ bool Recombinator::conformityC(const Hex &hex) {
// Check that all hex facets are consistent (2 triangle on the same boundary
// when the facet is on the region boundary)
-bool Recombinator::faces_statuquo(const Hex &hex) {
- for (unsigned int f = 0; f < 6; ++f) {
- bool status_quo = faces_statuquo(
- hex.vertex_in_facet(f, 0),
- hex.vertex_in_facet(f, 1),
- hex.vertex_in_facet(f, 2),
- hex.vertex_in_facet(f, 3));
- if (!status_quo) return false;
+bool Recombinator::faces_statuquo(const Hex &hex)
+{
+ for(unsigned int f = 0; f < 6; ++f) {
+ bool status_quo =
+ faces_statuquo(hex.vertex_in_facet(f, 0), hex.vertex_in_facet(f, 1),
+ hex.vertex_in_facet(f, 2), hex.vertex_in_facet(f, 3));
+ if(!status_quo) return false;
}
return true;
}
@@ -1257,7 +1321,9 @@ bool Recombinator::faces_statuquo(const Hex &hex) {
// Return false when two triangles in the facets that are not
// on the same boundary (same GFace) of the region.
// In other words, when a geo edge is a diagonal of the current facet.
-bool Recombinator::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+bool Recombinator::faces_statuquo(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
{
Tuple tuple1(a, b, c);
Tuple tuple2(c, d, a);
@@ -1265,18 +1331,18 @@ bool Recombinator::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex* d
std::multiset<Tuple>::iterator it1 = tuples.find(tuple1);
std::multiset<Tuple>::iterator it2 = tuples.find(tuple2);
- GFace* gf1 = NULL;
- GFace* gf2 = NULL;
+ GFace *gf1 = NULL;
+ GFace *gf2 = NULL;
- while (it1 != tuples.end() && it1->get_hash() == tuple1.get_hash()) {
- if (tuple1.same_vertices(*it1)) {
+ while(it1 != tuples.end() && it1->get_hash() == tuple1.get_hash()) {
+ if(tuple1.same_vertices(*it1)) {
gf1 = it1->get_gf();
}
it1++;
}
- while (it2 != tuples.end() && it2->get_hash() == tuple2.get_hash()) {
- if (tuple2.same_vertices(*it2)) {
+ while(it2 != tuples.end() && it2->get_hash() == tuple2.get_hash()) {
+ if(tuple2.same_vertices(*it2)) {
gf2 = it2->get_gf();
}
it2++;
@@ -1285,14 +1351,15 @@ bool Recombinator::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex* d
assert((gf1 == NULL && gf2 == NULL) || (gf1 != NULL && gf2 != NULL));
- if (gf1 != NULL && gf2 != NULL) {
- if (gf1 != gf2) {
+ if(gf1 != NULL && gf2 != NULL) {
+ if(gf1 != gf2) {
return false;
}
- else return true;
+ else
+ return true;
}
}
- // Copy paste alert
+ // Copy paste alert
{
// Now check the second possible triangulation for the facet
Tuple tuple1(a, b, d);
@@ -1301,81 +1368,88 @@ bool Recombinator::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex* d
std::multiset<Tuple>::iterator it1 = tuples.find(tuple1);
std::multiset<Tuple>::iterator it2 = tuples.find(tuple2);
- GFace* gf1 = NULL;
- GFace* gf2 = NULL;
+ GFace *gf1 = NULL;
+ GFace *gf2 = NULL;
- while (it1 != tuples.end() && it1->get_hash() == tuple1.get_hash()) {
- if (tuple1.same_vertices(*it1)) {
+ while(it1 != tuples.end() && it1->get_hash() == tuple1.get_hash()) {
+ if(tuple1.same_vertices(*it1)) {
gf1 = it1->get_gf();
}
it1++;
}
- while (it2 != tuples.end() && it2->get_hash() == tuple2.get_hash()) {
- if (tuple2.same_vertices(*it2)) {
+ while(it2 != tuples.end() && it2->get_hash() == tuple2.get_hash()) {
+ if(tuple2.same_vertices(*it2)) {
gf2 = it2->get_gf();
}
it2++;
}
- if (gf1 != NULL && gf2 != NULL) {
- if (gf1 != gf2) {
+ if(gf1 != NULL && gf2 != NULL) {
+ if(gf1 != gf2) {
return false;
}
- else return true;
+ else
+ return true;
}
}
// The facet are not on the boundary
return true;
}
-
// Store the hex facet triaangles (4 per facet) in TableA
-void Recombinator::build_hash_tableA(const Hex& hex) {
- for (unsigned int f = 0; f < 6; ++f) {
- for (unsigned int t = 0; t < 4; ++t) {
- MVertex* v0 = hex.getVertex(hex_facet_triangulation(f, t, 0));
- MVertex* v1 = hex.getVertex(hex_facet_triangulation(f, t, 1));
- MVertex* v2 = hex.getVertex(hex_facet_triangulation(f, t, 2));
- add_value_to_multiset(hash_tableA, Facet(v0, v1, v2));
- }
- }
+void Recombinator::build_hash_tableA(const Hex &hex)
+{
+ for(unsigned int f = 0; f < 6; ++f) {
+ for(unsigned int t = 0; t < 4; ++t) {
+ MVertex *v0 = hex.getVertex(hex_facet_triangulation(f, t, 0));
+ MVertex *v1 = hex.getVertex(hex_facet_triangulation(f, t, 1));
+ MVertex *v2 = hex.getVertex(hex_facet_triangulation(f, t, 2));
+ add_value_to_multiset(hash_tableA, Facet(v0, v1, v2));
+ }
+ }
}
// Store the hex facet diagonals in TableB
-void Recombinator::build_hash_tableB(const Hex& hex) {
- for (unsigned int i = 0; i < 12; ++i) {
- MVertex* v0 = hex.getVertex(hex_facet_diagonal[i][0]);
- MVertex* v1 = hex.getVertex(hex_facet_diagonal[i][1]);
+void Recombinator::build_hash_tableB(const Hex &hex)
+{
+ for(unsigned int i = 0; i < 12; ++i) {
+ MVertex *v0 = hex.getVertex(hex_facet_diagonal[i][0]);
+ MVertex *v1 = hex.getVertex(hex_facet_diagonal[i][1]);
add_value_to_multiset(hash_tableB, Diagonal(v0, v1));
}
}
// Store the hex edges in TableC
-void Recombinator::build_hash_tableC(const Hex& hex) {
- for (unsigned int e = 0; e < 12; ++e) {
- MVertex* v0 = hex.getVertex(hex_edge_to_vertex[e][0]);
- MVertex* v1 = hex.getVertex(hex_edge_to_vertex[e][1]);
+void Recombinator::build_hash_tableC(const Hex &hex)
+{
+ for(unsigned int e = 0; e < 12; ++e) {
+ MVertex *v0 = hex.getVertex(hex_edge_to_vertex[e][0]);
+ MVertex *v1 = hex.getVertex(hex_edge_to_vertex[e][1]);
add_value_to_multiset(hash_tableC, Diagonal(v0, v1));
}
}
-void Recombinator::print_hash_tableA() {
+void Recombinator::print_hash_tableA()
+{
std::multiset<Facet>::iterator it;
- for (it = hash_tableA.begin(); it != hash_tableA.end(); it++) {
+ for(it = hash_tableA.begin(); it != hash_tableA.end(); it++) {
printf("%lld\n", it->get_hash());
}
}
-void Recombinator::print_segment(const SPoint3& p1, const SPoint3& p2, std::ofstream& file) {
- file << "SL ("
- << p1.x() << ", " << p1.y() << ", " << p1.z() << ", "
- << p2.x() << ", " << p2.y() << ", " << p2.z() << ")"
- << "{10, 20};\n";
+void Recombinator::print_segment(const SPoint3 &p1, const SPoint3 &p2,
+ std::ofstream &file)
+{
+ file << "SL (" << p1.x() << ", " << p1.y() << ", " << p1.z() << ", " << p2.x()
+ << ", " << p2.y() << ", " << p2.z() << ")"
+ << "{10, 20};\n";
}
-double Recombinator::scaled_jacobian(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+double Recombinator::scaled_jacobian(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
SVector3 ab(a->point(), b->point());
SVector3 ac(a->point(), c->point());
SVector3 ad(a->point(), d->point());
@@ -1385,11 +1459,11 @@ double Recombinator::scaled_jacobian(MVertex* a, MVertex* b, MVertex* c, MVertex
double l_ad = ad.norm();
double val = dot(ab, crossprod(ac, ad));
- return val / (l_ab*l_ac*l_ad);
+ return val / (l_ab * l_ac * l_ad);
}
-/*double Recombinator::scaled_jacobian_face(MVertex* a,MVertex* b,MVertex* c,MVertex* d){
- double j1, j2, j3, j4;
+/*double Recombinator::scaled_jacobian_face(MVertex* a,MVertex* b,MVertex*
+c,MVertex* d){ double j1, j2, j3, j4;
j1 = std::abs(scaled_jacobian(a,b,d,c));
j2 = std::abs(scaled_jacobian(b,c,a,d));
@@ -1399,7 +1473,8 @@ double Recombinator::scaled_jacobian(MVertex* a, MVertex* b, MVertex* c, MVertex
return 1-2*(j1+j2+j3+j4)/4;
}*/
-double Recombinator::max_scaled_jacobian(MElement* element, int& index) {
+double Recombinator::max_scaled_jacobian(MElement *element, int &index)
+{
double val;
double j1, j2, j3, j4;
MVertex *a, *b, *c, *d;
@@ -1414,15 +1489,15 @@ double Recombinator::max_scaled_jacobian(MElement* element, int& index) {
j3 = scaled_jacobian(c, d, a, b);
j4 = scaled_jacobian(d, a, b, c);
- if (j1 >= j2 && j1 >= j3 && j1 >= j4) {
+ if(j1 >= j2 && j1 >= j3 && j1 >= j4) {
index = 0;
val = j1;
}
- else if (j2 >= j3 && j2 >= j4 && j2 >= j1) {
+ else if(j2 >= j3 && j2 >= j4 && j2 >= j1) {
index = 1;
val = j2;
}
- else if (j3 >= j4 && j3 >= j1 && j3 >= j2) {
+ else if(j3 >= j4 && j3 >= j1 && j3 >= j2) {
index = 2;
val = j3;
}
@@ -1434,7 +1509,8 @@ double Recombinator::max_scaled_jacobian(MElement* element, int& index) {
return val;
}
-double Recombinator::min_scaled_jacobian(Hex &hex) {
+double Recombinator::min_scaled_jacobian(Hex &hex)
+{
MVertex *a = hex.getVertex(0);
MVertex *b = hex.getVertex(1);
MVertex *c = hex.getVertex(2);
@@ -1465,11 +1541,11 @@ double Recombinator::min_scaled_jacobian(Hex &hex) {
double min = DBL_MAX;
double max = DBL_MIN;
- for (unsigned int i = 0; i < 8; i++) {
+ for(unsigned int i = 0; i < 8; i++) {
min = std::min(min, jacobians[i]);
max = std::max(max, jacobians[i]);
}
- if (max < 0) min = -max; // Why ? Why is there no test on min < -max ?? Jeanne
+ if(max < 0) min = -max; // Why ? Why is there no test on min < -max ?? Jeanne
/*MHexahedron *h1 = new MHexahedron(a, b, c, d, e, f, g, h);
MHexahedron *h2 = new MHexahedron(e, f, g, h, a, b, c, d);
@@ -1483,9 +1559,9 @@ double Recombinator::min_scaled_jacobian(Hex &hex) {
delete h1;
delete h2;
- double Min = std::max(min1,min2);*/ //fordebug
+ double Min = std::max(min1,min2);*/ // fordebug
- //return min > Min+.2 ? min : 0;
+ // return min > Min+.2 ? min : 0;
/*j1 = scaled_jacobian_face(a,b,c,d);
j2 = scaled_jacobian_face(e,f,g,h);
@@ -1516,7 +1592,9 @@ double Recombinator::min_scaled_jacobian(Hex &hex) {
Prism::Prism() {}
-Prism::Prism(MVertex* a2, MVertex* b2, MVertex* c2, MVertex* d2, MVertex* e2, MVertex* f2) {
+Prism::Prism(MVertex *a2, MVertex *b2, MVertex *c2, MVertex *d2, MVertex *e2,
+ MVertex *f2)
+{
a = a2;
b = b2;
c = c2;
@@ -1527,39 +1605,25 @@ Prism::Prism(MVertex* a2, MVertex* b2, MVertex* c2, MVertex* d2, MVertex* e2, MV
Prism::~Prism() {}
-double Prism::get_quality() const {
- return quality;
-}
+double Prism::get_quality() const { return quality; }
-void Prism::set_quality(double new_quality) {
- quality = new_quality;
-}
+void Prism::set_quality(double new_quality) { quality = new_quality; }
-MVertex* Prism::get_a() {
- return a;
-}
+MVertex *Prism::get_a() { return a; }
-MVertex* Prism::get_b() {
- return b;
-}
+MVertex *Prism::get_b() { return b; }
-MVertex* Prism::get_c() {
- return c;
-}
+MVertex *Prism::get_c() { return c; }
-MVertex* Prism::get_d() {
- return d;
-}
+MVertex *Prism::get_d() { return d; }
-MVertex* Prism::get_e() {
- return e;
-}
+MVertex *Prism::get_e() { return e; }
-MVertex* Prism::get_f() {
- return f;
-}
+MVertex *Prism::get_f() { return f; }
-void Prism::set_vertices(MVertex* a2, MVertex* b2, MVertex* c2, MVertex* d2, MVertex* e2, MVertex* f2) {
+void Prism::set_vertices(MVertex *a2, MVertex *b2, MVertex *c2, MVertex *d2,
+ MVertex *e2, MVertex *f2)
+{
a = a2;
b = b2;
c = c2;
@@ -1568,7 +1632,8 @@ void Prism::set_vertices(MVertex* a2, MVertex* b2, MVertex* c2, MVertex* d2, MVe
f = f2;
}
-bool Prism::operator<(const Prism& prism) const {
+bool Prism::operator<(const Prism &prism) const
+{
return quality > prism.get_quality();
}
@@ -1580,23 +1645,24 @@ Supplementary::Supplementary() {}
Supplementary::~Supplementary() {}
-void Supplementary::execute() {
- GRegion* gr;
- GModel* model = GModel::current();
+void Supplementary::execute()
+{
+ GRegion *gr;
+ GModel *model = GModel::current();
GModel::riter it;
- for (it = model->firstRegion(); it != model->lastRegion(); it++)
- {
+ for(it = model->firstRegion(); it != model->lastRegion(); it++) {
gr = *it;
- if (gr->getNumMeshElements() > 0) {
+ if(gr->getNumMeshElements() > 0) {
execute(gr);
}
}
}
-void Supplementary::execute(GRegion* gr) {
+void Supplementary::execute(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
MVertex *a, *b, *c, *d;
MVertex *e, *f, *g, *h;
@@ -1608,21 +1674,20 @@ void Supplementary::execute(GRegion* gr) {
build_vertex_to_tetrahedra(gr);
printf("connectivity\n");
-
- //file.open("qualPri.txt", std::fstream::out); //fordebug
+ // file.open("qualPri.txt", std::fstream::out); //fordebug
potential.clear();
pattern(gr);
printf("pattern\n");
- //file.close(); //fordebug
+ // file.close(); //fordebug
hash_tableA.clear();
hash_tableB.clear();
hash_tableC.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (eight(element)) {
+ if(eight(element)) {
a = element->getVertex(0);
b = element->getVertex(1);
c = element->getVertex(2);
@@ -1672,46 +1737,48 @@ void Supplementary::execute(GRegion* gr) {
create_quads_on_boundary(gr);
}
-void Supplementary::init_markings(GRegion* gr) {
+void Supplementary::init_markings(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
markings.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (four(element)) {
- markings.insert(std::pair<MElement*, bool>(element, false));
+ if(four(element)) {
+ markings.insert(std::pair<MElement *, bool>(element, false));
}
}
}
-void Supplementary::pattern(GRegion* gr) {
+void Supplementary::pattern(GRegion *gr)
+{
size_t i;
int j, k;
double quality;
- MElement* element;
+ MElement *element;
MVertex *a, *b, *c, *d;
MVertex *p, *q;
- std::vector<MVertex*> vertices;
- std::vector<MVertex*> already;
- std::set<MVertex*> bin1;
- std::set<MVertex*> bin2;
+ std::vector<MVertex *> vertices;
+ std::vector<MVertex *> already;
+ std::set<MVertex *> bin1;
+ std::set<MVertex *> bin2;
vertex_set_itr it1;
vertex_set_itr it2;
Prism prism;
vertices.resize(3);
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (four(element)) {
- for (j = 0; j < 4; j++) {
+ if(four(element)) {
+ for(j = 0; j < 4; j++) {
a = element->getVertex(j);
vertices[0] = element->getVertex((j + 1) % 4);
vertices[1] = element->getVertex((j + 2) % 4);
vertices[2] = element->getVertex((j + 3) % 4);
- for (k = 0; k < 3; k++) {
+ for(k = 0; k < 3; k++) {
b = vertices[k % 3];
c = vertices[(k + 1) % 3];
d = vertices[(k + 2) % 3];
@@ -1724,15 +1791,15 @@ void Supplementary::pattern(GRegion* gr) {
bin2.clear();
find(b, d, already, bin1);
find(c, d, already, bin2);
- for (it1 = bin1.begin(); it1 != bin1.end(); it1++) {
+ for(it1 = bin1.begin(); it1 != bin1.end(); it1++) {
p = *it1;
- for (it2 = bin2.begin(); it2 != bin2.end(); it2++) {
+ for(it2 = bin2.begin(); it2 != bin2.end(); it2++) {
q = *it2;
- if (p != q && linked(p, q)) {
+ if(p != q && linked(p, q)) {
prism = Prism(a, b, c, d, p, q);
quality = min_scaled_jacobian(prism);
prism.set_quality(quality);
- if (valid(prism)) {
+ if(valid(prism)) {
potential.push_back(prism);
}
}
@@ -1744,7 +1811,8 @@ void Supplementary::pattern(GRegion* gr) {
}
}
-void Supplementary::merge(GRegion* gr) {
+void Supplementary::merge(GRegion *gr)
+{
unsigned int i;
int count;
bool flag;
@@ -1752,21 +1820,21 @@ void Supplementary::merge(GRegion* gr) {
double quality;
MVertex *a, *b, *c;
MVertex *d, *e, *f;
- MElement* element;
- std::set<MElement*> parts;
- std::vector<MTetrahedron*> opt;
+ MElement *element;
+ std::set<MElement *> parts;
+ std::vector<MTetrahedron *> opt;
element_set_itr it;
- std::map<MElement*, bool>::iterator it2;
+ std::map<MElement *, bool>::iterator it2;
Prism prism;
count = 1;
quality = 0.0;
- for (i = 0; i < potential.size(); i++) {
+ for(i = 0; i < potential.size(); i++) {
prism = potential[i];
threshold = 0.6;
- if (prism.get_quality() < threshold) {
+ if(prism.get_quality() < threshold) {
break;
}
@@ -1786,39 +1854,40 @@ void Supplementary::merge(GRegion* gr) {
find(f, prism, parts);
flag = 1;
- for (it = parts.begin(); it != parts.end(); it++) {
+ for(it = parts.begin(); it != parts.end(); it++) {
element = *it;
it2 = markings.find(element);
- if (it2->second == 1 && !sliver(element, prism)) {
+ if(it2->second == 1 && !sliver(element, prism)) {
flag = 0;
break;
}
}
- if (!flag) continue;
+ if(!flag) continue;
- if (!valid(prism, parts)) {
+ if(!valid(prism, parts)) {
continue;
}
- if (!conformityA(prism)) {
+ if(!conformityA(prism)) {
continue;
}
- if (!conformityB(prism)) {
+ if(!conformityB(prism)) {
continue;
}
- if (!conformityC(prism)) {
+ if(!conformityC(prism)) {
continue;
}
- if (!faces_statuquo(prism)) {
+ if(!faces_statuquo(prism)) {
continue;
}
- //printf("%d - %d/%d - %f\n",count,i,(int)potential.size(),prism.get_quality());
+ // printf("%d - %d/%d -
+ // %f\n",count,i,(int)potential.size(),prism.get_quality());
quality = quality + prism.get_quality();
- for (it = parts.begin(); it != parts.end(); it++) {
+ for(it = parts.begin(); it != parts.end(); it++) {
element = *it;
it2 = markings.find(element);
it2->second = 1;
@@ -1835,10 +1904,10 @@ void Supplementary::merge(GRegion* gr) {
opt = gr->tetrahedra;
gr->tetrahedra.clear();
- for (i = 0; i < opt.size(); i++) {
- element = (MElement*)(opt[i]);
+ for(i = 0; i < opt.size(); i++) {
+ element = (MElement *)(opt[i]);
it2 = markings.find(element);
- if (it2->second == 0) {
+ if(it2->second == 0) {
gr->tetrahedra.push_back(opt[i]);
}
else {
@@ -1849,32 +1918,34 @@ void Supplementary::merge(GRegion* gr) {
printf("prisms average quality (0->1) : %f\n", quality / count);
}
-void Supplementary::rearrange(GRegion* gr) {
+void Supplementary::rearrange(GRegion *gr)
+{
size_t i;
- MElement* element;
+ MElement *element;
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
element->setVolumePositive();
}
}
-void Supplementary::statistics(GRegion* gr) {
+void Supplementary::statistics(GRegion *gr)
+{
size_t i;
int all_nbr, prism_nbr;
double all_volume, prism_volume, volume;
- MElement* element;
+ MElement *element;
all_nbr = 0;
prism_nbr = 0;
all_volume = 0.0;
prism_volume = 0.0;
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
volume = element->getVolume();
- if (six(element)) {
+ if(six(element)) {
prism_nbr = prism_nbr + 1;
prism_volume = prism_volume + volume;
}
@@ -1883,30 +1954,31 @@ void Supplementary::statistics(GRegion* gr) {
all_volume = all_volume + volume;
}
- printf("percentage of prisms (number) : %.2f\n", prism_nbr*100.0 / all_nbr);
- printf("percentage of prisms (volume) : %.2f\n", prism_volume*100.0 / all_volume);
+ printf("percentage of prisms (number) : %.2f\n", prism_nbr * 100.0 / all_nbr);
+ printf("percentage of prisms (volume) : %.2f\n",
+ prism_volume * 100.0 / all_volume);
}
-void Supplementary::build_tuples(GRegion* gr) {
+void Supplementary::build_tuples(GRegion *gr)
+{
unsigned int i;
MVertex *a, *b, *c;
- MElement* element;
- GFace* gf;
+ MElement *element;
+ GFace *gf;
tuples.clear();
triangles.clear();
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator it;
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator it;
- for (it = faces.begin(); it != faces.end(); it++)
- {
+ for(it = faces.begin(); it != faces.end(); it++) {
gf = *it;
- for (i = 0; i < gf->getNumMeshElements(); i++) {
+ for(i = 0; i < gf->getNumMeshElements(); i++) {
element = gf->getMeshElement(i);
- if (element->getNumVertices() == 3) {
+ if(element->getNumVertices() == 3) {
a = element->getVertex(0);
b = element->getVertex(1);
c = element->getVertex(2);
@@ -1917,19 +1989,20 @@ void Supplementary::build_tuples(GRegion* gr) {
}
}
-void Supplementary::create_quads_on_boundary(GRegion* gr) {
+void Supplementary::create_quads_on_boundary(GRegion *gr)
+{
unsigned int i;
MVertex *a, *b, *c;
MVertex *d, *e, *f;
- MElement* element;
- GFace* gf;
- std::vector<MElement*> opt;
+ MElement *element;
+ GFace *gf;
+ std::vector<MElement *> opt;
element_set_itr it2;
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (element->getNumVertices() == 6) {
+ if(element->getNumVertices() == 6) {
a = element->getVertex(0);
b = element->getVertex(1);
c = element->getVertex(2);
@@ -1943,21 +2016,20 @@ void Supplementary::create_quads_on_boundary(GRegion* gr) {
}
}
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator it;
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator it;
- for (it = faces.begin(); it != faces.end(); it++)
- {
+ for(it = faces.begin(); it != faces.end(); it++) {
gf = *it;
opt.clear();
- for (i = 0; i < gf->getNumMeshElements(); i++) {
+ for(i = 0; i < gf->getNumMeshElements(); i++) {
element = gf->getMeshElement(i);
- if (element->getNumVertices() == 3) {
+ if(element->getNumVertices() == 3) {
it2 = triangles.find(element);
- if (it2 == triangles.end()) {
+ if(it2 == triangles.end()) {
opt.push_back(element);
}
}
@@ -1965,22 +2037,24 @@ void Supplementary::create_quads_on_boundary(GRegion* gr) {
gf->triangles.clear();
- for (i = 0; i < opt.size(); i++) {
- gf->triangles.push_back((MTriangle*)opt[i]);
+ for(i = 0; i < opt.size(); i++) {
+ gf->triangles.push_back((MTriangle *)opt[i]);
}
}
}
-void Supplementary::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+void Supplementary::create_quads_on_boundary(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
bool flag1, flag2;
MElement *element1, *element2;
- GFace *gf1;//,*gf2;
+ GFace *gf1; //,*gf2;
Tuple tuple1, tuple2;
std::multiset<Tuple>::iterator it1;
std::multiset<Tuple>::iterator it2;
gf1 = NULL;
- //gf2 = NULL;
+ // gf2 = NULL;
tuple1 = Tuple(a, b, c);
tuple2 = Tuple(c, d, a);
@@ -1991,12 +2065,12 @@ void Supplementary::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c,
flag1 = 0;
flag2 = 0;
- while (it1 != tuples.end()) {
- if (tuple1.get_hash() != it1->get_hash()) {
+ while(it1 != tuples.end()) {
+ if(tuple1.get_hash() != it1->get_hash()) {
break;
}
- if (tuple1.same_vertices(*it1)) {
+ if(tuple1.same_vertices(*it1)) {
flag1 = 1;
element1 = it1->get_element();
gf1 = it1->get_gf();
@@ -2005,21 +2079,21 @@ void Supplementary::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c,
it1++;
}
- while (it2 != tuples.end()) {
- if (tuple2.get_hash() != it2->get_hash()) {
+ while(it2 != tuples.end()) {
+ if(tuple2.get_hash() != it2->get_hash()) {
break;
}
- if (tuple2.same_vertices(*it2)) {
+ if(tuple2.same_vertices(*it2)) {
flag2 = 1;
element2 = it2->get_element();
- //gf2 = it2->get_gf();
+ // gf2 = it2->get_gf();
}
it2++;
}
- if (flag1 && flag2) {
+ if(flag1 && flag2) {
triangles.insert(element1);
triangles.insert(element2);
@@ -2035,12 +2109,12 @@ void Supplementary::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c,
flag1 = 0;
flag2 = 0;
- while (it1 != tuples.end()) {
- if (tuple1.get_hash() != it1->get_hash()) {
+ while(it1 != tuples.end()) {
+ if(tuple1.get_hash() != it1->get_hash()) {
break;
}
- if (tuple1.same_vertices(*it1)) {
+ if(tuple1.same_vertices(*it1)) {
flag1 = 1;
element1 = it1->get_element();
gf1 = it1->get_gf();
@@ -2049,21 +2123,21 @@ void Supplementary::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c,
it1++;
}
- while (it2 != tuples.end()) {
- if (tuple2.get_hash() != it2->get_hash()) {
+ while(it2 != tuples.end()) {
+ if(tuple2.get_hash() != it2->get_hash()) {
break;
}
- if (tuple2.same_vertices(*it2)) {
+ if(tuple2.same_vertices(*it2)) {
flag2 = 1;
element2 = it2->get_element();
- //gf2 = it2->get_gf();
+ // gf2 = it2->get_gf();
}
it2++;
}
- if (flag1 && flag2) {
+ if(flag1 && flag2) {
triangles.insert(element1);
triangles.insert(element2);
@@ -2071,27 +2145,40 @@ void Supplementary::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c,
}
}
-bool Supplementary::four(MElement* element) {
- if (element->getNumVertices() == 4) return 1;
- else return 0;
+bool Supplementary::four(MElement *element)
+{
+ if(element->getNumVertices() == 4)
+ return 1;
+ else
+ return 0;
}
-bool Supplementary::five(MElement* element) {
- if (element->getNumVertices() == 5) return 1;
- else return 0;
+bool Supplementary::five(MElement *element)
+{
+ if(element->getNumVertices() == 5)
+ return 1;
+ else
+ return 0;
}
-bool Supplementary::six(MElement* element) {
- if (element->getNumVertices() == 6) return 1;
- else return 0;
+bool Supplementary::six(MElement *element)
+{
+ if(element->getNumVertices() == 6)
+ return 1;
+ else
+ return 0;
}
-bool Supplementary::eight(MElement* element) {
- if (element->getNumVertices() == 8) return 1;
- else return 0;
+bool Supplementary::eight(MElement *element)
+{
+ if(element->getNumVertices() == 8)
+ return 1;
+ else
+ return 0;
}
-bool Supplementary::sliver(MElement* element, Prism prism) {
+bool Supplementary::sliver(MElement *element, Prism prism)
+{
bool val;
bool flag1, flag2, flag3, flag4;
MVertex *a, *b, *c, *d;
@@ -2102,28 +2189,41 @@ bool Supplementary::sliver(MElement* element, Prism prism) {
c = element->getVertex(2);
d = element->getVertex(3);
- flag1 = inclusion(a, prism.get_a(), prism.get_d(), prism.get_f(), prism.get_c());
- flag2 = inclusion(b, prism.get_a(), prism.get_d(), prism.get_f(), prism.get_c());
- flag3 = inclusion(c, prism.get_a(), prism.get_d(), prism.get_f(), prism.get_c());
- flag4 = inclusion(d, prism.get_a(), prism.get_d(), prism.get_f(), prism.get_c());
- if (flag1 && flag2 && flag3 && flag4) val = 1;
-
- flag1 = inclusion(a, prism.get_a(), prism.get_b(), prism.get_e(), prism.get_d());
- flag2 = inclusion(b, prism.get_a(), prism.get_b(), prism.get_e(), prism.get_d());
- flag3 = inclusion(c, prism.get_a(), prism.get_b(), prism.get_e(), prism.get_d());
- flag4 = inclusion(d, prism.get_a(), prism.get_b(), prism.get_e(), prism.get_d());
- if (flag1 && flag2 && flag3 && flag4) val = 1;
-
- flag1 = inclusion(a, prism.get_b(), prism.get_c(), prism.get_f(), prism.get_e());
- flag2 = inclusion(b, prism.get_b(), prism.get_c(), prism.get_f(), prism.get_e());
- flag3 = inclusion(c, prism.get_b(), prism.get_c(), prism.get_f(), prism.get_e());
- flag4 = inclusion(d, prism.get_b(), prism.get_c(), prism.get_f(), prism.get_e());
- if (flag1 && flag2 && flag3 && flag4) val = 1;
+ flag1 =
+ inclusion(a, prism.get_a(), prism.get_d(), prism.get_f(), prism.get_c());
+ flag2 =
+ inclusion(b, prism.get_a(), prism.get_d(), prism.get_f(), prism.get_c());
+ flag3 =
+ inclusion(c, prism.get_a(), prism.get_d(), prism.get_f(), prism.get_c());
+ flag4 =
+ inclusion(d, prism.get_a(), prism.get_d(), prism.get_f(), prism.get_c());
+ if(flag1 && flag2 && flag3 && flag4) val = 1;
+
+ flag1 =
+ inclusion(a, prism.get_a(), prism.get_b(), prism.get_e(), prism.get_d());
+ flag2 =
+ inclusion(b, prism.get_a(), prism.get_b(), prism.get_e(), prism.get_d());
+ flag3 =
+ inclusion(c, prism.get_a(), prism.get_b(), prism.get_e(), prism.get_d());
+ flag4 =
+ inclusion(d, prism.get_a(), prism.get_b(), prism.get_e(), prism.get_d());
+ if(flag1 && flag2 && flag3 && flag4) val = 1;
+
+ flag1 =
+ inclusion(a, prism.get_b(), prism.get_c(), prism.get_f(), prism.get_e());
+ flag2 =
+ inclusion(b, prism.get_b(), prism.get_c(), prism.get_f(), prism.get_e());
+ flag3 =
+ inclusion(c, prism.get_b(), prism.get_c(), prism.get_f(), prism.get_e());
+ flag4 =
+ inclusion(d, prism.get_b(), prism.get_c(), prism.get_f(), prism.get_e());
+ if(flag1 && flag2 && flag3 && flag4) val = 1;
return val;
}
-bool Supplementary::valid(Prism prism, const std::set<MElement*>& parts) {
+bool Supplementary::valid(Prism prism, const std::set<MElement *> &parts)
+{
bool ok1, ok2, ok3, ok4;
bool flag1A, flag1B, flag1C, flag1D;
bool flag2A, flag2B, flag2C, flag2D;
@@ -2161,7 +2261,7 @@ bool Supplementary::valid(Prism prism, const std::set<MElement*>& parts) {
flag5 = inclusion(d, e, f, parts);
ok4 = flag4 && flag5;
- if (ok1 && ok2 && ok3 && ok4) {
+ if(ok1 && ok2 && ok3 && ok4) {
return 1;
}
else {
@@ -2169,58 +2269,78 @@ bool Supplementary::valid(Prism prism, const std::set<MElement*>& parts) {
}
}
-
-// Need this awful terrible removed function from Recombinator for what is below ....
-bool validFace(MVertex *a, MVertex *b, MVertex *c, MVertex *d, std::map<MVertex*, std::set<MElement*> > &vertexToElements) {
- std::map<MVertex*, std::set<MElement*> >::iterator itElV[4];
- MVertex *faceV[4] = { a, b, c, d };
- for (int iV = 0; iV < 4; iV++) {
+// Need this awful terrible removed function from Recombinator for what is below
+// ....
+bool validFace(MVertex *a, MVertex *b, MVertex *c, MVertex *d,
+ std::map<MVertex *, std::set<MElement *> > &vertexToElements)
+{
+ std::map<MVertex *, std::set<MElement *> >::iterator itElV[4];
+ MVertex *faceV[4] = {a, b, c, d};
+ for(int iV = 0; iV < 4; iV++) {
itElV[iV] = vertexToElements.find(faceV[iV]);
}
- size_t tris[4][3] = { { 0, 1, 2 },{ 0, 2, 3 },{ 0, 1, 3 },{ 1, 2, 3 } };
- size_t other[4] = { 3, 1, 2, 0 };
+ size_t tris[4][3] = {{0, 1, 2}, {0, 2, 3}, {0, 1, 3}, {1, 2, 3}};
+ size_t other[4] = {3, 1, 2, 0};
size_t nbTris[4];
- std::set<MElement*> buf1, buf2;
- for (int iTri = 0; iTri < 4; iTri++) {
- //We count the number of elements sharing the considered triangle
+ std::set<MElement *> buf1, buf2;
+ for(int iTri = 0; iTri < 4; iTri++) {
+ // We count the number of elements sharing the considered triangle
buf1.clear();
- std::set_intersection(itElV[tris[iTri][0]]->second.begin(), itElV[tris[iTri][0]]->second.end(), itElV[tris[iTri][1]]->second.begin(), itElV[tris[iTri][1]]->second.end(), std::inserter(buf1, buf1.end()));
+ std::set_intersection(
+ itElV[tris[iTri][0]]->second.begin(), itElV[tris[iTri][0]]->second.end(),
+ itElV[tris[iTri][1]]->second.begin(), itElV[tris[iTri][1]]->second.end(),
+ std::inserter(buf1, buf1.end()));
buf2.clear();
- std::set_intersection(buf1.begin(), buf1.end(), itElV[tris[iTri][2]]->second.begin(), itElV[tris[iTri][2]]->second.end(), std::inserter(buf2, buf2.end()));
+ std::set_intersection(
+ buf1.begin(), buf1.end(), itElV[tris[iTri][2]]->second.begin(),
+ itElV[tris[iTri][2]]->second.end(), std::inserter(buf2, buf2.end()));
buf1.clear();
- std::set_difference(buf2.begin(), buf2.end(), itElV[other[iTri]]->second.begin(), itElV[other[iTri]]->second.end(), std::inserter(buf1, buf1.end()));
+ std::set_difference(
+ buf2.begin(), buf2.end(), itElV[other[iTri]]->second.begin(),
+ itElV[other[iTri]]->second.end(), std::inserter(buf1, buf1.end()));
nbTris[iTri] = buf1.size();
}
bool valid = false;
// All sub-faces inside (2 elements)
- if (nbTris[0] == 2 && nbTris[1] == 2 && nbTris[2] == 0 && nbTris[3] == 0) valid = true;
- else if (nbTris[0] == 0 && nbTris[1] == 0 && nbTris[2] == 2 && nbTris[3] == 2) valid = true;
+ if(nbTris[0] == 2 && nbTris[1] == 2 && nbTris[2] == 0 && nbTris[3] == 0)
+ valid = true;
+ else if(nbTris[0] == 0 && nbTris[1] == 0 && nbTris[2] == 2 && nbTris[3] == 2)
+ valid = true;
// All sub-faces on the surface or facing a quad face (1 element)
- else if (nbTris[0] == 1 && nbTris[1] == 1 && nbTris[2] == 0 && nbTris[3] == 0) valid = true;
- else if (nbTris[0] == 0 && nbTris[1] == 0 && nbTris[2] == 1 && nbTris[3] == 1) valid = true;
- // Face is made of triangles on each side but they are nonconforming (OK for recombination, but why do these exist??)
- else if (nbTris[0] == 1 && nbTris[1] == 1 && nbTris[2] == 1 && nbTris[3] == 1) valid = true;
-
- //Geometry: A face with 4 nodes on the boundary should be close enough to planar
+ else if(nbTris[0] == 1 && nbTris[1] == 1 && nbTris[2] == 0 && nbTris[3] == 0)
+ valid = true;
+ else if(nbTris[0] == 0 && nbTris[1] == 0 && nbTris[2] == 1 && nbTris[3] == 1)
+ valid = true;
+ // Face is made of triangles on each side but they are nonconforming (OK for
+ // recombination, but why do these exist??)
+ else if(nbTris[0] == 1 && nbTris[1] == 1 && nbTris[2] == 1 && nbTris[3] == 1)
+ valid = true;
+
+ // Geometry: A face with 4 nodes on the boundary should be close enough to
+ // planar
int nbBndNodes = 0;
- if (a->onWhat()->dim() < 3) nbBndNodes++;
- if (b->onWhat()->dim() < 3) nbBndNodes++;
- if (c->onWhat()->dim() < 3) nbBndNodes++;
- if (d->onWhat()->dim() < 3) nbBndNodes++;
- if (nbBndNodes == 4) {
- SVector3 vec1 = SVector3(b->x() - a->x(), b->y() - a->y(), b->z() - a->z()).unit();
- SVector3 vec2 = SVector3(c->x() - a->x(), c->y() - a->y(), c->z() - a->z()).unit();
- SVector3 vec3 = SVector3(d->x() - a->x(), d->y() - a->y(), d->z() - a->z()).unit();
+ if(a->onWhat()->dim() < 3) nbBndNodes++;
+ if(b->onWhat()->dim() < 3) nbBndNodes++;
+ if(c->onWhat()->dim() < 3) nbBndNodes++;
+ if(d->onWhat()->dim() < 3) nbBndNodes++;
+ if(nbBndNodes == 4) {
+ SVector3 vec1 =
+ SVector3(b->x() - a->x(), b->y() - a->y(), b->z() - a->z()).unit();
+ SVector3 vec2 =
+ SVector3(c->x() - a->x(), c->y() - a->y(), c->z() - a->z()).unit();
+ SVector3 vec3 =
+ SVector3(d->x() - a->x(), d->y() - a->y(), d->z() - a->z()).unit();
SVector3 crossVec1Vec2 = crossprod(vec1, vec2);
double angle = fabs(acos(dot(crossVec1Vec2, vec3)) * 180 / M_PI);
double maxAngle = 15;
- if (fabs(angle - 90) > maxAngle) valid = false;
+ if(fabs(angle - 90) > maxAngle) valid = false;
}
return valid;
}
-bool validFaces(Prism &prism, Vertex2Elements &vertexToElements) {
+bool validFaces(Prism &prism, Vertex2Elements &vertexToElements)
+{
bool v1, v2, v3;
MVertex *a, *b, *c;
MVertex *d, *e, *f;
@@ -2232,16 +2352,15 @@ bool validFaces(Prism &prism, Vertex2Elements &vertexToElements) {
e = prism.get_e();
f = prism.get_f();
- v1 = validFace(a, d, f, c, vertexToElements); //SHOULD CHECK GEOMETRY
+ v1 = validFace(a, d, f, c, vertexToElements); // SHOULD CHECK GEOMETRY
v2 = validFace(a, d, e, b, vertexToElements);
v3 = validFace(b, c, f, e, vertexToElements);
return v1 && v2 && v3;
}
-
-
-bool Supplementary::valid(Prism prism) {
+bool Supplementary::valid(Prism prism)
+{
double k;
double eta1, eta2, eta3;
MVertex *a, *b, *c;
@@ -2260,7 +2379,7 @@ bool Supplementary::valid(Prism prism) {
eta2 = eta(a, b, e, d);
eta3 = eta(b, c, f, e);
- if (eta1 > k && eta2 > k && eta3 > k) {
+ if(eta1 > k && eta2 > k && eta3 > k) {
return validFaces(prism, vertex_to_tetrahedra);
}
else {
@@ -2268,9 +2387,10 @@ bool Supplementary::valid(Prism prism) {
}
}
-double Supplementary::eta(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+double Supplementary::eta(MVertex *a, MVertex *b, MVertex *c, MVertex *d)
+{
double val;
- MQuadrangle* quad;
+ MQuadrangle *quad;
quad = new MQuadrangle(a, b, c, d);
val = quad->etaShapeMeasure();
@@ -2278,7 +2398,8 @@ double Supplementary::eta(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
return val;
}
-bool Supplementary::linked(MVertex* v1, MVertex* v2) {
+bool Supplementary::linked(MVertex *v1, MVertex *v2)
+{
bool flag;
Vertex2Vertices::iterator it;
vertex_set_itr it2;
@@ -2286,9 +2407,9 @@ bool Supplementary::linked(MVertex* v1, MVertex* v2) {
it = vertex_to_vertices.find(v1);
flag = 0;
- if (it != vertex_to_vertices.end()) {
- for (it2 = (it->second).begin(); it2 != (it->second).end(); it2++) {
- if (*it2 == v2) {
+ if(it != vertex_to_vertices.end()) {
+ for(it2 = (it->second).begin(); it2 != (it->second).end(); it2++) {
+ if(*it2 == v2) {
flag = 1;
break;
}
@@ -2298,14 +2419,17 @@ bool Supplementary::linked(MVertex* v1, MVertex* v2) {
return flag;
}
-void Supplementary::find(MVertex* v1, MVertex* v2, const std::vector<MVertex*>& already, std::set<MVertex*>& final) {
+void Supplementary::find(MVertex *v1, MVertex *v2,
+ const std::vector<MVertex *> &already,
+ std::set<MVertex *> &final)
+{
Vertex2Vertices::iterator it1;
Vertex2Vertices::iterator it2;
it1 = vertex_to_vertices.find(v1);
it2 = vertex_to_vertices.find(v2);
- if (it1 != vertex_to_vertices.end() && it2 != vertex_to_vertices.end()) {
+ if(it1 != vertex_to_vertices.end() && it2 != vertex_to_vertices.end()) {
intersection(it1->second, it2->second, already, final);
}
}
@@ -2320,8 +2444,8 @@ void Supplementary::find(MVertex *getVertex, const Prism &prism,
it = vertex_to_tetrahedra.find(getVertex);
- if (it != vertex_to_tetrahedra.end()) {
- for (it2 = (it->second).begin(); it2 != (it->second).end(); it2++) {
+ if(it != vertex_to_tetrahedra.end()) {
+ for(it2 = (it->second).begin(); it2 != (it->second).end(); it2++) {
a = (*it2)->getVertex(0);
b = (*it2)->getVertex(1);
c = (*it2)->getVertex(2);
@@ -2332,76 +2456,95 @@ void Supplementary::find(MVertex *getVertex, const Prism &prism,
flag3 = inclusion(c, prism);
flag4 = inclusion(d, prism);
- if (flag1 && flag2 && flag3 && flag4) {
+ if(flag1 && flag2 && flag3 && flag4) {
final.insert(*it2);
}
}
}
}
-void Supplementary::intersection(const std::set<MVertex*>& bin1, const std::set<MVertex*>& bin2,
- const std::vector<MVertex*>& already, std::set<MVertex*>& final) {
+void Supplementary::intersection(const std::set<MVertex *> &bin1,
+ const std::set<MVertex *> &bin2,
+ const std::vector<MVertex *> &already,
+ std::set<MVertex *> &final)
+{
size_t i;
bool ok;
- std::set<MVertex*> temp;
+ std::set<MVertex *> temp;
vertex_set_itr it;
- std::set_intersection(bin1.begin(), bin1.end(), bin2.begin(), bin2.end(), std::inserter(temp, temp.end()));
+ std::set_intersection(bin1.begin(), bin1.end(), bin2.begin(), bin2.end(),
+ std::inserter(temp, temp.end()));
- for (it = temp.begin(); it != temp.end(); it++) {
+ for(it = temp.begin(); it != temp.end(); it++) {
ok = 1;
- for (i = 0; i < already.size(); i++) {
- if ((*it) == already[i]) {
+ for(i = 0; i < already.size(); i++) {
+ if((*it) == already[i]) {
ok = 0;
break;
}
}
- if (ok) {
+ if(ok) {
final.insert(*it);
}
}
}
-bool Supplementary::inclusion(MVertex* getVertex, Prism prism) {
+bool Supplementary::inclusion(MVertex *getVertex, Prism prism)
+{
bool flag;
flag = 0;
- if (getVertex == prism.get_a()) flag = 1;
- else if (getVertex == prism.get_b()) flag = 1;
- else if (getVertex == prism.get_c()) flag = 1;
- else if (getVertex == prism.get_d()) flag = 1;
- else if (getVertex == prism.get_e()) flag = 1;
- else if (getVertex == prism.get_f()) flag = 1;
+ if(getVertex == prism.get_a())
+ flag = 1;
+ else if(getVertex == prism.get_b())
+ flag = 1;
+ else if(getVertex == prism.get_c())
+ flag = 1;
+ else if(getVertex == prism.get_d())
+ flag = 1;
+ else if(getVertex == prism.get_e())
+ flag = 1;
+ else if(getVertex == prism.get_f())
+ flag = 1;
return flag;
}
-bool Supplementary::inclusion(MVertex* getVertex, MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+bool Supplementary::inclusion(MVertex *getVertex, MVertex *a, MVertex *b,
+ MVertex *c, MVertex *d)
+{
bool flag;
flag = 0;
- if (getVertex == a) flag = 1;
- else if (getVertex == b) flag = 1;
- else if (getVertex == c) flag = 1;
- else if (getVertex == d) flag = 1;
+ if(getVertex == a)
+ flag = 1;
+ else if(getVertex == b)
+ flag = 1;
+ else if(getVertex == c)
+ flag = 1;
+ else if(getVertex == d)
+ flag = 1;
return flag;
}
-bool Supplementary::inclusion(MVertex* v1, MVertex* v2, MVertex* v3, const std::set<MElement*>& bin) {
+bool Supplementary::inclusion(MVertex *v1, MVertex *v2, MVertex *v3,
+ const std::set<MElement *> &bin)
+{
bool ok;
bool flag1, flag2, flag3;
MVertex *a, *b, *c, *d;
- MElement* element;
- std::set<MElement*>::const_iterator it;
+ MElement *element;
+ std::set<MElement *>::const_iterator it;
ok = 0;
- for (it = bin.begin(); it != bin.end(); it++) {
+ for(it = bin.begin(); it != bin.end(); it++) {
element = *it;
a = element->getVertex(0);
@@ -2413,7 +2556,7 @@ bool Supplementary::inclusion(MVertex* v1, MVertex* v2, MVertex* v3, const std::
flag2 = inclusion(v2, a, b, c, d);
flag3 = inclusion(v3, a, b, c, d);
- if (flag1 && flag2 && flag3) {
+ if(flag1 && flag2 && flag3) {
ok = 1;
break;
}
@@ -2430,12 +2573,12 @@ bool Supplementary::inclusion(const Facet &facet)
it = hash_tableA.find(facet);
flag = 0;
- while (it != hash_tableA.end()) {
- if (facet.get_hash() != it->get_hash()) {
+ while(it != hash_tableA.end()) {
+ if(facet.get_hash() != it->get_hash()) {
break;
}
- if (facet.same_vertices(*it)) {
+ if(facet.same_vertices(*it)) {
flag = 1;
break;
}
@@ -2454,12 +2597,12 @@ bool Supplementary::inclusion(const Diagonal &diagonal)
it = hash_tableB.find(diagonal);
flag = 0;
- while (it != hash_tableB.end()) {
- if (diagonal.get_hash() != it->get_hash()) {
+ while(it != hash_tableB.end()) {
+ if(diagonal.get_hash() != it->get_hash()) {
break;
}
- if (diagonal.same_vertices(*it)) {
+ if(diagonal.same_vertices(*it)) {
flag = 1;
break;
}
@@ -2478,12 +2621,12 @@ bool Supplementary::duplicate(const Diagonal &diagonal)
it = hash_tableC.find(diagonal);
flag = 0;
- while (it != hash_tableC.end()) {
- if (diagonal.get_hash() != it->get_hash()) {
+ while(it != hash_tableC.end()) {
+ if(diagonal.get_hash() != it->get_hash()) {
break;
}
- if (diagonal.same_vertices(*it)) {
+ if(diagonal.same_vertices(*it)) {
flag = 1;
break;
}
@@ -2494,7 +2637,8 @@ bool Supplementary::duplicate(const Diagonal &diagonal)
return flag;
}
-bool Supplementary::conformityA(Prism prism) {
+bool Supplementary::conformityA(Prism prism)
+{
bool c1, c2, c3;
MVertex *a, *b, *c;
MVertex *d, *e, *f;
@@ -2513,7 +2657,8 @@ bool Supplementary::conformityA(Prism prism) {
return c1 && c2 && c3;
}
-bool Supplementary::conformityA(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+bool Supplementary::conformityA(MVertex *a, MVertex *b, MVertex *c, MVertex *d)
+{
bool c1, c2, c3, c4;
c1 = inclusion(Facet(a, b, c));
@@ -2524,7 +2669,8 @@ bool Supplementary::conformityA(MVertex* a, MVertex* b, MVertex* c, MVertex* d)
return (c1 && c2 && c3 && c4) || (!c1 && !c2 && !c3 && !c4);
}
-bool Supplementary::conformityB(Prism prism) {
+bool Supplementary::conformityB(Prism prism)
+{
bool flag1;
bool flag2;
bool c1, c2, c3;
@@ -2559,7 +2705,7 @@ bool Supplementary::conformityB(Prism prism) {
c6 = inclusion(Diagonal(c, e));
flag2 = flag2 || (c5 && !c6) || (!c5 && c6);
- if (flag1 || flag2) {
+ if(flag1 || flag2) {
return 0;
}
else {
@@ -2567,7 +2713,8 @@ bool Supplementary::conformityB(Prism prism) {
}
}
-bool Supplementary::conformityC(Prism prism) {
+bool Supplementary::conformityC(Prism prism)
+{
bool flag;
MVertex *a, *b, *c;
MVertex *d, *e, *f;
@@ -2586,7 +2733,7 @@ bool Supplementary::conformityC(Prism prism) {
flag = flag || duplicate(Diagonal(b, f));
flag = flag || duplicate(Diagonal(c, e));
- if (flag) {
+ if(flag) {
return 0;
}
else {
@@ -2594,7 +2741,8 @@ bool Supplementary::conformityC(Prism prism) {
}
}
-bool Supplementary::faces_statuquo(Prism prism) {
+bool Supplementary::faces_statuquo(Prism prism)
+{
bool c1, c2, c3;
MVertex *a, *b, *c;
MVertex *d, *e, *f;
@@ -2613,8 +2761,9 @@ bool Supplementary::faces_statuquo(Prism prism) {
return c1 && c2 && c3;
}
-bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
-
+bool Supplementary::faces_statuquo(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
bool flag1, flag2;
GFace *gf1, *gf2;
std::multiset<Tuple>::iterator it1;
@@ -2634,12 +2783,12 @@ bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex*
flag1 = 0;
flag2 = 0;
- while (it1 != tuples.end()) {
- if (tuple1.get_hash() != it1->get_hash()) {
+ while(it1 != tuples.end()) {
+ if(tuple1.get_hash() != it1->get_hash()) {
break;
}
- if (tuple1.same_vertices(*it1)) {
+ if(tuple1.same_vertices(*it1)) {
flag1 = 1;
gf1 = it1->get_gf();
}
@@ -2647,12 +2796,12 @@ bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex*
it1++;
}
- while (it2 != tuples.end()) {
- if (tuple2.get_hash() != it2->get_hash()) {
+ while(it2 != tuples.end()) {
+ if(tuple2.get_hash() != it2->get_hash()) {
break;
}
- if (tuple2.same_vertices(*it2)) {
+ if(tuple2.same_vertices(*it2)) {
flag2 = 1;
gf2 = it2->get_gf();
}
@@ -2660,8 +2809,8 @@ bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex*
it2++;
}
- if (flag1 && flag2) {
- if (gf1 != gf2) {
+ if(flag1 && flag2) {
+ if(gf1 != gf2) {
ok = 0;
}
}
@@ -2675,12 +2824,12 @@ bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex*
flag1 = 0;
flag2 = 0;
- while (it1 != tuples.end()) {
- if (tuple1.get_hash() != it1->get_hash()) {
+ while(it1 != tuples.end()) {
+ if(tuple1.get_hash() != it1->get_hash()) {
break;
}
- if (tuple1.same_vertices(*it1)) {
+ if(tuple1.same_vertices(*it1)) {
flag1 = 1;
gf1 = it1->get_gf();
}
@@ -2688,12 +2837,12 @@ bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex*
it1++;
}
- while (it2 != tuples.end()) {
- if (tuple2.get_hash() != it2->get_hash()) {
+ while(it2 != tuples.end()) {
+ if(tuple2.get_hash() != it2->get_hash()) {
break;
}
- if (tuple2.same_vertices(*it2)) {
+ if(tuple2.same_vertices(*it2)) {
flag2 = 1;
gf2 = it2->get_gf();
}
@@ -2701,8 +2850,8 @@ bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex*
it2++;
}
- if (flag1 && flag2) {
- if (gf1 != gf2) {
+ if(flag1 && flag2) {
+ if(gf1 != gf2) {
ok = 0;
}
}
@@ -2710,22 +2859,22 @@ bool Supplementary::faces_statuquo(MVertex* a, MVertex* b, MVertex* c, MVertex*
return ok;
}
-void Supplementary::build_vertex_to_vertices(GRegion* gr) {
-
- std::set<MVertex*> bin;
+void Supplementary::build_vertex_to_vertices(GRegion *gr)
+{
+ std::set<MVertex *> bin;
vertex_to_vertices.clear();
- for (GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
- MElement* element = gr->getMeshElement(i);
- if (four(element)) {
- for (std::size_t j = 0; j < element->getNumVertices(); j++) {
+ for(GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *element = gr->getMeshElement(i);
+ if(four(element)) {
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
MVertex *a = element->getVertex(j);
MVertex *b = element->getVertex((j + 1) % 4);
MVertex *c = element->getVertex((j + 2) % 4);
MVertex *d = element->getVertex((j + 3) % 4);
Vertex2Vertices::iterator it = vertex_to_vertices.find(a);
- if (it != vertex_to_vertices.end()) {
+ if(it != vertex_to_vertices.end()) {
it->second.insert(b);
it->second.insert(c);
it->second.insert(d);
@@ -2735,39 +2884,42 @@ void Supplementary::build_vertex_to_vertices(GRegion* gr) {
bin.insert(b);
bin.insert(c);
bin.insert(d);
- vertex_to_vertices.insert(std::pair<MVertex*, std::set<MVertex*> >(a, bin));
+ vertex_to_vertices.insert(
+ std::pair<MVertex *, std::set<MVertex *> >(a, bin));
}
}
}
}
}
-void Supplementary::build_vertex_to_tetrahedra(GRegion* gr) {
-
- std::set<MElement*> bin;
+void Supplementary::build_vertex_to_tetrahedra(GRegion *gr)
+{
+ std::set<MElement *> bin;
vertex_to_tetrahedra.clear();
- for (GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
- MElement* element = gr->getMeshElement(i);
- if (four(element)) {
- for (std::size_t j = 0; j < element->getNumVertices(); j++) {
- MVertex* getVertex = element->getVertex(j);
+ for(GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *element = gr->getMeshElement(i);
+ if(four(element)) {
+ for(std::size_t j = 0; j < element->getNumVertices(); j++) {
+ MVertex *getVertex = element->getVertex(j);
Vertex2Elements::iterator it = vertex_to_tetrahedra.find(getVertex);
- if (it != vertex_to_tetrahedra.end()) {
+ if(it != vertex_to_tetrahedra.end()) {
it->second.insert(element);
}
else {
bin.clear();
bin.insert(element);
- vertex_to_tetrahedra.insert(std::pair<MVertex*, std::set<MElement*> >(getVertex, bin));
+ vertex_to_tetrahedra.insert(
+ std::pair<MVertex *, std::set<MElement *> >(getVertex, bin));
}
}
}
}
}
-void Supplementary::build_hash_tableA(Prism prism) {
+void Supplementary::build_hash_tableA(Prism prism)
+{
MVertex *a, *b, *c;
MVertex *d, *e, *f;
@@ -2783,7 +2935,9 @@ void Supplementary::build_hash_tableA(Prism prism) {
build_hash_tableA(b, c, f, e);
}
-void Supplementary::build_hash_tableA(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+void Supplementary::build_hash_tableA(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
build_hash_tableA(Facet(a, b, c));
build_hash_tableA(Facet(a, c, d));
build_hash_tableA(Facet(a, b, d));
@@ -2798,12 +2952,12 @@ void Supplementary::build_hash_tableA(const Facet &facet)
it = hash_tableA.find(facet);
flag = 1;
- while (it != hash_tableA.end()) {
- if (facet.get_hash() != it->get_hash()) {
+ while(it != hash_tableA.end()) {
+ if(facet.get_hash() != it->get_hash()) {
break;
}
- if (facet.same_vertices(*it)) {
+ if(facet.same_vertices(*it)) {
flag = 0;
break;
}
@@ -2811,12 +2965,13 @@ void Supplementary::build_hash_tableA(const Facet &facet)
it++;
}
- if (flag) {
+ if(flag) {
hash_tableA.insert(facet);
}
}
-void Supplementary::build_hash_tableB(Prism prism) {
+void Supplementary::build_hash_tableB(Prism prism)
+{
MVertex *a, *b, *c;
MVertex *d, *e, *f;
@@ -2832,7 +2987,9 @@ void Supplementary::build_hash_tableB(Prism prism) {
build_hash_tableB(b, e, f, c);
}
-void Supplementary::build_hash_tableB(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+void Supplementary::build_hash_tableB(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
build_hash_tableB(Diagonal(a, c));
build_hash_tableB(Diagonal(b, d));
}
@@ -2845,12 +3002,12 @@ void Supplementary::build_hash_tableB(const Diagonal &diagonal)
it = hash_tableB.find(diagonal);
flag = 1;
- while (it != hash_tableB.end()) {
- if (diagonal.get_hash() != it->get_hash()) {
+ while(it != hash_tableB.end()) {
+ if(diagonal.get_hash() != it->get_hash()) {
break;
}
- if (diagonal.same_vertices(*it)) {
+ if(diagonal.same_vertices(*it)) {
flag = 0;
break;
}
@@ -2858,12 +3015,13 @@ void Supplementary::build_hash_tableB(const Diagonal &diagonal)
it++;
}
- if (flag) {
+ if(flag) {
hash_tableB.insert(diagonal);
}
}
-void Supplementary::build_hash_tableC(Prism prism) {
+void Supplementary::build_hash_tableC(Prism prism)
+{
MVertex *a, *b, *c;
MVertex *d, *e, *f;
@@ -2893,12 +3051,12 @@ void Supplementary::build_hash_tableC(const Diagonal &diagonal)
it = hash_tableC.find(diagonal);
flag = 1;
- while (it != hash_tableC.end()) {
- if (diagonal.get_hash() != it->get_hash()) {
+ while(it != hash_tableC.end()) {
+ if(diagonal.get_hash() != it->get_hash()) {
break;
}
- if (diagonal.same_vertices(*it)) {
+ if(diagonal.same_vertices(*it)) {
flag = 0;
break;
}
@@ -2906,12 +3064,14 @@ void Supplementary::build_hash_tableC(const Diagonal &diagonal)
it++;
}
- if (flag) {
+ if(flag) {
hash_tableC.insert(diagonal);
}
}
-double Supplementary::scaled_jacobian(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+double Supplementary::scaled_jacobian(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
double val;
double l1, l2, l3, l4;
SVector3 vec1, vec2, vec3, vec4;
@@ -2928,10 +3088,12 @@ double Supplementary::scaled_jacobian(MVertex* a, MVertex* b, MVertex* c, MVerte
l4 = vec4.norm();
val = dot(vec1, crossprod(vec2, vec3));
- return val * (1 / (l1*l2*l3) + 1 / (l1*l4*l3) + 1 / (l2*l4*l3)) / 3 * coeff;
+ return val * (1 / (l1 * l2 * l3) + 1 / (l1 * l4 * l3) + 1 / (l2 * l4 * l3)) /
+ 3 * coeff;
}
-double Supplementary::min_scaled_jacobian(Prism prism) {
+double Supplementary::min_scaled_jacobian(Prism prism)
+{
int i;
double min, max;
double j1, j2, j3, j4, j5, j6;
@@ -2962,11 +3124,11 @@ double Supplementary::min_scaled_jacobian(Prism prism) {
min = 1000000000.0;
max = -1000000000.0;
- for (i = 0; i < 6; i++) {
+ for(i = 0; i < 6; i++) {
min = std::min(min, jacobians[i]);
max = std::max(max, jacobians[i]);
}
- if (max < 0) min = -max;
+ if(max < 0) min = -max;
/*MPrism *p1 = new MPrism(a, b, c, d, e, f);
MPrism *p2 = new MPrism(d, e, f, a, b, c);
@@ -2977,12 +3139,11 @@ double Supplementary::min_scaled_jacobian(Prism prism) {
}
file << min << " " << min1 << " " << min2 << std::endl;
delete p1;
- delete p2;*/ //fordebug
+ delete p2;*/ // fordebug
return min;
}
-
/********************************************/
/****************class PostOp****************/
/********************************************/
@@ -2991,36 +3152,37 @@ PostOp::PostOp() {}
PostOp::~PostOp() {}
-void PostOp::execute(int level, int conformity) {
- GRegion* gr;
- GModel* model = GModel::current();
+void PostOp::execute(int level, int conformity)
+{
+ GRegion *gr;
+ GModel *model = GModel::current();
GModel::riter it;
- for (it = model->firstRegion(); it != model->lastRegion(); it++)
- {
+ for(it = model->firstRegion(); it != model->lastRegion(); it++) {
gr = *it;
- if (gr->getNumMeshElements() > 0) {
+ if(gr->getNumMeshElements() > 0) {
execute(gr, level, conformity);
}
}
}
-void PostOp::executeNew(GRegion* gr)
+void PostOp::executeNew(GRegion *gr)
{
printf("..............PYRAMIDS NEW................\n");
build_vertex_to_tetrahedra(gr);
build_vertex_to_hexPrism(gr);
- std::set<MElement*> tetrahedra;
- tetrahedra.insert(&(gr->tetrahedra[0]), &(gr->tetrahedra[0]) + gr->tetrahedra.size());
+ std::set<MElement *> tetrahedra;
+ tetrahedra.insert(&(gr->tetrahedra[0]),
+ &(gr->tetrahedra[0]) + gr->tetrahedra.size());
std::set<Facet> boundaryTriangles;
std::set<Facet> pendingTriangles;
- std::vector<MElement*> mesh;
+ std::vector<MElement *> mesh;
int n = 0;
- while (tetrahedra.size()) {
+ while(tetrahedra.size()) {
MElement *t = *tetrahedra.begin();
MVertex *a = t->getVertex(0);
@@ -3038,24 +3200,24 @@ void PostOp::executeNew(GRegion* gr)
mesh.clear();
tetrahedra.erase(t);
- while (pendingTriangles.size()) {
+ while(pendingTriangles.size()) {
Facet f = *pendingTriangles.begin();
- std::set<MElement*> potential;
+ std::set<MElement *> potential;
find_tetrahedra(f.get_a(), f.get_b(), f.get_c(), potential);
element_set_itr it = potential.begin();
- while (it != potential.end()) {
- if (tetrahedra.find(*it) == tetrahedra.end())
+ while(it != potential.end()) {
+ if(tetrahedra.find(*it) == tetrahedra.end())
potential.erase(it++);
else
++it;
}
- if (potential.size() > 1) {
+ if(potential.size() > 1) {
Msg::Error("I didn't expect that. Aaaah, don't know what I should do");
}
- else if (potential.size() == 1) {
+ else if(potential.size() == 1) {
MElement *t = *potential.begin();
MVertex *a = t->getVertex(0);
@@ -3085,20 +3247,19 @@ void PostOp::executeNew(GRegion* gr)
mesh.clear();
pendingTriangles = boundaryTriangles;
- while (pendingTriangles.size()) {
+ while(pendingTriangles.size()) {
Facet f = *pendingTriangles.begin();
MFace quad = find_quadFace(f.get_a(), f.get_b(), f.get_c());
- if (!quad.getNumVertices()) {
+ if(!quad.getNumVertices()) {
mesh.push_back(new MTriangle(f.get_a(), f.get_b(), f.get_c()));
pendingTriangles.erase(f);
}
else {
- //TODO erase other pending triangle
- mesh.push_back(new MQuadrangle(quad.getVertex(0),
- quad.getVertex(1),
- quad.getVertex(2),
- quad.getVertex(3)));
- Facet f = Facet(quad.getVertex(0), quad.getVertex(1), quad.getVertex(2));
+ // TODO erase other pending triangle
+ mesh.push_back(new MQuadrangle(quad.getVertex(0), quad.getVertex(1),
+ quad.getVertex(2), quad.getVertex(3)));
+ Facet f =
+ Facet(quad.getVertex(0), quad.getVertex(1), quad.getVertex(2));
pendingTriangles.erase(f);
f = Facet(quad.getVertex(1), quad.getVertex(2), quad.getVertex(3));
pendingTriangles.erase(f);
@@ -3117,10 +3278,11 @@ void PostOp::executeNew(GRegion* gr)
}
}
-void PostOp::removeElseAdd(std::set<Facet> &set, MVertex *a, MVertex *b, MVertex *c)
+void PostOp::removeElseAdd(std::set<Facet> &set, MVertex *a, MVertex *b,
+ MVertex *c)
{
Facet f = Facet(a, b, c);
- if (set.find(f) != set.end()) {
+ if(set.find(f) != set.end()) {
set.erase(f);
}
else {
@@ -3128,11 +3290,11 @@ void PostOp::removeElseAdd(std::set<Facet> &set, MVertex *a, MVertex *b, MVertex
}
}
-void PostOp::writeMSH(const char *filename, std::vector<MElement*> &elements)
+void PostOp::writeMSH(const char *filename, std::vector<MElement *> &elements)
{
- std::set<MVertex*> vertices;
- for (std::size_t i = 0; i < elements.size(); ++i) {
- for (std::size_t k = 0; k < elements[i]->getNumVertices(); ++k)
+ std::set<MVertex *> vertices;
+ for(std::size_t i = 0; i < elements.size(); ++i) {
+ for(std::size_t k = 0; k < elements[i]->getNumVertices(); ++k)
vertices.insert(elements[i]->getVertex(k));
}
@@ -3146,17 +3308,18 @@ void PostOp::writeMSH(const char *filename, std::vector<MElement*> &elements)
fprintf(f, "%d\n", (int)vertices.size());
vertex_set_itr it;
int n = 0;
- for (it = vertices.begin(); it != vertices.end(); ++it) {
- fprintf(f, "%d %22.15E %22.15E %22.15E\n", ++n, (*it)->x(), (*it)->y(), (*it)->z());
+ for(it = vertices.begin(); it != vertices.end(); ++it) {
+ fprintf(f, "%d %22.15E %22.15E %22.15E\n", ++n, (*it)->x(), (*it)->y(),
+ (*it)->z());
(*it)->setIndex(n);
}
fprintf(f, "$EndNodes\n");
fprintf(f, "$Elements\n");
fprintf(f, "%d\n", (int)elements.size());
- for (std::size_t i = 0; i < elements.size(); ++i) {
+ for(std::size_t i = 0; i < elements.size(); ++i) {
fprintf(f, "%d %d 0", elements[i]->getNum(), elements[i]->getTypeForMSH());
- for (std::size_t k = 0; k < elements[i]->getNumVertices(); ++k)
+ for(std::size_t k = 0; k < elements[i]->getNumVertices(); ++k)
fprintf(f, " %d", elements[i]->getVertex(k)->getIndex());
fprintf(f, "\n");
}
@@ -3165,7 +3328,7 @@ void PostOp::writeMSH(const char *filename, std::vector<MElement*> &elements)
fclose(f);
}
-MFace PostOp::find_quadFace(MVertex* v1, MVertex* v2, MVertex* v3)
+MFace PostOp::find_quadFace(MVertex *v1, MVertex *v2, MVertex *v3)
{
Vertex2Elements::iterator it1;
Vertex2Elements::iterator it2;
@@ -3175,32 +3338,33 @@ MFace PostOp::find_quadFace(MVertex* v1, MVertex* v2, MVertex* v3)
it2 = vertex_to_hexPrism.find(v2);
it3 = vertex_to_hexPrism.find(v3);
- std::set<MElement*> buf, final;
+ std::set<MElement *> buf, final;
- if (it1 != vertex_to_tetrahedra.end() && it2 != vertex_to_tetrahedra.end() && it3 != vertex_to_tetrahedra.end()) {
+ if(it1 != vertex_to_tetrahedra.end() && it2 != vertex_to_tetrahedra.end() &&
+ it3 != vertex_to_tetrahedra.end()) {
intersection(it1->second, it2->second, buf);
intersection(buf, it3->second, final);
}
- if (final.size() > 1) Msg::Error("This shouldn't happen ...");
+ if(final.size() > 1) Msg::Error("This shouldn't happen ...");
element_set_itr it;
- for (it = final.begin(); it != final.end(); ++it) {
+ for(it = final.begin(); it != final.end(); ++it) {
MElement *el = *it;
- if (el->getType() == TYPE_PRI) {
- for (int i = 2; i < 5; ++i) {
+ if(el->getType() == TYPE_PRI) {
+ for(int i = 2; i < 5; ++i) {
MFace f = el->getFace(i);
matchQuadFace(f, v1, v2, v3);
- if (f.getNumVertices()) {
+ if(f.getNumVertices()) {
return f;
}
}
}
- else if (el->getType() == TYPE_HEX) {
- for (int i = 0; i < 6; ++i) {
+ else if(el->getType() == TYPE_HEX) {
+ for(int i = 0; i < 6; ++i) {
MFace f = el->getFace(i);
matchQuadFace(f, v1, v2, v3);
- if (f.getNumVertices()) {
+ if(f.getNumVertices()) {
return f;
}
}
@@ -3209,55 +3373,53 @@ MFace PostOp::find_quadFace(MVertex* v1, MVertex* v2, MVertex* v3)
return MFace();
}
-MVertex* PostOp::otherVertexQuadFace(MFace &f, MVertex* v1, MVertex* v2, MVertex* v3)
+MVertex *PostOp::otherVertexQuadFace(MFace &f, MVertex *v1, MVertex *v2,
+ MVertex *v3)
{
int n = 0;
MVertex *v = 0;
- for (int i = 0; i < 4; ++i) {
- if (f.getVertex(i) != v1 &&
- f.getVertex(i) != v2 &&
- f.getVertex(i) != v3) {
+ for(int i = 0; i < 4; ++i) {
+ if(f.getVertex(i) != v1 && f.getVertex(i) != v2 && f.getVertex(i) != v3) {
++n;
v = f.getVertex(i);
}
}
- if (n == 1) return v;
+ if(n == 1) return v;
return NULL;
}
-void PostOp::matchQuadFace(MFace &f, MVertex* v1, MVertex* v2, MVertex* v3)
+void PostOp::matchQuadFace(MFace &f, MVertex *v1, MVertex *v2, MVertex *v3)
{
- MVertex* vertices[3] = { v1, v2, v3 };
+ MVertex *vertices[3] = {v1, v2, v3};
int n = 0, ind = -1;
- //MVertex *v;
- for (int i = 0; i < 4; ++i) {
- if (f.getVertex(i) != v1 &&
- f.getVertex(i) != v2 &&
- f.getVertex(i) != v3) {
+ // MVertex *v;
+ for(int i = 0; i < 4; ++i) {
+ if(f.getVertex(i) != v1 && f.getVertex(i) != v2 && f.getVertex(i) != v3) {
++n;
- //v = f.getVertex(i);
+ // v = f.getVertex(i);
ind = i;
}
}
- if (n != 1) {
+ if(n != 1) {
f = MFace();
return;
}
- for (int i = 0; i < 3; ++i) {
- if (f.getVertex(ind + 1 % 4) == vertices[i]) {
- if (f.getVertex(ind + 2 % 4) == vertices[i + 1 % 3]) {
+ for(int i = 0; i < 3; ++i) {
+ if(f.getVertex(ind + 1 % 4) == vertices[i]) {
+ if(f.getVertex(ind + 2 % 4) == vertices[i + 1 % 3]) {
return;
}
else {
- f = MFace(f.getVertex(3), f.getVertex(2), f.getVertex(1), f.getVertex(0));
+ f =
+ MFace(f.getVertex(3), f.getVertex(2), f.getVertex(1), f.getVertex(0));
}
}
}
}
-
-void PostOp::execute(GRegion* gr, int level, int conformity) {
+void PostOp::execute(GRegion *gr, int level, int conformity)
+{
printf("................PYRAMIDS................\n");
estimate1 = 0;
estimate2 = 0;
@@ -3265,14 +3427,14 @@ void PostOp::execute(GRegion* gr, int level, int conformity) {
build_tuples(gr);
- if (level >= 2) {
+ if(level >= 2) {
init_markings(gr);
build_vertex_to_tetrahedra(gr);
pyramids1(gr);
rearrange(gr);
}
- if (conformity == 2 || conformity == 3) {
+ if(conformity == 2 || conformity == 3) {
init_markings(gr);
build_vertex_to_tetrahedra(gr);
build_vertex_to_pyramids(gr);
@@ -3280,7 +3442,7 @@ void PostOp::execute(GRegion* gr, int level, int conformity) {
rearrange(gr);
}
- if (conformity == 3 || conformity == 4) {
+ if(conformity == 3 || conformity == 4) {
init_markings_hex(gr);
build_vertex_to_tetrahedra(gr);
build_vertex_to_pyramids(gr);
@@ -3300,7 +3462,7 @@ void PostOp::execute(GRegion* gr, int level, int conformity) {
rearrange(gr);
}
- if (conformity >= 1) {
+ if(conformity >= 1) {
init_markings(gr);
build_vertex_to_tetrahedra(gr);
build_vertex_to_pyramids(gr);
@@ -3313,72 +3475,76 @@ void PostOp::execute(GRegion* gr, int level, int conformity) {
create_quads_on_boundary(gr);
}
-void PostOp::init_markings_hex(GRegion* gr) {
+void PostOp::init_markings_hex(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
markings.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (eight(element)) {
- markings.insert(std::pair<MElement*, bool>(element, false));
+ if(eight(element)) {
+ markings.insert(std::pair<MElement *, bool>(element, false));
}
}
}
-void PostOp::init_markings_pri(GRegion* gr) {
+void PostOp::init_markings_pri(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
markings.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (six(element)) {
- markings.insert(std::pair<MElement*, bool>(element, false));
+ if(six(element)) {
+ markings.insert(std::pair<MElement *, bool>(element, false));
}
}
}
-void PostOp::init_markings_pyr(GRegion* gr) {
+void PostOp::init_markings_pyr(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
markings.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (five(element)) {
- markings.insert(std::pair<MElement*, bool>(element, false));
+ if(five(element)) {
+ markings.insert(std::pair<MElement *, bool>(element, false));
}
}
}
-
-void PostOp::init_markings(GRegion* gr) {
+void PostOp::init_markings(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
markings.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (four(element) || five(element)) {
- markings.insert(std::pair<MElement*, bool>(element, false));
+ if(four(element) || five(element)) {
+ markings.insert(std::pair<MElement *, bool>(element, false));
}
}
}
-void PostOp::split_hexahedra(GRegion* gr) {
- std::vector<MElement*> hexahedra;
- std::vector<MHexahedron*> opt;
- std::map<MElement*, bool>::iterator it;
+void PostOp::split_hexahedra(GRegion *gr)
+{
+ std::vector<MElement *> hexahedra;
+ std::vector<MHexahedron *> opt;
+ std::map<MElement *, bool>::iterator it;
hexahedra.clear();
- for (size_t i = 0; i < gr->getNumMeshElements(); i++) {
+ for(size_t i = 0; i < gr->getNumMeshElements(); i++) {
MElement *element = gr->getMeshElement(i);
- if (eight(element)) {
+ if(eight(element)) {
hexahedra.push_back(element);
}
}
- for (size_t i = 0; i < hexahedra.size(); i++) {
+ for(size_t i = 0; i < hexahedra.size(); i++) {
MElement *element = hexahedra[i];
MVertex *a = element->getVertex(0);
MVertex *b = element->getVertex(1);
@@ -3391,15 +3557,21 @@ void PostOp::split_hexahedra(GRegion* gr) {
bool conform = true;
conform &= (nonConformDiag(b, a, d, c, gr) == 0);
- if (conform) conform &= (nonConformDiag(e, f, g, h, gr) == 0);
- if (conform) conform &= (nonConformDiag(a, b, f, e, gr) == 0);
- if (conform) conform &= (nonConformDiag(b, c, g, f, gr) == 0);
- if (conform) conform &= (nonConformDiag(c, d, h, g, gr) == 0);
- if (conform) conform &= (nonConformDiag(d, a, e, h, gr) == 0);
- if (!conform) {
- double x = (a->x() + b->x() + c->x() + d->x() + e->x() + f->x() + g->x() + h->x()) / 8.0;
- double y = (a->y() + b->y() + c->y() + d->y() + e->y() + f->y() + g->y() + h->y()) / 8.0;
- double z = (a->z() + b->z() + c->z() + d->z() + e->z() + f->z() + g->z() + h->z()) / 8.0;
+ if(conform) conform &= (nonConformDiag(e, f, g, h, gr) == 0);
+ if(conform) conform &= (nonConformDiag(a, b, f, e, gr) == 0);
+ if(conform) conform &= (nonConformDiag(b, c, g, f, gr) == 0);
+ if(conform) conform &= (nonConformDiag(c, d, h, g, gr) == 0);
+ if(conform) conform &= (nonConformDiag(d, a, e, h, gr) == 0);
+ if(!conform) {
+ double x = (a->x() + b->x() + c->x() + d->x() + e->x() + f->x() + g->x() +
+ h->x()) /
+ 8.0;
+ double y = (a->y() + b->y() + c->y() + d->y() + e->y() + f->y() + g->y() +
+ h->y()) /
+ 8.0;
+ double z = (a->z() + b->z() + c->z() + d->z() + e->z() + f->z() + g->z() +
+ h->z()) /
+ 8.0;
MVertex *mid = new MVertex(x, y, z, gr);
gr->addMeshVertex(mid);
@@ -3425,10 +3597,10 @@ void PostOp::split_hexahedra(GRegion* gr) {
opt = gr->hexahedra;
gr->hexahedra.clear();
- for (size_t i = 0; i < opt.size(); i++) {
- MElement *element = (MElement*)(opt[i]);
+ for(size_t i = 0; i < opt.size(); i++) {
+ MElement *element = (MElement *)(opt[i]);
it = markings.find(element);
- if (it->second == 0) {
+ if(it->second == 0) {
gr->hexahedra.push_back(opt[i]);
}
else {
@@ -3437,21 +3609,22 @@ void PostOp::split_hexahedra(GRegion* gr) {
}
}
-void PostOp::split_prisms(GRegion* gr) {
- std::vector<MElement*> prisms;
- std::vector<MPrism*> opt;
- std::map<MElement*, bool>::iterator it;
+void PostOp::split_prisms(GRegion *gr)
+{
+ std::vector<MElement *> prisms;
+ std::vector<MPrism *> opt;
+ std::map<MElement *, bool>::iterator it;
prisms.clear();
- for (size_t i = 0; i < gr->getNumMeshElements(); i++) {
+ for(size_t i = 0; i < gr->getNumMeshElements(); i++) {
MElement *element = gr->getMeshElement(i);
- if (six(element)) {
+ if(six(element)) {
prisms.push_back(element);
}
}
- for (size_t i = 0; i < prisms.size(); i++) {
+ for(size_t i = 0; i < prisms.size(); i++) {
MElement *element = prisms[i];
MVertex *a = element->getVertex(0);
MVertex *b = element->getVertex(1);
@@ -3464,12 +3637,11 @@ void PostOp::split_prisms(GRegion* gr) {
pyramids1(a, b, e, d, gr);
pyramids1(b, c, f, e, gr);
-
bool conform = true;
conform &= (nonConformDiag(a, d, f, c, gr) == 0);
- if (conform) conform &= (nonConformDiag(a, b, e, d, gr) == 0);
- if (conform) conform &= (nonConformDiag(b, c, f, e, gr) == 0);
- if (!conform) {
+ if(conform) conform &= (nonConformDiag(a, b, e, d, gr) == 0);
+ if(conform) conform &= (nonConformDiag(b, c, f, e, gr) == 0);
+ if(!conform) {
double x = (a->x() + b->x() + c->x() + d->x() + e->x() + f->x()) / 6.0;
double y = (a->y() + b->y() + c->y() + d->y() + e->y() + f->y()) / 6.0;
double z = (a->z() + b->z() + c->z() + d->z() + e->z() + f->z()) / 6.0;
@@ -3496,10 +3668,10 @@ void PostOp::split_prisms(GRegion* gr) {
opt = gr->prisms;
gr->prisms.clear();
- for (size_t i = 0; i < opt.size(); i++) {
- MElement *element = (MElement*)(opt[i]);
+ for(size_t i = 0; i < opt.size(); i++) {
+ MElement *element = (MElement *)(opt[i]);
it = markings.find(element);
- if (it->second == 0) {
+ if(it->second == 0) {
gr->prisms.push_back(opt[i]);
}
else {
@@ -3508,24 +3680,25 @@ void PostOp::split_prisms(GRegion* gr) {
}
}
-void PostOp::split_pyramids(GRegion* gr) {
- std::vector<MElement*> pyramids;
- std::vector<MPyramid*> opt;
- std::map<MElement*, bool>::iterator it;
+void PostOp::split_pyramids(GRegion *gr)
+{
+ std::vector<MElement *> pyramids;
+ std::vector<MPyramid *> opt;
+ std::map<MElement *, bool>::iterator it;
pyramids.clear();
- for (size_t i = 0; i < gr->getNumMeshElements(); i++) {
+ for(size_t i = 0; i < gr->getNumMeshElements(); i++) {
MElement *element = gr->getMeshElement(i);
- if (five(element)) {
+ if(five(element)) {
pyramids.push_back(element);
}
}
- for (size_t i = 0; i < pyramids.size(); i++) {
+ for(size_t i = 0; i < pyramids.size(); i++) {
MElement *element = pyramids[i];
it = markings.find(element);
- if (it->second == 1) continue;
+ if(it->second == 1) continue;
MVertex *a = element->getVertex(0);
MVertex *b = element->getVertex(1);
@@ -3534,7 +3707,7 @@ void PostOp::split_pyramids(GRegion* gr) {
MVertex *apex = element->getVertex(4);
int nDiag = nonConformDiag(a, b, c, d, gr);
- if (nDiag == 1) {
+ if(nDiag == 1) {
MTetrahedron *temp = new MTetrahedron(c, b, a, apex);
gr->addTetrahedron(temp);
temp = new MTetrahedron(c, a, d, apex);
@@ -3542,7 +3715,7 @@ void PostOp::split_pyramids(GRegion* gr) {
it = markings.find(element);
it->second = 1;
}
- else if (nDiag == 2) {
+ else if(nDiag == 2) {
MTetrahedron *temp = new MTetrahedron(b, a, d, apex);
gr->addTetrahedron(temp);
temp = new MTetrahedron(b, d, c, apex);
@@ -3550,12 +3723,12 @@ void PostOp::split_pyramids(GRegion* gr) {
it = markings.find(element);
it->second = 1;
}
- std::set<MElement*> otherPyr;
+ std::set<MElement *> otherPyr;
find_pyramids_from_quad(a, b, c, d, otherPyr);
- if (otherPyr.size() == 2) {
+ if(otherPyr.size() == 2) {
element_set_itr myit = otherPyr.begin();
MElement *other = *myit;
- if (other == element) {
+ if(other == element) {
other = *(++myit);
}
// TODO test also quality of tet after split of other pyr ?
@@ -3569,7 +3742,7 @@ void PostOp::split_pyramids(GRegion* gr) {
MVertex *d2 = other->getVertex(3);
MVertex *apex2 = other->getVertex(4);
MTetrahedron *tempA3, *tempA4, *tempB3, *tempB4;
- if (a2 == a || a2 == c) {
+ if(a2 == a || a2 == c) {
tempA3 = new MTetrahedron(a2, b2, c2, apex2);
tempA4 = new MTetrahedron(a2, c2, d2, apex2);
tempB3 = new MTetrahedron(a2, b2, d2, apex2);
@@ -3585,39 +3758,27 @@ void PostOp::split_pyramids(GRegion* gr) {
MTetrahedron *tempC2 = new MTetrahedron(b, c, apex2, apex);
MTetrahedron *tempC3 = new MTetrahedron(c, d, apex2, apex);
MTetrahedron *tempC4 = new MTetrahedron(d, a, apex2, apex);
- if (tempA1->getVolumeSign() < 0 ||
- tempA2->getVolumeSign() < 0 ||
- tempA3->getVolumeSign() < 0 ||
- tempA4->getVolumeSign() < 0 ||
- tempB1->getVolumeSign() < 0 ||
- tempB2->getVolumeSign() < 0 ||
- tempB3->getVolumeSign() < 0 ||
- tempB4->getVolumeSign() < 0 ||
- tempC1->getVolumeSign() < 0 ||
- tempC2->getVolumeSign() < 0 ||
- tempC3->getVolumeSign() < 0 ||
- tempC4->getVolumeSign() < 0) {
+ if(tempA1->getVolumeSign() < 0 || tempA2->getVolumeSign() < 0 ||
+ tempA3->getVolumeSign() < 0 || tempA4->getVolumeSign() < 0 ||
+ tempB1->getVolumeSign() < 0 || tempB2->getVolumeSign() < 0 ||
+ tempB3->getVolumeSign() < 0 || tempB4->getVolumeSign() < 0 ||
+ tempC1->getVolumeSign() < 0 || tempC2->getVolumeSign() < 0 ||
+ tempC3->getVolumeSign() < 0 || tempC4->getVolumeSign() < 0) {
Msg::Error("%d %d %d %d %d %d %d %d %d %d %d %d",
- tempA1->getVolumeSign(),
- tempA2->getVolumeSign(),
- tempA3->getVolumeSign(),
- tempA4->getVolumeSign(),
- tempB1->getVolumeSign(),
- tempB2->getVolumeSign(),
- tempB3->getVolumeSign(),
- tempB4->getVolumeSign(),
- tempC1->getVolumeSign(),
- tempC2->getVolumeSign(),
- tempC3->getVolumeSign(),
- tempC4->getVolumeSign());
+ tempA1->getVolumeSign(), tempA2->getVolumeSign(),
+ tempA3->getVolumeSign(), tempA4->getVolumeSign(),
+ tempB1->getVolumeSign(), tempB2->getVolumeSign(),
+ tempB3->getVolumeSign(), tempB4->getVolumeSign(),
+ tempC1->getVolumeSign(), tempC2->getVolumeSign(),
+ tempC3->getVolumeSign(), tempC4->getVolumeSign());
}
double qA = tempA1->minIsotropyMeasure() + tempA2->minIsotropyMeasure() +
- tempA3->minIsotropyMeasure() + tempA4->minIsotropyMeasure();
+ tempA3->minIsotropyMeasure() + tempA4->minIsotropyMeasure();
double qB = tempB1->minIsotropyMeasure() + tempB2->minIsotropyMeasure() +
- tempB3->minIsotropyMeasure() + tempB4->minIsotropyMeasure();
+ tempB3->minIsotropyMeasure() + tempB4->minIsotropyMeasure();
double qC = tempC1->minIsotropyMeasure() + tempC2->minIsotropyMeasure() +
- tempC3->minIsotropyMeasure() + tempC4->minIsotropyMeasure();
- if (qA > qB && qA > qC) {
+ tempC3->minIsotropyMeasure() + tempC4->minIsotropyMeasure();
+ if(qA > qB && qA > qC) {
Msg::Info("A");
gr->addTetrahedron(tempA1);
gr->addTetrahedron(tempA2);
@@ -3632,7 +3793,7 @@ void PostOp::split_pyramids(GRegion* gr) {
delete tempC3;
delete tempC4;
}
- else if (qB > qC) {
+ else if(qB > qC) {
Msg::Info("B");
gr->addTetrahedron(tempB1);
gr->addTetrahedron(tempB2);
@@ -3674,10 +3835,10 @@ void PostOp::split_pyramids(GRegion* gr) {
opt = gr->pyramids;
gr->pyramids.clear();
- for (size_t i = 0; i < opt.size(); i++) {
- MElement *element = (MElement*)(opt[i]);
+ for(size_t i = 0; i < opt.size(); i++) {
+ MElement *element = (MElement *)(opt[i]);
it = markings.find(element);
- if (it->second == 0) {
+ if(it->second == 0) {
gr->pyramids.push_back(opt[i]);
}
else {
@@ -3686,12 +3847,13 @@ void PostOp::split_pyramids(GRegion* gr) {
}
}
-
-int PostOp::nonConformDiag(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion* gr) {
- std::set<MElement*> diag1a;
- std::set<MElement*> diag1b;
- std::set<MElement*> diag2a;
- std::set<MElement*> diag2b;
+int PostOp::nonConformDiag(MVertex *a, MVertex *b, MVertex *c, MVertex *d,
+ GRegion *gr)
+{
+ std::set<MElement *> diag1a;
+ std::set<MElement *> diag1b;
+ std::set<MElement *> diag2a;
+ std::set<MElement *> diag2b;
find_tetrahedra(a, b, c, diag1a);
find_tetrahedra(a, c, d, diag1b);
@@ -3701,41 +3863,40 @@ int PostOp::nonConformDiag(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegi
find_pyramids_from_tri(a, c, d, diag1b);
find_pyramids_from_tri(b, c, d, diag2a);
find_pyramids_from_tri(a, b, d, diag2b);
- if (diag1a.size() == 1 || diag1b.size() == 1) {
+ if(diag1a.size() == 1 || diag1b.size() == 1) {
return 1;
}
- else if (diag2a.size() == 1 || diag2b.size() == 1) {
+ else if(diag2a.size() == 1 || diag2b.size() == 1) {
return 2;
}
return 0;
}
-
-
-void PostOp::pyramids1(GRegion* gr) {
+void PostOp::pyramids1(GRegion *gr)
+{
unsigned int i;
MVertex *a, *b, *c, *d;
MVertex *e, *f, *g, *h;
- MElement* element;
- std::vector<MElement*> hexahedra;
- std::vector<MElement*> prisms;
- std::vector<MTetrahedron*> opt;
- std::map<MElement*, bool>::iterator it;
+ MElement *element;
+ std::vector<MElement *> hexahedra;
+ std::vector<MElement *> prisms;
+ std::vector<MTetrahedron *> opt;
+ std::map<MElement *, bool>::iterator it;
hexahedra.clear();
prisms.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (eight(element)) {
+ if(eight(element)) {
hexahedra.push_back(element);
}
- else if (six(element)) {
+ else if(six(element)) {
prisms.push_back(element);
}
}
- for (i = 0; i < hexahedra.size(); i++) {
+ for(i = 0; i < hexahedra.size(); i++) {
element = hexahedra[i];
a = element->getVertex(0);
@@ -3755,7 +3916,7 @@ void PostOp::pyramids1(GRegion* gr) {
pyramids1(d, a, e, h, gr);
}
- for (i = 0; i < prisms.size(); i++) {
+ for(i = 0; i < prisms.size(); i++) {
element = prisms[i];
a = element->getVertex(0);
@@ -3775,10 +3936,10 @@ void PostOp::pyramids1(GRegion* gr) {
opt = gr->tetrahedra;
gr->tetrahedra.clear();
- for (i = 0; i < opt.size(); i++) {
- element = (MElement*)(opt[i]);
+ for(i = 0; i < opt.size(); i++) {
+ element = (MElement *)(opt[i]);
it = markings.find(element);
- if (it->second == 0) {
+ if(it->second == 0) {
gr->tetrahedra.push_back(opt[i]);
}
else {
@@ -3787,32 +3948,32 @@ void PostOp::pyramids1(GRegion* gr) {
}
}
-
-void PostOp::pyramids2(GRegion* gr, bool allowNonConforming) {
+void PostOp::pyramids2(GRegion *gr, bool allowNonConforming)
+{
unsigned int i;
MVertex *a, *b, *c, *d;
MVertex *e, *f, *g, *h;
- MElement* element;
- std::vector<MElement*> hexahedra;
- std::vector<MElement*> prisms;
- std::vector<MTetrahedron*> opt1;
- std::vector<MPyramid*> opt2;
- std::map<MElement*, bool>::iterator it;
+ MElement *element;
+ std::vector<MElement *> hexahedra;
+ std::vector<MElement *> prisms;
+ std::vector<MTetrahedron *> opt1;
+ std::vector<MPyramid *> opt2;
+ std::map<MElement *, bool>::iterator it;
hexahedra.clear();
prisms.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (eight(element)) {
+ if(eight(element)) {
hexahedra.push_back(element);
}
- else if (six(element)) {
+ else if(six(element)) {
prisms.push_back(element);
}
}
- for (i = 0; i < hexahedra.size(); i++) {
+ for(i = 0; i < hexahedra.size(); i++) {
element = hexahedra[i];
a = element->getVertex(0);
@@ -3832,7 +3993,7 @@ void PostOp::pyramids2(GRegion* gr, bool allowNonConforming) {
pyramids2(d, a, e, h, gr, allowNonConforming);
}
- for (i = 0; i < prisms.size(); i++) {
+ for(i = 0; i < prisms.size(); i++) {
element = prisms[i];
a = element->getVertex(0);
@@ -3852,10 +4013,10 @@ void PostOp::pyramids2(GRegion* gr, bool allowNonConforming) {
opt1 = gr->tetrahedra;
gr->tetrahedra.clear();
- for (i = 0; i < opt1.size(); i++) {
- element = (MElement*)(opt1[i]);
+ for(i = 0; i < opt1.size(); i++) {
+ element = (MElement *)(opt1[i]);
it = markings.find(element);
- if (it->second == 0) {
+ if(it->second == 0) {
gr->tetrahedra.push_back(opt1[i]);
}
else {
@@ -3868,10 +4029,10 @@ void PostOp::pyramids2(GRegion* gr, bool allowNonConforming) {
opt2 = gr->pyramids;
gr->pyramids.clear();
- for (i = 0; i < opt2.size(); i++) {
- element = (MElement*)(opt2[i]);
+ for(i = 0; i < opt2.size(); i++) {
+ element = (MElement *)(opt2[i]);
it = markings.find(element);
- if (it->second == 0) {
+ if(it->second == 0) {
gr->pyramids.push_back(opt2[i]);
}
else {
@@ -3880,16 +4041,18 @@ void PostOp::pyramids2(GRegion* gr, bool allowNonConforming) {
}
}
-void PostOp::pyramids1(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion* gr) {
- MVertex* getVertex;
- std::set<MElement*> bin;
- std::set<MElement*> bin1a;
- std::set<MElement*> bin2a;
- std::set<MElement*> bin1b;
- std::set<MElement*> bin2b;
+void PostOp::pyramids1(MVertex *a, MVertex *b, MVertex *c, MVertex *d,
+ GRegion *gr)
+{
+ MVertex *getVertex;
+ std::set<MElement *> bin;
+ std::set<MElement *> bin1a;
+ std::set<MElement *> bin2a;
+ std::set<MElement *> bin1b;
+ std::set<MElement *> bin2b;
element_set_itr it;
- std::map<MElement*, bool>::iterator it1;
- std::map<MElement*, bool>::iterator it2;
+ std::map<MElement *, bool>::iterator it1;
+ std::map<MElement *, bool>::iterator it2;
bin1a.clear();
bin1b.clear();
@@ -3906,32 +4069,32 @@ void PostOp::pyramids1(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion*
// find_tetrahedra(b,d,bin2);
bin.clear();
- for (it = bin1a.begin(); it != bin1a.end(); it++) {
+ for(it = bin1a.begin(); it != bin1a.end(); it++) {
bin.insert(*it);
}
- for (it = bin1b.begin(); it != bin1b.end(); it++) {
+ for(it = bin1b.begin(); it != bin1b.end(); it++) {
bin.insert(*it);
}
- for (it = bin2a.begin(); it != bin2a.end(); it++) {
+ for(it = bin2a.begin(); it != bin2a.end(); it++) {
bin.insert(*it);
}
- for (it = bin2b.begin(); it != bin2b.end(); it++) {
+ for(it = bin2b.begin(); it != bin2b.end(); it++) {
bin.insert(*it);
}
- if (bin.size() == 2) { //2 tetrahedra on face
+ if(bin.size() == 2) { // 2 tetrahedra on face
it = bin.begin();
- it1 = markings.find(*it); //1st tetrahedra
+ it1 = markings.find(*it); // 1st tetrahedra
it++;
- it2 = markings.find(*it); //2nd tetrahedra
+ it2 = markings.find(*it); // 2nd tetrahedra
- if (it1->second == 0 && it2->second == 0) {
+ if(it1->second == 0 && it2->second == 0) {
getVertex = find(a, b, c, d, *it);
- MVertex* vertex1 = find(a, b, c, d, *bin.begin());
- if (!getVertex || !vertex1) Msg::Fatal("Topological error");
- if (getVertex == vertex1) {
+ MVertex *vertex1 = find(a, b, c, d, *bin.begin());
+ if(!getVertex || !vertex1) Msg::Fatal("Topological error");
+ if(getVertex == vertex1) {
MPyramid *pyr = new MPyramid(a, b, c, d, getVertex);
- if (valid(pyr)) {
+ if(valid(pyr)) {
gr->addPyramid(pyr);
it1->second = 1;
it2->second = 1;
@@ -3941,29 +4104,29 @@ void PostOp::pyramids1(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion*
}
}
-
-void PostOp::trihedra(GRegion* gr) {
+void PostOp::trihedra(GRegion *gr)
+{
unsigned int i;
MVertex *a, *b, *c, *d;
MVertex *e, *f, *g, *h;
- MElement* element;
- std::vector<MElement*> hexahedra;
- std::vector<MElement*> prisms;
- std::vector<MTetrahedron*> opt1;
- std::vector<MPyramid*> opt2;
- std::map<MElement*, bool>::iterator it;
-
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *element;
+ std::vector<MElement *> hexahedra;
+ std::vector<MElement *> prisms;
+ std::vector<MTetrahedron *> opt1;
+ std::vector<MPyramid *> opt2;
+ std::map<MElement *, bool>::iterator it;
+
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (eight(element)) {
+ if(eight(element)) {
hexahedra.push_back(element);
}
- else if (six(element)) {
+ else if(six(element)) {
prisms.push_back(element);
}
}
- for (i = 0; i < hexahedra.size(); i++) {
+ for(i = 0; i < hexahedra.size(); i++) {
element = hexahedra[i];
a = element->getVertex(0);
@@ -3983,7 +4146,7 @@ void PostOp::trihedra(GRegion* gr) {
trihedra(d, a, e, h, gr);
}
- for (i = 0; i < prisms.size(); i++) {
+ for(i = 0; i < prisms.size(); i++) {
element = prisms[i];
a = element->getVertex(0);
@@ -3997,14 +4160,15 @@ void PostOp::trihedra(GRegion* gr) {
trihedra(a, b, e, d, gr);
trihedra(b, c, f, e, gr);
}
-
}
-void PostOp::trihedra(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion* gr) {
- std::set<MElement*> diag1a;
- std::set<MElement*> diag1b;
- std::set<MElement*> diag2a;
- std::set<MElement*> diag2b;
+void PostOp::trihedra(MVertex *a, MVertex *b, MVertex *c, MVertex *d,
+ GRegion *gr)
+{
+ std::set<MElement *> diag1a;
+ std::set<MElement *> diag1b;
+ std::set<MElement *> diag2a;
+ std::set<MElement *> diag2b;
find_tetrahedra(a, b, c, diag1a);
find_tetrahedra(a, c, d, diag1b);
@@ -4014,39 +4178,49 @@ void PostOp::trihedra(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion* g
find_pyramids_from_tri(a, c, d, diag1b);
find_pyramids_from_tri(b, c, d, diag2a);
find_pyramids_from_tri(a, b, d, diag2b);
- if (diag1a.size() == 1 || diag1b.size() == 1) {
+ if(diag1a.size() == 1 || diag1b.size() == 1) {
MTrihedron *trih = new MTrihedron(b, c, d, a);
- if (diag1a.size() != 1 || diag1b.size() != 1 || diag2a.size() != 0 || diag2b.size() != 0) Msg::Error("Quad face neighbor with %i+%i triangular faces (other diagonal: %i+%i) Trihedron: %i", diag1a.size(), diag1b.size(), diag2a.size(), diag2b.size(), trih->getNum());
+ if(diag1a.size() != 1 || diag1b.size() != 1 || diag2a.size() != 0 ||
+ diag2b.size() != 0)
+ Msg::Error("Quad face neighbor with %i+%i triangular faces (other "
+ "diagonal: %i+%i) Trihedron: %i",
+ diag1a.size(), diag1b.size(), diag2a.size(), diag2b.size(),
+ trih->getNum());
gr->addTrihedron(trih);
}
- else if (diag2a.size() == 1 || diag2b.size() == 1) {
+ else if(diag2a.size() == 1 || diag2b.size() == 1) {
MTrihedron *trih = new MTrihedron(a, b, c, d);
- if (diag1a.size() != 0 || diag1b.size() != 0 || diag2a.size() != 1 || diag2b.size() != 1) Msg::Error("Quad face neighbor with %i+%i triangular faces (other diagonal: %i+%i) Trihedron: %i", diag2a.size(), diag2b.size(), diag1a.size(), diag1b.size(), trih->getNum());
+ if(diag1a.size() != 0 || diag1b.size() != 0 || diag2a.size() != 1 ||
+ diag2b.size() != 1)
+ Msg::Error("Quad face neighbor with %i+%i triangular faces (other "
+ "diagonal: %i+%i) Trihedron: %i",
+ diag2a.size(), diag2b.size(), diag1a.size(), diag1b.size(),
+ trih->getNum());
gr->addTrihedron(trih);
}
}
-void PostOp::pyramids2(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion* gr, bool allowNonConforming) {
-
-
+void PostOp::pyramids2(MVertex *a, MVertex *b, MVertex *c, MVertex *d,
+ GRegion *gr, bool allowNonConforming)
+{
bool flag;
double x, y, z;
- MVertex* mid;
+ MVertex *mid;
MVertex *diagA, *diagB, *nDiagA, *nDiagB;
MVertex *N1, *N2;
MVertex *v1, *v2, *v3, *v4, *v5;
- MTetrahedron* temp;
- MPyramid* temp2;
- std::vector<MElement*> movables;
- std::set<MVertex*> Ns;
- std::set<MElement*> bin1a, bin1b;
- std::set<MElement*> bin2a, bin2b;
- std::set<MElement*> bin3a, bin3b;
- std::set<MElement*> bin4a, bin4b;
- std::set<MElement*> tetrahedra;
- std::set<MElement*> pyramids;
+ MTetrahedron *temp;
+ MPyramid *temp2;
+ std::vector<MElement *> movables;
+ std::set<MVertex *> Ns;
+ std::set<MElement *> bin1a, bin1b;
+ std::set<MElement *> bin2a, bin2b;
+ std::set<MElement *> bin3a, bin3b;
+ std::set<MElement *> bin4a, bin4b;
+ std::set<MElement *> tetrahedra;
+ std::set<MElement *> pyramids;
element_set_itr it;
- std::map<MElement*, bool>::iterator it2;
+ std::map<MElement *, bool>::iterator it2;
flag = 0;
@@ -4070,38 +4244,38 @@ void PostOp::pyramids2(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion*
tetrahedra.clear();
pyramids.clear();
- if ((bin1a.size() + bin3a.size() == 1) && (bin1b.size() + bin3b.size() == 1)) {
+ if((bin1a.size() + bin3a.size() == 1) && (bin1b.size() + bin3b.size() == 1)) {
flag = true;
- for (it = bin1a.begin(); it != bin1a.end(); it++) {
+ for(it = bin1a.begin(); it != bin1a.end(); it++) {
tetrahedra.insert(*it);
}
- for (it = bin1b.begin(); it != bin1b.end(); it++) {
+ for(it = bin1b.begin(); it != bin1b.end(); it++) {
tetrahedra.insert(*it);
}
- for (it = bin3a.begin(); it != bin3a.end(); it++) {
+ for(it = bin3a.begin(); it != bin3a.end(); it++) {
pyramids.insert(*it);
}
- for (it = bin3b.begin(); it != bin3b.end(); it++) {
+ for(it = bin3b.begin(); it != bin3b.end(); it++) {
pyramids.insert(*it);
}
}
- else if ((bin2a.size() + bin4a.size() == 1) && (bin2b.size() + bin4b.size() == 1)) {
- for (it = bin2a.begin(); it != bin2a.end(); it++) {
+ else if((bin2a.size() + bin4a.size() == 1) &&
+ (bin2b.size() + bin4b.size() == 1)) {
+ for(it = bin2a.begin(); it != bin2a.end(); it++) {
tetrahedra.insert(*it);
}
- for (it = bin2b.begin(); it != bin2b.end(); it++) {
+ for(it = bin2b.begin(); it != bin2b.end(); it++) {
tetrahedra.insert(*it);
}
- for (it = bin4a.begin(); it != bin4a.end(); it++) {
+ for(it = bin4a.begin(); it != bin4a.end(); it++) {
pyramids.insert(*it);
}
- for (it = bin4b.begin(); it != bin4b.end(); it++) {
+ for(it = bin4b.begin(); it != bin4b.end(); it++) {
pyramids.insert(*it);
}
}
-
- if (flag) {
+ if(flag) {
diagA = c;
diagB = a;
nDiagA = b;
@@ -4125,49 +4299,56 @@ void PostOp::pyramids2(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion*
mid = 0;
movables.clear();
-
- if (tetrahedra.size() > 0 || pyramids.size() > 0) {
- //A quad face can share only one of those:
+ if(tetrahedra.size() > 0 || pyramids.size() > 0) {
+ // A quad face can share only one of those:
// 2 triangles split by the first diagonal
// 2 triangles split by the second diagonal
// 0 triangle with all nodes being on the boundary
- if ((bin1a.size() + bin3a.size()) == 1 && (bin1b.size() + bin3b.size()) == 1) {
+ if((bin1a.size() + bin3a.size()) == 1 &&
+ (bin1b.size() + bin3b.size()) == 1) {
// MTrihedron *trih = new MTrihedron(b, c, d, a);
// gr->addTrihedron(trih);
}
- else if ((bin2a.size() + bin4a.size()) == 1 && (bin2b.size() + bin4b.size()) == 1) {
+ else if((bin2a.size() + bin4a.size()) == 1 &&
+ (bin2b.size() + bin4b.size()) == 1) {
// MTrihedron *trih = new MTrihedron(a, b, c, d);
// gr->addTrihedron(trih);
}
- else if (bin1a.size() != 0 || bin1b.size() != 0 || bin2a.size() != 0 || bin2b.size() != 0
- || bin3a.size() != 0 || bin3b.size() != 0 || bin4a.size() != 0 || bin4b.size() != 0
- || a->onWhat()->dim() > 2 || b->onWhat()->dim() > 2 || c->onWhat()->dim() > 2 || d->onWhat()->dim() > 2)
- Msg::Fatal("Topological issue: inner quad face facing something else than 2 triangles: %i %i %i %i %i %i %i %i dim %i %i %i", bin1a.size(), bin1b.size(), bin2a.size(), bin2b.size(), bin3a.size(), bin3b.size(), bin4a.size(), bin4b.size(), a->onWhat()->dim(), b->onWhat()->dim(), c->onWhat()->dim(), d->onWhat()->dim());
-
-
- MVertex* otherV[2];
+ else if(bin1a.size() != 0 || bin1b.size() != 0 || bin2a.size() != 0 ||
+ bin2b.size() != 0 || bin3a.size() != 0 || bin3b.size() != 0 ||
+ bin4a.size() != 0 || bin4b.size() != 0 || a->onWhat()->dim() > 2 ||
+ b->onWhat()->dim() > 2 || c->onWhat()->dim() > 2 ||
+ d->onWhat()->dim() > 2)
+ Msg::Fatal("Topological issue: inner quad face facing something else "
+ "than 2 triangles: %i %i %i %i %i %i %i %i dim %i %i %i",
+ bin1a.size(), bin1b.size(), bin2a.size(), bin2b.size(),
+ bin3a.size(), bin3b.size(), bin4a.size(), bin4b.size(),
+ a->onWhat()->dim(), b->onWhat()->dim(), c->onWhat()->dim(),
+ d->onWhat()->dim());
+
+ MVertex *otherV[2];
int i = 0;
- for (it = tetrahedra.begin(); it != tetrahedra.end(); it++) {
+ for(it = tetrahedra.begin(); it != tetrahedra.end(); it++) {
otherV[i++] = findInTriFace(diagA, diagB, nDiagA, nDiagB, *it);
}
- for (it = pyramids.begin(); it != pyramids.end(); it++) {
+ for(it = pyramids.begin(); it != pyramids.end(); it++) {
otherV[i++] = findInTriFace(diagA, diagB, nDiagA, nDiagB, *it);
}
- if (!otherV[0] || !otherV[1]) Msg::Fatal("Topological error");
+ if(!otherV[0] || !otherV[1]) Msg::Fatal("Topological error");
MPyramid *pyr = new MPyramid(a, b, c, d, otherV[0]);
bool pyrOk = valid(pyr);
delete pyr;
- if (otherV[0] == otherV[1] && pyrOk) {
+ if(otherV[0] == otherV[1] && pyrOk) {
estimate1 = estimate1 + tetrahedra.size() + 2 * pyramids.size();
estimate2 = estimate2 + 1;
- //x = (diagA->x() + diagB->x() + otherV[0]->x())/3;
- //y = (diagA->y() + diagB->y() + otherV[0]->y())/3;
- //z = (diagA->z() + diagB->z() + otherV[0]->z())/3;
+ // x = (diagA->x() + diagB->x() + otherV[0]->x())/3;
+ // y = (diagA->y() + diagB->y() + otherV[0]->y())/3;
+ // z = (diagA->z() + diagB->z() + otherV[0]->z())/3;
- //We create a flat pyramid and let the optimizer fix it
+ // We create a flat pyramid and let the optimizer fix it
x = (a->x() + b->x() + c->x() + d->x()) / 4;
y = (a->y() + b->y() + c->y() + d->y()) / 4;
z = (a->z() + b->z() + c->z() + d->z()) / 4;
@@ -4181,36 +4362,38 @@ void PostOp::pyramids2(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion*
temp2 = new MPyramid(a, b, c, d, mid);
gr->addPyramid(temp2);
- markings.insert(std::pair<MElement*, bool>(temp2, false));
+ markings.insert(std::pair<MElement *, bool>(temp2, false));
build_vertex_to_pyramids(temp2);
- // printf("Creating pyramid with vertices %i %i %i %i %i\n", a->getNum(), b->getNum(), c->getNum(), d->getNum(), mid->getNum());
-
-
- for (it = tetrahedra.begin(); it != tetrahedra.end(); it++) {
+ // printf("Creating pyramid with vertices %i %i %i %i %i\n",
+ // a->getNum(), b->getNum(), c->getNum(), d->getNum(),
+ // mid->getNum());
+ for(it = tetrahedra.begin(); it != tetrahedra.end(); it++) {
MVertex *Nout = findInTriFace(diagA, diagB, nDiagA, nDiagB, *it);
MVertex *Nin = other(*it, diagA, diagB, Nout);
// N1 = other(*it,diagA,diagB);
-
- if (Nout != 0 && Nin != 0) {
+ if(Nout != 0 && Nin != 0) {
Ns.insert(N1);
Ns.insert(N2);
-
temp = new MTetrahedron(mid, diagB, Nin, Nout);
gr->addTetrahedron(temp);
- markings.insert(std::pair<MElement*, bool>(temp, false));
+ markings.insert(std::pair<MElement *, bool>(temp, false));
build_vertex_to_tetrahedra(temp);
movables.push_back(temp);
- // printf("Creating tet with vertices %i %i %i %i\n", N1->getNum(), N2->getNum(), diagA->getNum(), mid->getNum());
+ // printf("Creating tet with vertices %i %i %i %i\n",
+ // N1->getNum(), N2->getNum(), diagA->getNum(),
+ // mid->getNum());
temp = new MTetrahedron(diagA, mid, Nin, Nout);
gr->addTetrahedron(temp);
- markings.insert(std::pair<MElement*, bool>(temp, false));
+ markings.insert(std::pair<MElement *, bool>(temp, false));
build_vertex_to_tetrahedra(temp);
movables.push_back(temp);
- // printf("Creating tet with vertices %i %i %i %i\n", N1->getNum(), N2->getNum(), diagB->getNum(), mid->getNum());
+ // printf("Creating tet with vertices %i %i %i %i\n",
+ // N1->getNum(), N2->getNum(), diagB->getNum(),
+ // mid->getNum());
it2 = markings.find(*it);
it2->second = 1;
@@ -4221,57 +4404,55 @@ void PostOp::pyramids2(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion*
}
}
- for (it = pyramids.begin(); it != pyramids.end(); it++) {
+ for(it = pyramids.begin(); it != pyramids.end(); it++) {
v1 = (*it)->getVertex(0);
v2 = (*it)->getVertex(1);
v3 = (*it)->getVertex(2);
v4 = (*it)->getVertex(3);
- v5 = (*it)->getVertex(4); //apex
-
+ v5 = (*it)->getVertex(4); // apex
-
- //My version (sign-preserving)
+ // My version (sign-preserving)
temp2 = new MPyramid(v1, v2, v3, v4, mid);
gr->addPyramid(temp2);
- markings.insert(std::pair<MElement*, bool>(temp2, false));
+ markings.insert(std::pair<MElement *, bool>(temp2, false));
build_vertex_to_pyramids(temp2);
MVertex *NoutDiag = findInTriFace(diagA, diagB, nDiagA, nDiagB, *it);
MVertex *NoutNDiag = NULL;
- for (int iV = 0; iV < 5; iV++) {
+ for(int iV = 0; iV < 5; iV++) {
MVertex *v = (*it)->getVertex(iV);
- if (v != a && v != b && v != c && v != d && v != NoutDiag) {
+ if(v != a && v != b && v != c && v != d && v != NoutDiag) {
NoutNDiag = v;
break;
}
}
- MVertex *NinNDiag = findInTriFace(diagA, diagB, NoutDiag, NoutNDiag, *it);
- if (v5 == diagA) {
+ MVertex *NinNDiag =
+ findInTriFace(diagA, diagB, NoutDiag, NoutNDiag, *it);
+ if(v5 == diagA) {
temp = new MTetrahedron(diagA, mid, NinNDiag, NoutNDiag);
gr->addTetrahedron(temp);
- markings.insert(std::pair<MElement*, bool>(temp, false));
+ markings.insert(std::pair<MElement *, bool>(temp, false));
build_vertex_to_tetrahedra(temp);
movables.push_back(temp);
temp = new MTetrahedron(diagA, mid, NoutNDiag, NoutDiag);
gr->addTetrahedron(temp);
- markings.insert(std::pair<MElement*, bool>(temp, false));
+ markings.insert(std::pair<MElement *, bool>(temp, false));
build_vertex_to_tetrahedra(temp);
movables.push_back(temp);
}
- else if (v5 == diagB) {
+ else if(v5 == diagB) {
temp = new MTetrahedron(mid, diagB, NinNDiag, NoutNDiag);
gr->addTetrahedron(temp);
- markings.insert(std::pair<MElement*, bool>(temp, false));
+ markings.insert(std::pair<MElement *, bool>(temp, false));
build_vertex_to_tetrahedra(temp);
movables.push_back(temp);
temp = new MTetrahedron(diagB, mid, NoutNDiag, NoutDiag);
gr->addTetrahedron(temp);
- markings.insert(std::pair<MElement*, bool>(temp, false));
+ markings.insert(std::pair<MElement *, bool>(temp, false));
build_vertex_to_tetrahedra(temp);
movables.push_back(temp);
}
-
// if(v1!=diagA && v1!=diagB){
// Ns.insert(v1);
// }
@@ -4335,19 +4516,21 @@ void PostOp::pyramids2(MVertex* a, MVertex* b, MVertex* c, MVertex* d, GRegion*
}
}
-void PostOp::rearrange(GRegion* gr) {
+void PostOp::rearrange(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
element->setVolumePositive();
}
}
-void PostOp::statistics(GRegion* gr) {
+void PostOp::statistics(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
nbr = 0;
nbr8 = 0;
@@ -4361,80 +4544,80 @@ void PostOp::statistics(GRegion* gr) {
vol5 = 0.0;
vol4 = 0.0;
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (eight(element)) {
+ if(eight(element)) {
nbr8 = nbr8 + 1;
vol8 = vol8 + element->getVolume();
}
- if (six(element)) {
+ if(six(element)) {
nbr6 = nbr6 + 1;
vol6 = vol6 + element->getVolume();
}
- if (five(element)) {
+ if(five(element)) {
nbr5 = nbr5 + 1;
vol5 = vol5 + workaround(element);
}
- if (four(element)) {
+ if(four(element)) {
nbr4 = nbr4 + 1;
vol4 = vol4 + element->getVolume();
}
- if (fourTrih(element)) {
+ if(fourTrih(element)) {
nbr4Trih = nbr4Trih + 1;
}
nbr = nbr + 1;
- if (!five(element)) {
+ if(!five(element)) {
vol = vol + element->getVolume();
}
else {
- //vol = vol + workaround(element);
+ // vol = vol + workaround(element);
vol = vol + element->getVolume();
}
}
printf("Number :\n");
- printf(" percentage of hexahedra : %.2f\n", nbr8*100.0 / nbr);
- printf(" percentage of prisms : %.2f\n", nbr6*100.0 / nbr);
- printf(" percentage of pyramids : %.2f\n", nbr5*100.0 / nbr);
- printf(" percentage of tetrahedra : %.2f\n", nbr4*100.0 / nbr);
- printf(" percentage of trihedra : %.2f\n", nbr4Trih*100.0 / nbr);
+ printf(" percentage of hexahedra : %.2f\n", nbr8 * 100.0 / nbr);
+ printf(" percentage of prisms : %.2f\n", nbr6 * 100.0 / nbr);
+ printf(" percentage of pyramids : %.2f\n", nbr5 * 100.0 / nbr);
+ printf(" percentage of tetrahedra : %.2f\n", nbr4 * 100.0 / nbr);
+ printf(" percentage of trihedra : %.2f\n", nbr4Trih * 100.0 / nbr);
printf("Volume :\n");
- printf(" percentage of hexahedra : %.2f\n", vol8*100.0 / vol);
- printf(" percentage of prisms : %.2f\n", vol6*100.0 / vol);
- printf(" percentage of pyramids : %.2f\n", vol5*100.0 / vol);
- printf(" percentage of tetrahedra : %.2f\n", vol4*100.0 / vol);
+ printf(" percentage of hexahedra : %.2f\n", vol8 * 100.0 / vol);
+ printf(" percentage of prisms : %.2f\n", vol6 * 100.0 / vol);
+ printf(" percentage of pyramids : %.2f\n", vol5 * 100.0 / vol);
+ printf(" percentage of tetrahedra : %.2f\n", vol4 * 100.0 / vol);
printf("Total number of elements : %lu\n", gr->getNumMeshElements());
printf("Total volume : %f\n", vol);
printf("Misc : %d %d %d\n", estimate1, estimate2, iterations);
}
-void PostOp::build_tuples(GRegion* gr) {
+void PostOp::build_tuples(GRegion *gr)
+{
unsigned int i;
MVertex *a, *b, *c;
- MElement* element;
- GFace* gf;
+ MElement *element;
+ GFace *gf;
tuples.clear();
triangles.clear();
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator it;
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator it;
- for (it = faces.begin(); it != faces.end(); it++)
- {
+ for(it = faces.begin(); it != faces.end(); it++) {
gf = *it;
- for (i = 0; i < gf->getNumMeshElements(); i++) {
+ for(i = 0; i < gf->getNumMeshElements(); i++) {
element = gf->getMeshElement(i);
- if (element->getNumVertices() == 3) {
+ if(element->getNumVertices() == 3) {
a = element->getVertex(0);
b = element->getVertex(1);
c = element->getVertex(2);
@@ -4445,43 +4628,43 @@ void PostOp::build_tuples(GRegion* gr) {
}
}
-void PostOp::create_quads_on_boundary(GRegion* gr) {
+void PostOp::create_quads_on_boundary(GRegion *gr)
+{
unsigned int i;
- MVertex *a, *b, *c, *d;//,*e;
- MElement* element;
- GFace* gf;
- std::vector<MElement*> opt;
+ MVertex *a, *b, *c, *d; //,*e;
+ MElement *element;
+ GFace *gf;
+ std::vector<MElement *> opt;
element_set_itr it2;
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (element->getNumVertices() == 5) {
+ if(element->getNumVertices() == 5) {
a = element->getVertex(0);
b = element->getVertex(1);
c = element->getVertex(2);
d = element->getVertex(3);
- //e = element->getVertex(4);
+ // e = element->getVertex(4);
create_quads_on_boundary(a, b, c, d);
}
}
- std::vector<GFace*> faces = gr->faces();
- std::vector<GFace*>::iterator it;
+ std::vector<GFace *> faces = gr->faces();
+ std::vector<GFace *>::iterator it;
- for (it = faces.begin(); it != faces.end(); it++)
- {
+ for(it = faces.begin(); it != faces.end(); it++) {
gf = *it;
opt.clear();
- for (i = 0; i < gf->getNumMeshElements(); i++) {
+ for(i = 0; i < gf->getNumMeshElements(); i++) {
element = gf->getMeshElement(i);
- if (element->getNumVertices() == 3) {
+ if(element->getNumVertices() == 3) {
it2 = triangles.find(element);
- if (it2 == triangles.end()) {
+ if(it2 == triangles.end()) {
opt.push_back(element);
}
}
@@ -4489,22 +4672,24 @@ void PostOp::create_quads_on_boundary(GRegion* gr) {
gf->triangles.clear();
- for (i = 0; i < opt.size(); i++) {
- gf->triangles.push_back((MTriangle*)opt[i]);
+ for(i = 0; i < opt.size(); i++) {
+ gf->triangles.push_back((MTriangle *)opt[i]);
}
}
}
-void PostOp::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c, MVertex* d) {
+void PostOp::create_quads_on_boundary(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d)
+{
bool flag1, flag2;
MElement *element1, *element2;
- GFace *gf1;//,*gf2;
+ GFace *gf1; //,*gf2;
Tuple tuple1, tuple2;
std::multiset<Tuple>::iterator it1;
std::multiset<Tuple>::iterator it2;
gf1 = NULL;
- //gf2 = NULL;
+ // gf2 = NULL;
tuple1 = Tuple(a, b, c);
tuple2 = Tuple(c, d, a);
@@ -4515,12 +4700,12 @@ void PostOp::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c, MVerte
flag1 = 0;
flag2 = 0;
- while (it1 != tuples.end()) {
- if (tuple1.get_hash() != it1->get_hash()) {
+ while(it1 != tuples.end()) {
+ if(tuple1.get_hash() != it1->get_hash()) {
break;
}
- if (tuple1.same_vertices(*it1)) {
+ if(tuple1.same_vertices(*it1)) {
flag1 = 1;
element1 = it1->get_element();
gf1 = it1->get_gf();
@@ -4529,21 +4714,21 @@ void PostOp::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c, MVerte
it1++;
}
- while (it2 != tuples.end()) {
- if (tuple2.get_hash() != it2->get_hash()) {
+ while(it2 != tuples.end()) {
+ if(tuple2.get_hash() != it2->get_hash()) {
break;
}
- if (tuple2.same_vertices(*it2)) {
+ if(tuple2.same_vertices(*it2)) {
flag2 = 1;
element2 = it2->get_element();
- //gf2 = it2->get_gf();
+ // gf2 = it2->get_gf();
}
it2++;
}
- if (flag1 && flag2) {
+ if(flag1 && flag2) {
triangles.insert(element1);
triangles.insert(element2);
@@ -4559,12 +4744,12 @@ void PostOp::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c, MVerte
flag1 = 0;
flag2 = 0;
- while (it1 != tuples.end()) {
- if (tuple1.get_hash() != it1->get_hash()) {
+ while(it1 != tuples.end()) {
+ if(tuple1.get_hash() != it1->get_hash()) {
break;
}
- if (tuple1.same_vertices(*it1)) {
+ if(tuple1.same_vertices(*it1)) {
flag1 = 1;
element1 = it1->get_element();
gf1 = it1->get_gf();
@@ -4573,21 +4758,21 @@ void PostOp::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c, MVerte
it1++;
}
- while (it2 != tuples.end()) {
- if (tuple2.get_hash() != it2->get_hash()) {
+ while(it2 != tuples.end()) {
+ if(tuple2.get_hash() != it2->get_hash()) {
break;
}
- if (tuple2.same_vertices(*it2)) {
+ if(tuple2.same_vertices(*it2)) {
flag2 = 1;
element2 = it2->get_element();
- //gf2 = it2->get_gf();
+ // gf2 = it2->get_gf();
}
it2++;
}
- if (flag1 && flag2) {
+ if(flag1 && flag2) {
triangles.insert(element1);
triangles.insert(element2);
@@ -4595,41 +4780,58 @@ void PostOp::create_quads_on_boundary(MVertex* a, MVertex* b, MVertex* c, MVerte
}
}
-bool PostOp::four(MElement* element) {
- if (element->getNumVertices() == 4 && element->getNumFaces() == 4) return 1;
- else return 0;
+bool PostOp::four(MElement *element)
+{
+ if(element->getNumVertices() == 4 && element->getNumFaces() == 4)
+ return 1;
+ else
+ return 0;
}
-bool PostOp::fourTrih(MElement* element) {
- if (element->getNumVertices() == 4 && element->getNumFaces() == 3) return 1;
- else return 0;
+bool PostOp::fourTrih(MElement *element)
+{
+ if(element->getNumVertices() == 4 && element->getNumFaces() == 3)
+ return 1;
+ else
+ return 0;
}
-bool PostOp::five(MElement* element) {
- if (element->getNumVertices() == 5) return 1;
- else return 0;
+bool PostOp::five(MElement *element)
+{
+ if(element->getNumVertices() == 5)
+ return 1;
+ else
+ return 0;
}
-bool PostOp::six(MElement* element) {
- if (element->getNumVertices() == 6) return 1;
- else return 0;
+bool PostOp::six(MElement *element)
+{
+ if(element->getNumVertices() == 6)
+ return 1;
+ else
+ return 0;
}
-bool PostOp::eight(MElement* element) {
- if (element->getNumVertices() == 8) return 1;
- else return 0;
+bool PostOp::eight(MElement *element)
+{
+ if(element->getNumVertices() == 8)
+ return 1;
+ else
+ return 0;
}
-bool PostOp::equal(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4) {
- if ((v1 == v3 && v2 == v4) || (v1 == v4 && v2 == v3)) {
+bool PostOp::equal(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4)
+{
+ if((v1 == v3 && v2 == v4) || (v1 == v4 && v2 == v3)) {
return 1;
}
else {
return 0;
}
}
-bool PostOp::equal(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
- MVertex* va, MVertex* vb, MVertex* vc, MVertex* vd) {
+bool PostOp::equal(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MVertex *va, MVertex *vb, MVertex *vc, MVertex *vd)
+{
// return (v1==vd && v2==vc && v3==vb && v4==va) ||
// (v1==vc && v2==vb && v3==va && v4==vd) ||
// (v1==vb && v2==va && v3==vd && v4==vc) ||
@@ -4654,16 +4856,17 @@ bool PostOp::equal(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4,
// (v1==vc && v2==vd && v3==vb && v4==va) ||
// (v1==vb && v2==vc && v3==va && v4==vd) ||
// (v1==va && v2==vb && v3==vd && v4==vc);
- // assuming that at least (v1,v2,v3,v4) are all different vertices
- // or (va,vb,vc,vd) are all different vertices
+ // assuming that at least (v1,v2,v3,v4) are all different vertices
+ // or (va,vb,vc,vd) are all different vertices
return (v1 == va || v1 == vb || v1 == vc || v1 == vd) &&
- (v2 == va || v2 == vb || v2 == vc || v2 == vd) &&
- (v3 == va || v3 == vb || v3 == vc || v3 == vd) &&
- (v4 == va || v4 == vb || v4 == vc || v4 == vd);
+ (v2 == va || v2 == vb || v2 == vc || v2 == vd) &&
+ (v3 == va || v3 == vb || v3 == vc || v3 == vd) &&
+ (v4 == va || v4 == vb || v4 == vc || v4 == vd);
}
-bool PostOp::different(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4) {
- if (v1 != v3 && v1 != v4 && v2 != v3 && v2 != v4) {
+bool PostOp::different(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4)
+{
+ if(v1 != v3 && v1 != v4 && v2 != v3 && v2 != v4) {
return 1;
}
else {
@@ -4671,13 +4874,13 @@ bool PostOp::different(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4) {
}
}
-MVertex* PostOp::other(MElement* element, MVertex* v1, MVertex* v2) {
-
- MVertex* pointer = NULL;
+MVertex *PostOp::other(MElement *element, MVertex *v1, MVertex *v2)
+{
+ MVertex *pointer = NULL;
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
- if (getVertex != v1 && getVertex != v2) {
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
+ if(getVertex != v1 && getVertex != v2) {
pointer = getVertex;
break;
}
@@ -4686,13 +4889,13 @@ MVertex* PostOp::other(MElement* element, MVertex* v1, MVertex* v2) {
return pointer;
}
-MVertex* PostOp::other(MElement* element, MVertex* v1, MVertex* v2, MVertex* v3) {
-
- MVertex* pointer = NULL;
+MVertex *PostOp::other(MElement *element, MVertex *v1, MVertex *v2, MVertex *v3)
+{
+ MVertex *pointer = NULL;
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
- if (getVertex != v1 && getVertex != v2 && getVertex != v3) {
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
+ if(getVertex != v1 && getVertex != v2 && getVertex != v3) {
pointer = getVertex;
break;
}
@@ -4701,13 +4904,15 @@ MVertex* PostOp::other(MElement* element, MVertex* v1, MVertex* v2, MVertex* v3)
return pointer;
}
-void PostOp::mean(const std::set<MVertex*>& Ns, MVertex* mid, const std::vector<MElement*>& movables) {
+void PostOp::mean(const std::set<MVertex *> &Ns, MVertex *mid,
+ const std::vector<MElement *> &movables)
+{
unsigned int i;
int j;
bool flag;
double x, y, z;
double init_x, init_y, init_z;
- std::set<MVertex*>::const_iterator it;
+ std::set<MVertex *>::const_iterator it;
x = 0.0;
y = 0.0;
@@ -4717,7 +4922,7 @@ void PostOp::mean(const std::set<MVertex*>& Ns, MVertex* mid, const std::vector<
init_y = mid->y();
init_z = mid->z();
- for (it = Ns.begin(); it != Ns.end(); it++) {
+ for(it = Ns.begin(); it != Ns.end(); it++) {
x = x + (*it)->x();
y = y + (*it)->y();
z = z + (*it)->z();
@@ -4727,50 +4932,50 @@ void PostOp::mean(const std::set<MVertex*>& Ns, MVertex* mid, const std::vector<
y = y / Ns.size();
z = z / Ns.size();
- for (i = 0; i < movables.size(); i++) {
+ for(i = 0; i < movables.size(); i++) {
movables[i]->setVolumePositive();
}
mid->setXYZ(x, y, z);
- for (j = 0; j < 100; j++) {
+ for(j = 0; j < 100; j++) {
flag = 0;
- for (i = 0; i < movables.size(); i++) {
- if (movables[i]->getVolume() < 0.0) {
+ for(i = 0; i < movables.size(); i++) {
+ if(movables[i]->getVolume() < 0.0) {
flag = 1;
}
}
- if (!flag) {
+ if(!flag) {
break;
}
- x = 0.1*init_x + 0.9*mid->x();
- y = 0.1*init_y + 0.9*mid->y();
- z = 0.1*init_z + 0.9*mid->z();
+ x = 0.1 * init_x + 0.9 * mid->x();
+ y = 0.1 * init_y + 0.9 * mid->y();
+ z = 0.1 * init_z + 0.9 * mid->z();
mid->setXYZ(x, y, z);
}
iterations = iterations + j;
- for (j = 0; j < 6; j++) {
+ for(j = 0; j < 6; j++) {
flag = 0;
- for (i = 0; i < movables.size(); i++) {
- if (movables[i]->gammaShapeMeasure() < 0.2) {
+ for(i = 0; i < movables.size(); i++) {
+ if(movables[i]->gammaShapeMeasure() < 0.2) {
flag = 1;
}
}
- if (!flag) {
+ if(!flag) {
break;
}
- x = 0.1*init_x + 0.9*mid->x();
- y = 0.1*init_y + 0.9*mid->y();
- z = 0.1*init_z + 0.9*mid->z();
+ x = 0.1 * init_x + 0.9 * mid->x();
+ y = 0.1 * init_y + 0.9 * mid->y();
+ z = 0.1 * init_z + 0.9 * mid->z();
mid->setXYZ(x, y, z);
}
@@ -4778,16 +4983,19 @@ void PostOp::mean(const std::set<MVertex*>& Ns, MVertex* mid, const std::vector<
iterations = iterations + j;
}
-double PostOp::workaround(MElement* element) {
+double PostOp::workaround(MElement *element)
+{
double volume;
- MTetrahedron* temp1;
- MTetrahedron* temp2;
+ MTetrahedron *temp1;
+ MTetrahedron *temp2;
volume = 0.0;
- if (five(element)) {
- temp1 = new MTetrahedron(element->getVertex(0), element->getVertex(1), element->getVertex(2), element->getVertex(4));
- temp2 = new MTetrahedron(element->getVertex(2), element->getVertex(3), element->getVertex(0), element->getVertex(4));
+ if(five(element)) {
+ temp1 = new MTetrahedron(element->getVertex(0), element->getVertex(1),
+ element->getVertex(2), element->getVertex(4));
+ temp2 = new MTetrahedron(element->getVertex(2), element->getVertex(3),
+ element->getVertex(0), element->getVertex(4));
volume = fabs(temp1->getVolume()) + fabs(temp2->getVolume());
delete temp1;
delete temp2;
@@ -4796,31 +5004,39 @@ double PostOp::workaround(MElement* element) {
return volume;
}
-//For an element find a getVertex which is in a face inluding in but not out
-MVertex* PostOp::findInTriFace(MVertex* in0, MVertex* in1, MVertex* out0, MVertex* out1, MElement* element) {
- for (int iF = 0; iF < element->getNumFaces(); iF++) {
+// For an element find a getVertex which is in a face inluding in but not out
+MVertex *PostOp::findInTriFace(MVertex *in0, MVertex *in1, MVertex *out0,
+ MVertex *out1, MElement *element)
+{
+ for(int iF = 0; iF < element->getNumFaces(); iF++) {
const MFace &face = element->getFace(iF);
- if (face.getNumVertices() != 3) continue;
+ if(face.getNumVertices() != 3) continue;
int nbIn = 0;
int hasOut = false;
- for (int iV = 0; iV < 3; iV++) {
- if (face.getVertex(iV) == in0 || face.getVertex(iV) == in1) nbIn++;
- if (face.getVertex(iV) == out0 || face.getVertex(iV) == out1) { hasOut = true; continue; }
+ for(int iV = 0; iV < 3; iV++) {
+ if(face.getVertex(iV) == in0 || face.getVertex(iV) == in1) nbIn++;
+ if(face.getVertex(iV) == out0 || face.getVertex(iV) == out1) {
+ hasOut = true;
+ continue;
+ }
}
- if (nbIn == 2 && !hasOut)
- for (int iV = 0; iV < 3; iV++)
- if (face.getVertex(iV) != in0 && face.getVertex(iV) != in1) return face.getVertex(iV);
+ if(nbIn == 2 && !hasOut)
+ for(int iV = 0; iV < 3; iV++)
+ if(face.getVertex(iV) != in0 && face.getVertex(iV) != in1)
+ return face.getVertex(iV);
}
return NULL;
}
-MVertex* PostOp::find(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4, MElement* element) {
-
- MVertex* pointer = NULL;
+MVertex *PostOp::find(MVertex *v1, MVertex *v2, MVertex *v3, MVertex *v4,
+ MElement *element)
+{
+ MVertex *pointer = NULL;
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
- if (getVertex != v1 && getVertex != v2 && getVertex != v3 && getVertex != v4) {
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
+ if(getVertex != v1 && getVertex != v2 && getVertex != v3 &&
+ getVertex != v4) {
pointer = getVertex;
break;
}
@@ -4829,19 +5045,23 @@ MVertex* PostOp::find(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4, MEleme
return pointer;
}
-void PostOp::find_tetrahedra(MVertex* v1, MVertex* v2, std::set<MElement*>& final) {
+void PostOp::find_tetrahedra(MVertex *v1, MVertex *v2,
+ std::set<MElement *> &final)
+{
Vertex2Elements::iterator it1;
Vertex2Elements::iterator it2;
it1 = vertex_to_tetrahedra.find(v1);
it2 = vertex_to_tetrahedra.find(v2);
- if (it1 != vertex_to_tetrahedra.end() && it2 != vertex_to_tetrahedra.end()) {
+ if(it1 != vertex_to_tetrahedra.end() && it2 != vertex_to_tetrahedra.end()) {
intersection(it1->second, it2->second, final);
}
}
-void PostOp::find_tetrahedra(MVertex* v1, MVertex* v2, MVertex* v3, std::set<MElement*>& final) {
+void PostOp::find_tetrahedra(MVertex *v1, MVertex *v2, MVertex *v3,
+ std::set<MElement *> &final)
+{
Vertex2Elements::iterator it1;
Vertex2Elements::iterator it2;
Vertex2Elements::iterator it3;
@@ -4850,22 +5070,24 @@ void PostOp::find_tetrahedra(MVertex* v1, MVertex* v2, MVertex* v3, std::set<MEl
it2 = vertex_to_tetrahedra.find(v2);
it3 = vertex_to_tetrahedra.find(v3);
- std::set<MElement*> buf;
+ std::set<MElement *> buf;
- if (it1 != vertex_to_tetrahedra.end() && it2 != vertex_to_tetrahedra.end() && it3 != vertex_to_tetrahedra.end()) {
+ if(it1 != vertex_to_tetrahedra.end() && it2 != vertex_to_tetrahedra.end() &&
+ it3 != vertex_to_tetrahedra.end()) {
intersection(it1->second, it2->second, buf);
intersection(buf, it3->second, final);
-
}
}
-void PostOp::find_pyramids_from_tri(MVertex* v1, MVertex* v2, MVertex* v3, std::set<MElement*>& final) {
+void PostOp::find_pyramids_from_tri(MVertex *v1, MVertex *v2, MVertex *v3,
+ std::set<MElement *> &final)
+{
bool flag;
element_set_itr it;
Vertex2Elements::iterator it1;
Vertex2Elements::iterator it2;
Vertex2Elements::iterator it3;
- std::set<MElement*> temp1, temp2;
+ std::set<MElement *> temp1, temp2;
it1 = vertex_to_pyramids.find(v1);
it2 = vertex_to_pyramids.find(v2);
@@ -4874,44 +5096,48 @@ void PostOp::find_pyramids_from_tri(MVertex* v1, MVertex* v2, MVertex* v3, std::
temp1.clear();
temp2.clear();
- if (it1 != vertex_to_pyramids.end() && it2 != vertex_to_pyramids.end() && it3 != vertex_to_pyramids.end()) {
+ if(it1 != vertex_to_pyramids.end() && it2 != vertex_to_pyramids.end() &&
+ it3 != vertex_to_pyramids.end()) {
intersection(it1->second, it2->second, temp1);
intersection(temp1, it3->second, temp2);
}
- //Now temp2 contains pyramids containing the 3 vertices
- //We check that one getVertex is on the summit and the others are neighbors in the base
- for (it = temp2.begin(); it != temp2.end(); it++) {
+ // Now temp2 contains pyramids containing the 3 vertices
+ // We check that one getVertex is on the summit and the others are neighbors
+ // in the base
+ for(it = temp2.begin(); it != temp2.end(); it++) {
flag = false;
- if (v1 == (*it)->getVertex(4)) {
+ if(v1 == (*it)->getVertex(4)) {
flag = (equal(v2, v3, (*it)->getVertex(0), (*it)->getVertex(1)) ||
- equal(v2, v3, (*it)->getVertex(1), (*it)->getVertex(2)) ||
- equal(v2, v3, (*it)->getVertex(2), (*it)->getVertex(3)) ||
- equal(v2, v3, (*it)->getVertex(3), (*it)->getVertex(0)));
+ equal(v2, v3, (*it)->getVertex(1), (*it)->getVertex(2)) ||
+ equal(v2, v3, (*it)->getVertex(2), (*it)->getVertex(3)) ||
+ equal(v2, v3, (*it)->getVertex(3), (*it)->getVertex(0)));
}
- if (v2 == (*it)->getVertex(4)) {
+ if(v2 == (*it)->getVertex(4)) {
flag = (equal(v1, v3, (*it)->getVertex(0), (*it)->getVertex(1)) ||
- equal(v1, v3, (*it)->getVertex(1), (*it)->getVertex(2)) ||
- equal(v1, v3, (*it)->getVertex(2), (*it)->getVertex(3)) ||
- equal(v1, v3, (*it)->getVertex(3), (*it)->getVertex(0)));
+ equal(v1, v3, (*it)->getVertex(1), (*it)->getVertex(2)) ||
+ equal(v1, v3, (*it)->getVertex(2), (*it)->getVertex(3)) ||
+ equal(v1, v3, (*it)->getVertex(3), (*it)->getVertex(0)));
}
- if (v3 == (*it)->getVertex(4)) {
+ if(v3 == (*it)->getVertex(4)) {
flag = (equal(v1, v2, (*it)->getVertex(0), (*it)->getVertex(1)) ||
- equal(v1, v2, (*it)->getVertex(1), (*it)->getVertex(2)) ||
- equal(v1, v2, (*it)->getVertex(2), (*it)->getVertex(3)) ||
- equal(v1, v2, (*it)->getVertex(3), (*it)->getVertex(0)));
+ equal(v1, v2, (*it)->getVertex(1), (*it)->getVertex(2)) ||
+ equal(v1, v2, (*it)->getVertex(2), (*it)->getVertex(3)) ||
+ equal(v1, v2, (*it)->getVertex(3), (*it)->getVertex(0)));
}
- if (flag) {
+ if(flag) {
final.insert(*it);
}
}
}
-void PostOp::find_pyramids_from_quad(MVertex* v1, MVertex* v2, MVertex* v3, MVertex* v4, std::set<MElement*>& final) {
+void PostOp::find_pyramids_from_quad(MVertex *v1, MVertex *v2, MVertex *v3,
+ MVertex *v4, std::set<MElement *> &final)
+{
element_set_itr it;
Vertex2Elements::iterator it1;
Vertex2Elements::iterator it2;
Vertex2Elements::iterator it3;
Vertex2Elements::iterator it4;
- std::set<MElement*> temp1, temp2, temp3;
+ std::set<MElement *> temp1, temp2, temp3;
it1 = vertex_to_pyramids.find(v1);
it2 = vertex_to_pyramids.find(v2);
@@ -4922,42 +5148,43 @@ void PostOp::find_pyramids_from_quad(MVertex* v1, MVertex* v2, MVertex* v3, MVer
temp2.clear();
temp3.clear();
- if (it1 != vertex_to_pyramids.end() && it2 != vertex_to_pyramids.end() &&
- it3 != vertex_to_pyramids.end() && it4 != vertex_to_pyramids.end()) {
+ if(it1 != vertex_to_pyramids.end() && it2 != vertex_to_pyramids.end() &&
+ it3 != vertex_to_pyramids.end() && it4 != vertex_to_pyramids.end()) {
intersection(it1->second, it2->second, temp1);
intersection(temp1, it3->second, temp2);
intersection(temp2, it4->second, temp3);
}
- //Now temp3 contains pyramids containing the 4 vertices
- //We check that the 4 vertices are in the base
+ // Now temp3 contains pyramids containing the 4 vertices
+ // We check that the 4 vertices are in the base
// TODO: not necessary?
- for (it = temp2.begin(); it != temp2.end(); it++) {
- if (equal(v1, v2, v3, v4, (*it)->getVertex(0), (*it)->getVertex(1),
- (*it)->getVertex(2), (*it)->getVertex(3))) {
+ for(it = temp2.begin(); it != temp2.end(); it++) {
+ if(equal(v1, v2, v3, v4, (*it)->getVertex(0), (*it)->getVertex(1),
+ (*it)->getVertex(2), (*it)->getVertex(3))) {
final.insert(*it);
}
}
}
-
-void PostOp::find_pyramids(MVertex* v1, MVertex* v2, std::set<MElement*>& final) {
+void PostOp::find_pyramids(MVertex *v1, MVertex *v2,
+ std::set<MElement *> &final)
+{
bool flag1, flag2, flag3, flag4;
bool flag5, flag6, flag7, flag8;
element_set_itr it;
Vertex2Elements::iterator it1;
Vertex2Elements::iterator it2;
- std::set<MElement*> temp;
+ std::set<MElement *> temp;
it1 = vertex_to_pyramids.find(v1);
it2 = vertex_to_pyramids.find(v2);
temp.clear();
- if (it1 != vertex_to_pyramids.end() && it2 != vertex_to_pyramids.end()) {
+ if(it1 != vertex_to_pyramids.end() && it2 != vertex_to_pyramids.end()) {
intersection(it1->second, it2->second, temp);
}
- for (it = temp.begin(); it != temp.end(); it++) {
+ for(it = temp.begin(); it != temp.end(); it++) {
flag1 = equal(v1, v2, (*it)->getVertex(0), (*it)->getVertex(1));
flag2 = equal(v1, v2, (*it)->getVertex(1), (*it)->getVertex(2));
flag3 = equal(v1, v2, (*it)->getVertex(2), (*it)->getVertex(3));
@@ -4966,13 +5193,14 @@ void PostOp::find_pyramids(MVertex* v1, MVertex* v2, std::set<MElement*>& final)
flag6 = equal(v1, v2, (*it)->getVertex(1), (*it)->getVertex(4));
flag7 = equal(v1, v2, (*it)->getVertex(2), (*it)->getVertex(4));
flag8 = equal(v1, v2, (*it)->getVertex(3), (*it)->getVertex(4));
- if (flag1 || flag2 || flag3 || flag4 || flag5 || flag6 || flag7 || flag8) {
+ if(flag1 || flag2 || flag3 || flag4 || flag5 || flag6 || flag7 || flag8) {
final.insert(*it);
}
}
}
-//void PostOp::find_pyramids(MVertex* v1,MVertex* v2,std::set<MElement*>& final){
+// void PostOp::find_pyramids(MVertex* v1,MVertex* v2,std::set<MElement*>&
+// final){
// bool flag1,flag2,flag3,flag4;
// bool flag5,flag6,flag7,flag8;
// element_set_itr it;
@@ -5004,164 +5232,181 @@ void PostOp::find_pyramids(MVertex* v1, MVertex* v2, std::set<MElement*>& final)
// }
//}
-
-void PostOp::intersection(const std::set<MElement*>& bin1, const std::set<MElement*>& bin2, std::set<MElement*>& final) {
- std::set_intersection(bin1.begin(), bin1.end(), bin2.begin(), bin2.end(), std::inserter(final, final.end()));
+void PostOp::intersection(const std::set<MElement *> &bin1,
+ const std::set<MElement *> &bin2,
+ std::set<MElement *> &final)
+{
+ std::set_intersection(bin1.begin(), bin1.end(), bin2.begin(), bin2.end(),
+ std::inserter(final, final.end()));
}
-void PostOp::build_vertex_to_tetrahedra(GRegion* gr) {
+void PostOp::build_vertex_to_tetrahedra(GRegion *gr)
+{
unsigned int i;
- MElement* element;
+ MElement *element;
vertex_to_tetrahedra.clear();
- for (i = 0; i < gr->getNumMeshElements(); i++) {
+ for(i = 0; i < gr->getNumMeshElements(); i++) {
element = gr->getMeshElement(i);
- if (four(element)) {
+ if(four(element)) {
build_vertex_to_tetrahedra(element);
}
}
}
-void PostOp::build_vertex_to_tetrahedra(MElement* element) {
-
- std::set<MElement*> bin;
+void PostOp::build_vertex_to_tetrahedra(MElement *element)
+{
+ std::set<MElement *> bin;
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
Vertex2Elements::iterator it = vertex_to_tetrahedra.find(getVertex);
- if (it != vertex_to_tetrahedra.end()) {
+ if(it != vertex_to_tetrahedra.end()) {
it->second.insert(element);
}
else {
bin.clear();
bin.insert(element);
- vertex_to_tetrahedra.insert(std::pair<MVertex*, std::set<MElement*> >(getVertex, bin));
+ vertex_to_tetrahedra.insert(
+ std::pair<MVertex *, std::set<MElement *> >(getVertex, bin));
}
}
}
-void PostOp::erase_vertex_to_tetrahedra(MElement* element) {
-
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
+void PostOp::erase_vertex_to_tetrahedra(MElement *element)
+{
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
Vertex2Elements::iterator it = vertex_to_tetrahedra.find(getVertex);
- if (it != vertex_to_tetrahedra.end()) {
+ if(it != vertex_to_tetrahedra.end()) {
it->second.erase(element);
}
}
}
-void PostOp::build_vertex_to_pyramids(GRegion* gr) {
-
+void PostOp::build_vertex_to_pyramids(GRegion *gr)
+{
vertex_to_pyramids.clear();
- for (GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
- MElement* element = gr->getMeshElement(i);
- if (five(element)) {
+ for(GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *element = gr->getMeshElement(i);
+ if(five(element)) {
build_vertex_to_pyramids(element);
}
}
}
-void PostOp::build_vertex_to_pyramids(MElement* element) {
-
- std::set<MElement*> bin;
+void PostOp::build_vertex_to_pyramids(MElement *element)
+{
+ std::set<MElement *> bin;
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
Vertex2Elements::iterator it = vertex_to_pyramids.find(getVertex);
- if (it != vertex_to_pyramids.end()) {
+ if(it != vertex_to_pyramids.end()) {
it->second.insert(element);
}
else {
bin.clear();
bin.insert(element);
- vertex_to_pyramids.insert(std::pair<MVertex*, std::set<MElement*> >(getVertex, bin));
+ vertex_to_pyramids.insert(
+ std::pair<MVertex *, std::set<MElement *> >(getVertex, bin));
}
}
}
-void PostOp::erase_vertex_to_pyramids(MElement* element) {
-
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
+void PostOp::erase_vertex_to_pyramids(MElement *element)
+{
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
Vertex2Elements::iterator it = vertex_to_pyramids.find(getVertex);
- if (it != vertex_to_pyramids.end()) {
+ if(it != vertex_to_pyramids.end()) {
it->second.erase(element);
}
}
}
-
-void PostOp::build_vertex_to_hexPrism(GRegion* gr) {
-
+void PostOp::build_vertex_to_hexPrism(GRegion *gr)
+{
vertex_to_hexPrism.clear();
- for (GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
- MElement* element = gr->getMeshElement(i);
- if (six(element) || eight(element)) {
+ for(GRegion::size_type i = 0; i < gr->getNumMeshElements(); i++) {
+ MElement *element = gr->getMeshElement(i);
+ if(six(element) || eight(element)) {
build_vertex_to_hexPrism(element);
}
}
}
-void PostOp::build_vertex_to_hexPrism(MElement* element) {
-
- std::set<MElement*> bin;
+void PostOp::build_vertex_to_hexPrism(MElement *element)
+{
+ std::set<MElement *> bin;
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
Vertex2Elements::iterator it = vertex_to_hexPrism.find(getVertex);
- if (it != vertex_to_hexPrism.end()) {
+ if(it != vertex_to_hexPrism.end()) {
it->second.insert(element);
}
else {
bin.clear();
bin.insert(element);
- vertex_to_hexPrism.insert(std::pair<MVertex*, std::set<MElement*> >(getVertex, bin));
+ vertex_to_hexPrism.insert(
+ std::pair<MVertex *, std::set<MElement *> >(getVertex, bin));
}
}
}
-void PostOp::erase_vertex_to_hexPrism(MElement* element) {
-
- for (std::size_t i = 0; i < element->getNumVertices(); i++) {
- MVertex* getVertex = element->getVertex(i);
+void PostOp::erase_vertex_to_hexPrism(MElement *element)
+{
+ for(std::size_t i = 0; i < element->getNumVertices(); i++) {
+ MVertex *getVertex = element->getVertex(i);
Vertex2Elements::iterator it = vertex_to_hexPrism.find(getVertex);
- if (it != vertex_to_hexPrism.end()) {
+ if(it != vertex_to_hexPrism.end()) {
it->second.erase(element);
}
}
}
-
-
-//Angle between two triangular faces located on the boundary should be high enough
-bool PostOp::valid(MPyramid *pyr) {
- MVertex *V[4] = { pyr->getVertex(0), pyr->getVertex(1), pyr->getVertex(2), pyr->getVertex(3) };
+// Angle between two triangular faces located on the boundary should be high
+// enough
+bool PostOp::valid(MPyramid *pyr)
+{
+ MVertex *V[4] = {pyr->getVertex(0), pyr->getVertex(1), pyr->getVertex(2),
+ pyr->getVertex(3)};
MVertex *apex = pyr->getVertex(4);
- if (apex->onWhat()->dim() < 3) {
- for (int iP = 0; iP < 4; iP++) { //loop on pairs of triangles
+ if(apex->onWhat()->dim() < 3) {
+ for(int iP = 0; iP < 4; iP++) { // loop on pairs of triangles
int nbBndNodes = 0;
- if (V[(0 + iP) % 4]->onWhat()->dim() < 3) nbBndNodes++;
- if (V[(1 + iP) % 4]->onWhat()->dim() < 3) nbBndNodes++;
- if (V[(2 + iP) % 4]->onWhat()->dim() < 3) nbBndNodes++;
- if (nbBndNodes == 3) {
- SVector3 vec1 = SVector3(V[(0 + iP) % 4]->x() - apex->x(), V[(0 + iP) % 4]->y() - apex->y(), V[(0 + iP) % 4]->z() - apex->z()).unit();
- SVector3 vec2 = SVector3(V[(1 + iP) % 4]->x() - apex->x(), V[(1 + iP) % 4]->y() - apex->y(), V[(1 + iP) % 4]->z() - apex->z()).unit();
- SVector3 vec3 = SVector3(V[(2 + iP) % 4]->x() - apex->x(), V[(2 + iP) % 4]->y() - apex->y(), V[(2 + iP) % 4]->z() - apex->z()).unit();
+ if(V[(0 + iP) % 4]->onWhat()->dim() < 3) nbBndNodes++;
+ if(V[(1 + iP) % 4]->onWhat()->dim() < 3) nbBndNodes++;
+ if(V[(2 + iP) % 4]->onWhat()->dim() < 3) nbBndNodes++;
+ if(nbBndNodes == 3) {
+ SVector3 vec1 = SVector3(V[(0 + iP) % 4]->x() - apex->x(),
+ V[(0 + iP) % 4]->y() - apex->y(),
+ V[(0 + iP) % 4]->z() - apex->z())
+ .unit();
+ SVector3 vec2 = SVector3(V[(1 + iP) % 4]->x() - apex->x(),
+ V[(1 + iP) % 4]->y() - apex->y(),
+ V[(1 + iP) % 4]->z() - apex->z())
+ .unit();
+ SVector3 vec3 = SVector3(V[(2 + iP) % 4]->x() - apex->x(),
+ V[(2 + iP) % 4]->y() - apex->y(),
+ V[(2 + iP) % 4]->z() - apex->z())
+ .unit();
SVector3 crossVec1Vec2 = crossprod(vec1, vec2);
- double angle = std::abs(std::acos(dot(crossVec1Vec2, vec3)) * 180 / M_PI);
+ double angle =
+ std::abs(std::acos(dot(crossVec1Vec2, vec3)) * 180 / M_PI);
double minAngle = 30;
- if (std::abs(angle - 90) < minAngle) return false;
+ if(std::abs(angle - 90) < minAngle) return false;
}
}
}
@@ -5171,13 +5416,13 @@ bool PostOp::valid(MPyramid *pyr) {
// Why template?
template <class T>
void export_the_clique_graphviz_format(cliques_compatibility_graph<T> &cl,
- int clique_number, string filename)
+ int clique_number, string filename)
{
ofstream out(filename.c_str());
out << "Graph G {" << endl;
typename multimap<int, set<T> >::reverse_iterator it_all = cl.allQ.rbegin();
- for (int i = 0; i < clique_number; i++) {
+ for(int i = 0; i < clique_number; i++) {
it_all++;
}
// int clique_size = it_all->second.size();
@@ -5189,16 +5434,18 @@ void export_the_clique_graphviz_format(cliques_compatibility_graph<T> &cl,
multimap<int, int> done;
// export all hex
- typename cliques_compatibility_graph<T>::graph::const_iterator itgraph = cl.begin_graph();
- typename cliques_compatibility_graph<T>::graph_data::const_iterator itgraphdata;
+ typename cliques_compatibility_graph<T>::graph::const_iterator itgraph =
+ cl.begin_graph();
+ typename cliques_compatibility_graph<T>::graph_data::const_iterator
+ itgraphdata;
- for (; itgraph != cl.end_graph(); itgraph++) {
+ for(; itgraph != cl.end_graph(); itgraph++) {
T firsthex = itgraph->second.first;
// if (!post_check_validation(firsthex)) continue;
typename map<T, int>::iterator itfind = visited_hex.find(firsthex);
int num1 = 0;
- if (itfind == visited_hex.end()) {
+ if(itfind == visited_hex.end()) {
num1 = counter;
visited_hex[firsthex] = counter++;
}
@@ -5206,12 +5453,12 @@ void export_the_clique_graphviz_format(cliques_compatibility_graph<T> &cl,
num1 = itfind->second;
}
itgraphdata = itgraph->second.second.begin();
- for (; itgraphdata != itgraph->second.second.end(); itgraphdata++) {
+ for(; itgraphdata != itgraph->second.second.end(); itgraphdata++) {
T secondhex = itgraphdata->second;
// if (!post_check_validation(secondhex)) continue;
itfind = visited_hex.find(secondhex);
int num2 = 0;
- if (itfind == visited_hex.end()) {
+ if(itfind == visited_hex.end()) {
num2 = counter;
visited_hex[secondhex] = counter++;
}
@@ -5222,13 +5469,14 @@ void export_the_clique_graphviz_format(cliques_compatibility_graph<T> &cl,
bool found = false;
pair<multimap<int, int>::iterator, multimap<int, int>::iterator> range =
done.equal_range(num1);
- for (multimap<int, int>::iterator it = range.first; it != range.second; it++) {
- if (it->second == num2) {
+ for(multimap<int, int>::iterator it = range.first; it != range.second;
+ it++) {
+ if(it->second == num2) {
found = true;
break;
}
}
- if (!found) {
+ if(!found) {
done.insert(make_pair(num1, num2));
done.insert(make_pair(num2, num1));
out << num1 << " -- " << num2 << " ;" << endl;
@@ -5236,9 +5484,10 @@ void export_the_clique_graphviz_format(cliques_compatibility_graph<T> &cl,
}
}
// export chosen hex with different color
- for (; ithex != ithexen; ithex++) { // brutal post-check: random pickup of hexahedra in clique
+ for(; ithex != ithexen;
+ ithex++) { // brutal post-check: random pickup of hexahedra in clique
typename map<T, int>::iterator itfind = visited_hex.find(*ithex);
- if (itfind == visited_hex.end()) {
+ if(itfind == visited_hex.end()) {
cout << "graph export: should not happen ! " << endl;
throw;
int num2 = 0;
@@ -5247,25 +5496,24 @@ void export_the_clique_graphviz_format(cliques_compatibility_graph<T> &cl,
out << num2 << " [shape=circle, style=filled, fillcolor=red];" << endl;
}
else
- out << itfind->second << " [shape=circle, style=filled, fillcolor=red];" << endl;
+ out << itfind->second << " [shape=circle, style=filled, fillcolor=red];"
+ << endl;
}
out << "}" << endl;
out.close();
}
-template<class T>
-clique_stop_criteria<T>::clique_stop_criteria(map<T, std::set<MElement*> > &_m, int _i)
- : hex_to_tet(_m), total_number_tet(_i)
-{
-};
+template <class T>
+clique_stop_criteria<T>::clique_stop_criteria(map<T, std::set<MElement *> > &_m,
+ int _i)
+ : hex_to_tet(_m), total_number_tet(_i){};
-template<class T>
-clique_stop_criteria<T>::~clique_stop_criteria() {};
+template <class T> clique_stop_criteria<T>::~clique_stop_criteria(){};
-template<class T>
-void clique_stop_criteria<T>::export_corresponding_mesh
-(const graph_data_no_hash &clique) const
+template <class T>
+void clique_stop_criteria<T>::export_corresponding_mesh(
+ const graph_data_no_hash &clique) const
{
// NB: fct not often called...
@@ -5274,16 +5522,17 @@ void clique_stop_criteria<T>::export_corresponding_mesh
string filenametets("best_clique_so_far_remaining_tets.msh");
// create set of all tets
- set<MElement*> tets;
- set<MElement*> hexs;
- map<MVertex*, int> vertices;
+ set<MElement *> tets;
+ set<MElement *> hexs;
+ map<MVertex *, int> vertices;
int counterv = 1;
- typename map<T, std::set<MElement*> >::const_iterator it = hex_to_tet.begin();
- for (; it != hex_to_tet.end(); it++) {
- std::set<MElement*>::const_iterator itt = it->second.begin();
- for (; itt != it->second.end(); itt++) {
+ typename map<T, std::set<MElement *> >::const_iterator it =
+ hex_to_tet.begin();
+ for(; it != hex_to_tet.end(); it++) {
+ std::set<MElement *>::const_iterator itt = it->second.begin();
+ for(; itt != it->second.end(); itt++) {
tets.insert(*itt);
- for (int i = 0; i < 4; i++) {
+ for(int i = 0; i < 4; i++) {
vertices.insert(make_pair((*itt)->getVertex(i), counterv));
counterv++;
}
@@ -5291,21 +5540,28 @@ void clique_stop_criteria<T>::export_corresponding_mesh
}
// create MHexahedron, remove included tets from set "tets"
- for (typename graph_data_no_hash::const_iterator it = clique.begin();
- it != clique.end(); it++) {
- typename map<T, std::set<MElement*> >::const_iterator itfind = hex_to_tet.find(*it);
- if (itfind == hex_to_tet.end()) {
- cout << "clique_stop_criteria::void export_corresponding_mesh : not found !!!" << endl;
+ for(typename graph_data_no_hash::const_iterator it = clique.begin();
+ it != clique.end(); it++) {
+ typename map<T, std::set<MElement *> >::const_iterator itfind =
+ hex_to_tet.find(*it);
+ if(itfind == hex_to_tet.end()) {
+ cout << "clique_stop_criteria::void export_corresponding_mesh : not "
+ "found !!!"
+ << endl;
throw;
}
// remove tets
- for (set<MElement*>::const_iterator ittet = itfind->second.begin(); ittet != itfind->second.end(); ittet++) {
+ for(set<MElement *>::const_iterator ittet = itfind->second.begin();
+ ittet != itfind->second.end(); ittet++) {
tets.erase(*ittet);
}
// create MHexahedron
- Hex* hex = *it;
- MHexahedron *h = new MHexahedron(hex->getVertex(0), hex->getVertex(1), hex->getVertex(2), hex->getVertex(3), hex->getVertex(4), hex->getVertex(5), hex->getVertex(6), hex->getVertex(7));
- for (int i = 0; i < 8; i++) {
+ Hex *hex = *it;
+ MHexahedron *h =
+ new MHexahedron(hex->getVertex(0), hex->getVertex(1), hex->getVertex(2),
+ hex->getVertex(3), hex->getVertex(4), hex->getVertex(5),
+ hex->getVertex(6), hex->getVertex(7));
+ for(int i = 0; i < 8; i++) {
vertices.insert(make_pair(hex->getVertex(i), counterv));
counterv++;
}
@@ -5315,25 +5571,36 @@ void clique_stop_criteria<T>::export_corresponding_mesh
// export mesh FIXME: why not use MElement::writeMSH
ofstream out(filename.c_str());
ofstream outtets(filenametets.c_str());
- out << "$MeshFormat" << endl << "2.2 0 8" << endl << "$EndMeshFormat"
- << endl << "$Nodes" << endl << vertices.size() << endl;
- outtets << "$MeshFormat" << endl << "2.2 0 8" << endl << "$EndMeshFormat"
- << endl << "$Nodes" << endl << vertices.size() << endl;
+ out << "$MeshFormat" << endl
+ << "2.2 0 8" << endl
+ << "$EndMeshFormat" << endl
+ << "$Nodes" << endl
+ << vertices.size() << endl;
+ outtets << "$MeshFormat" << endl
+ << "2.2 0 8" << endl
+ << "$EndMeshFormat" << endl
+ << "$Nodes" << endl
+ << vertices.size() << endl;
// write vertices
- for (map<MVertex*, int>::iterator it = vertices.begin(); it != vertices.end(); it++) {
- out << it->second << " " << it->first->x() << " "
- << it->first->y() << " " << it->first->z() << endl;
- outtets << it->second << " " << it->first->x() << " "
- << it->first->y() << " " << it->first->z() << endl;
- }
- out << "$EndNodes" << endl << "$Elements" << endl << (hexs.size() + tets.size()) << endl;
- outtets << "$EndNodes" << endl << "$Elements" << endl << (hexs.size() + tets.size()) << endl;
+ for(map<MVertex *, int>::iterator it = vertices.begin(); it != vertices.end();
+ it++) {
+ out << it->second << " " << it->first->x() << " " << it->first->y() << " "
+ << it->first->z() << endl;
+ outtets << it->second << " " << it->first->x() << " " << it->first->y()
+ << " " << it->first->z() << endl;
+ }
+ out << "$EndNodes" << endl
+ << "$Elements" << endl
+ << (hexs.size() + tets.size()) << endl;
+ outtets << "$EndNodes" << endl
+ << "$Elements" << endl
+ << (hexs.size() + tets.size()) << endl;
// write hexs
int counter = 1;
int countertets = 1;
- for (set<MElement*>::iterator it = hexs.begin(); it != hexs.end(); it++) {
+ for(set<MElement *>::iterator it = hexs.begin(); it != hexs.end(); it++) {
out << counter << " 5 2 0 26";
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
MVertex *v = (*it)->getVertex(i);
out << " " << vertices[v];
}
@@ -5341,10 +5608,10 @@ void clique_stop_criteria<T>::export_corresponding_mesh
counter++;
}
// write tets
- for (set<MElement*>::iterator it = tets.begin(); it != tets.end(); it++) {
+ for(set<MElement *>::iterator it = tets.begin(); it != tets.end(); it++) {
out << counter << " 4 2 0 26";
outtets << counter << " 4 2 0 26";
- for (std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
+ for(std::size_t i = 0; i < (*it)->getNumVertices(); i++) {
MVertex *v = (*it)->getVertex(i);
out << " " << vertices[v];
outtets << " " << vertices[v];
@@ -5360,50 +5627,54 @@ void clique_stop_criteria<T>::export_corresponding_mesh
outtets.close();
}
-
-template<class T>
-bool clique_stop_criteria<T>::stop(const graph_data_no_hash &clique)const
+template <class T>
+bool clique_stop_criteria<T>::stop(const graph_data_no_hash &clique) const
{
unsigned int total = 0;
// need to detect slivers !!!!!!!!!!!!!!!!!!!!!!!!!!
// it seems like slivers are presents in different potential hex.
- // So, can be located by finding dupli!cates, instead of computing volumes...??????
+ // So, can be located by finding dupli!cates, instead of computing
+ // volumes...??????
- set<MElement*> thetets;
+ set<MElement *> thetets;
// set<MElement*> slivers;
- for (typename graph_data_no_hash::const_iterator it = clique.begin(); it != clique.end(); it++) {
- typename map<T, std::set<MElement*> >::const_iterator itfind = hex_to_tet.find(*it);
- if (itfind == hex_to_tet.end()) {
+ for(typename graph_data_no_hash::const_iterator it = clique.begin();
+ it != clique.end(); it++) {
+ typename map<T, std::set<MElement *> >::const_iterator itfind =
+ hex_to_tet.find(*it);
+ if(itfind == hex_to_tet.end()) {
cout << "clique_stop_criteria::bool stop : not found !!!" << endl;
throw;
}
// total += (itfind->second.size());
// cout << "volumes=" << endl;
- for (set<MElement*>::const_iterator ittet = itfind->second.begin(); ittet != itfind->second.end(); ittet++) {
+ for(set<MElement *>::const_iterator ittet = itfind->second.begin();
+ ittet != itfind->second.end(); ittet++) {
// set<MElement*>::iterator itfindtet = thetets.find(*ittet);
// if (itfindtet!=thetets.end()){
// cout << "Tet " << *ittet << " already done !!!" << endl;
// slivers.insert(*ittet);
// }
thetets.insert(*ittet);
- //cout << (*ittet) << " : " << (*ittet)->getVolume()<< endl;;
+ // cout << (*ittet) << " : " << (*ittet)->getVolume()<< endl;;
}
-
-
}
// to be sure, adding volume criteria...
vector<double> volumes;
- for (set<MElement*>::iterator it = thetets.begin(); it != thetets.end(); it++) {
+ for(set<MElement *>::iterator it = thetets.begin(); it != thetets.end();
+ it++) {
volumes.push_back((*it)->getVolume());
}
- int meanvolume = (std::accumulate(volumes.begin(), volumes.end(), 0)) / volumes.size();
+ int meanvolume =
+ (std::accumulate(volumes.begin(), volumes.end(), 0)) / volumes.size();
int nb_slivers = 0;
- double threshold = 1.e-3*meanvolume;
- for (set<MElement*>::iterator it = thetets.begin(); it != thetets.end(); it++) {
- if ((*it)->getVolume() < threshold) {
+ double threshold = 1.e-3 * meanvolume;
+ for(set<MElement *>::iterator it = thetets.begin(); it != thetets.end();
+ it++) {
+ if((*it)->getVolume() < threshold) {
nb_slivers++;
}
}
@@ -5412,68 +5683,54 @@ bool clique_stop_criteria<T>::stop(const graph_data_no_hash &clique)const
// cout << "# tet = " << total << " on " << total_number_tet << endl;
// cout << "#slivers = " << slivers.size() << endl;
- if (total >= total_number_tet) {
- cout << endl << " ************** criteria reached, domain is filled with hex !!! ***************" << endl << endl;
- return true;// the maximum clique is maximum !!! only hex !!!
+ if(total >= total_number_tet) {
+ cout << endl
+ << " ************** criteria reached, domain is filled with hex !!! "
+ "***************"
+ << endl
+ << endl;
+ return true; // the maximum clique is maximum !!! only hex !!!
}
return false;
}
-
-template<class T>
+template <class T>
cliques_compatibility_graph<T>::cliques_compatibility_graph(
- graph &_g,
- const map<T, std::vector<double> > &_hex_ranks,
- unsigned int _max_nb_cliques,
- unsigned int _nb_hex_potentiels,
- clique_stop_criteria<T> *csc,
- ptrfunction_export fct
- ):
- found_the_ultimate_max_clique(false),
- export_clique_graph(fct),
- debug(false),
- max_nb_cliques(_max_nb_cliques),
- nb_hex_potentiels(_nb_hex_potentiels),
- max_clique_size(0),
- position(0),
- total_nodes_number(0),
- total_nb_of_cliques_searched(0),
- max_nb_of_stored_cliques(10),
- criteria(csc),
- cancel_search(false),
- hex_ranks(_hex_ranks),
- G(_g)
-{
-};
+ graph &_g, const map<T, std::vector<double> > &_hex_ranks,
+ unsigned int _max_nb_cliques, unsigned int _nb_hex_potentiels,
+ clique_stop_criteria<T> *csc, ptrfunction_export fct)
+ : found_the_ultimate_max_clique(false), export_clique_graph(fct),
+ debug(false), max_nb_cliques(_max_nb_cliques),
+ nb_hex_potentiels(_nb_hex_potentiels), max_clique_size(0), position(0),
+ total_nodes_number(0), total_nb_of_cliques_searched(0),
+ max_nb_of_stored_cliques(10), criteria(csc), cancel_search(false),
+ hex_ranks(_hex_ranks), G(_g){};
-template<class T>
-cliques_compatibility_graph<T>::~cliques_compatibility_graph()
-{
-};
+template <class T>
+cliques_compatibility_graph<T>::~cliques_compatibility_graph(){};
-template<class T>
-void cliques_compatibility_graph<T>::find_cliques()
+template <class T> void cliques_compatibility_graph<T>::find_cliques()
{
// init
graph_data s;
- for (typename graph::iterator it = G.begin(); it != G.end(); it++) {
+ for(typename graph::iterator it = G.begin(); it != G.end(); it++) {
s.insert(make_pair(it->first, it->second.first));
}
find_cliques(s, 0);
- if (!cancel_search) {
- cout << total_nb_of_cliques_searched << " cliques have been found." << endl << flush;
+ if(!cancel_search) {
+ cout << total_nb_of_cliques_searched << " cliques have been found." << endl
+ << flush;
}
-
};
-template<class T>
-void cliques_compatibility_graph<T>::export_cliques()
+template <class T> void cliques_compatibility_graph<T>::export_cliques()
{
typename multimap<int, set<T> >::reverse_iterator itstore = allQ.rbegin();
- for (; itstore != allQ.rend(); itstore++) {
+ for(; itstore != allQ.rend(); itstore++) {
cout << "clique of size " << itstore->first << ": {";
- for (typename set<T>::iterator it = itstore->second.begin(); it != itstore->second.end(); it++) {
+ for(typename set<T>::iterator it = itstore->second.begin();
+ it != itstore->second.end(); it++) {
cout << *it << " ";
}
cout << "}" << endl;
@@ -5482,18 +5739,19 @@ void cliques_compatibility_graph<T>::export_cliques()
// A clique was found. Store it sometimes and decide what to do next.
// Shall we continue looking for better cliques or not.
-template<class T>
-void cliques_compatibility_graph<T>::store_clique(int n)
+template <class T> void cliques_compatibility_graph<T>::store_clique(int n)
{
total_nb_of_cliques_searched++;
// Should the search for other cliques be stopped?
// --- Criteria on the number of cliques
- if ((max_nb_cliques != 0) && (total_nb_of_cliques_searched >= max_nb_cliques)) {
+ if((max_nb_cliques != 0) &&
+ (total_nb_of_cliques_searched >= max_nb_cliques)) {
cancel_search = true;
}
- // --- Criteria on the space filling of the cliques - all tets are in a hex - we filled the domain :)
- if (criteria->stop(Q)) {
+ // --- Criteria on the space filling of the cliques - all tets are in a hex -
+ // we filled the domain :)
+ if(criteria->stop(Q)) {
cancel_search = true;
found_the_ultimate_max_clique = true;
}
@@ -5501,10 +5759,10 @@ void cliques_compatibility_graph<T>::store_clique(int n)
// Should we store the clique and/or delete some other cliques?
bool store_it = true;
bool delete_worst = false;
- if (max_nb_of_stored_cliques && allQ.size()>=max_nb_of_stored_cliques) {
+ if(max_nb_of_stored_cliques && allQ.size() >= max_nb_of_stored_cliques) {
// We have not enough space, a choice is to be made
int worst_clique_size = (allQ.begin())->first;
- if ((int)Q.size() <= worst_clique_size) {
+ if((int)Q.size() <= worst_clique_size) {
// The current clique is smaller than the smallest already stored
store_it = false;
}
@@ -5513,10 +5771,12 @@ void cliques_compatibility_graph<T>::store_clique(int n)
delete_worst = true;
}
}
- if (store_it) {
- typename multimap<int, set<T> >::iterator itstore = allQ.insert(make_pair(Q.size(), set<T>()));
+ if(store_it) {
+ typename multimap<int, set<T> >::iterator itstore =
+ allQ.insert(make_pair(Q.size(), set<T>()));
itstore->second.insert(Q.begin(), Q.end());
- //for (typename graph_data_no_hash::iterator it = Q.begin(); it != Q.end(); it++) {
+ // for (typename graph_data_no_hash::iterator it = Q.begin(); it != Q.end();
+ // it++) {
// itstore->second.insert(*it);
// if (debug) {
// //for (int i=0;i<n;i++) cout << " ";
@@ -5525,58 +5785,65 @@ void cliques_compatibility_graph<T>::store_clique(int n)
//}
}
// finally, possibly delete worst clique, to reduce memory footprint
- if (delete_worst) {
+ if(delete_worst) {
allQ.erase(allQ.begin());
}
bool found_best_clique_so_far = Q.size() > max_clique_size;
- if (found_best_clique_so_far) {
+ if(found_best_clique_so_far) {
max_clique_size = Q.size();
- cout << "found a maximum clique of size " << Q.size() << ", exporting" << endl;
+ cout << "found a maximum clique of size " << Q.size() << ", exporting"
+ << endl;
}
- if (found_best_clique_so_far) {
+ if(found_best_clique_so_far) {
string filename("best_clique_so_far.dot");
- export_clique_graph(const_cast<cliques_compatibility_graph<T>&>(*this), 0, filename);
+ export_clique_graph(const_cast<cliques_compatibility_graph<T> &>(*this), 0,
+ filename);
criteria->export_corresponding_mesh(Q);
}
// Printing info mess
const bool verbose = false;
- if (verbose) cout << "MAX CLIQUE found of size " << Q.size() << " # total cliques searched:" << total_nb_of_cliques_searched << endl;
-
- if (total_nb_of_cliques_searched % 10000 == 0) {
- if (max_nb_cliques > 0)
- cout << "found " << total_nb_of_cliques_searched << " cliques on " << max_nb_cliques << endl << flush;
+ if(verbose)
+ cout << "MAX CLIQUE found of size " << Q.size()
+ << " # total cliques searched:" << total_nb_of_cliques_searched
+ << endl;
+
+ if(total_nb_of_cliques_searched % 10000 == 0) {
+ if(max_nb_cliques > 0)
+ cout << "found " << total_nb_of_cliques_searched << " cliques on "
+ << max_nb_cliques << endl
+ << flush;
else
- cout << "found " << total_nb_of_cliques_searched << " cliques " << endl << flush;
+ cout << "found " << total_nb_of_cliques_searched << " cliques " << endl
+ << flush;
}
- if (debug) {
- for (int i = 0; i < n; i++) cout << " ";
+ if(debug) {
+ for(int i = 0; i < n; i++) cout << " ";
cout << "MAX CLIQUE found of size " << Q.size() << ": ";
}
-
-
};
// Recursive function to find all maximal cliques in the input subgraph.
// Implements more or less the algorithm proposed in
-// "The worst-case complexity for generating all maximal cliques and computational experiments"
+// "The worst-case complexity for generating all maximal cliques and
+// computational experiments"
// Tomita et al., 2006. doi 10.1016/j.tcs.2006.06.015
//
// Very very very inefficient.
//
// What is n? the index of the clique being explored??.
-template<class T>
+template <class T>
void cliques_compatibility_graph<T>::find_cliques(graph_data &subgraph, int n)
{
// possible end
- if (subgraph.size() == 0) {
+ if(subgraph.size() == 0) {
store_clique(n);
return;
}
- if (subgraph.size() == 1) {
+ if(subgraph.size() == 1) {
typename graph_data::iterator ittemp = subgraph.begin();
T u = ittemp->second;
Q.insert(u);
@@ -5585,7 +5852,7 @@ void cliques_compatibility_graph<T>::find_cliques(graph_data &subgraph, int n)
return;
}
- T u = NULL; // Let's face it, this is a pointer.
+ T u = NULL; // Let's face it, this is a pointer.
hash_key u_key = 0;
// Choose the pivot: the node of the subgraph that
// has a maximum number of adjacent nodes in the set of candidates
@@ -5599,15 +5866,16 @@ void cliques_compatibility_graph<T>::find_cliques(graph_data &subgraph, int n)
split_set_BW(u, u_key, subgraph, white, black);
// Explore all candidate and branches from there
- while (white.size() > 0) {
+ while(white.size() > 0) {
Q.insert(u);
- if (n == 0) {
- total_nodes_number = std::max(total_nodes_number, (unsigned int)white.size());
+ if(n == 0) {
+ total_nodes_number =
+ std::max(total_nodes_number, (unsigned int)white.size());
position++;
}
find_cliques(black, n + 1);
- if (cancel_search) {
+ if(cancel_search) {
break;
}
@@ -5616,25 +5884,25 @@ void cliques_compatibility_graph<T>::find_cliques(graph_data &subgraph, int n)
Q.erase(u);
black.clear();
- if (white.size() > 0) {
+ if(white.size() > 0) {
typename graph_data::iterator ittemp = white.begin();
u = ittemp->second;
u_key = ittemp->first;
- fill_black_set(u, u_key, subgraph, black);// building the black set only
+ fill_black_set(u, u_key, subgraph, black); // building the black set only
}
}
}
-
-template<class T>
-void cliques_compatibility_graph<T>::erase_entry(graph_data &subgraph, T &u, hash_key &key)
+template <class T>
+void cliques_compatibility_graph<T>::erase_entry(graph_data &subgraph, T &u,
+ hash_key &key)
{
pair<typename graph_data::iterator, typename graph_data::iterator> range =
subgraph.equal_range(key);
typename graph_data::iterator it = range.first;
- for (; it != range.second; it++) {
- if (it->second == u) {
+ for(; it != range.second; it++) {
+ if(it->second == u) {
subgraph.erase(it);
return;
}
@@ -5643,14 +5911,17 @@ void cliques_compatibility_graph<T>::erase_entry(graph_data &subgraph, T &u, has
// Chooses the node which ahs the maximum number of neighbors in the subgraph.
// Does not implement exactly what's is the paper [Tomita et al. 2006] where u
-// is chosen to maximize the intersection of its neighbors in the CAND subset. No idea why. JP.
-template<class T>
-void cliques_compatibility_graph<T>::choose_u(const graph_data &subgraph, T &u, hash_key &u_key)
+// is chosen to maximize the intersection of its neighbors in the CAND subset.
+// No idea why. JP.
+template <class T>
+void cliques_compatibility_graph<T>::choose_u(const graph_data &subgraph, T &u,
+ hash_key &u_key)
{
double valuemax = -DBL_MAX;
- for (typename graph_data::const_iterator it = subgraph.begin(); it != subgraph.end(); it++) {
+ for(typename graph_data::const_iterator it = subgraph.begin();
+ it != subgraph.end(); it++) {
double value = function_to_maximize_for_u(it->second, it->first, subgraph);
- if (value > valuemax) {
+ if(value > valuemax) {
valuemax = value;
u = it->second;
u_key = it->first;
@@ -5658,75 +5929,76 @@ void cliques_compatibility_graph<T>::choose_u(const graph_data &subgraph, T &u,
}
}
-template<class T>
-void cliques_compatibility_graph<T>::split_set_BW(
- const T &u,
- const hash_key &u_key,
- const graph_data &subgraph,
- graph_data &white,
- graph_data &black)
+template <class T>
+void cliques_compatibility_graph<T>::split_set_BW(const T &u,
+ const hash_key &u_key,
+ const graph_data &subgraph,
+ graph_data &white,
+ graph_data &black)
{
// splitting set subgraph into white and black nodes
white.insert(make_pair(u_key, u));
typename graph_data::const_iterator it = subgraph.begin();
- for (; it != subgraph.end(); it++) {
- if (u == (it->second)) continue;
- if (!compatibility(u, u_key, it->second, it->first))
+ for(; it != subgraph.end(); it++) {
+ if(u == (it->second)) continue;
+ if(!compatibility(u, u_key, it->second, it->first))
white.insert(make_pair(it->first, it->second));
else
black.insert(make_pair(it->first, it->second));
}
}
-
-
-template<class T>
-void cliques_compatibility_graph<T>::fill_black_set(const T &u, const hash_key &u_key,
- const graph_data &subgraph, graph_data &black)
+template <class T>
+void cliques_compatibility_graph<T>::fill_black_set(const T &u,
+ const hash_key &u_key,
+ const graph_data &subgraph,
+ graph_data &black)
{
// filling black set
typename graph_data::const_iterator it = subgraph.begin();
- for (; it != subgraph.end(); it++) {
- if (u == (it->second)) continue;
- if (compatibility(u, u_key, it->second, it->first))
+ for(; it != subgraph.end(); it++) {
+ if(u == (it->second)) continue;
+ if(compatibility(u, u_key, it->second, it->first))
black.insert(make_pair(it->first, it->second));
}
}
-
// Count the number of neighbors of u in the input graph
-// We are looking for the u that has a maximal number of adjacent nodes in the graph
-template<class T>
+// We are looking for the u that has a maximal number of adjacent nodes in the
+// graph
+template <class T>
double cliques_compatibility_graph<T>::function_to_maximize_for_u(
- const T &u,
- const hash_key &u_key,
- const graph_data &subgraph)
+ const T &u, const hash_key &u_key, const graph_data &subgraph)
{
int counter = 0;
- for (typename graph_data::const_iterator it = subgraph.begin(); it != subgraph.end(); it++) {
- if ((it->second) == u) continue;
- if (compatibility(u, u_key, it->second, it->first))
- counter++;
+ for(typename graph_data::const_iterator it = subgraph.begin();
+ it != subgraph.end(); it++) {
+ if((it->second) == u) continue;
+ if(compatibility(u, u_key, it->second, it->first)) counter++;
}
return (double)counter;
}
-
// Returns true if v is adjacent to u in graph G
-template<class T>
-bool cliques_compatibility_graph<T>::compatibility(const T &u, const hash_key &u_key,
- const T &v, const hash_key &v_key)
+template <class T>
+bool cliques_compatibility_graph<T>::compatibility(const T &u,
+ const hash_key &u_key,
+ const T &v,
+ const hash_key &v_key)
{
// Find u data
- pair<typename graph::const_iterator, typename graph::const_iterator> range_ukey = G.equal_range(u_key);
+ pair<typename graph::const_iterator, typename graph::const_iterator>
+ range_ukey = G.equal_range(u_key);
typename graph::const_iterator itfind_u = range_ukey.first;
- for (; itfind_u != range_ukey.second; itfind_u++) {
- if (itfind_u->second.first == u) break;
+ for(; itfind_u != range_ukey.second; itfind_u++) {
+ if(itfind_u->second.first == u) break;
}
// Check if v is in u data
- pair<typename graph_data::const_iterator, typename graph_data::const_iterator> range_vkey = itfind_u->second.second.equal_range(v_key);
- for (typename graph_data::const_iterator itfind_v = range_vkey.first; itfind_v != range_vkey.second; itfind_v++) {
- if (itfind_v->second == v) {
+ pair<typename graph_data::const_iterator, typename graph_data::const_iterator>
+ range_vkey = itfind_u->second.second.equal_range(v_key);
+ for(typename graph_data::const_iterator itfind_v = range_vkey.first;
+ itfind_v != range_vkey.second; itfind_v++) {
+ if(itfind_v->second == v) {
return true;
}
}
@@ -5734,164 +6006,162 @@ bool cliques_compatibility_graph<T>::compatibility(const T &u, const hash_key &u
}
// Returns true if v is NOT adjacent to u in graph G
-template<class T>
-bool cliques_losses_graph<T>::compatibility(
- const T &u, const hash_key &u_key,
- const T &v, const hash_key &v_key)
+template <class T>
+bool cliques_losses_graph<T>::compatibility(const T &u, const hash_key &u_key,
+ const T &v, const hash_key &v_key)
{
return !cliques_compatibility_graph<T>::compatibility(u, u_key, v, v_key);
}
-
-template<class T>
-cliques_losses_graph<T>::cliques_losses_graph (
- graph &_g,
- const map<T, std::vector<double> > &_hex_ranks,
- unsigned int _max_nb_cliques,
- unsigned int _nb_hex_potentiels,
- clique_stop_criteria<T> *csc,
- ptrfunction_export fct
-)
+template <class T>
+cliques_losses_graph<T>::cliques_losses_graph(
+ graph &_g, const map<T, std::vector<double> > &_hex_ranks,
+ unsigned int _max_nb_cliques, unsigned int _nb_hex_potentiels,
+ clique_stop_criteria<T> *csc, ptrfunction_export fct)
: cliques_compatibility_graph<T>(_g, _hex_ranks, _max_nb_cliques,
- _nb_hex_potentiels, csc, fct)/*, G(_g)*/
-{
-};
-
-template<class T>
-cliques_losses_graph<T>::~cliques_losses_graph() {
-};
+ _nb_hex_potentiels, csc, fct) /*, G(_g)*/
+ {};
+template <class T> cliques_losses_graph<T>::~cliques_losses_graph(){};
//////////////////////////////////////////////////////////////////////////////////////////////////////////
-PEEntity::PEEntity(const vector<MVertex*> &_v) :vertices(_v) {
+PEEntity::PEEntity(const vector<MVertex *> &_v) : vertices(_v)
+{
compute_hash();
}
-//PEEntity::PEEntity(unsigned long long l):hash(l){
+// PEEntity::PEEntity(unsigned long long l):hash(l){
//}
-void PEEntity::compute_hash() {
+void PEEntity::compute_hash()
+{
hash = 0;
- for (vector<MVertex*>::const_iterator it = vertices.begin(); it != vertices.end(); it++)
+ for(vector<MVertex *>::const_iterator it = vertices.begin();
+ it != vertices.end(); it++)
hash += (*it)->getNum();
}
-size_t PEEntity::get_hash() const {
- return hash;
-}
+size_t PEEntity::get_hash() const { return hash; }
PEEntity::~PEEntity() {}
-MVertex* PEEntity::getVertex(size_t n)const {
- if ((n > get_max_nb_vertices()) || vertices.empty()) {
- cout << " PEEntity::getVertex : wrong getVertex number : int n = " << n << endl;
+MVertex *PEEntity::getVertex(size_t n) const
+{
+ if((n > get_max_nb_vertices()) || vertices.empty()) {
+ cout << " PEEntity::getVertex : wrong getVertex number : int n = " << n
+ << endl;
throw;
}
return vertices[n];
}
-bool PEEntity::hasVertex(MVertex *v)const {
+bool PEEntity::hasVertex(MVertex *v) const
+{
return (find(vertices.begin(), vertices.end(), v) != vertices.end());
}
-bool PEEntity::same_vertices(const PEEntity *t)const {
- for (vector<MVertex*>::const_iterator it = vertices.begin(); it != vertices.end(); it++) {
- if (!(t->hasVertex(*it)))
- return false;
+bool PEEntity::same_vertices(const PEEntity *t) const
+{
+ for(vector<MVertex *>::const_iterator it = vertices.begin();
+ it != vertices.end(); it++) {
+ if(!(t->hasVertex(*it))) return false;
}
return true;
}
-bool PEEntity::operator<(const PEEntity& t) const {
+bool PEEntity::operator<(const PEEntity &t) const
+{
return hash < t.get_hash();
}
-//bool PEEntity::operator==(const PEEntity& t) const{
+// bool PEEntity::operator==(const PEEntity& t) const{
// return (hash==t.get_hash());
//}
-//bool PEEntity::operator==(const size_t& l) const{
+// bool PEEntity::operator==(const size_t& l) const{
// return (hash==l);
//}
+PELine::~PELine(){};
-PELine::~PELine() {};
-
-PELine::PELine(const vector<MVertex*> &_v) :PEEntity(_v) {
- if (vertices.size() != get_max_nb_vertices()) {
+PELine::PELine(const vector<MVertex *> &_v) : PEEntity(_v)
+{
+ if(vertices.size() != get_max_nb_vertices()) {
cout << "PELine: wrong number of vertices given !!! aborting ! " << endl;
throw;
}
compute_hash();
}
-size_t PELine::get_max_nb_vertices()const { return 2; };
+size_t PELine::get_max_nb_vertices() const { return 2; };
+PETriangle::~PETriangle(){};
-PETriangle::~PETriangle() {};
-
-PETriangle::PETriangle(const vector<MVertex*> &_v) :PEEntity(_v) {
- if (vertices.size() != get_max_nb_vertices()) {
- cout << "PETriangle: wrong number of vertices given !!! aborting ! " << endl;
+PETriangle::PETriangle(const vector<MVertex *> &_v) : PEEntity(_v)
+{
+ if(vertices.size() != get_max_nb_vertices()) {
+ cout << "PETriangle: wrong number of vertices given !!! aborting ! "
+ << endl;
throw;
}
compute_hash();
}
-//PETriangle::PETriangle(const unsigned long long l):PEEntity(l){
+// PETriangle::PETriangle(const unsigned long long l):PEEntity(l){
//}
-size_t PETriangle::get_max_nb_vertices()const { return 3; };
+size_t PETriangle::get_max_nb_vertices() const { return 3; };
+PEQuadrangle::~PEQuadrangle(){};
-PEQuadrangle::~PEQuadrangle() {};
-
-PEQuadrangle::PEQuadrangle(const vector<MVertex*> &_v) :PEEntity(_v) {
- if (vertices.size() != get_max_nb_vertices()) {
- cout << "PEQuadrangle: wrong number of vertices given !!! aborting ! " << endl;
+PEQuadrangle::PEQuadrangle(const vector<MVertex *> &_v) : PEEntity(_v)
+{
+ if(vertices.size() != get_max_nb_vertices()) {
+ cout << "PEQuadrangle: wrong number of vertices given !!! aborting ! "
+ << endl;
throw;
}
compute_hash();
}
-//PEQuadrangle::PEQuadrangle(const unsigned long long l):PEEntity(l){
+// PEQuadrangle::PEQuadrangle(const unsigned long long l):PEEntity(l){
//}
-size_t PEQuadrangle::get_max_nb_vertices()const { return 4; };
+size_t PEQuadrangle::get_max_nb_vertices() const { return 4; };
// Check the validity of the hex
// and add it to the potential hex.
// TODO -- WE NEED ASSERTIONS in release mode and a command line to print stuff
-// TODO -- Implement clear validity checks - topological validity and geometrical validity
-// WARNING this function seems to be a mess -- I expect it to do not work as expected. JP.
-// Stuff are commented, the test to check if a potential exist seems does not work
-// and is bypassed.
-void Recombinator_Graph::fill_tet_to_hex_table(Hex *hex) {
+// TODO -- Implement clear validity checks - topological validity and
+// geometrical validity WARNING this function seems to be a mess -- I expect it
+// to do not work as expected. JP. Stuff are commented, the test to check if a
+// potential exist seems does not work and is bypassed.
+void Recombinator_Graph::fill_tet_to_hex_table(Hex *hex)
+{
const bool very_verbose = false;
const bool bypass = true;
- if (very_verbose) {
+ if(very_verbose) {
cout << " fill_tet_to_hex_table:: treating hex " << hex << " made of ";
- for (int i = 0; i < 8; i++)
- cout << " " << hex->getVertex(i)->getNum();
+ for(int i = 0; i < 8; i++) cout << " " << hex->getVertex(i)->getNum();
cout << endl;
}
- if (!valid(*hex, tet_mesh)) {
- if (very_verbose) cout << "NOT VALID hex !!! " << endl;
+ if(!valid(*hex, tet_mesh)) {
+ if(very_verbose) cout << "NOT VALID hex !!! " << endl;
delete hex;
return;
}
MElement *element;
- std::set<MElement*> parts;
+ std::set<MElement *> parts;
// recovering all the tets forming the current hex
parts.clear();
::find(*hex, parts, tet_mesh);
- if (!valid(*hex, parts)) {
- if (very_verbose) cout << " NOT VALID hex (parts) " << endl;
+ if(!valid(*hex, parts)) {
+ if(very_verbose) cout << " NOT VALID hex (parts) " << endl;
delete hex;
return;
}
@@ -5900,75 +6170,90 @@ void Recombinator_Graph::fill_tet_to_hex_table(Hex *hex) {
// first, check if the hex has the right number of vertices (=8 !!!)
// non, c'est pas toujours le cas !!! ???
- set<MVertex*> vertices;
- for (element_set_itr it = parts.begin(); it != parts.end(); it++) {
+ set<MVertex *> vertices;
+ for(element_set_itr it = parts.begin(); it != parts.end(); it++) {
element = *it;
- for (int i = 0; i < 4; i++) {
+ for(int i = 0; i < 4; i++) {
vertices.insert(element->getVertex(i));
}
}
- if (vertices.size() != 8) {
- if (very_verbose) cout << "------------- WARNING !!!!! An hex has " << vertices.size() << "vertices" << endl;
+ if(vertices.size() != 8) {
+ if(very_verbose)
+ cout << "------------- WARNING !!!!! An hex has " << vertices.size()
+ << "vertices" << endl;
delete hex;
return;
}
- // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
- // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
- // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
- // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
- // le test suivant déconne, cf. cube à 125 hex... sais pas pourquoi, mais ça élimine des hex potentiels
- // tout à fait valides (et nécessaires à la solution optimale)!!!
- // dans le cas cube125: ce test fait passer le #hex potentiels recensés par les patterns de recombinaison
- // d'environ 1000 à 2434 ??? !!!, ça double aussi le nbre d'hex dans le graphe des pertes
- // en fait, si les noeuds par exemple a b c d deviennent b c d a, on a une rotation et un hex tout pourri...
- // mais qui a même hash et mêmes noeuds ?!?!
- // now, check if the hex already exists...
- if (!bypass) {
- graph_data::const_iterator itfind = find_the_created_potential_hex(hex, created_potential_hex);
- if (itfind != created_potential_hex.end()) {
+ // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!! le test suivant déconne, cf. cube à 125
+ // hex... sais pas pourquoi, mais ça élimine des hex potentiels tout à fait
+ // valides (et nécessaires à la solution optimale)!!! dans le cas cube125: ce
+ // test fait passer le #hex potentiels recensés par les patterns de
+ // recombinaison d'environ 1000 à 2434 ??? !!!, ça double aussi le nbre d'hex
+ // dans le graphe des pertes en fait, si les noeuds par exemple a b c d
+ // deviennent b c d a, on a une rotation et un hex tout pourri... mais qui a
+ // même hash et mêmes noeuds ?!?! now, check if the hex already exists...
+ if(!bypass) {
+ graph_data::const_iterator itfind =
+ find_the_created_potential_hex(hex, created_potential_hex);
+ if(itfind != created_potential_hex.end()) {
delete hex;
- if (very_verbose)
- cout << " WARNING: current hex already exists in the created potentiel hex database. Not adding the hex." << endl;
+ if(very_verbose)
+ cout << " WARNING: current hex already exists in the created potentiel "
+ "hex database. Not adding the hex."
+ << endl;
return;
}
}
- // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
- // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
- // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
- // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
-
-
- // counting the number of triangular external faces. If different from 12, discard the hex !
- // if not, build the face/hex table
- std::multimap<unsigned long long, pair<PETriangle*, int> > faces_temp;
- for (element_set_itr it_tet = parts.begin(); it_tet != parts.end(); it_tet++) {// for all tets
- for (int i = 0; i < 4; i++) {// for all faces
+ // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!! TODO !!!!
+ // TODO !!!! TODO !!!!
+
+ // counting the number of triangular external faces. If different from 12,
+ // discard the hex ! if not, build the face/hex table
+ std::multimap<unsigned long long, pair<PETriangle *, int> > faces_temp;
+ for(element_set_itr it_tet = parts.begin(); it_tet != parts.end();
+ it_tet++) { // for all tets
+ for(int i = 0; i < 4; i++) { // for all faces
MFace f = (*it_tet)->getFace(i);
add_face(f.getVertex(0), f.getVertex(1), f.getVertex(2), faces_temp);
}
}
int count = 0;
- std::multimap<unsigned long long, pair<PETriangle*, int> >::iterator it_face = faces_temp.begin();
- std::multimap<unsigned long long, pair<PETriangle*, int> >::iterator it_faceen = faces_temp.end();
- for (; it_face != it_faceen; it_face++)// counting
- if (it_face->second.second == 1)
- count++;
-
- if (count != 12) {
- if (very_verbose) cout << "------------- WARNING !!!!! fill_tet_to_hex_table:: hex has "
- << count << " faces ... discard the hex." << endl;
+ std::multimap<unsigned long long, pair<PETriangle *, int> >::iterator
+ it_face = faces_temp.begin();
+ std::multimap<unsigned long long, pair<PETriangle *, int> >::iterator
+ it_faceen = faces_temp.end();
+ for(; it_face != it_faceen; it_face++) // counting
+ if(it_face->second.second == 1) count++;
+
+ if(count != 12) {
+ if(very_verbose)
+ cout << "------------- WARNING !!!!! fill_tet_to_hex_table:: hex has "
+ << count << " faces ... discard the hex." << endl;
delete hex;
return;
}
-
it_face = faces_temp.begin();
- for (; it_face != it_faceen; it_face++) {// for all faces, storing the external faces
+ for(; it_face != it_faceen;
+ it_face++) { // for all faces, storing the external faces
PETriangle *t = it_face->second.first;
- if (it_face->second.second == 1)
+ if(it_face->second.second == 1)
add_face(t->getVertex(0), t->getVertex(1), t->getVertex(2), hex);
else
delete t;
@@ -5981,35 +6266,36 @@ void Recombinator_Graph::fill_tet_to_hex_table(Hex *hex) {
// might be a source of the above problem... but I am quite unsure. JP.
created_potential_hex.insert(make_pair(hex->get_hash(), hex));
add_edges(hex);
- for (element_set_itr it = parts.begin(); it != parts.end(); it++) {
+ for(element_set_itr it = parts.begin(); it != parts.end(); it++) {
element = *it;
tet_to_hex[element].insert(hex);
hex_to_tet[hex].insert(element);
}
- if (very_verbose) {
+ if(very_verbose) {
export_single_hex_all(hex, "");
}
}
-
-void Recombinator_Graph::buildGraphOnly(unsigned int max_nb_cliques, string filename) {
- GRegion* gr;
- GModel* model = GModel::current();
+void Recombinator_Graph::buildGraphOnly(unsigned int max_nb_cliques,
+ string filename)
+{
+ GRegion *gr;
+ GModel *model = GModel::current();
GModel::riter it;
- for (it = model->firstRegion(); it != model->lastRegion(); it++)
- {
+ for(it = model->firstRegion(); it != model->lastRegion(); it++) {
gr = *it;
- if (gr->getNumMeshElements() > 0) {
+ if(gr->getNumMeshElements() > 0) {
buildGraphOnly(gr, max_nb_cliques, filename);
}
}
}
-
-void Recombinator_Graph::buildGraphOnly(GRegion* gr, unsigned int max_nb_cliques, string filename) {
-
+void Recombinator_Graph::buildGraphOnly(GRegion *gr,
+ unsigned int max_nb_cliques,
+ string filename)
+{
set_current_region(gr);
tet_mesh.initialize(current_region);
@@ -6026,30 +6312,30 @@ void Recombinator_Graph::buildGraphOnly(GRegion* gr, unsigned int max_nb_cliques
found_the_ultimate_max_clique = false;
}
-
-
-void Recombinator_Graph::execute_blossom(unsigned int max_nb_cliques, string filename) {
- GRegion* gr;
- GModel* model = GModel::current();
+void Recombinator_Graph::execute_blossom(unsigned int max_nb_cliques,
+ string filename)
+{
+ GRegion *gr;
+ GModel *model = GModel::current();
GModel::riter it;
model->writeMSH("beforeyamakawa.msh");
- for (it = model->firstRegion(); it != model->lastRegion(); it++)
- {
+ for(it = model->firstRegion(); it != model->lastRegion(); it++) {
gr = *it;
- if (gr->getNumMeshElements() > 0) {
+ if(gr->getNumMeshElements() > 0) {
execute_blossom(gr, max_nb_cliques, filename);
}
}
}
-
-Recombinator_Graph::~Recombinator_Graph() {
- for (iter it = triangular_faces.begin(); it != triangular_faces.end(); it++) {
+Recombinator_Graph::~Recombinator_Graph()
+{
+ for(iter it = triangular_faces.begin(); it != triangular_faces.end(); it++) {
delete it->second;
}
- for (linemap::iterator it = edges_and_diagonals.begin(); it != edges_and_diagonals.end(); it++) {
+ for(linemap::iterator it = edges_and_diagonals.begin();
+ it != edges_and_diagonals.end(); it++) {
delete it->second;
}
@@ -6057,18 +6343,15 @@ Recombinator_Graph::~Recombinator_Graph() {
// that it is hard to tell which pointers are actually owned by the class. JP
}
-
-void Recombinator_Graph::createBlossomInfo() {
-
+void Recombinator_Graph::createBlossomInfo()
+{
throw;
-
- GRegion* gr;
- GModel* model = GModel::current();
+ GRegion *gr;
+ GModel *model = GModel::current();
GModel::riter it;
- for (it = model->firstRegion(); it != model->lastRegion(); it++)
- {
+ for(it = model->firstRegion(); it != model->lastRegion(); it++) {
gr = *it;
// if(gr->getNumMeshElements()>0){
createBlossomInfo(gr);
@@ -6076,25 +6359,26 @@ void Recombinator_Graph::createBlossomInfo() {
}
}
-
-void Recombinator_Graph::createBlossomInfo(GRegion *gr) {
-
+void Recombinator_Graph::createBlossomInfo(GRegion *gr)
+{
throw;
- // remove quads, create triangles, and store blossom information (triangles pairs)
- std::vector<GFace*> faces = gr->faces();
+ // remove quads, create triangles, and store blossom information (triangles
+ // pairs)
+ std::vector<GFace *> faces = gr->faces();
GFace *gf;
MElement *element;
PETriangle *t11, *t12, *t21, *t22;
cout << "recover blossom info" << endl;
- for (std::vector<GFace*>::iterator it = faces.begin(); it != faces.end(); it++) {
+ for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end();
+ it++) {
gf = *it;
- std::vector<MQuadrangle*>::iterator it_quad = gf->quadrangles.begin();
+ std::vector<MQuadrangle *>::iterator it_quad = gf->quadrangles.begin();
- for (; it_quad != gf->quadrangles.end(); it_quad++) {
+ for(; it_quad != gf->quadrangles.end(); it_quad++) {
element = *it_quad;
// recovering triangular faces
@@ -6115,15 +6399,15 @@ void Recombinator_Graph::createBlossomInfo(GRegion *gr) {
tri_to_gface_info[t22] = gf;
// adding triangles
- gf->addTriangle(new MTriangle(element->getVertex(0), element->getVertex(1), element->getVertex(2)));
- gf->addTriangle(new MTriangle(element->getVertex(0), element->getVertex(2), element->getVertex(3)));
-
+ gf->addTriangle(new MTriangle(
+ element->getVertex(0), element->getVertex(1), element->getVertex(2)));
+ gf->addTriangle(new MTriangle(
+ element->getVertex(0), element->getVertex(2), element->getVertex(3)));
}
// deleting quads
gf->quadrangles.clear();
}
-
// // cut pyramids in 2 tets, remove pyramids
// std::vector<MPyramid*>::iterator it_pyramid = gr->pyramids.begin();
// MPyramid *p;
@@ -6134,8 +6418,10 @@ void Recombinator_Graph::createBlossomInfo(GRegion *gr) {
// // arbirary cut of the pyramid...
// p = *it_pyramid;
// // add tets
- // gr->addTetrahedron(new MTetrahedron(p->getVertex(0), p->getVertex(1),p->getVertex(2),p->getVertex(4)));
- // gr->addTetrahedron(new MTetrahedron(p->getVertex(0), p->getVertex(2),p->getVertex(3),p->getVertex(4)));
+ // gr->addTetrahedron(new MTetrahedron(p->getVertex(0),
+ // p->getVertex(1),p->getVertex(2),p->getVertex(4)));
+ // gr->addTetrahedron(new MTetrahedron(p->getVertex(0),
+ // p->getVertex(2),p->getVertex(3),p->getVertex(4)));
//
// // add triangles to the right GFace
// v.clear();
@@ -6145,12 +6431,15 @@ void Recombinator_Graph::createBlossomInfo(GRegion *gr) {
// t11 = new PETriangle(v);
// it_find_tri = find_the_triangle(t11, triangular_faces);
// if (it_find_tri != triangular_faces.end()){
- // std::list<GFace*>::iterator it_find_face = std::find(faces.begin(), faces.end(),tri_to_gface_info[it_find_tri->second]);
- // if (it_find_face!=faces.end()){
- // (*it_find_face)->addTriangle(new MTriangle(p->getVertex(0), p->getVertex(1), p->getVertex(2)));
+ // std::list<GFace*>::iterator it_find_face = std::find(faces.begin(),
+ // faces.end(),tri_to_gface_info[it_find_tri->second]); if
+ // (it_find_face!=faces.end()){
+ // (*it_find_face)->addTriangle(new MTriangle(p->getVertex(0),
+ // p->getVertex(1), p->getVertex(2)));
// }
// else
- // cout << "WARNING blossom: face not found ! Can't add triangle !" << endl;
+ // cout << "WARNING blossom: face not found ! Can't add triangle !" <<
+ // endl;
// }
// else
// cout << "WARNING blossom: triangle not found ! " << endl;
@@ -6163,12 +6452,15 @@ void Recombinator_Graph::createBlossomInfo(GRegion *gr) {
// t11 = new PETriangle(v);
// it_find_tri = find_the_triangle(t11, triangular_faces);
// if (it_find_tri != triangular_faces.end()){
- // std::list<GFace*>::iterator it_find_face = std::find(faces.begin(), faces.end(),tri_to_gface_info[it_find_tri->second]);
- // if (it_find_face!=faces.end()){
- // (*it_find_face)->addTriangle(new MTriangle(p->getVertex(0), p->getVertex(2),p->getVertex(3)));
+ // std::list<GFace*>::iterator it_find_face = std::find(faces.begin(),
+ // faces.end(),tri_to_gface_info[it_find_tri->second]); if
+ // (it_find_face!=faces.end()){
+ // (*it_find_face)->addTriangle(new MTriangle(p->getVertex(0),
+ // p->getVertex(2),p->getVertex(3)));
// }
// else
- // cout << "WARNING blossom: face not found ! Can't add triangle !" << endl;
+ // cout << "WARNING blossom: face not found ! Can't add triangle !" <<
+ // endl;
// }
// else
// cout << "WARNING blossom: triangle not found ! " << endl;
@@ -6177,16 +6469,12 @@ void Recombinator_Graph::createBlossomInfo(GRegion *gr) {
// // erase all pyramids
// cout << "erasing all pyramids" << endl;
// gr->pyramids.clear();
-
-
-
-
}
-
-
-void Recombinator_Graph::execute_blossom(GRegion* gr, unsigned int max_nb_cliques, string filename) {
-
+void Recombinator_Graph::execute_blossom(GRegion *gr,
+ unsigned int max_nb_cliques,
+ string filename)
+{
throw;
initialize_structures(gr);
@@ -6195,7 +6483,6 @@ void Recombinator_Graph::execute_blossom(GRegion* gr, unsigned int max_nb_clique
tet_to_hex.clear();
created_potential_hex.clear();
-
Msg::Info("Building Connectivity...");
double a = Cpu();
@@ -6203,30 +6490,33 @@ void Recombinator_Graph::execute_blossom(GRegion* gr, unsigned int max_nb_clique
compute_potential_hexes();
create_losses_graph(gr);
- // add points to potential hexas containing original blossom pairs of triangles
+ // add points to potential hexas containing original blossom pairs of
+ // triangles
compute_hex_ranks_blossom();
double time_building_graph = (Cpu() - a);
-
a = Cpu();
// a criteria to stop when the whole domain is exclusively composed of hex
- clique_stop_criteria<Hex*> criteria(hex_to_tet, gr->tetrahedra.size());
+ clique_stop_criteria<Hex *> criteria(hex_to_tet, gr->tetrahedra.size());
- cliques_losses_graph<Hex*> cl(incompatibility_graph, hex_ranks, max_nb_cliques, hex_to_tet.size(), &criteria, export_the_clique_graphviz_format);
+ cliques_losses_graph<Hex *> cl(incompatibility_graph, hex_ranks,
+ max_nb_cliques, hex_to_tet.size(), &criteria,
+ export_the_clique_graphviz_format);
cl.find_cliques();
- //cl.export_cliques();
-
+ // cl.export_cliques();
double time_cliques = (Cpu() - a);
cout << "RECOMBINATOR_GRAPH timing:" << endl;
- cout << " ------- TIME BUILDING GRAPH : " << time_building_graph << " subgraph." << endl;
- cout << " ------- TIME CLIQUE : " << time_cliques << " subgraph." << endl;
+ cout << " ------- TIME BUILDING GRAPH : " << time_building_graph
+ << " subgraph." << endl;
+ cout << " ------- TIME CLIQUE : " << time_cliques << " subgraph."
+ << endl;
int clique_number = 0;
- if (filename.empty()) filename.assign("mygraph.dot");
+ if(filename.empty()) filename.assign("mygraph.dot");
// export_clique_graphviz_format(cl,1,"mygraph2.dot");
export_the_clique_graphviz_format(cl, clique_number, filename);
@@ -6260,17 +6550,19 @@ void Recombinator_Graph::execute_blossom(GRegion* gr, unsigned int max_nb_clique
// create_quads_on_boundary(gr);
}
-
-// return the triangular face ijk if it exists. If not, creates it and returns it.
-PETriangle* Recombinator_Graph::get_triangle(MElement *element, int i, int j, int k) {
- vector<MVertex*> v;
+// return the triangular face ijk if it exists. If not, creates it and returns
+// it.
+PETriangle *Recombinator_Graph::get_triangle(MElement *element, int i, int j,
+ int k)
+{
+ vector<MVertex *> v;
PETriangle *t;
v.push_back(element->getVertex(i));
v.push_back(element->getVertex(j));
v.push_back(element->getVertex(k));
t = new PETriangle(v);
citer itfind = find_the_triangle(t, triangular_faces);
- if (itfind == triangular_faces.end()) {
+ if(itfind == triangular_faces.end()) {
itfind = triangular_faces.insert(make_pair(t->get_hash(), t));
}
else {
@@ -6281,14 +6573,12 @@ PETriangle* Recombinator_Graph::get_triangle(MElement *element, int i, int j, in
}
Recombinator_Graph::Recombinator_Graph(unsigned int _n, const string &filename)
- : max_nb_cliques(_n)
- , graphfilename(filename)
+ : max_nb_cliques(_n), graphfilename(filename)
{
}
-
-
-void Recombinator_Graph::execute(GRegion* gr) {
+void Recombinator_Graph::execute(GRegion *gr)
+{
printf("................HEXAHEDRA...GRAPH RECOMBINATOR................\n");
initialize_structures(gr);
@@ -6301,16 +6591,17 @@ void Recombinator_Graph::execute(GRegion* gr) {
// a criteria to stop when the whole domain is exclusively composed of hex
found_the_ultimate_max_clique = false;
- clique_stop_criteria<Hex*> criteria(hex_to_tet, gr->tetrahedra.size());
- cliques_losses_graph<Hex*> cl(incompatibility_graph, hex_ranks, max_nb_cliques, hex_to_tet.size(),
- &criteria, export_the_clique_graphviz_format);
+ clique_stop_criteria<Hex *> criteria(hex_to_tet, gr->tetrahedra.size());
+ cliques_losses_graph<Hex *> cl(incompatibility_graph, hex_ranks,
+ max_nb_cliques, hex_to_tet.size(), &criteria,
+ export_the_clique_graphviz_format);
cl.find_cliques();
found_the_ultimate_max_clique = cl.found_the_ultimate_max_clique;
int clique_number = 0;
- if (graphfilename.empty()) graphfilename.assign("mygraph.dot");
- //export_clique_graphviz_format(cl,1,"mygraph2.dot");
+ if(graphfilename.empty()) graphfilename.assign("mygraph.dot");
+ // export_clique_graphviz_format(cl,1,"mygraph2.dot");
export_the_clique_graphviz_format(cl, clique_number, graphfilename);
merge_clique(gr, cl, clique_number);
@@ -6320,21 +6611,20 @@ void Recombinator_Graph::execute(GRegion* gr) {
double quality;
};
- typedef boost::adjacency_list<
- boost::vecS,
- boost::vecS,
- boost::undirectedS, vertex> graph_type;
+ typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
+ vertex>
+ graph_type;
typedef boost::graph_traits<graph_type>::vertex_descriptor vertex_id;
graph_type graph;
- std::map<std::set<MElement*>, vertex_id> vertex_map;
+ std::map<std::set<MElement *>, vertex_id> vertex_map;
- for (graph::iterator it = incompatibility_graph.begin();
- it != incompatibility_graph.end(); it++) {
+ for(graph::iterator it = incompatibility_graph.begin();
+ it != incompatibility_graph.end(); it++) {
Hex *hex = it->second.first;
- const std::set<MElement*> &key = hex_to_tet[hex];
- if (vertex_map.find(key) == vertex_map.end()) {
+ const std::set<MElement *> &key = hex_to_tet[hex];
+ if(vertex_map.find(key) == vertex_map.end()) {
vertex_id vid = add_vertex(graph);
graph[vid].hex = hex;
graph[vid].quality = hex->get_quality();
@@ -6343,17 +6633,17 @@ void Recombinator_Graph::execute(GRegion* gr) {
}
}
- for (graph::iterator it = incompatibility_graph.begin();
- it != incompatibility_graph.end(); it++) {
+ for(graph::iterator it = incompatibility_graph.begin();
+ it != incompatibility_graph.end(); it++) {
Hex *hex = it->second.first;
vertex_id vid = vertex_map[hex_to_tet[hex]];
- for (graph_data::const_iterator data_it = it->second.second.begin();
- data_it != it->second.second.end(); data_it++) {
+ for(graph_data::const_iterator data_it = it->second.second.begin();
+ data_it != it->second.second.end(); data_it++) {
Hex *other_hex = data_it->second;
vertex_id other_vid = vertex_map[hex_to_tet[other_hex]];
- if (vid != other_vid && !edge(vid, other_vid, graph).second) {
+ if(vid != other_vid && !edge(vid, other_vid, graph).second) {
add_edge(vid, other_vid, graph);
}
}
@@ -6363,15 +6653,15 @@ void Recombinator_Graph::execute(GRegion* gr) {
get(&vertex::quality, graph);
std::vector<vertex_id> vertices;
- maximum_weight_independent_set(
- graph, weight_map, std::back_inserter(vertices));
+ maximum_weight_independent_set(graph, weight_map,
+ std::back_inserter(vertices));
hash_tableA.clear();
hash_tableB.clear();
hash_tableC.clear();
- for (std::vector<vertex_id>::const_iterator it = vertices.begin();
- it != vertices.end(); it++) {
+ for(std::vector<vertex_id>::const_iterator it = vertices.begin();
+ it != vertices.end(); it++) {
Hex *hex = graph[*it].hex;
merge_hex(gr, hex);
}
@@ -6383,26 +6673,27 @@ void Recombinator_Graph::execute(GRegion* gr) {
create_quads_on_boundary();
}
-
-void Recombinator_Graph::merge_clique(GRegion* gr, cliques_losses_graph<Hex*> &cl, int clique_number) {
-
- multimap<int, set<Hex*> >::reverse_iterator it_all = cl.allQ.rbegin();
- multimap<int, set<Hex*> >::reverse_iterator it_allen = cl.allQ.rend();
+void Recombinator_Graph::merge_clique(GRegion *gr,
+ cliques_losses_graph<Hex *> &cl,
+ int clique_number)
+{
+ multimap<int, set<Hex *> >::reverse_iterator it_all = cl.allQ.rbegin();
+ multimap<int, set<Hex *> >::reverse_iterator it_allen = cl.allQ.rend();
int clique_counter = 0;
- std::set<MElement*> parts;
- //int clique_size = 0;
+ std::set<MElement *> parts;
+ // int clique_size = 0;
- for (int i = 0; i < clique_number; i++) {
+ for(int i = 0; i < clique_number; i++) {
it_all++;
}
- for (; it_all != it_allen; it_all++, clique_counter++) {
- if (clique_counter >= 1) break;
+ for(; it_all != it_allen; it_all++, clique_counter++) {
+ if(clique_counter >= 1) break;
- //cout << "--------------------- clique " << clique_counter << " made of ";
- //clique_size = it_all->second.size();
- set<Hex*>::iterator ithex = it_all->second.begin();
- set<Hex*>::iterator ithexen = it_all->second.end();
+ // cout << "--------------------- clique " << clique_counter << " made of ";
+ // clique_size = it_all->second.size();
+ set<Hex *>::iterator ithex = it_all->second.begin();
+ set<Hex *>::iterator ithexen = it_all->second.end();
double quality = 0.;
int count = 0;
@@ -6410,9 +6701,10 @@ void Recombinator_Graph::merge_clique(GRegion* gr, cliques_losses_graph<Hex*> &c
hash_tableB.clear();
hash_tableC.clear();
- for (; ithex != ithexen; ithex++) { // brutal post-check: random pickup of hexahedra in clique
+ for(; ithex != ithexen;
+ ithex++) { // brutal post-check: random pickup of hexahedra in clique
Hex *current_hex = *ithex;
- if (merge_hex(gr, current_hex)) {
+ if(merge_hex(gr, current_hex)) {
quality = quality + current_hex->get_quality();
count++;
}
@@ -6420,27 +6712,25 @@ void Recombinator_Graph::merge_clique(GRegion* gr, cliques_losses_graph<Hex*> &c
}
}
-bool Recombinator_Graph::merge_hex(GRegion *gr, Hex *hex) {
- if (!post_check_validation(hex))
- return false;
+bool Recombinator_Graph::merge_hex(GRegion *gr, Hex *hex)
+{
+ if(!post_check_validation(hex)) return false;
MHexahedron *h = new MHexahedron(hex->vertices());
gr->addHexahedron(h);
- std::set<MElement*>::iterator it_tet_to_remove = hex_to_tet[hex].begin();
- std::vector<MTetrahedron*>::iterator itfind_tet_region;
- for (; it_tet_to_remove != hex_to_tet[hex].end(); it_tet_to_remove++) {
- itfind_tet_region = std::find(gr->tetrahedra.begin(),
- gr->tetrahedra.end(),
- (MTetrahedron*)(*it_tet_to_remove));
+ std::set<MElement *>::iterator it_tet_to_remove = hex_to_tet[hex].begin();
+ std::vector<MTetrahedron *>::iterator itfind_tet_region;
+ for(; it_tet_to_remove != hex_to_tet[hex].end(); it_tet_to_remove++) {
+ itfind_tet_region = std::find(gr->tetrahedra.begin(), gr->tetrahedra.end(),
+ (MTetrahedron *)(*it_tet_to_remove));
- if (itfind_tet_region != gr->tetrahedra.end()) {
+ if(itfind_tet_region != gr->tetrahedra.end()) {
gr->tetrahedra.erase(itfind_tet_region);
delete *it_tet_to_remove;
}
}
-
build_hash_tableA(*hex);
build_hash_tableB(*hex);
build_hash_tableC(*hex);
@@ -6448,12 +6738,8 @@ bool Recombinator_Graph::merge_hex(GRegion *gr, Hex *hex) {
return true;
}
-
-
// Why derive then ?? this is quite stupid
-void Recombinator_Graph::merge(GRegion* gr) {
- throw;
-}
+void Recombinator_Graph::merge(GRegion *gr) { throw; }
void Recombinator_Graph::export_tets(set<MElement *> &tetset, Hex *hex,
const string &s)
@@ -6469,20 +6755,19 @@ void Recombinator_Graph::export_tets(set<MElement *> &tetset, Hex *hex,
element_set_itr it = tetset.begin();
element_set_itr iten = tetset.end();
int count = 0;
- for (; it != iten; it++, count++) {
+ for(; it != iten; it++, count++) {
out << "SS(";
- for (int n = 0; n < 4; n++) {
+ for(int n = 0; n < 4; n++) {
MVertex *v = (*it)->getVertex(n);
out << v->x() << "," << v->y() << "," << v->z();
- if (n != 3) out << ",";
+ if(n != 3) out << ",";
}
out << "){";
- for (int n = 0; n < 4; n++) {
+ for(int n = 0; n < 4; n++) {
out << count;
- if (n != 3) out << ",";
+ if(n != 3) out << ",";
}
out << "};" << endl;
-
}
out << "};" << endl;
out.close();
@@ -6501,20 +6786,19 @@ void Recombinator_Graph::export_single_hex_tet(Hex *hex, const string &s)
element_set_itr it = hex_to_tet[hex].begin();
element_set_itr iten = hex_to_tet[hex].end();
int count = 0;
- for (; it != iten; it++, count++) {
+ for(; it != iten; it++, count++) {
out << "SS(";
- for (int n = 0; n < 4; n++) {
+ for(int n = 0; n < 4; n++) {
MVertex *v = (*it)->getVertex(n);
out << v->x() << "," << v->y() << "," << v->z();
- if (n != 3) out << ",";
+ if(n != 3) out << ",";
}
out << "){";
- for (int n = 0; n < 4; n++) {
+ for(int n = 0; n < 4; n++) {
out << count;
- if (n != 3) out << ",";
+ if(n != 3) out << ",";
}
out << "};" << endl;
-
}
out << "};" << endl;
out.close();
@@ -6538,15 +6822,15 @@ void Recombinator_Graph::export_single_hex(Hex *hex, const string &s)
out << "View \"hex\" {" << endl;
out << "SH(";
- for (int n = 0; n < 8; n++) {
+ for(int n = 0; n < 8; n++) {
MVertex *v = hex->getVertex(n);
out << v->x() << "," << v->y() << "," << v->z();
- if (n != 7) out << ",";
+ if(n != 7) out << ",";
}
out << "){";
- for (int n = 0; n < 8; n++) {
+ for(int n = 0; n < 8; n++) {
out << "0.";
- if (n != 7) out << ",";
+ if(n != 7) out << ",";
}
out << "};" << endl;
@@ -6564,63 +6848,60 @@ void Recombinator_Graph::export_single_hex_faces(Hex *hex, const string &s)
ofstream out(ss.str().c_str());
out << "View \"hex faces\" {" << endl;
- std::set<PETriangle*>::iterator it = hex_to_faces[hex].begin();
- std::set<PETriangle*>::iterator iten = hex_to_faces[hex].end();
+ std::set<PETriangle *>::iterator it = hex_to_faces[hex].begin();
+ std::set<PETriangle *>::iterator iten = hex_to_faces[hex].end();
int count = 0;
- for (; it != iten; it++, count++) {
+ for(; it != iten; it++, count++) {
out << "ST(";
- for (int n = 0; n < 3; n++) {
+ for(int n = 0; n < 3; n++) {
MVertex *v = (*it)->getVertex(n);
out << v->x() << "," << v->y() << "," << v->z();
- if (n != 2) out << ",";
+ if(n != 2) out << ",";
}
out << "){";
- for (int n = 0; n < 3; n++) {
+ for(int n = 0; n < 3; n++) {
out << count;
- if (n != 2) out << ",";
+ if(n != 2) out << ",";
}
out << "};" << endl;
-
}
out << "};" << endl;
out.close();
}
-
-
-void Recombinator_Graph::export_hex_init_degree(GRegion *gr, const std::map<Hex*, int> &init_degree, const vector<Hex*> &chosen_hex) {
+void Recombinator_Graph::export_hex_init_degree(
+ GRegion *gr, const std::map<Hex *, int> &init_degree,
+ const vector<Hex *> &chosen_hex)
+{
stringstream ss;
ss << "init_degree";
ss << ".pos";
ofstream out(ss.str().c_str());
- std::vector<Hex*>::const_iterator it = chosen_hex.begin();
+ std::vector<Hex *>::const_iterator it = chosen_hex.begin();
out << "View \"hex\" {" << endl;
- for (; it != chosen_hex.end(); it++) {
+ for(; it != chosen_hex.end(); it++) {
out << "SH(";
- for (int n = 0; n < 8; n++) {
+ for(int n = 0; n < 8; n++) {
MVertex *v = (*it)->getVertex(n);
out << v->x() << "," << v->y() << "," << v->z();
- if (n != 7) out << ",";
+ if(n != 7) out << ",";
}
- map<Hex*, int>::const_iterator itfind = init_degree.find(*it);
+ map<Hex *, int>::const_iterator itfind = init_degree.find(*it);
out << "){";
- for (int n = 0; n < 8; n++) {
+ for(int n = 0; n < 8; n++) {
out << itfind->second;
- if (n != 7) out << ",";
+ if(n != 7) out << ",";
}
out << "};" << endl;
-
}
out << "};" << endl;
-
-
out.close();
}
-
-void Recombinator_Graph::export_hexmesh_so_far(int &file) {
+void Recombinator_Graph::export_hexmesh_so_far(int &file)
+{
stringstream ss;
stringstream ssinit;
ss << "hex_mesh_temp";
@@ -6630,15 +6911,14 @@ void Recombinator_Graph::export_hexmesh_so_far(int &file) {
ss << ".msh";
ofstream out(ss.str().c_str());
- GModel* model = GModel::current();
+ GModel *model = GModel::current();
model->save(ss.str().c_str());
out.close();
}
-
-
-void Recombinator_Graph::export_all_hex(int &file, GRegion *gr) {
+void Recombinator_Graph::export_all_hex(int &file, GRegion *gr)
+{
stringstream ss;
stringstream ssinit;
ss << "hex_progression";
@@ -6652,68 +6932,67 @@ void Recombinator_Graph::export_all_hex(int &file, GRegion *gr) {
ssinit << ".pos";
ofstream out(ss.str().c_str());
- std::vector<MHexahedron*>::iterator it = gr->hexahedra.begin();
+ std::vector<MHexahedron *>::iterator it = gr->hexahedra.begin();
int i = 1;
out << "View \"hex\" {" << endl;
- for (; it != gr->hexahedra.end(); it++, i++) {
+ for(; it != gr->hexahedra.end(); it++, i++) {
out << "SH(";
- for (int n = 0; n < 8; n++) {
+ for(int n = 0; n < 8; n++) {
MVertex *v = (*it)->getVertex(n);
out << v->x() << "," << v->y() << "," << v->z();
- if (n != 7) out << ",";
+ if(n != 7) out << ",";
}
out << "){";
- for (int n = 0; n < 8; n++) {
+ for(int n = 0; n < 8; n++) {
out << i;
- if (n != 7) out << ",";
+ if(n != 7) out << ",";
}
out << "};" << endl;
-
}
out << "};" << endl;
-
-
out.close();
}
-
-// check if the hex is good enough to be put into the graph. If not in the graph, it cannot be chosen...
-bool Recombinator_Graph::is_not_good_enough(Hex* hex) {
+// check if the hex is good enough to be put into the graph. If not in the
+// graph, it cannot be chosen...
+bool Recombinator_Graph::is_not_good_enough(Hex *hex)
+{
double quality_threshold = 0.5;
return hex->get_quality() < quality_threshold || !faces_statuquo(*hex);
}
-
-// Add entries in the incompatibility_graph for all hexes sharing a non-sliver tetrahedra
-// For the entry to be added the hex also have to be good_enough
+// Add entries in the incompatibility_graph for all hexes sharing a non-sliver
+// tetrahedra For the entry to be added the hex also have to be good_enough
void Recombinator_Graph::create_indirect_neighbors_graph()
{
- std::map<MElement*, std::set<Hex*> >::iterator it_tet = tet_to_hex.begin();
- for (; it_tet != tet_to_hex.end(); it_tet++) {
- std::set<Hex*>::iterator it_hex1 = it_tet->second.begin();
- for (; it_hex1 != it_tet->second.end(); it_hex1++) {
+ std::map<MElement *, std::set<Hex *> >::iterator it_tet = tet_to_hex.begin();
+ for(; it_tet != tet_to_hex.end(); it_tet++) {
+ std::set<Hex *>::iterator it_hex1 = it_tet->second.begin();
+ for(; it_hex1 != it_tet->second.end(); it_hex1++) {
Hex *hex = *it_hex1;
- if (sliver(it_tet->first, *hex)) {
- // Slivers may be shared by several hex and do not define an incompatibility relationship
+ if(sliver(it_tet->first, *hex)) {
+ // Slivers may be shared by several hex and do not define an
+ // incompatibility relationship
continue;
}
- if (is_not_good_enough(hex)) {
+ if(is_not_good_enough(hex)) {
continue;
}
graph::iterator itfind_graph = find_hex_in_graph(hex);
- if (itfind_graph == incompatibility_graph.end()) {
+ if(itfind_graph == incompatibility_graph.end()) {
// Add the hex to the graph
- itfind_graph = incompatibility_graph.insert(make_pair(hex->get_hash(), make_pair(hex, graph_data())));
+ itfind_graph = incompatibility_graph.insert(
+ make_pair(hex->get_hash(), make_pair(hex, graph_data())));
set_of_all_hex_in_graph.insert(hex);
}
// Link the hex as incompatible to all the good enough hex
// that share the current tet
- for (std::set<Hex*>::iterator it_hex2 = it_tet->second.begin();
- it_hex2 != it_tet->second.end(); it_hex2++) {
- Hex* hex2 = *it_hex2;
- if (hex != hex2 && !is_not_good_enough(hex2)) {
+ for(std::set<Hex *>::iterator it_hex2 = it_tet->second.begin();
+ it_hex2 != it_tet->second.end(); it_hex2++) {
+ Hex *hex2 = *it_hex2;
+ if(hex != hex2 && !is_not_good_enough(hex2)) {
// Add the pair hex-hex2 to the graph
itfind_graph->second.second.insert(make_pair(hex2->get_hash(), hex2));
}
@@ -6722,29 +7001,35 @@ void Recombinator_Graph::create_indirect_neighbors_graph()
}
}
-
-std::multimap<unsigned long long, Hex* >::const_iterator
- Recombinator_Graph::find_the_created_potential_hex(Hex *hex, const std::multimap<unsigned long long, Hex*> &list)
+std::multimap<unsigned long long, Hex *>::const_iterator
+Recombinator_Graph::find_the_created_potential_hex(
+ Hex *hex, const std::multimap<unsigned long long, Hex *> &list)
{
std::pair<graph_data::const_iterator, graph_data::const_iterator> range =
list.equal_range(hex->get_hash());
- for (graph_data::const_iterator it = range.first; it != range.second; it++) {
+ for(graph_data::const_iterator it = range.first; it != range.second; it++) {
Hex *candidate = it->second;
- if (candidate->same_vertices(hex)) {
+ if(candidate->same_vertices(hex)) {
return it;
}
}
return list.end();
}
-
-std::multimap<unsigned long long, pair<PETriangle*, int> >::iterator
- Recombinator_Graph::find_the_triangle(PETriangle *t, std::multimap<unsigned long long, pair<PETriangle*, int> > &list)
+std::multimap<unsigned long long, pair<PETriangle *, int> >::iterator
+Recombinator_Graph::find_the_triangle(
+ PETriangle *t,
+ std::multimap<unsigned long long, pair<PETriangle *, int> > &list)
{
- std::pair<std::multimap<unsigned long long, pair<PETriangle*, int> >::iterator, std::multimap<unsigned long long, pair<PETriangle*, int> >::iterator> range = list.equal_range(t->get_hash());
- for (std::multimap<unsigned long long, pair<PETriangle*, int> >::iterator it = range.first; it != range.second; it++) {
+ std::pair<
+ std::multimap<unsigned long long, pair<PETriangle *, int> >::iterator,
+ std::multimap<unsigned long long, pair<PETriangle *, int> >::iterator>
+ range = list.equal_range(t->get_hash());
+ for(std::multimap<unsigned long long, pair<PETriangle *, int> >::iterator it =
+ range.first;
+ it != range.second; it++) {
PETriangle *candidate = it->second.first;
- if (candidate->same_vertices(t)) {
+ if(candidate->same_vertices(t)) {
it->second.second++;
return it;
}
@@ -6752,39 +7037,42 @@ std::multimap<unsigned long long, pair<PETriangle*, int> >::iterator
return list.end();
}
-
-
-Recombinator_Graph::citer Recombinator_Graph::find_the_triangle(PETriangle *t, const trimap &list) {
+Recombinator_Graph::citer
+Recombinator_Graph::find_the_triangle(PETriangle *t, const trimap &list)
+{
std::pair<citer, citer> range = list.equal_range(t->get_hash());
- for (citer it = range.first; it != range.second; it++) {
- if (it->second->same_vertices(t)) return it;
+ for(citer it = range.first; it != range.second; it++) {
+ if(it->second->same_vertices(t)) return it;
}
return list.end();
}
-
-Recombinator_Graph::linemap::const_iterator Recombinator_Graph::find_the_line(PELine *t, const linemap &list) {
- std::pair<linemap::const_iterator, linemap::const_iterator> range = list.equal_range(t->get_hash());
- for (linemap::const_iterator it = range.first; it != range.second; it++) {
- if (it->second->same_vertices(t)) return it;
+Recombinator_Graph::linemap::const_iterator
+Recombinator_Graph::find_the_line(PELine *t, const linemap &list)
+{
+ std::pair<linemap::const_iterator, linemap::const_iterator> range =
+ list.equal_range(t->get_hash());
+ for(linemap::const_iterator it = range.first; it != range.second; it++) {
+ if(it->second->same_vertices(t)) return it;
}
return list.end();
}
-
-void Recombinator_Graph::export_direct_neighbor_table(int max) {
+void Recombinator_Graph::export_direct_neighbor_table(int max)
+{
stringstream ss;
ss << "neighbors_table";
ofstream out(ss.str().c_str());
- std::multimap<int, Hex*>::iterator it = ndegree.begin();
+ std::multimap<int, Hex *>::iterator it = ndegree.begin();
int counter = 0;
out << " n neighbors_rank hex* quality" << endl;
- for (; it != ndegree.end(); it++, counter++) {
- if (counter >= max) break;
+ for(; it != ndegree.end(); it++, counter++) {
+ if(counter >= max) break;
Hex *hex = it->second;
- out << counter << " " << it->first << " " << hex << " " << hex->get_quality() << endl;
+ out << counter << " " << it->first << " " << hex << " "
+ << hex->get_quality() << endl;
stringstream ss2;
ss2 << "neighbors_table_hex";
char chose[256];
@@ -6794,15 +7082,15 @@ void Recombinator_Graph::export_direct_neighbor_table(int max) {
ofstream out2(ss2.str().c_str());
out2 << "View \"hex\" {" << endl;
out2 << "SH(";
- for (int n = 0; n < 8; n++) {
+ for(int n = 0; n < 8; n++) {
MVertex *v = hex->getVertex(n);
out2 << v->x() << "," << v->y() << "," << v->z();
- if (n != 7) out2 << ",";
+ if(n != 7) out2 << ",";
}
out2 << "){";
- for (int n = 0; n < 8; n++) {
+ for(int n = 0; n < 8; n++) {
out2 << it->first;
- if (n != 7) out2 << ",";
+ if(n != 7) out2 << ",";
}
out2 << "};" << endl;
out2 << "};" << endl;
@@ -6811,10 +7099,11 @@ void Recombinator_Graph::export_direct_neighbor_table(int max) {
out.close();
}
-
-void print_stats_graph(const Recombinator_Graph::graph& in) {
+void print_stats_graph(const Recombinator_Graph::graph &in)
+{
int total = 0;
- for (Recombinator_Graph::graph::const_iterator it = in.begin(); it != in.end(); it++) {
+ for(Recombinator_Graph::graph::const_iterator it = in.begin(); it != in.end();
+ it++) {
total += it->second.second.size();
}
size_t nb_entries = in.size();
@@ -6822,10 +7111,9 @@ void print_stats_graph(const Recombinator_Graph::graph& in) {
cout << "Number of hexes: " << nb_entries << endl;
double average_connectivity = total / ((double)(nb_entries));
cout << "#hex potentiels recensés dans le graphe des pertes: " << nb_entries
- << " #connectivité moyenne: " << average_connectivity << endl;
+ << " #connectivité moyenne: " << average_connectivity << endl;
}
-
void Recombinator_Graph::create_losses_graph(GRegion *gr)
{
incompatibility_graph.clear();
@@ -6835,46 +7123,46 @@ void Recombinator_Graph::create_losses_graph(GRegion *gr)
print_stats_graph(incompatibility_graph);
};
-
// fills incompatibility_graph if two hex are incompatible direct neighbors,
-// i.e. (they DO NOT have one tet in common) and (they are neighbors (face(s) in common) but DO NOT pass the compatibility tests)
+// i.e. (they DO NOT have one tet in common) and (they are neighbors (face(s) in
+// common) but DO NOT pass the compatibility tests)
void Recombinator_Graph::create_direct_neighbors_incompatibility_graph()
{
- for (std::map<Hex*, std::set<MElement*> >::iterator it_hex = hex_to_tet.begin();
- it_hex != hex_to_tet.end(); it_hex++
- ) {
+ for(std::map<Hex *, std::set<MElement *> >::iterator it_hex =
+ hex_to_tet.begin();
+ it_hex != hex_to_tet.end(); it_hex++) {
Hex *hex = it_hex->first;
- if (is_not_good_enough(hex)) {
+ if(is_not_good_enough(hex)) {
// Why is it even there in the first place? JP
continue;
}
// Find or create the hex data in the incompatibility graph
graph::iterator itfind_graph = find_hex_in_graph(hex);
- if (itfind_graph == incompatibility_graph.end()) {
- incompatibility_graph.insert(make_pair(hex->get_hash(), make_pair(hex, graph_data())));
+ if(itfind_graph == incompatibility_graph.end()) {
+ incompatibility_graph.insert(
+ make_pair(hex->get_hash(), make_pair(hex, graph_data())));
set_of_all_hex_in_graph.insert(hex);
}
// For each hex the hash tables are rebuit
clear_and_build_hash_tables(*hex);
- std::vector<Hex*> visited_hex;
+ std::vector<Hex *> visited_hex;
// Check compatibility with the that share an facet with hex
- const std::set<PETriangle*>& hex_faces = hex_to_faces[hex];
- for (std::set<PETriangle*>::const_iterator it_faces = hex_faces.begin();
- it_faces != hex_faces.end(); it_faces++
- ) {
+ const std::set<PETriangle *> &hex_faces = hex_to_faces[hex];
+ for(std::set<PETriangle *>::const_iterator it_faces = hex_faces.begin();
+ it_faces != hex_faces.end(); it_faces++) {
PETriangle *face = *it_faces;
- const std::set<Hex*>& hex_sharing_triangle = faces_to_hex[face];
- for (std::set<Hex*>::const_iterator it_neighbors= hex_sharing_triangle.begin();
- it_neighbors != hex_sharing_triangle.end(); it_neighbors++
- ) {
+ const std::set<Hex *> &hex_sharing_triangle = faces_to_hex[face];
+ for(std::set<Hex *>::const_iterator it_neighbors =
+ hex_sharing_triangle.begin();
+ it_neighbors != hex_sharing_triangle.end(); it_neighbors++) {
Hex *other_hex = *it_neighbors;
- if (other_hex == hex) continue;
+ if(other_hex == hex) continue;
- if (std::count(visited_hex.begin(), visited_hex.end(), other_hex) > 0) {
+ if(std::count(visited_hex.begin(), visited_hex.end(), other_hex) > 0) {
continue;
}
else {
@@ -6884,19 +7172,20 @@ void Recombinator_Graph::create_direct_neighbors_incompatibility_graph()
evaluate_hex_couple(hex, other_hex);
}
}
- //Check compatibility with the hex that share a edges (2 vertices) with hex
+ // Check compatibility with the hex that share a edges (2 vertices) with hex
// change following...
- const std::set<PELine*>& hex_edges = hex_to_edges[hex];
- for (std::set<PELine*>::const_iterator it_line = hex_edges.begin(); it_line != hex_edges.end(); it_line++) {
+ const std::set<PELine *> &hex_edges = hex_to_edges[hex];
+ for(std::set<PELine *>::const_iterator it_line = hex_edges.begin();
+ it_line != hex_edges.end(); it_line++) {
PELine *line = *it_line;
- const std::set<Hex*>& hex_sharing_edge = edges_to_hex[line];
- for (std::set<Hex*>::const_iterator it_neighbors = hex_sharing_edge.begin();
- it_neighbors!=hex_sharing_edge.end() ; it_neighbors++
- ) {
+ const std::set<Hex *> &hex_sharing_edge = edges_to_hex[line];
+ for(std::set<Hex *>::const_iterator it_neighbors =
+ hex_sharing_edge.begin();
+ it_neighbors != hex_sharing_edge.end(); it_neighbors++) {
Hex *other_hex = *it_neighbors;
- if (other_hex == hex) continue;
- if (std::count(visited_hex.begin(), visited_hex.end(), other_hex) > 0) {
+ if(other_hex == hex) continue;
+ if(std::count(visited_hex.begin(), visited_hex.end(), other_hex) > 0) {
continue;
}
else {
@@ -6912,68 +7201,70 @@ void Recombinator_Graph::create_direct_neighbors_incompatibility_graph()
// Check the compatibility of the two input hex
// And add one graph entry when they are incompatible
// WHAT IS IN THE TABLES when this function is called ????? JP
-// Nothing is checked between the hex - most evaluation are done on the other_hex ...
-void Recombinator_Graph::evaluate_hex_couple(Hex* hex, Hex* other_hex)
+// Nothing is checked between the hex - most evaluation are done on the
+// other_hex ...
+void Recombinator_Graph::evaluate_hex_couple(Hex *hex, Hex *other_hex)
{
// Why are the not good enough hex here in the first place? JP
- if (is_not_good_enough(other_hex)) {
+ if(is_not_good_enough(other_hex)) {
return;
}
- if (find_hex_couple_in_graph(hex, other_hex)) {
+ if(find_hex_couple_in_graph(hex, other_hex)) {
return;
}
- if (!conformityA(*other_hex)) {
+ if(!conformityA(*other_hex)) {
add_graph_entry(hex, other_hex);
return;
}
- if (!conformityB(*other_hex)) {
+ if(!conformityB(*other_hex)) {
add_graph_entry(hex, other_hex);
return;
}
- if (!conformityC(*other_hex)) {
+ if(!conformityC(*other_hex)) {
add_graph_entry(hex, other_hex);
return;
}
- if (!faces_statuquo(*other_hex)) {
+ if(!faces_statuquo(*other_hex)) {
add_graph_entry(hex, other_hex);
return;
}
}
-
-bool Recombinator_Graph::post_check_validation(Hex* current_hex)
+bool Recombinator_Graph::post_check_validation(Hex *current_hex)
{
- if (!conformityA(*current_hex)) {
+ if(!conformityA(*current_hex)) {
return false;
}
- if (!conformityB(*current_hex)) {
+ if(!conformityB(*current_hex)) {
return false;
}
- if (!conformityC(*current_hex)) {
+ if(!conformityC(*current_hex)) {
return false;
}
- if (!faces_statuquo(*current_hex)) {
+ if(!faces_statuquo(*current_hex)) {
return false;
}
return true;
}
-
-void Recombinator_Graph::add_face(MVertex *a, MVertex* b, MVertex *c, std::multimap<unsigned long long, pair<PETriangle*, int> > &f)
+void Recombinator_Graph::add_face(
+ MVertex *a, MVertex *b, MVertex *c,
+ std::multimap<unsigned long long, pair<PETriangle *, int> > &f)
{
- vector<MVertex*> v;
+ vector<MVertex *> v;
v.push_back(a);
v.push_back(b);
v.push_back(c);
PETriangle *q = new PETriangle(v);
- std::multimap<unsigned long long, pair<PETriangle*, int> >::iterator itfind = find_the_triangle(q, f);
- if (itfind == f.end()) {
+ std::multimap<unsigned long long, pair<PETriangle *, int> >::iterator itfind =
+ find_the_triangle(q, f);
+ if(itfind == f.end()) {
f.insert(make_pair(q->get_hash(), make_pair(q, 1)));
}
else {
@@ -6981,16 +7272,15 @@ void Recombinator_Graph::add_face(MVertex *a, MVertex* b, MVertex *c, std::multi
}
}
-
-void Recombinator_Graph::add_face(MVertex *a, MVertex* b, MVertex *c, Hex *hex)
+void Recombinator_Graph::add_face(MVertex *a, MVertex *b, MVertex *c, Hex *hex)
{
- vector<MVertex*> v;
+ vector<MVertex *> v;
v.push_back(a);
v.push_back(b);
v.push_back(c);
PETriangle *q = new PETriangle(v);
citer itfind = find_the_triangle(q, triangular_faces);
- if (itfind == triangular_faces.end()) {
+ if(itfind == triangular_faces.end()) {
itfind = triangular_faces.insert(make_pair(q->get_hash(), q));
}
else {
@@ -7002,12 +7292,11 @@ void Recombinator_Graph::add_face(MVertex *a, MVertex* b, MVertex *c, Hex *hex)
faces_to_hex[q].insert(hex);
}
-
void Recombinator_Graph::add_edges(Hex *hex)
{
- for (unsigned int f = 0; f < 6; ++f) {
- std::vector<MVertex*> facet_vertices (4);
- for (unsigned int v = 0; v < 4; ++v) {
+ for(unsigned int f = 0; f < 6; ++f) {
+ std::vector<MVertex *> facet_vertices(4);
+ for(unsigned int v = 0; v < 4; ++v) {
facet_vertices[v] = hex->vertex_in_facet(f, v);
}
fill_edges_table(facet_vertices, hex);
@@ -7016,19 +7305,19 @@ void Recombinator_Graph::add_edges(Hex *hex)
// For all pairs of two vertices among the 4 input vertices
// set the mapping between the edge (PELine) and the input hex.
-void Recombinator_Graph::fill_edges_table(const std::vector<MVertex*>& quad_vertices, Hex *hex)
+void Recombinator_Graph::fill_edges_table(
+ const std::vector<MVertex *> &quad_vertices, Hex *hex)
{
- for (unsigned int i =0; i<4; ++i ){
- for (unsigned int j= i+1; j<4; ++j) {
-
- std::vector<MVertex*> edge;
+ for(unsigned int i = 0; i < 4; ++i) {
+ for(unsigned int j = i + 1; j < 4; ++j) {
+ std::vector<MVertex *> edge;
edge.push_back(quad_vertices[i]);
edge.push_back(quad_vertices[j]);
// see if already exists or not...
PELine *l = new PELine(edge);
linemap::const_iterator itfind = find_the_line(l, edges_and_diagonals);
- if (itfind == edges_and_diagonals.end()) {
+ if(itfind == edges_and_diagonals.end()) {
itfind = edges_and_diagonals.insert(make_pair(l->get_hash(), l));
}
else {
@@ -7042,73 +7331,78 @@ void Recombinator_Graph::fill_edges_table(const std::vector<MVertex*>& quad_vert
}
}
-
-Recombinator_Graph::graph::iterator Recombinator_Graph::find_hex_in_graph(Hex* hex)
+Recombinator_Graph::graph::iterator
+Recombinator_Graph::find_hex_in_graph(Hex *hex)
{
- pair<graph::iterator, graph::iterator> range = incompatibility_graph.equal_range(hex->get_hash());
- if (range.first == range.second) return incompatibility_graph.end();
+ pair<graph::iterator, graph::iterator> range =
+ incompatibility_graph.equal_range(hex->get_hash());
+ if(range.first == range.second) return incompatibility_graph.end();
graph::iterator it = range.first;
- for (; it != range.second; it++) {
- if (it->second.first == hex) {
+ for(; it != range.second; it++) {
+ if(it->second.first == hex) {
return it;
}
}
return incompatibility_graph.end();
}
-Recombinator_Graph::graph_data::iterator Recombinator_Graph::find_hex_in_graphrow(Hex* hex, graph_data &row)
+Recombinator_Graph::graph_data::iterator
+Recombinator_Graph::find_hex_in_graphrow(Hex *hex, graph_data &row)
{
- pair<graph_data::iterator, graph_data::iterator> range = row.equal_range(hex->get_hash());
- if (range.first == range.second) return row.end();
+ pair<graph_data::iterator, graph_data::iterator> range =
+ row.equal_range(hex->get_hash());
+ if(range.first == range.second) return row.end();
graph_data::iterator it = range.first;
- for (; it != range.second; it++) {
- if (it->second == hex) {
+ for(; it != range.second; it++) {
+ if(it->second == hex) {
return it;
}
}
return row.end();
}
-bool Recombinator_Graph::find_hex_couple_in_graph(Hex* hex, Hex* other_hex)
+bool Recombinator_Graph::find_hex_couple_in_graph(Hex *hex, Hex *other_hex)
{
graph::iterator it = find_hex_in_graph(hex);
- if (it == incompatibility_graph.end()) return false;
+ if(it == incompatibility_graph.end()) return false;
graph_data::iterator itt = find_hex_in_graphrow(other_hex, it->second.second);
- if (itt == it->second.second.end()) return false;
+ if(itt == it->second.second.end()) return false;
return true;
-
}
-
-void Recombinator_Graph::add_graph_entry(Hex* hex, Hex* other_hex)
+void Recombinator_Graph::add_graph_entry(Hex *hex, Hex *other_hex)
{
graph::iterator itfind_graph = find_hex_in_graph(hex);
- if (itfind_graph == incompatibility_graph.end()) {
- itfind_graph = incompatibility_graph.insert(make_pair(hex->get_hash(), make_pair(hex, graph_data())));
- itfind_graph->second.second.insert(make_pair(other_hex->get_hash(), other_hex));
+ if(itfind_graph == incompatibility_graph.end()) {
+ itfind_graph = incompatibility_graph.insert(
+ make_pair(hex->get_hash(), make_pair(hex, graph_data())));
+ itfind_graph->second.second.insert(
+ make_pair(other_hex->get_hash(), other_hex));
set_of_all_hex_in_graph.insert(hex);
}
else {
- itfind_graph->second.second.insert(make_pair(other_hex->get_hash(), other_hex));
+ itfind_graph->second.second.insert(
+ make_pair(other_hex->get_hash(), other_hex));
}
-
}
void Recombinator_Graph::compute_hex_ranks()
{
create_faces_connectivity();
- for (std::map<Hex*, set<PETriangle*> >::iterator it = hex_to_faces.begin(); it != hex_to_faces.end(); it++) {
- Hex* hex = it->first;
+ for(std::map<Hex *, set<PETriangle *> >::iterator it = hex_to_faces.begin();
+ it != hex_to_faces.end(); it++) {
+ Hex *hex = it->first;
// Count the number of facets on boundary for the hex
int boundary_count = 0.;
- for (set<PETriangle*>::iterator itf = it->second.begin(); itf != it->second.end(); itf++) {
- PETriangle* face = *itf;
- if (faces_connectivity[face] == 1) boundary_count += 1.;
+ for(set<PETriangle *>::iterator itf = it->second.begin();
+ itf != it->second.end(); itf++) {
+ PETriangle *face = *itf;
+ if(faces_connectivity[face] == 1) boundary_count += 1.;
}
vector<double> hex_rank(2);
@@ -7118,11 +7412,12 @@ void Recombinator_Graph::compute_hex_ranks()
}
}
-
// Complex way to get the number of tets around a triangular facet
void Recombinator_Graph::create_faces_connectivity()
{
- for (std::map<MElement*, std::set<Hex*> >::iterator it_tet = tet_to_hex.begin(); it_tet != tet_to_hex.end(); it_tet++) {
+ for(std::map<MElement *, std::set<Hex *> >::iterator it_tet =
+ tet_to_hex.begin();
+ it_tet != tet_to_hex.end(); it_tet++) {
add_face_connectivity(it_tet->first, 0, 1, 2);
add_face_connectivity(it_tet->first, 0, 1, 3);
add_face_connectivity(it_tet->first, 0, 2, 3);
@@ -7131,73 +7426,71 @@ void Recombinator_Graph::create_faces_connectivity()
}
// Complex way to get the number of tets around a triangular facet
-void Recombinator_Graph::add_face_connectivity(MElement *tet, int i, int j, int k)
+void Recombinator_Graph::add_face_connectivity(MElement *tet, int i, int j,
+ int k)
{
- vector<MVertex*> v;
+ vector<MVertex *> v;
PETriangle *t;
v.push_back(tet->getVertex(i));
v.push_back(tet->getVertex(j));
v.push_back(tet->getVertex(k));
t = new PETriangle(v);
citer itfind = find_the_triangle(t, triangular_faces);
- if (itfind != triangular_faces.end()) {
+ if(itfind != triangular_faces.end()) {
faces_connectivity[itfind->second]++;
}
delete t;
}
-
void Recombinator_Graph::compute_hex_ranks_blossom()
{
create_faces_connectivity();
- for (map<Hex*, set<PETriangle*> >::iterator it = hex_to_faces.begin(); it != hex_to_faces.end(); it++) {
- Hex* hex = it->first;
+ for(map<Hex *, set<PETriangle *> >::iterator it = hex_to_faces.begin();
+ it != hex_to_faces.end(); it++) {
+ Hex *hex = it->first;
double nb_faces_on_boundary = 0.;
- for (set<PETriangle*>::iterator face = it->second.begin(); face != it->second.end(); face++) {
- if (faces_connectivity[*face] == 1) nb_faces_on_boundary += 1.;
+ for(set<PETriangle *>::iterator face = it->second.begin();
+ face != it->second.end(); face++) {
+ if(faces_connectivity[*face] == 1) nb_faces_on_boundary += 1.;
}
- map<Hex*, vector<double> >::iterator itfind = hex_ranks.find(hex);
- if (itfind == hex_ranks.end())
+ map<Hex *, vector<double> >::iterator itfind = hex_ranks.find(hex);
+ if(itfind == hex_ranks.end())
hex_ranks.insert(make_pair(hex, vector<double>(3)));
hex_ranks[hex][0] = nb_faces_on_boundary;
hex_ranks[hex][1] = hex->get_quality();
int count_blossom = 0;
- for (unsigned int f = 0; f < 6; ++f) {
+ for(unsigned int f = 0; f < 6; ++f) {
bool face_in_blossom_info = find_face_in_blossom_info(
hex->vertex_in_facet(f, 0), hex->vertex_in_facet(f, 1),
hex->vertex_in_facet(f, 2), hex->vertex_in_facet(f, 3));
- if (face_in_blossom_info) count_blossom++;
+ if(face_in_blossom_info) count_blossom++;
}
hex_ranks[hex][2] = count_blossom;
}
}
bool Recombinator_Graph::find_face_in_blossom_info(MVertex *a, MVertex *b,
- MVertex *c, MVertex *d)
+ MVertex *c, MVertex *d)
{
PETriangle *t1, *t2;
t1 = get_triangle(a, b, c);
t2 = get_triangle(a, c, d);
- if (is_blossom_pair(t1, t2))
- return true;
-
+ if(is_blossom_pair(t1, t2)) return true;
t1 = get_triangle(a, b, d);
t2 = get_triangle(b, c, d);
- if (is_blossom_pair(t1, t2))
- return true;
+ if(is_blossom_pair(t1, t2)) return true;
return false;
}
-
-PETriangle* Recombinator_Graph::get_triangle(MVertex*a, MVertex* b, MVertex *c)
+PETriangle *Recombinator_Graph::get_triangle(MVertex *a, MVertex *b, MVertex *c)
{
- vector<MVertex*> v;
+ vector<MVertex *> v;
v.push_back(a);
v.push_back(b);
v.push_back(c);
@@ -7207,13 +7500,11 @@ PETriangle* Recombinator_Graph::get_triangle(MVertex*a, MVertex* b, MVertex *c)
return (it_find_tri->second);
}
-
bool Recombinator_Graph::is_blossom_pair(PETriangle *t1, PETriangle *t2)
{
tripair::iterator itfind = blossom_info.find(t1);
- if (itfind != blossom_info.end()) {
- if (t2 == itfind->second)
- return true;
+ if(itfind != blossom_info.end()) {
+ if(t2 == itfind->second) return true;
}
return false;
}
diff --git a/Mesh/yamakawa.h b/Mesh/yamakawa.h
index b8c56cf2f683d49fd2b4cc318a0c60ccd8acd749..ae053ee7dc5ba54a5b9b9d893e1fc05a77198c05 100644
--- a/Mesh/yamakawa.h
+++ b/Mesh/yamakawa.h
@@ -8,7 +8,6 @@
#ifndef _YAMAKAWA_H_
#define _YAMAKAWA_H_
-
#include "GRegion.h"
#include "MVertex.h"
#include "MHexahedron.h"
@@ -25,15 +24,16 @@ using namespace std;
extern void export_gregion_mesh(GRegion *gr, const string &filename);
class Hex {
- private:
+private:
double quality;
unsigned long long hash;
- std::vector<MVertex*> vertices_;
- private:
+ std::vector<MVertex *> vertices_;
+
+private:
void set_hash()
{
hash = 0.;
- for (int i = 0; i < 8; ++i) {
+ for(int i = 0; i < 8; ++i) {
hash += vertices_[i]->getNum();
}
}
@@ -47,16 +47,17 @@ class Hex {
set_hash();
compute_quality();
}
- public:
+
+public:
Hex() : quality(0.), hash(0.) {}
- Hex(const std::vector<MVertex*>& vertices):
- quality(0.), hash(0), vertices_(vertices)
+ Hex(const std::vector<MVertex *> &vertices)
+ : quality(0.), hash(0), vertices_(vertices)
{
initialize();
}
- Hex(MVertex* a2, MVertex* b2, MVertex* c2, MVertex* d2, MVertex* e2,
- MVertex* f2, MVertex* g2, MVertex* h2) :
- quality(0.)
+ Hex(MVertex *a2, MVertex *b2, MVertex *c2, MVertex *d2, MVertex *e2,
+ MVertex *f2, MVertex *g2, MVertex *h2)
+ : quality(0.)
{
vertices_.push_back(a2);
vertices_.push_back(b2);
@@ -68,11 +69,11 @@ class Hex {
vertices_.push_back(h2);
initialize();
}
- ~Hex() {};
+ ~Hex(){};
double get_quality() const { return quality; }
- MVertex* getVertex(unsigned int i) const
+ MVertex *getVertex(unsigned int i) const
{
- if (i < 8) {
+ if(i < 8) {
return vertices_[i];
}
else {
@@ -81,12 +82,12 @@ class Hex {
return NULL;
}
}
- const std::vector<MVertex*>& vertices() const { return vertices_; }
- MVertex* vertex_in_facet(unsigned int facet, unsigned int v_in_facet) const;
+ const std::vector<MVertex *> &vertices() const { return vertices_; }
+ MVertex *vertex_in_facet(unsigned int facet, unsigned int v_in_facet) const;
bool hasVertex(MVertex *v) const
{
- for (int i = 0; i < 8; i++) {
- if (getVertex(i) == v) {
+ for(int i = 0; i < 8; i++) {
+ if(getVertex(i) == v) {
return true;
}
}
@@ -94,75 +95,76 @@ class Hex {
}
bool same_vertices(Hex *h) const
{
- for (int i = 0; i < 8; i++) {
- if (!(h->hasVertex(getVertex(i)))) {
+ for(int i = 0; i < 8; i++) {
+ if(!(h->hasVertex(getVertex(i)))) {
return false;
}
}
return true;
}
- int vertex_index(MVertex* v) const
+ int vertex_index(MVertex *v) const
{
- for (unsigned int i = 0; i < 8; ++i) {
- if (vertices_[i] == v) {
+ for(unsigned int i = 0; i < 8; ++i) {
+ if(vertices_[i] == v) {
return i;
}
}
return -1;
}
- bool contains(MVertex* v) const
- {
- return vertex_index(v) != -1;
- }
+ bool contains(MVertex *v) const { return vertex_index(v) != -1; }
unsigned long long get_hash()
{
- if (hash == 0. && vertices_[0]!=NULL) {
+ if(hash == 0. && vertices_[0] != NULL) {
set_hash();
}
return hash;
}
- bool operator<(const Hex& hex) const
+ bool operator<(const Hex &hex) const
{
- return quality > hex.get_quality(); // Why > ??? Shouldn't it be < ?? Jeanne.
+ return quality >
+ hex.get_quality(); // Why > ??? Shouldn't it be < ?? Jeanne.
}
};
class Facet {
- private:
+private:
MVertex *a, *b, *c;
int num[3];
unsigned long long hash;
- public:
+
+public:
Facet() : a(NULL), b(NULL), c(NULL), hash(0.)
{
num[0] = -1;
num[1] = -1;
num[2] = -1;
}
- Facet(MVertex* a2, MVertex* b2, MVertex* c2) :
- a(a2), b(b2), c(c2), hash(0.)
+ Facet(MVertex *a2, MVertex *b2, MVertex *c2) : a(a2), b(b2), c(c2), hash(0.)
{
num[0] = -1;
num[1] = -1;
num[2] = -1;
compute_hash();
}
- ~Facet() {};
- MVertex* get_a() const { return a; }
- MVertex* get_b() const { return b; }
- MVertex* get_c() const { return c; }
- void set_vertices(MVertex*a2, MVertex*b2, MVertex*c2)
+ ~Facet(){};
+ MVertex *get_a() const { return a; }
+ MVertex *get_b() const { return b; }
+ MVertex *get_c() const { return c; }
+ void set_vertices(MVertex *a2, MVertex *b2, MVertex *c2)
{
a = a2;
b = b2;
c = c2;
compute_hash();
}
- bool same_vertices(const Facet& facet) const
+ bool same_vertices(const Facet &facet) const
{
- bool c1 = (a == facet.get_a()) || (a == facet.get_b()) || (a == facet.get_c());
- bool c2 = (b == facet.get_a()) || (b == facet.get_b()) || (b == facet.get_c());
- bool c3 = (c == facet.get_a()) || (c == facet.get_b()) || (c == facet.get_c());
+ bool c1 =
+ (a == facet.get_a()) || (a == facet.get_b()) || (a == facet.get_c());
+ bool c2 =
+ (b == facet.get_a()) || (b == facet.get_b()) || (b == facet.get_c());
+ bool c3 =
+ (c == facet.get_a()) || (c == facet.get_b()) || (c == facet.get_c());
return c1 && c2 && c3;
}
void compute_hash()
@@ -171,27 +173,27 @@ class Facet {
num[1] = b->getNum();
num[2] = c->getNum();
std::sort(num, num + 3);
- hash = num[2] + 1e4*num[1] + 1e8*num[0];
+ hash = num[2] + 1e4 * num[1] + 1e8 * num[0];
}
unsigned long long get_hash() const { return hash; }
- bool operator<(const Facet& rhs) const {
- return hash<rhs.get_hash();
- }
+ bool operator<(const Facet &rhs) const { return hash < rhs.get_hash(); }
};
-class Diagonal{
- private:
- MVertex *a,*b;
+class Diagonal {
+private:
+ MVertex *a, *b;
unsigned long long hash;
- private:
+
+private:
void compute_hash() { hash = a->getNum() + b->getNum(); }
- public:
- Diagonal() :a(NULL), b(NULL), hash() {};
- Diagonal(MVertex*a2, MVertex*b2) :a(a2), b(b2){ compute_hash(); }
- ~Diagonal() {};
- MVertex* get_a() const {return a;}
- MVertex* get_b() const {return b;}
- void set_vertices(MVertex*a2, MVertex*b2)
+
+public:
+ Diagonal() : a(NULL), b(NULL), hash(){};
+ Diagonal(MVertex *a2, MVertex *b2) : a(a2), b(b2) { compute_hash(); }
+ ~Diagonal(){};
+ MVertex *get_a() const { return a; }
+ MVertex *get_b() const { return b; }
+ void set_vertices(MVertex *a2, MVertex *b2)
{
a = a2;
b = b2;
@@ -204,7 +206,7 @@ class Diagonal{
return c1 && c2;
}
unsigned long long get_hash() const { return hash; }
- bool operator<(const Diagonal& rhs) const { return hash<rhs.get_hash(); }
+ bool operator<(const Diagonal &rhs) const { return hash < rhs.get_hash(); }
};
class Tuple {
@@ -216,23 +218,15 @@ private:
public:
Tuple()
- : vertex1(NULL)
- , vertex2(NULL)
- , vertex3(NULL)
- , element(NULL)
- , gf(NULL)
- , hash(0)
+ : vertex1(NULL), vertex2(NULL), vertex3(NULL), element(NULL), gf(NULL),
+ hash(0)
{
}
Tuple(MVertex *const a, MVertex *const b, MVertex *const c,
MElement *const element2, GFace *const gf2)
- : vertex1(NULL)
- , vertex2(NULL)
- , vertex3(NULL)
- , element(element2)
- , gf(gf2)
- , hash(a->getNum() + b->getNum() + c->getNum())
+ : vertex1(NULL), vertex2(NULL), vertex3(NULL), element(element2), gf(gf2),
+ hash(a->getNum() + b->getNum() + c->getNum())
{
MVertex *tmp[3] = {a, b, c};
std::sort(tmp, tmp + 3);
@@ -242,12 +236,8 @@ public:
}
Tuple(MVertex *const a, MVertex *const b, MVertex *const c)
- : vertex1(NULL)
- , vertex2(NULL)
- , vertex3(NULL)
- , element(NULL)
- , gf(NULL)
- , hash(a->getNum() + b->getNum() + c->getNum())
+ : vertex1(NULL), vertex2(NULL), vertex3(NULL), element(NULL), gf(NULL),
+ hash(a->getNum() + b->getNum() + c->getNum())
{
MVertex *tmp[3] = {a, b, c};
std::sort(tmp, tmp + 3);
@@ -280,11 +270,11 @@ public:
// mesh
class TetMeshConnectivity {
public:
- typedef std::set<MVertex*> VertexSet;
- typedef std::set<MElement*> TetSet;
- TetMeshConnectivity() {};
- ~TetMeshConnectivity() {};
- void initialize(GRegion* region)
+ typedef std::set<MVertex *> VertexSet;
+ typedef std::set<MElement *> TetSet;
+ TetMeshConnectivity(){};
+ ~TetMeshConnectivity(){};
+ void initialize(GRegion *region)
{
Msg::Info("Initialize Connectivity Information...");
clear();
@@ -296,145 +286,151 @@ public:
vertex_to_vertices_.clear();
vertex_to_elements_.clear();
}
- VertexSet& vertices_around_vertex(MVertex* v)
+ VertexSet &vertices_around_vertex(MVertex *v)
{
return vertex_to_vertices_[v];
}
- TetSet& tets_around_vertex(MVertex* v)
- {
- return vertex_to_elements_[v];
- }
- bool are_vertex_neighbors(MVertex* v0, MVertex* v1)
+ TetSet &tets_around_vertex(MVertex *v) { return vertex_to_elements_[v]; }
+ bool are_vertex_neighbors(MVertex *v0, MVertex *v1)
{
return vertices_around_vertex(v0).count(v1) > 0;
}
- void vertices_around_vertices(MVertex* v0, MVertex* v1, VertexSet& result)
+ void vertices_around_vertices(MVertex *v0, MVertex *v1, VertexSet &result)
{
- const VertexSet& neighbors0 = vertices_around_vertex(v0);
- const VertexSet& neighbors1 = vertices_around_vertex(v1);
+ const VertexSet &neighbors0 = vertices_around_vertex(v0);
+ const VertexSet &neighbors1 = vertices_around_vertex(v1);
std::set_intersection(neighbors0.begin(), neighbors0.end(),
- neighbors1.begin(), neighbors1.end(), std::inserter(result, result.end()));
+ neighbors1.begin(), neighbors1.end(),
+ std::inserter(result, result.end()));
}
- void vertices_around_vertices(MVertex* v0, MVertex* v1, MVertex* v2, VertexSet& result)
+ void vertices_around_vertices(MVertex *v0, MVertex *v1, MVertex *v2,
+ VertexSet &result)
{
VertexSet tmp;
vertices_around_vertices(v0, v1, tmp);
- const VertexSet& neighbors2 = vertices_around_vertex(v2);
- std::set_intersection(neighbors2.begin(), neighbors2.end(),
- tmp.begin(), tmp.end(), std::inserter(result, result.end()));
+ const VertexSet &neighbors2 = vertices_around_vertex(v2);
+ std::set_intersection(neighbors2.begin(), neighbors2.end(), tmp.begin(),
+ tmp.end(), std::inserter(result, result.end()));
}
- void tets_around_vertices(MVertex* v0, MVertex* v1, TetSet& result)
+ void tets_around_vertices(MVertex *v0, MVertex *v1, TetSet &result)
{
- const TetSet& elements0 = tets_around_vertex(v0);
- const TetSet& elements1 = tets_around_vertex(v1);
- std::set_intersection(elements0.begin(), elements0.end(),
- elements1.begin(), elements1.end(), std::inserter(result, result.end()));
+ const TetSet &elements0 = tets_around_vertex(v0);
+ const TetSet &elements1 = tets_around_vertex(v1);
+ std::set_intersection(elements0.begin(), elements0.end(), elements1.begin(),
+ elements1.end(), std::inserter(result, result.end()));
}
- void tets_around_vertices(MVertex* v0, MVertex* v1, MVertex* v2, TetSet& result)
+ void tets_around_vertices(MVertex *v0, MVertex *v1, MVertex *v2,
+ TetSet &result)
{
TetSet tmp;
tets_around_vertices(v0, v1, tmp);
- const TetSet& elements2 = tets_around_vertex(v2);
- std::set_intersection(tmp.begin(), tmp.end(),
- elements2.begin(), elements2.end(), std::inserter(result, result.end()));
+ const TetSet &elements2 = tets_around_vertex(v2);
+ std::set_intersection(tmp.begin(), tmp.end(), elements2.begin(),
+ elements2.end(), std::inserter(result, result.end()));
}
- private:
+private:
// TODO Change this costly implementation
// Replace maps by vectors and store adjacent vertices whose
// index is bigger
- void initialize_vertex_to_vertices(GRegion* region)
+ void initialize_vertex_to_vertices(GRegion *region)
{
int nbtets = region->getNumMeshElements();
- for (int i = 0; i < nbtets; i++) {
- MElement* tet = region->getMeshElement(i);
- for (int j = 0; j < 4; j++) {
- MVertex* a = tet->getVertex(j);
- MVertex* b = tet->getVertex((j + 1) % 4);
- MVertex* c = tet->getVertex((j + 2) % 4);
- MVertex* d = tet->getVertex((j + 3) % 4);
- std::map<MVertex*, std::set<MVertex*> >::iterator it = vertex_to_vertices_.find(a);
- if (it != vertex_to_vertices_.end()) {
+ for(int i = 0; i < nbtets; i++) {
+ MElement *tet = region->getMeshElement(i);
+ for(int j = 0; j < 4; j++) {
+ MVertex *a = tet->getVertex(j);
+ MVertex *b = tet->getVertex((j + 1) % 4);
+ MVertex *c = tet->getVertex((j + 2) % 4);
+ MVertex *d = tet->getVertex((j + 3) % 4);
+ std::map<MVertex *, std::set<MVertex *> >::iterator it =
+ vertex_to_vertices_.find(a);
+ if(it != vertex_to_vertices_.end()) {
it->second.insert(b);
it->second.insert(c);
it->second.insert(d);
}
else {
- std::set<MVertex*> bin;
+ std::set<MVertex *> bin;
bin.insert(b);
bin.insert(c);
bin.insert(d);
- vertex_to_vertices_.insert(std::pair<MVertex*, std::set<MVertex*> >(a, bin));
+ vertex_to_vertices_.insert(
+ std::pair<MVertex *, std::set<MVertex *> >(a, bin));
}
}
}
}
- void initialize_vertex_to_elements(GRegion* region)
+ void initialize_vertex_to_elements(GRegion *region)
{
int nbtets = region->getNumMeshElements();
- for (int i = 0; i < nbtets; i++) {
- MElement* tet = region->getMeshElement(i);
- for (unsigned int j = 0; j < 4; j++) {
- MVertex* getVertex = tet->getVertex(j);
- std::map<MVertex*, std::set<MElement*> >::iterator it = vertex_to_elements_.find(getVertex);
- if (it != vertex_to_elements_.end()) {
+ for(int i = 0; i < nbtets; i++) {
+ MElement *tet = region->getMeshElement(i);
+ for(unsigned int j = 0; j < 4; j++) {
+ MVertex *getVertex = tet->getVertex(j);
+ std::map<MVertex *, std::set<MElement *> >::iterator it =
+ vertex_to_elements_.find(getVertex);
+ if(it != vertex_to_elements_.end()) {
it->second.insert(tet);
}
else {
- std::set<MElement*> bin;
+ std::set<MElement *> bin;
bin.insert(tet);
- vertex_to_elements_.insert(std::pair<MVertex*, std::set<MElement*> >(getVertex, bin));
+ vertex_to_elements_.insert(
+ std::pair<MVertex *, std::set<MElement *> >(getVertex, bin));
}
}
}
}
- private:
- std::map<MVertex*, std::set<MVertex*> > vertex_to_vertices_;
- std::map<MVertex*, std::set<MElement*> > vertex_to_elements_;
+
+private:
+ std::map<MVertex *, std::set<MVertex *> > vertex_to_vertices_;
+ std::map<MVertex *, std::set<MElement *> > vertex_to_elements_;
};
-class Recombinator{
- public:
- typedef std::set<MVertex*>::iterator vertex_set_itr;
- typedef std::set<MElement*>::iterator element_set_itr;
+class Recombinator {
+public:
+ typedef std::set<MVertex *>::iterator vertex_set_itr;
+ typedef std::set<MElement *>::iterator element_set_itr;
- typedef std::map<MVertex*, std::set<MVertex*> > Vertex2Vertices;
- typedef std::map<MVertex*, std::set<MElement*> > Vertex2Elements;
+ typedef std::map<MVertex *, std::set<MVertex *> > Vertex2Vertices;
+ typedef std::map<MVertex *, std::set<MElement *> > Vertex2Elements;
- Recombinator() :current_region(NULL), hex_threshold_quality(0.6) {};
+ Recombinator() : current_region(NULL), hex_threshold_quality(0.6){};
virtual ~Recombinator();
virtual void execute();
- virtual void execute(GRegion*);
+ virtual void execute(GRegion *);
- protected:
+protected:
// ---- Initialization of the structures
- virtual void initialize_structures(GRegion* region) {
+ virtual void initialize_structures(GRegion *region)
+ {
set_current_region(region);
tet_mesh.initialize(current_region);
build_tuples();
init_markings();
- // What happens when the mesh of the region is not only constituted of tets? JP
+ // What happens when the mesh of the region is not only constituted of tets?
+ // JP
}
void init_markings();
void build_tuples();
- void set_current_region(GRegion* region) { current_region = region; }
+ void set_current_region(GRegion *region) { current_region = region; }
// ---- Create the final mesh -------
virtual void merge();
- virtual void merge(GRegion*){}
+ virtual void merge(GRegion *) {}
void delete_marked_tets_in_region() const;
// Check if the hex is valid and compatible with the
// previously built hexes and add it to the region
- bool add_hex_to_region_if_valid(const Hex& hex);
+ bool add_hex_to_region_if_valid(const Hex &hex);
// ---- Computation of potential hexes
- virtual void clear_potential_hex_info() {
- potential.clear();
- }
- void compute_potential_hexes() {
+ virtual void clear_potential_hex_info() { potential.clear(); }
+ void compute_potential_hexes()
+ {
clear_potential_hex_info();
pattern1();
pattern2();
@@ -444,61 +440,63 @@ class Recombinator{
void pattern1();
void pattern2();
void pattern3();
- virtual void add_or_free_potential_hex(Hex* candidate);
+ virtual void add_or_free_potential_hex(Hex *candidate);
// ----- Helpers to debug -------
void print_all_potential_hex() const;
void print_hash_tableA();
- void print_segment(const SPoint3&, const SPoint3&, std::ofstream&);
+ void print_segment(const SPoint3 &, const SPoint3 &, std::ofstream &);
// ----- Conformity stuff -------
- bool is_potential_hex_conform(const Hex& hex);
- bool conformityA(const Hex&);
- bool conformityB(const Hex&);
- bool conformityC(const Hex&);
+ bool is_potential_hex_conform(const Hex &hex);
+ bool conformityA(const Hex &);
+ bool conformityB(const Hex &);
+ bool conformityC(const Hex &);
- bool faces_statuquo(const Hex&);
- bool faces_statuquo(MVertex*, MVertex*, MVertex*, MVertex*);
+ bool faces_statuquo(const Hex &);
+ bool faces_statuquo(MVertex *, MVertex *, MVertex *, MVertex *);
- bool are_all_tets_free(const std::set<MElement*>& tets) const;
+ bool are_all_tets_free(const std::set<MElement *> &tets) const;
- void mark_tets(const std::set<MElement*>& tets);
- void clear_hash_tables() {
+ void mark_tets(const std::set<MElement *> &tets);
+ void clear_hash_tables()
+ {
hash_tableA.clear();
hash_tableB.clear();
hash_tableC.clear();
}
- void build_hash_tableA(const Hex& hex);
- void build_hash_tableB(const Hex& hex);
- void build_hash_tableC(const Hex& hex);
+ void build_hash_tableA(const Hex &hex);
+ void build_hash_tableB(const Hex &hex);
+ void build_hash_tableC(const Hex &hex);
// ----- Post-processing -------
- void improve_final_mesh() {
+ void improve_final_mesh()
+ {
set_region_elements_positive();
create_quads_on_boundary();
}
// Reverse of of built elements with a negative volume
void set_region_elements_positive();
void create_quads_on_boundary();
- void create_quads_on_boundary(MVertex*, MVertex*, MVertex*, MVertex*);
+ void create_quads_on_boundary(MVertex *, MVertex *, MVertex *, MVertex *);
void delete_quad_triangles_in_boundary() const;
// ---- Functions that should not be part of the class
- double scaled_jacobian(MVertex*, MVertex*, MVertex*, MVertex*);
- double max_scaled_jacobian(MElement*, int&);
- double min_scaled_jacobian(Hex&);
+ double scaled_jacobian(MVertex *, MVertex *, MVertex *, MVertex *);
+ double max_scaled_jacobian(MElement *, int &);
+ double min_scaled_jacobian(Hex &);
void print_statistics();
- protected:
+protected:
// Object in charge of answering connectivity request
// in the initial region tetrahedral mesh
TetMeshConnectivity tet_mesh;
- GRegion* current_region;
+ GRegion *current_region;
double hex_threshold_quality;
- std::vector<Hex*> potential;
- std::map<MElement*,bool> markings;
+ std::vector<Hex *> potential;
+ std::map<MElement *, bool> markings;
// Already chosen facet triangles (4 per hex facet)
std::multiset<Facet> hash_tableA;
// Already chosen hex facet diagonals
@@ -507,65 +505,66 @@ class Recombinator{
std::multiset<Diagonal> hash_tableC;
std::multiset<Tuple> tuples;
- std::set<MElement*> triangles;
+ std::set<MElement *> triangles;
};
class PEEntity {
protected:
- vector<MVertex*> vertices;
+ vector<MVertex *> vertices;
size_t hash;
void compute_hash();
+
public:
- PEEntity(const vector<MVertex*> &_v);
+ PEEntity(const vector<MVertex *> &_v);
virtual ~PEEntity();
virtual size_t get_max_nb_vertices() const = 0;
- MVertex* getVertex(size_t n) const;
- bool hasVertex(MVertex *v)const;
+ MVertex *getVertex(size_t n) const;
+ bool hasVertex(MVertex *v) const;
size_t get_hash() const;
- bool same_vertices(const PEEntity *t)const;
- bool operator<(const PEEntity&) const;
+ bool same_vertices(const PEEntity *t) const;
+ bool operator<(const PEEntity &) const;
};
class PELine : public PEEntity {
public:
- PELine(const vector<MVertex*> &_v);
+ PELine(const vector<MVertex *> &_v);
virtual ~PELine();
size_t get_max_nb_vertices() const;
};
class PETriangle : public PEEntity {
public:
- PETriangle(const vector<MVertex*> &_v);
- //PETriangle(size_t l);
+ PETriangle(const vector<MVertex *> &_v);
+ // PETriangle(size_t l);
virtual ~PETriangle();
size_t get_max_nb_vertices() const;
};
class PEQuadrangle : public PEEntity {
public:
- PEQuadrangle(const vector<MVertex*> &_v);
- //PEQuadrangle(size_t l);
+ PEQuadrangle(const vector<MVertex *> &_v);
+ // PEQuadrangle(size_t l);
virtual ~PEQuadrangle();
size_t get_max_nb_vertices() const;
};
// Why are the following classes templates???
-// Used with only with Hex*, implemented in the cpp file (bad idea) and does not seem robust. JP.
+// Used with only with Hex*, implemented in the cpp file (bad idea) and does not
+// seem robust. JP.
// Very very complicated way to answer one question
// Do we have all the tets of the input mesh for a given combination of hex?
// Slivers are tricky since they can be in shared by 2 hex.
-template<class T>
-class clique_stop_criteria {
+template <class T> class clique_stop_criteria {
public:
typedef std::set<T> graph_data_no_hash;
- clique_stop_criteria(map<T, std::set<MElement*> > &_m, int _i);
+ clique_stop_criteria(map<T, std::set<MElement *> > &_m, int _i);
~clique_stop_criteria();
- bool stop(const graph_data_no_hash &clique)const;
- void export_corresponding_mesh(const graph_data_no_hash &clique)const;
+ bool stop(const graph_data_no_hash &clique) const;
+ void export_corresponding_mesh(const graph_data_no_hash &clique) const;
private:
- const map<T, std::set<MElement*> > &hex_to_tet;
+ const map<T, std::set<MElement *> > &hex_to_tet;
const unsigned int total_number_tet;
};
@@ -573,24 +572,23 @@ private:
// This complicates everything and is useless as the class
// cannot be used outside the .cpp file where it is implemented.
// TODO - Rewrite this without multimaps or unnecessary abstractions.
-template<class T>
-class cliques_compatibility_graph {
+template <class T> class cliques_compatibility_graph {
public:
typedef unsigned long long hash_key;
typedef std::set<T> graph_data_no_hash;
typedef std::multimap<hash_key, T> graph_data;
- typedef std::multimap<hash_key, pair<T, graph_data > > graph;
+ typedef std::multimap<hash_key, pair<T, graph_data> > graph;
typedef std::map<int, T> ranking_data;
- typedef void(*ptrfunction_export)(cliques_compatibility_graph<T>&, int, string);
+ typedef void (*ptrfunction_export)(cliques_compatibility_graph<T> &, int,
+ string);
- cliques_compatibility_graph(
- graph &_g,
- const map<T, std::vector<double> > &_hex_ranks,
- unsigned int _max_nb_cliques,
- unsigned int _nb_hex_potentiels,
- clique_stop_criteria<T> *csc,
- ptrfunction_export fct);
+ cliques_compatibility_graph(graph &_g,
+ const map<T, std::vector<double> > &_hex_ranks,
+ unsigned int _max_nb_cliques,
+ unsigned int _nb_hex_potentiels,
+ clique_stop_criteria<T> *csc,
+ ptrfunction_export fct);
virtual ~cliques_compatibility_graph();
void find_cliques();
void export_cliques();
@@ -609,13 +607,18 @@ public:
protected:
void erase_entry(graph_data &subgraph, T &u, hash_key &key);
void find_cliques(graph_data &subgraph, int n);
- void split_set_BW(const T &u, const hash_key &u_key, const graph_data &subgraph, graph_data &white, graph_data &black);
- void fill_black_set(const T &u, const hash_key &u_key, const graph_data &subgraph, graph_data &black);
+ void split_set_BW(const T &u, const hash_key &u_key,
+ const graph_data &subgraph, graph_data &white,
+ graph_data &black);
+ void fill_black_set(const T &u, const hash_key &u_key,
+ const graph_data &subgraph, graph_data &black);
void choose_u(const graph_data &subgraph, T &u, hash_key &u_key);
- double function_to_maximize_for_u(const T &u, const hash_key &u_key, const graph_data &subgraph);
+ double function_to_maximize_for_u(const T &u, const hash_key &u_key,
+ const graph_data &subgraph);
void store_clique(int n);
// Returns true if two nodes are connected in the graph
- virtual bool compatibility(const T &u, const hash_key &u_key, const T &v, const hash_key &v_key);
+ virtual bool compatibility(const T &u, const hash_key &u_key, const T &v,
+ const hash_key &v_key);
ptrfunction_export export_clique_graph;
@@ -627,55 +630,55 @@ protected:
unsigned int position;
unsigned int total_nodes_number;
unsigned int total_nb_of_cliques_searched;
- unsigned int max_nb_of_stored_cliques;// to reduce memory footprint (set to zero if no limit)
- clique_stop_criteria<T>* criteria;
+ unsigned int max_nb_of_stored_cliques; // to reduce memory footprint (set to
+ // zero if no limit)
+ clique_stop_criteria<T> *criteria;
bool cancel_search;
// Not used in anyway
const map<T, std::vector<double> > &hex_ranks;
graph &G;
- graph_data_no_hash Q;// the current clique
+ graph_data_no_hash Q; // the current clique
};
// Non necessary derivation
-template<class T>
+template <class T>
class cliques_losses_graph : public cliques_compatibility_graph<T> {
public:
typedef unsigned long long hash_key;
typedef multimap<hash_key, T> graph_data;
- typedef multimap<hash_key, pair<T, graph_data > > graph;
- typedef void(*ptrfunction_export)(cliques_compatibility_graph<T>&, int, string);
-
- cliques_losses_graph(
- graph &_g,
- const map<T, std::vector<double> > &_hex_ranks,
- unsigned int _max_nb_cliques,
- unsigned int _nb_hex_potentiels,
- clique_stop_criteria<T> *csc,
- ptrfunction_export fct);
+ typedef multimap<hash_key, pair<T, graph_data> > graph;
+ typedef void (*ptrfunction_export)(cliques_compatibility_graph<T> &, int,
+ string);
+
+ cliques_losses_graph(graph &_g,
+ const map<T, std::vector<double> > &_hex_ranks,
+ unsigned int _max_nb_cliques,
+ unsigned int _nb_hex_potentiels,
+ clique_stop_criteria<T> *csc, ptrfunction_export fct);
virtual ~cliques_losses_graph();
protected:
// Returns true if the two nodes are compatible
// (connected in compatiblity graph - not connected in losses graph)
- virtual bool compatibility(const T &u, const hash_key &u_key, const T &v, const hash_key &v_key);
+ virtual bool compatibility(const T &u, const hash_key &u_key, const T &v,
+ const hash_key &v_key);
};
-
-class Recombinator_Graph : public Recombinator{
+class Recombinator_Graph : public Recombinator {
public:
typedef size_t my_hash_key;
- typedef multimap<my_hash_key,PETriangle*> trimap;
- typedef map<PETriangle*, PETriangle*> tripair;
- typedef multimap<my_hash_key, PELine*> linemap;
+ typedef multimap<my_hash_key, PETriangle *> trimap;
+ typedef map<PETriangle *, PETriangle *> tripair;
+ typedef multimap<my_hash_key, PELine *> linemap;
- //typedef tr1::unordered_multimap<my_hash_key,PETriangle*> trimap;
+ // typedef tr1::unordered_multimap<my_hash_key,PETriangle*> trimap;
typedef trimap::iterator iter;
typedef trimap::const_iterator citer;
typedef unsigned long long hash_key;
- typedef multimap<hash_key, Hex*> graph_data;
- typedef multimap<hash_key, pair<Hex*, graph_data > > graph;
+ typedef multimap<hash_key, Hex *> graph_data;
+ typedef multimap<hash_key, pair<Hex *, graph_data> > graph;
protected:
bool debug;
@@ -686,91 +689,103 @@ protected:
// Topological information to navigate in the input tet mesh
// to navigate between the potential hexes and the input tet mesh
- std::map<Hex*, std::set<MElement*> > hex_to_tet;
- std::map<MElement*, std::set<Hex*> >tet_to_hex;
- std::map<Hex*, std::set<PELine*> > hex_to_edges;
- std::map<PELine*, std::set<Hex*> > edges_to_hex;
- std::map<Hex*, std::set<PETriangle*> > hex_to_faces;
- std::map<PETriangle*, std::set<Hex*> > faces_to_hex;
- // Number of tets containing a tet - Is the facet on the boundary (1 tet) or not (2 tets)?
- std::map<PETriangle*, unsigned int > faces_connectivity;
-
- std::map<Hex*, std::vector<double> > hex_ranks;
+ std::map<Hex *, std::set<MElement *> > hex_to_tet;
+ std::map<MElement *, std::set<Hex *> > tet_to_hex;
+ std::map<Hex *, std::set<PELine *> > hex_to_edges;
+ std::map<PELine *, std::set<Hex *> > edges_to_hex;
+ std::map<Hex *, std::set<PETriangle *> > hex_to_faces;
+ std::map<PETriangle *, std::set<Hex *> > faces_to_hex;
+ // Number of tets containing a tet - Is the facet on the boundary (1 tet) or
+ // not (2 tets)?
+ std::map<PETriangle *, unsigned int> faces_connectivity;
+
+ std::map<Hex *, std::vector<double> > hex_ranks;
graph incompatibility_graph;
- std::set<Hex*> set_of_all_hex_in_graph;
-
- std::multimap<unsigned long long, Hex*> created_potential_hex;
-
- std::multimap<double, Hex*> degree; // degree = the final ranking of hexahedra
- std::multimap<int, Hex*> idegree; // idegree = number of connected hex in indirect neighbors graph
- std::multimap<int, Hex*> ndegree; // ndegree = number of direct neighbors !!! not chosen yet !!!
- std::map<Hex*, int> reverse_idegree;
- std::map<Hex*, int> reverse_ndegree;
- // each tet has at least one neighbor, at most four. For all not chosen hex, check this data to find how many direct neighbors...
+ std::set<Hex *> set_of_all_hex_in_graph;
+
+ std::multimap<unsigned long long, Hex *> created_potential_hex;
+
+ std::multimap<double, Hex *>
+ degree; // degree = the final ranking of hexahedra
+ std::multimap<int, Hex *>
+ idegree; // idegree = number of connected hex in indirect neighbors graph
+ std::multimap<int, Hex *>
+ ndegree; // ndegree = number of direct neighbors !!! not chosen yet !!!
+ std::map<Hex *, int> reverse_idegree;
+ std::map<Hex *, int> reverse_ndegree;
+ // each tet has at least one neighbor, at most four. For all not chosen hex,
+ // check this data to find how many direct neighbors...
// std::map<MElement*,set<PETriangle*> > tet_to_triangle;
- std::map<PETriangle*, set<MElement*> > triangle_to_tet;
- std::map<MElement*, int> tet_degree;
+ std::map<PETriangle *, set<MElement *> > triangle_to_tet;
+ std::map<MElement *, int> tet_degree;
tripair blossom_info;
trimap triangular_faces;
linemap edges_and_diagonals;
- map<PETriangle*, GFace*> tri_to_gface_info;
-
- vector<Hex*> chosen_hex;
- vector<MElement*> chosen_tet;
- bool post_check_validation(Hex* current_hex);
+ map<PETriangle *, GFace *> tri_to_gface_info;
+ vector<Hex *> chosen_hex;
+ vector<MElement *> chosen_tet;
+ bool post_check_validation(Hex *current_hex);
protected:
void create_faces_connectivity();
void add_face_connectivity(MElement *tet, int i, int j, int k);
void add_edges(Hex *hex);
- void fill_edges_table(const std::vector<MVertex*>&, Hex *hex);
- void add_face(MVertex *a,MVertex* b,MVertex *c,Hex *hex);
- void add_face(MVertex *a,MVertex* b,MVertex *c,std::multimap<unsigned long long, pair<PETriangle*,int> > &f);
+ void fill_edges_table(const std::vector<MVertex *> &, Hex *hex);
+ void add_face(MVertex *a, MVertex *b, MVertex *c, Hex *hex);
+ void add_face(MVertex *a, MVertex *b, MVertex *c,
+ std::multimap<unsigned long long, pair<PETriangle *, int> > &f);
// All the blossom related stuff is out of date - or not working
// Cannot be called. To remove?
- bool find_face_in_blossom_info(MVertex *a, MVertex *b, MVertex *c, MVertex *d);
+ bool find_face_in_blossom_info(MVertex *a, MVertex *b, MVertex *c,
+ MVertex *d);
void compute_hex_ranks_blossom();
- PETriangle* get_triangle(MVertex*a, MVertex* b, MVertex *c);
+ PETriangle *get_triangle(MVertex *a, MVertex *b, MVertex *c);
bool is_blossom_pair(PETriangle *t1, PETriangle *t2);
citer find_the_triangle(PETriangle *t, const trimap &list);
- linemap::const_iterator find_the_line(PELine *t, const linemap &list);
- std::multimap<unsigned long long, pair<PETriangle*,int> >::iterator
- find_the_triangle(PETriangle *t, std::multimap<unsigned long long, pair<PETriangle*, int> > &list);
- std::multimap<unsigned long long, Hex* >::const_iterator
- find_the_created_potential_hex(Hex *t, const std::multimap<unsigned long long, Hex*> &list);
-
+ linemap::const_iterator find_the_line(PELine *t, const linemap &list);
+ std::multimap<unsigned long long, pair<PETriangle *, int> >::iterator
+ find_the_triangle(
+ PETriangle *t,
+ std::multimap<unsigned long long, pair<PETriangle *, int> > &list);
+ std::multimap<unsigned long long, Hex *>::const_iterator
+ find_the_created_potential_hex(
+ Hex *t, const std::multimap<unsigned long long, Hex *> &list);
- PETriangle* get_triangle(MElement *element, int i, int j, int k);
+ PETriangle *get_triangle(MElement *element, int i, int j, int k);
void compute_hex_ranks();
- // check if the hex is good enough to be put into the graph. If not in the graph, it cannot be chosen...
- bool is_not_good_enough(Hex* hex);
+ // check if the hex is good enough to be put into the graph. If not in the
+ // graph, it cannot be chosen...
+ bool is_not_good_enough(Hex *hex);
// fills incompatibility_graph if two hex share a common (non-sliver!) tet
void create_indirect_neighbors_graph();
- graph::iterator find_hex_in_graph(Hex* hex);
- graph_data::iterator find_hex_in_graphrow(Hex* hex, graph_data &row);
- bool find_hex_couple_in_graph(Hex* hex, Hex* other_hex);
- void add_graph_entry(Hex* hex, Hex* other_hex);
+ graph::iterator find_hex_in_graph(Hex *hex);
+ graph_data::iterator find_hex_in_graphrow(Hex *hex, graph_data &row);
+ bool find_hex_couple_in_graph(Hex *hex, Hex *other_hex);
+ void add_graph_entry(Hex *hex, Hex *other_hex);
// fills incompatibility_graph if two hex are incompatible direct neighbors,
- // i.e. they have one (or more) common face or common edge and are not compatible
+ // i.e. they have one (or more) common face or common edge and are not
+ // compatible
void create_direct_neighbors_incompatibility_graph();
- void evaluate_hex_couple(Hex* hex, Hex* other_hex);
+ void evaluate_hex_couple(Hex *hex, Hex *other_hex);
- // if two hex are not connected in the incompatibility_graph, they are compatible
+ // if two hex are not connected in the incompatibility_graph, they are
+ // compatible
void create_losses_graph(GRegion *gr);
- void merge_clique(GRegion* gr, cliques_losses_graph<Hex*> &cl,int clique_number=0);
+ void merge_clique(GRegion *gr, cliques_losses_graph<Hex *> &cl,
+ int clique_number = 0);
/*
* Tries to merge tetrahedra into one hexahedron. Returns false if the hex
@@ -781,22 +796,26 @@ protected:
void fill_tet_to_hex_table(Hex *hex);
// Reimplementation
- virtual void add_or_free_potential_hex(Hex* candidate) {
+ virtual void add_or_free_potential_hex(Hex *candidate)
+ {
fill_tet_to_hex_table(candidate);
}
- virtual void clear_potential_hex_info() {
+ virtual void clear_potential_hex_info()
+ {
hex_to_tet.clear();
tet_to_hex.clear();
created_potential_hex.clear();
}
- virtual void initialize_structures(GRegion* region) {
+ virtual void initialize_structures(GRegion *region)
+ {
set_current_region(region);
tet_mesh.initialize(current_region);
build_tuples();
}
- void clear_and_build_hash_tables(const Hex& hex) {
+ void clear_and_build_hash_tables(const Hex &hex)
+ {
hash_tableA.clear();
hash_tableB.clear();
hash_tableC.clear();
@@ -807,7 +826,7 @@ protected:
// Throw an assertion
using Recombinator::merge;
- void merge(GRegion*);
+ void merge(GRegion *);
// ------- exports --------
// ---- seems that it won't export nothing since the
@@ -817,237 +836,258 @@ protected:
void export_single_hex(Hex *hex, const string &s);
void export_single_hex_faces(Hex *hex, const string &s);
void export_single_hex_tet(Hex *hex, const string &s);
- void export_all_hex(int &file,GRegion *gr);
+ void export_all_hex(int &file, GRegion *gr);
void export_hexmesh_so_far(int &file);
void export_direct_neighbor_table(int max);
- void export_hex_init_degree(GRegion *gr, const std::map<Hex*,int> &init_degree, const vector<Hex*> &chosen_hex);
+ void export_hex_init_degree(GRegion *gr,
+ const std::map<Hex *, int> &init_degree,
+ const vector<Hex *> &chosen_hex);
public:
Recombinator_Graph(unsigned int max_nb_cliques,
const string &filename = string());
virtual ~Recombinator_Graph();
using Recombinator::execute;
- virtual void execute(GRegion*);
-
- virtual void buildGraphOnly(unsigned int max_nb_cliques, string filename=string());
- virtual void buildGraphOnly(GRegion*, unsigned int max_nb_cliques, string filename=string());
- virtual void execute_blossom(unsigned int max_nb_cliques, string filename=string());
+ virtual void execute(GRegion *);
+
+ virtual void buildGraphOnly(unsigned int max_nb_cliques,
+ string filename = string());
+ virtual void buildGraphOnly(GRegion *, unsigned int max_nb_cliques,
+ string filename = string());
+ virtual void execute_blossom(unsigned int max_nb_cliques,
+ string filename = string());
// What is this function supposed to do?
// Right now it throws at the first line. JP
- virtual void execute_blossom(GRegion*, unsigned int max_nb_cliques, string filename=string());
+ virtual void execute_blossom(GRegion *, unsigned int max_nb_cliques,
+ string filename = string());
virtual void createBlossomInfo();
void createBlossomInfo(GRegion *gr);
- const std::set<Hex*>& getHexInGraph() const { return set_of_all_hex_in_graph; };
+ const std::set<Hex *> &getHexInGraph() const
+ {
+ return set_of_all_hex_in_graph;
+ };
bool found_the_ultimate_max_clique;
};
-class Prism{
+class Prism {
private:
double quality;
- MVertex *a,*b,*c,*d,*e,*f;
+ MVertex *a, *b, *c, *d, *e, *f;
+
public:
- typedef std::set<MVertex*>::iterator vertex_set_itr;
- typedef std::set<MElement*>::iterator element_set_itr;
+ typedef std::set<MVertex *>::iterator vertex_set_itr;
+ typedef std::set<MElement *>::iterator element_set_itr;
Prism();
- Prism(MVertex*,MVertex*,MVertex*,MVertex*,MVertex*,MVertex*);
+ Prism(MVertex *, MVertex *, MVertex *, MVertex *, MVertex *, MVertex *);
~Prism();
double get_quality() const;
void set_quality(double);
- MVertex* get_a();
- MVertex* get_b();
- MVertex* get_c();
- MVertex* get_d();
- MVertex* get_e();
- MVertex* get_f();
- void set_vertices(MVertex*,MVertex*,MVertex*,MVertex*,MVertex*,MVertex*);
- bool operator<(const Prism&) const;
+ MVertex *get_a();
+ MVertex *get_b();
+ MVertex *get_c();
+ MVertex *get_d();
+ MVertex *get_e();
+ MVertex *get_f();
+ void set_vertices(MVertex *, MVertex *, MVertex *, MVertex *, MVertex *,
+ MVertex *);
+ bool operator<(const Prism &) const;
};
-
// Une ENORME partie de ce code est du copie-colle depuis Recombinator
-class Supplementary{
+class Supplementary {
private:
std::vector<Prism> potential;
- std::map<MElement*,bool> markings;
- std::map<MVertex*,std::set<MVertex*> > vertex_to_vertices;
- std::map<MVertex*,std::set<MElement*> > vertex_to_tetrahedra;
+ std::map<MElement *, bool> markings;
+ std::map<MVertex *, std::set<MVertex *> > vertex_to_vertices;
+ std::map<MVertex *, std::set<MElement *> > vertex_to_tetrahedra;
std::multiset<Facet> hash_tableA;
std::multiset<Diagonal> hash_tableB;
std::multiset<Diagonal> hash_tableC;
std::multiset<Tuple> tuples;
- std::set<MElement*> triangles;
- //std::fstream file; //fordebug
+ std::set<MElement *> triangles;
+ // std::fstream file; //fordebug
public:
- typedef std::set<MVertex*>::iterator vertex_set_itr;
- typedef std::set<MElement*>::iterator element_set_itr;
+ typedef std::set<MVertex *>::iterator vertex_set_itr;
+ typedef std::set<MElement *>::iterator element_set_itr;
- typedef std::map<MVertex*, std::set<MVertex*> > Vertex2Vertices;
- typedef std::map<MVertex*, std::set<MElement*> > Vertex2Elements;
+ typedef std::map<MVertex *, std::set<MVertex *> > Vertex2Vertices;
+ typedef std::map<MVertex *, std::set<MElement *> > Vertex2Elements;
Supplementary();
~Supplementary();
void execute();
- void execute(GRegion*);
-
- void init_markings(GRegion*);
- void pattern(GRegion*);
- void merge(GRegion*);
- void rearrange(GRegion*);
- void statistics(GRegion*);
- void build_tuples(GRegion*);
- void create_quads_on_boundary(GRegion*);
- void create_quads_on_boundary(MVertex*,MVertex*,MVertex*,MVertex*);
-
- bool four(MElement*);
- bool five(MElement*);
- bool six(MElement*);
- bool eight(MElement*);
-
- bool sliver(MElement*,Prism);
- bool valid(Prism,const std::set<MElement*>&);
+ void execute(GRegion *);
+
+ void init_markings(GRegion *);
+ void pattern(GRegion *);
+ void merge(GRegion *);
+ void rearrange(GRegion *);
+ void statistics(GRegion *);
+ void build_tuples(GRegion *);
+ void create_quads_on_boundary(GRegion *);
+ void create_quads_on_boundary(MVertex *, MVertex *, MVertex *, MVertex *);
+
+ bool four(MElement *);
+ bool five(MElement *);
+ bool six(MElement *);
+ bool eight(MElement *);
+
+ bool sliver(MElement *, Prism);
+ bool valid(Prism, const std::set<MElement *> &);
bool valid(Prism);
- double eta(MVertex*,MVertex*,MVertex*,MVertex*);
- bool linked(MVertex*,MVertex*);
+ double eta(MVertex *, MVertex *, MVertex *, MVertex *);
+ bool linked(MVertex *, MVertex *);
- void find(MVertex*,MVertex*,const std::vector<MVertex*>&,std::set<MVertex*>&);
+ void find(MVertex *, MVertex *, const std::vector<MVertex *> &,
+ std::set<MVertex *> &);
void find(MVertex *, const Prism &, std::set<MElement *> &);
- void intersection(const std::set<MVertex*>&,const std::set<MVertex*>&,const std::vector<MVertex*>&,std::set<MVertex*>&);
+ void intersection(const std::set<MVertex *> &, const std::set<MVertex *> &,
+ const std::vector<MVertex *> &, std::set<MVertex *> &);
- bool inclusion(MVertex*,Prism);
- bool inclusion(MVertex*,MVertex*,MVertex*,MVertex*,MVertex*);
- bool inclusion(MVertex*,MVertex*,MVertex*,const std::set<MElement*>&);
+ bool inclusion(MVertex *, Prism);
+ bool inclusion(MVertex *, MVertex *, MVertex *, MVertex *, MVertex *);
+ bool inclusion(MVertex *, MVertex *, MVertex *, const std::set<MElement *> &);
bool inclusion(const Facet &);
bool inclusion(const Diagonal &);
bool duplicate(const Diagonal &);
bool conformityA(Prism);
- bool conformityA(MVertex*,MVertex*,MVertex*,MVertex*);
+ bool conformityA(MVertex *, MVertex *, MVertex *, MVertex *);
bool conformityB(Prism);
bool conformityC(Prism);
bool faces_statuquo(Prism);
- bool faces_statuquo(MVertex*,MVertex*,MVertex*,MVertex*);
+ bool faces_statuquo(MVertex *, MVertex *, MVertex *, MVertex *);
- void build_vertex_to_vertices(GRegion*);
- void build_vertex_to_tetrahedra(GRegion*);
+ void build_vertex_to_vertices(GRegion *);
+ void build_vertex_to_tetrahedra(GRegion *);
void build_hash_tableA(Prism);
- void build_hash_tableA(MVertex*,MVertex*,MVertex*,MVertex*);
+ void build_hash_tableA(MVertex *, MVertex *, MVertex *, MVertex *);
void build_hash_tableA(const Facet &);
void build_hash_tableB(Prism);
- void build_hash_tableB(MVertex*,MVertex*,MVertex*,MVertex*);
+ void build_hash_tableB(MVertex *, MVertex *, MVertex *, MVertex *);
void build_hash_tableB(const Diagonal &);
void build_hash_tableC(Prism);
void build_hash_tableC(const Diagonal &);
- double scaled_jacobian(MVertex*,MVertex*,MVertex*,MVertex*);
+ double scaled_jacobian(MVertex *, MVertex *, MVertex *, MVertex *);
double min_scaled_jacobian(Prism);
};
-class PostOp{
+class PostOp {
private:
- int nbr,nbr8,nbr6,nbr5,nbr4,nbr4Trih;
- double vol,vol8,vol6,vol5,vol4;
+ int nbr, nbr8, nbr6, nbr5, nbr4, nbr4Trih;
+ double vol, vol8, vol6, vol5, vol4;
int estimate1;
int estimate2;
int iterations;
- std::map<MElement*,bool> markings;
- std::map<MVertex*,std::set<MElement*> > vertex_to_tetrahedra;
- std::map<MVertex*,std::set<MElement*> > vertex_to_pyramids;
- std::map<MVertex*,std::set<MElement*> > vertex_to_hexPrism;
+ std::map<MElement *, bool> markings;
+ std::map<MVertex *, std::set<MElement *> > vertex_to_tetrahedra;
+ std::map<MVertex *, std::set<MElement *> > vertex_to_pyramids;
+ std::map<MVertex *, std::set<MElement *> > vertex_to_hexPrism;
std::multiset<Tuple> tuples;
- std::set<MElement*> triangles;
+ std::set<MElement *> triangles;
public:
- typedef std::set<MVertex*>::iterator vertex_set_itr;
- typedef std::set<MElement*>::iterator element_set_itr;
+ typedef std::set<MVertex *>::iterator vertex_set_itr;
+ typedef std::set<MElement *>::iterator element_set_itr;
- typedef std::map<MVertex*, std::set<MVertex*> > Vertex2Vertices;
- typedef std::map<MVertex*, std::set<MElement*> > Vertex2Elements;
+ typedef std::map<MVertex *, std::set<MVertex *> > Vertex2Vertices;
+ typedef std::map<MVertex *, std::set<MElement *> > Vertex2Elements;
PostOp();
~PostOp();
void execute(int, int);
- //level - 0: hex, 1: hex+prisms, 2: hex+prism+pyramids
- //conformity - 0: nonconforming, 1: trihedra, 2: pyramids+trihedra, 3:pyramids+hexPrismSplit+trihedra, 4:hexPrismSplit+trihedra
- void execute(GRegion*,int level, int conformity);
- void executeNew(GRegion*);
-
- inline int get_nb_hexahedra()const{return nbr8;};
- inline double get_vol_hexahedra()const{return vol8;};
- inline int get_nb_elements()const{return nbr;};
- inline double get_vol_elements()const{return vol;};
-
- void init_markings(GRegion*);
- void init_markings_hex(GRegion*);
- void init_markings_pri(GRegion*);
- void init_markings_pyr(GRegion*);
- void pyramids1(GRegion*);
- void pyramids2(GRegion*, bool allowNonConforming=false);
- void trihedra(GRegion*);
- void split_hexahedra(GRegion*);
- void split_prisms(GRegion*);
- void split_pyramids(GRegion*);
- int nonConformDiag(MVertex* a,MVertex* b,MVertex* c,MVertex* d,GRegion* gr);
- void pyramids1(MVertex*,MVertex*,MVertex*,MVertex*,GRegion*);
- void pyramids2(MVertex*,MVertex*,MVertex*,MVertex*,GRegion*, bool allowNonConforming);
- void trihedra(MVertex*,MVertex*,MVertex*,MVertex*,GRegion*);
- void rearrange(GRegion*);
- void statistics(GRegion*);
- void build_tuples(GRegion*);
- void create_quads_on_boundary(GRegion*);
- void create_quads_on_boundary(MVertex*,MVertex*,MVertex*,MVertex*);
-
- //returns the geometrical validity of the pyramid
+ // level - 0: hex, 1: hex+prisms, 2: hex+prism+pyramids
+ // conformity - 0: nonconforming, 1: trihedra, 2: pyramids+trihedra,
+ // 3:pyramids+hexPrismSplit+trihedra, 4:hexPrismSplit+trihedra
+ void execute(GRegion *, int level, int conformity);
+ void executeNew(GRegion *);
+
+ inline int get_nb_hexahedra() const { return nbr8; };
+ inline double get_vol_hexahedra() const { return vol8; };
+ inline int get_nb_elements() const { return nbr; };
+ inline double get_vol_elements() const { return vol; };
+
+ void init_markings(GRegion *);
+ void init_markings_hex(GRegion *);
+ void init_markings_pri(GRegion *);
+ void init_markings_pyr(GRegion *);
+ void pyramids1(GRegion *);
+ void pyramids2(GRegion *, bool allowNonConforming = false);
+ void trihedra(GRegion *);
+ void split_hexahedra(GRegion *);
+ void split_prisms(GRegion *);
+ void split_pyramids(GRegion *);
+ int nonConformDiag(MVertex *a, MVertex *b, MVertex *c, MVertex *d,
+ GRegion *gr);
+ void pyramids1(MVertex *, MVertex *, MVertex *, MVertex *, GRegion *);
+ void pyramids2(MVertex *, MVertex *, MVertex *, MVertex *, GRegion *,
+ bool allowNonConforming);
+ void trihedra(MVertex *, MVertex *, MVertex *, MVertex *, GRegion *);
+ void rearrange(GRegion *);
+ void statistics(GRegion *);
+ void build_tuples(GRegion *);
+ void create_quads_on_boundary(GRegion *);
+ void create_quads_on_boundary(MVertex *, MVertex *, MVertex *, MVertex *);
+
+ // returns the geometrical validity of the pyramid
bool valid(MPyramid *pyr);
- bool four(MElement*);
- bool fourTrih(MElement*);
- bool five(MElement*);
- bool six(MElement*);
- bool eight(MElement*);
-
- bool equal(MVertex*,MVertex*,MVertex*,MVertex*);
- bool equal(MVertex*,MVertex*,MVertex*,MVertex*,MVertex*,MVertex*,MVertex*,MVertex*);
- bool different(MVertex*,MVertex*,MVertex*,MVertex*);
- MVertex* other(MElement*,MVertex*,MVertex*);
- MVertex* other(MElement*,MVertex*,MVertex*,MVertex*);
- void mean(const std::set<MVertex*>&,MVertex*,const std::vector<MElement*>&);
- double workaround(MElement*);
-
- MVertex* find(MVertex*,MVertex*,MVertex*,MVertex*,MElement*);
- MVertex* findInTriFace(MVertex* in0,MVertex* in1,MVertex* out0,MVertex* out1,MElement* element);
- void find_tetrahedra(MVertex*,MVertex*,std::set<MElement*>&);
- void find_tetrahedra(MVertex*,MVertex*,MVertex*,std::set<MElement*>&);
- void find_pyramids_from_tri(MVertex*,MVertex*,MVertex*,std::set<MElement*>&);
- void find_pyramids_from_quad(MVertex*,MVertex*,MVertex*,MVertex*,std::set<MElement*>&);
- void find_pyramids(MVertex*,MVertex*,std::set<MElement*>&);
-
- void intersection(const std::set<MElement*>&,const std::set<MElement*>&,std::set<MElement*>&);
-
- void build_vertex_to_tetrahedra(GRegion*);
- void build_vertex_to_tetrahedra(MElement*);
- void erase_vertex_to_tetrahedra(MElement*);
-
- void build_vertex_to_pyramids(GRegion*);
- void build_vertex_to_pyramids(MElement*);
- void erase_vertex_to_pyramids(MElement*);
-
- void build_vertex_to_hexPrism(GRegion*);
- void build_vertex_to_hexPrism(MElement*);
- void erase_vertex_to_hexPrism(MElement*);
-
- void removeElseAdd(std::set<Facet>&, MVertex*, MVertex*, MVertex*);
- void writeMSH(const char *filename, std::vector<MElement*>&);
- MFace find_quadFace(MVertex*, MVertex*, MVertex*);
- MVertex* otherVertexQuadFace(MFace&, MVertex*, MVertex*, MVertex*);
- void matchQuadFace(MFace&, MVertex*, MVertex*, MVertex*);
+ bool four(MElement *);
+ bool fourTrih(MElement *);
+ bool five(MElement *);
+ bool six(MElement *);
+ bool eight(MElement *);
+
+ bool equal(MVertex *, MVertex *, MVertex *, MVertex *);
+ bool equal(MVertex *, MVertex *, MVertex *, MVertex *, MVertex *, MVertex *,
+ MVertex *, MVertex *);
+ bool different(MVertex *, MVertex *, MVertex *, MVertex *);
+ MVertex *other(MElement *, MVertex *, MVertex *);
+ MVertex *other(MElement *, MVertex *, MVertex *, MVertex *);
+ void mean(const std::set<MVertex *> &, MVertex *,
+ const std::vector<MElement *> &);
+ double workaround(MElement *);
+
+ MVertex *find(MVertex *, MVertex *, MVertex *, MVertex *, MElement *);
+ MVertex *findInTriFace(MVertex *in0, MVertex *in1, MVertex *out0,
+ MVertex *out1, MElement *element);
+ void find_tetrahedra(MVertex *, MVertex *, std::set<MElement *> &);
+ void find_tetrahedra(MVertex *, MVertex *, MVertex *, std::set<MElement *> &);
+ void find_pyramids_from_tri(MVertex *, MVertex *, MVertex *,
+ std::set<MElement *> &);
+ void find_pyramids_from_quad(MVertex *, MVertex *, MVertex *, MVertex *,
+ std::set<MElement *> &);
+ void find_pyramids(MVertex *, MVertex *, std::set<MElement *> &);
+
+ void intersection(const std::set<MElement *> &, const std::set<MElement *> &,
+ std::set<MElement *> &);
+
+ void build_vertex_to_tetrahedra(GRegion *);
+ void build_vertex_to_tetrahedra(MElement *);
+ void erase_vertex_to_tetrahedra(MElement *);
+
+ void build_vertex_to_pyramids(GRegion *);
+ void build_vertex_to_pyramids(MElement *);
+ void erase_vertex_to_pyramids(MElement *);
+
+ void build_vertex_to_hexPrism(GRegion *);
+ void build_vertex_to_hexPrism(MElement *);
+ void erase_vertex_to_hexPrism(MElement *);
+
+ void removeElseAdd(std::set<Facet> &, MVertex *, MVertex *, MVertex *);
+ void writeMSH(const char *filename, std::vector<MElement *> &);
+ MFace find_quadFace(MVertex *, MVertex *, MVertex *);
+ MVertex *otherVertexQuadFace(MFace &, MVertex *, MVertex *, MVertex *);
+ void matchQuadFace(MFace &, MVertex *, MVertex *, MVertex *);
};
#endif