From 2f299b8b1995d965123ac10cded757932af0f4ad Mon Sep 17 00:00:00 2001
From: Paul-Emile Bernard <paul-emile.bernard@uclouvain.be>
Date: Fri, 20 Mar 2015 14:09:41 +0000
Subject: [PATCH] esthetic modifications
---
Mesh/BGMBase.cpp | 18 --------
Mesh/BGMBase.h | 1 -
Mesh/BackgroundMesh2D.cpp | 34 --------------
Mesh/BackgroundMesh2D.h | 2 -
Mesh/BackgroundMesh3D.cpp | 49 --------------------
Mesh/BackgroundMesh3D.h | 3 --
Mesh/BackgroundMeshManager.cpp | 6 ---
Mesh/BackgroundMeshTools.cpp | 21 ---------
Mesh/BackgroundMeshTools.h | 2 -
Mesh/Field.cpp | 7 +--
Mesh/pointInsertion.cpp | 22 +--------
Mesh/pointInsertion.h | 3 --
Mesh/pointInsertionRTreeTools.cpp | 13 ------
Mesh/pointInsertionRTreeTools.h | 15 ------
Mesh/surfaceFiller.cpp | 9 +---
Mesh/yamakawa.cpp | 77 -------------------------------
Mesh/yamakawa.h | 6 ---
17 files changed, 5 insertions(+), 283 deletions(-)
diff --git a/Mesh/BGMBase.cpp b/Mesh/BGMBase.cpp
index 6f64e2d88b..436c47430c 100644
--- a/Mesh/BGMBase.cpp
+++ b/Mesh/BGMBase.cpp
@@ -57,7 +57,6 @@ void BGMBase::export_scalar(const string &filename, const DoubleStorageType &_wh
// cout << "export_scalar DONE " << endl;
}
-//------------------------------------------------------------------------
void BGMBase::export_vector(const string &filename, const VectorStorageType &_whatToPrint)const{
FILE *f = Fopen (filename.c_str(),"w");
@@ -109,7 +108,6 @@ void BGMBase::export_vector(const string &filename, const VectorStorageType &_wh
fclose(f);
}
-//------------------------------------------------------------------------
void BGMBase::export_tensor_as_vectors(const string &filename, const TensorStorageType &_whatToPrint)const{
FILE *f = Fopen (filename.c_str(),"w");
@@ -130,30 +128,25 @@ void BGMBase::export_tensor_as_vectors(const string &filename, const TensorStora
fclose(f);
}
-//------------------------------------------------------------------------
BGMBase::BGMBase(int dim,GEntity *_gf):octree(NULL),gf(_gf), DIM(dim), order(1),debug(false){
if(debug) cout << "BGMBase::constructor " << endl;
}
-//------------------------------------------------------------------------
BGMBase::~BGMBase(){
}
-//------------------------------------------------------------------------
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){
return (getOctree()->find(u, v, w, DIM, strict));
}
-//------------------------------------------------------------------------
vector<double> BGMBase::get_field_value(double u, double v, double w, const VectorStorageType &data){
MElement *e = const_cast<MElement*>(findElement(u, v, w ));
@@ -170,7 +163,6 @@ vector<double> BGMBase::get_field_value(double u, double v, double w, const Vect
return res;
}
-//------------------------------------------------------------------------
double BGMBase::get_field_value(double u, double v, double w, const DoubleStorageType &data){
MElement *e = const_cast<MElement*>(findElement(u, v, w));
@@ -184,19 +176,16 @@ double BGMBase::get_field_value(double u, double v, double w, const DoubleStorag
return e->interpolate(values, element_uvw[0], element_uvw[1], element_uvw[2], 1, order);
}
-//------------------------------------------------------------------------
double BGMBase::size(double u, double v, double w){
return get_field_value(u,v,w,sizeField);
}
-//------------------------------------------------------------------------
double BGMBase::size(const MVertex *v){
return get_nodal_value(v,sizeField);
}
-//------------------------------------------------------------------------
vector<double> BGMBase::get_nodal_value(const MVertex *v,const VectorStorageType &data)const{
if(debug) cout << "BGMBase::get_nodal_value(const MVertex *v,const map<MVertex*,vector<double> > &data)" << endl;
@@ -209,7 +198,6 @@ vector<double> BGMBase::get_nodal_value(const MVertex *v,const VectorStorageType
return itfind->second;
}
-//------------------------------------------------------------------------
double BGMBase::get_nodal_value(const MVertex *v,const DoubleStorageType &data)const{
if(debug) cout << "BGMBase::get_nodal_value(const MVertex *v,const map<MVertex*,double> &data)" << endl;
@@ -222,7 +210,6 @@ double BGMBase::get_nodal_value(const MVertex *v,const DoubleStorageType &data)c
return itfind->second;
}
-//------------------------------------------------------------------------
vector<vector<double> > BGMBase::get_nodal_values(const MElement *e,const VectorStorageType &data)const{
if(debug) cout << "BGMBase::get_nodal_values(const MElement *e,const map<MVertex*,vector<double> > &data)" << endl;
@@ -236,7 +223,6 @@ vector<vector<double> > BGMBase::get_nodal_values(const MElement *e,const Vector
return res;
}
-//------------------------------------------------------------------------
vector<double> BGMBase::get_nodal_values(const MElement *e,const DoubleStorageType &data)const{
if(debug) cout << "BGMBase::get_nodal_values(const MElement *e,const map<MVertex*,double> &data)" << endl;
@@ -247,7 +233,6 @@ vector<double> BGMBase::get_nodal_values(const MElement *e,const DoubleStorageTy
return res;
}
-//------------------------------------------------------------------------
vector<double> BGMBase::get_element_uvw_from_xyz (const MElement *e, double x, double y,double z) const{
double element_uvw[3];
@@ -260,7 +245,6 @@ vector<double> BGMBase::get_element_uvw_from_xyz (const MElement *e, double x, d
return res;
}
-//------------------------------------------------------------------------
set<MVertex*> BGMBase::get_vertices_of_maximum_dim(int dim){
set<MVertex*> bnd_vertices;
@@ -274,13 +258,11 @@ set<MVertex*> BGMBase::get_vertices_of_maximum_dim(int dim){
return bnd_vertices;
}
-//------------------------------------------------------------------------
GEntity* BGMBase::getBackgroundGEntity(){
return gf;
}
-//------------------------------------------------------------------------
diff --git a/Mesh/BGMBase.h b/Mesh/BGMBase.h
index e44a31d77b..1ba8e99125 100644
--- a/Mesh/BGMBase.h
+++ b/Mesh/BGMBase.h
@@ -97,6 +97,5 @@ class BGMBase{
};
-//------------------------------------------------------------------------
#endif
diff --git a/Mesh/BackgroundMesh2D.cpp b/Mesh/BackgroundMesh2D.cpp
index 8f49d36279..3170f88841 100644
--- a/Mesh/BackgroundMesh2D.cpp
+++ b/Mesh/BackgroundMesh2D.cpp
@@ -34,7 +34,6 @@
using namespace std;
-//------------------------------------------------------------------------
class evalDiffusivityFunction : public simpleFunction<double>{
public:
@@ -47,7 +46,6 @@ class evalDiffusivityFunction : public simpleFunction<double>{
const double threshold;
};
-//------------------------------------------------------------------------
//TODO: move this fct ???
/* applies rotations of amplitude pi to set the
@@ -59,7 +57,6 @@ void normalizeAngle(double &angle) {
while ( angle >= M_PI * .5 ) angle -= (M_PI * .5);
}
-//------------------------------------------------------------------------
void backgroundMesh2D::create_face_mesh(){
@@ -85,7 +82,6 @@ void backgroundMesh2D::create_face_mesh(){
create_mesh_copy();
}
-//------------------------------------------------------------------------
MElementOctree* backgroundMesh2D::getOctree(){
if(!octree){
@@ -95,13 +91,11 @@ MElementOctree* backgroundMesh2D::getOctree(){
return octree;
}
-//------------------------------------------------------------------------
const MElement* backgroundMesh2D::getElement(unsigned int i)const{
return elements[i];
}
-//------------------------------------------------------------------------
void backgroundMesh2D::reset(bool erase_2D3D){
unset();
@@ -126,7 +120,6 @@ void backgroundMesh2D::reset(bool erase_2D3D){
}
}
-//------------------------------------------------------------------------
void backgroundMesh2D::unset(){
for (unsigned int i = 0; i < vertices.size(); i++) delete vertices[i];
@@ -135,7 +128,6 @@ void backgroundMesh2D::unset(){
octree=NULL;
}
-//------------------------------------------------------------------------
void backgroundMesh2D::create_mesh_copy(){
// TODO: useful to extend it to other elements ???
@@ -164,13 +156,11 @@ void backgroundMesh2D::create_mesh_copy(){
}
}
-//------------------------------------------------------------------------------------------
GPoint backgroundMesh2D::get_GPoint_from_MVertex(const MVertex *v)const{
return dynamic_cast<GFace*>(gf)->point(SPoint2(v->x(),v->y()));
}
-//------------------------------------------------------------------------
backgroundMesh2D::backgroundMesh2D(GFace *_gf, bool erase_2D3D):BGMBase(2,_gf),sizeFactor(1.){
if(debug) cout << "backgroundMesh2D::constructor " << endl;
@@ -184,13 +174,11 @@ backgroundMesh2D::backgroundMesh2D(GFace *_gf, bool erase_2D3D):BGMBase(2,_gf),s
}
-//------------------------------------------------------------------------
backgroundMesh2D::~backgroundMesh2D(){
unset();
}
-//------------------------------------------------------------------------
void backgroundMesh2D::propagateValues(DoubleStorageType &dirichlet, simpleFunction<double> &eval_diffusivity, bool in_parametric_plane){
#if defined(HAVE_SOLVER)
@@ -266,7 +254,6 @@ void backgroundMesh2D::propagateValues(DoubleStorageType &dirichlet, simpleFunct
#endif
}
-//------------------------------------------------------------------------
void backgroundMesh2D::computeSizeField(){
GFace *face = dynamic_cast<GFace*>(gf);
@@ -308,7 +295,6 @@ void backgroundMesh2D::computeSizeField(){
}
}
-//------------------------------------------------------------------------
inline double myAngle (const SVector3 &a, const SVector3 &b, const SVector3 &d){
double cosTheta = dot(a,b);
@@ -316,7 +302,6 @@ inline double myAngle (const SVector3 &a, const SVector3 &b, const SVector3 &d){
return atan2 (sinTheta,cosTheta);
}
-//------------------------------------------------------------------------
void backgroundMesh2D::updateSizes(){
DoubleStorageType::iterator itv = sizeField.begin();
@@ -368,14 +353,8 @@ void backgroundMesh2D::updateSizes(){
}
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
frameFieldBackgroundMesh2D::frameFieldBackgroundMesh2D(GFace *_gf):backgroundMesh2D(_gf,false){
@@ -388,11 +367,9 @@ frameFieldBackgroundMesh2D::frameFieldBackgroundMesh2D(GFace *_gf):backgroundMes
face->triangles = tempTR;
}
-//------------------------------------------------------------------------
frameFieldBackgroundMesh2D::~frameFieldBackgroundMesh2D(){}
-//------------------------------------------------------------------------
void frameFieldBackgroundMesh2D::reset(bool erase_2D3D){
@@ -425,28 +402,24 @@ void frameFieldBackgroundMesh2D::reset(bool erase_2D3D){
}
}
-//------------------------------------------------------------------------
double frameFieldBackgroundMesh2D::get_smoothness(MVertex *v){
if(debug) cout << "frameFieldBackgroundMesh2D::get_smoothness(MVertex *v)" << endl;
return get_nodal_value(v,smoothness);
}
-//------------------------------------------------------------------------
double frameFieldBackgroundMesh2D::get_smoothness(double u, double v){
if(debug) cout << "frameFieldBackgroundMesh2D::get_smoothness(double u, double v)" << endl;
return get_field_value(u,v,0.,smoothness);
}
-//------------------------------------------------------------------------
double frameFieldBackgroundMesh2D::angle(MVertex *v){
if(debug) cout << "frameFieldBackgroundMesh2D::angle(MVertex *v)" << endl;
return get_nodal_value(v,angles);
}
-//------------------------------------------------------------------------
double frameFieldBackgroundMesh2D::angle(double u, double v){
MElement *e = const_cast<MElement*>(findElement(u, v));
@@ -465,7 +438,6 @@ double frameFieldBackgroundMesh2D::angle(double u, double v){
return a;
}
-//------------------------------------------------------------------------
void frameFieldBackgroundMesh2D::computeCrossField(simpleFunction<double> &eval_diffusivity){
angles.clear();
@@ -528,7 +500,6 @@ void frameFieldBackgroundMesh2D::computeCrossField(simpleFunction<double> &eval_
}
}
-//------------------------------------------------------------------------
void frameFieldBackgroundMesh2D::eval_crossfield(double u, double v, STensor3 &cf){
double quadAngle = angle(u,v);
@@ -564,7 +535,6 @@ void frameFieldBackgroundMesh2D::eval_crossfield(double u, double v, STensor3 &c
return;
}
-//------------------------------------------------------------------------
void frameFieldBackgroundMesh2D::eval_crossfield(MVertex *vert, STensor3 &cf){
SPoint2 parampoint;
@@ -573,7 +543,6 @@ void frameFieldBackgroundMesh2D::eval_crossfield(MVertex *vert, STensor3 &cf){
return eval_crossfield(parampoint[0], parampoint[1], cf);
}
-//------------------------------------------------------------------------
void frameFieldBackgroundMesh2D::computeSmoothness(){
smoothness.clear();
@@ -618,7 +587,6 @@ void frameFieldBackgroundMesh2D::computeSmoothness(){
}
}
-//------------------------------------------------------------------------
void frameFieldBackgroundMesh2D::exportCrossField(const string &filename){
FILE *f = Fopen (filename.c_str(),"w");
@@ -641,7 +609,6 @@ void frameFieldBackgroundMesh2D::exportCrossField(const string &filename){
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){
@@ -669,7 +636,6 @@ Pair<SVector3, SVector3> frameFieldBackgroundMesh2D::compute_crossfield_directio
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){
diff --git a/Mesh/BackgroundMesh2D.h b/Mesh/BackgroundMesh2D.h
index a0820bcba2..820937bd81 100644
--- a/Mesh/BackgroundMesh2D.h
+++ b/Mesh/BackgroundMesh2D.h
@@ -78,7 +78,6 @@ class backgroundMesh2D : public BGMBase {
};
-//------------------------------------------------------------------------
class RK_form{// informations for RK at one point
public:
@@ -105,7 +104,6 @@ class RK_form{// informations for RK at one point
double angle,localsize;
};
-//------------------------------------------------------------------------
class frameFieldBackgroundMesh2D : public backgroundMesh2D{
diff --git a/Mesh/BackgroundMesh3D.cpp b/Mesh/BackgroundMesh3D.cpp
index 628431c443..6e422d4f21 100644
--- a/Mesh/BackgroundMesh3D.cpp
+++ b/Mesh/BackgroundMesh3D.cpp
@@ -33,7 +33,6 @@ int signof(int i){
return ((i < 0) ? -1 : 1);
}
-//------------------------------------------------------------------------
// TODO: virer les trucs "vertextorank", mettre cette classe-ci :
@@ -48,18 +47,15 @@ int signof(int i){
// const double threshold;
//};
-//------------------------------------------------------------------------------------------
backgroundMesh3D::backgroundMesh3D(GRegion *_gr):BGMBase(3,_gr),debug(false),verbose(false){
computeSizeField();
}
-//------------------------------------------------------------------------------------------
backgroundMesh3D::~backgroundMesh3D(){
}
-//------------------------------------------------------------------------------------------
void backgroundMesh3D::computeSizeField(){
@@ -94,7 +90,6 @@ void backgroundMesh3D::computeSizeField(){
// cout << "backgroundMesh3D::size of sizeField: " << sizeField.size() << endl;
}
-//------------------------------------------------------------------------------------------
void backgroundMesh3D::propagateValues(DoubleStorageType &dirichlet, simpleFunction<double> &eval_diffusivity, bool in_parametric_plane){
// same as Size_field::solve()
@@ -166,41 +161,35 @@ void backgroundMesh3D::propagateValues(DoubleStorageType &dirichlet, simpleFunct
#endif
}
-//------------------------------------------------------------------------------------------
GPoint backgroundMesh3D::get_GPoint_from_MVertex(const MVertex *v)const{
return GPoint(v->x(),v->y(),v->z(),dynamic_cast<GRegion*>(gf));
}
-//------------------------------------------------------------------------------------------
MVertex* backgroundMesh3D::get_nearest_neighbor(const MVertex *v){
double distance;
return get_nearest_neighbor(v->x(),v->y(),v->z(), distance);
}
-//------------------------------------------------------------------------------------------
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){
double distance;
return get_nearest_neighbor(x,y,z,distance);
}
-//------------------------------------------------------------------------------------------
MVertex* backgroundMesh3D::get_nearest_neighbor(double x, double y, double z, double &distance ){
double xyz[3] = {x,y,z};
return get_nearest_neighbor(xyz, distance);
}
-//------------------------------------------------------------------------
MElementOctree* backgroundMesh3D::getOctree(){
if(!octree){
@@ -211,7 +200,6 @@ MElementOctree* backgroundMesh3D::getOctree(){
return octree;
}
-//------------------------------------------------------------------------------------------
MVertex* backgroundMesh3D::get_nearest_neighbor(const double* xyz, double & distance ){
// using the octree instead of ANN, faster.
@@ -240,16 +228,9 @@ MVertex* backgroundMesh3D::get_nearest_neighbor(const double* xyz, double & dist
// return it->second;
}
-//------------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------------
vector<montripletbis> frameFieldBackgroundMesh3D::permutation = vector<montripletbis>();
-//------------------------------------------------------------------------------------------
frameFieldBackgroundMesh3D::frameFieldBackgroundMesh3D(GRegion *_gr):backgroundMesh3D(_gr){
@@ -286,7 +267,6 @@ frameFieldBackgroundMesh3D::frameFieldBackgroundMesh3D(GRegion *_gr):backgroundM
}
}
-//------------------------------------------------------------------------------------------
frameFieldBackgroundMesh3D::~frameFieldBackgroundMesh3D(){
#if defined(HAVE_ANN)
@@ -295,7 +275,6 @@ frameFieldBackgroundMesh3D::~frameFieldBackgroundMesh3D(){
#endif
}
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::initiate_ANN_research(){
#ifdef HAVE_ANN
@@ -315,7 +294,6 @@ void frameFieldBackgroundMesh3D::initiate_ANN_research(){
return;
}
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::computeSmoothnessOnlyFromBoundaries(){
// this is used when the crossfield is not smoothed !!!
@@ -351,7 +329,6 @@ void frameFieldBackgroundMesh3D::computeSmoothnessOnlyFromBoundaries(){
}
}
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::computeCrossField(){
// TODO: mettre des parametres façon gmsh ???
@@ -564,7 +541,6 @@ void frameFieldBackgroundMesh3D::computeCrossField(){
}
-//------------------------------------------------------------------------------------------
//STensor3 frameFieldBackgroundMesh3D::get_random_cross()const{
// SVector3 vec1(rand()%10000/9999. , rand()%10000/9999. , rand()%10000/9999. );
@@ -583,7 +559,6 @@ void frameFieldBackgroundMesh3D::computeCrossField(){
// return random_cross;
//}
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::initiate_crossfield(){
crossField.clear();
@@ -634,14 +609,12 @@ void frameFieldBackgroundMesh3D::initiate_crossfield(){
}
}
-//------------------------------------------------------------------------------------------
MVertex* frameFieldBackgroundMesh3D::get_nearest_neighbor_on_boundary(MVertex* v){
double distance;
return get_nearest_neighbor_on_boundary(v,distance);
}
-//------------------------------------------------------------------------------------------
MVertex* frameFieldBackgroundMesh3D::get_nearest_neighbor_on_boundary(MVertex* v, double &distance){
#ifdef HAVE_ANN
@@ -665,37 +638,31 @@ MVertex* frameFieldBackgroundMesh3D::get_nearest_neighbor_on_boundary(MVertex* v
#endif
}
-//------------------------------------------------------------------------------------------
double frameFieldBackgroundMesh3D::get_smoothness(double x, double y, double z){
return get_field_value(x,y,z,crossFieldSmoothness);
};
-//------------------------------------------------------------------------------------------
double frameFieldBackgroundMesh3D::get_approximate_smoothness(double x, double y, double 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());
}
-//------------------------------------------------------------------------------------------
double frameFieldBackgroundMesh3D::get_smoothness(MVertex *v){
return get_nodal_value(v,crossFieldSmoothness);
};
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::eval_approximate_crossfield(double x, double y, double z, STensor3 &cf){
cf = crossField[get_nearest_neighbor(x,y,z)];
};
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::eval_approximate_crossfield(const MVertex *vert, STensor3 &cf){
// check if vertex is ours...
@@ -706,35 +673,30 @@ void frameFieldBackgroundMesh3D::eval_approximate_crossfield(const MVertex *vert
eval_approximate_crossfield(vert->x(),vert->y(),vert->z(),cf);
};
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::get_vectorial_smoothness(double x, double y, double z, SVector3 &cf){
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){
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){
vector<double>res = get_field_value(x,y,z,crossFieldVectorialSmoothness);
return res[idir];
};
-//------------------------------------------------------------------------------------------
double frameFieldBackgroundMesh3D::get_vectorial_smoothness(const int idir, const MVertex *vert){
vector<double> res = get_nodal_value(vert,crossFieldVectorialSmoothness);
return res[idir];
};
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::build_vertex_to_element_table(){
GRegion *gr = dynamic_cast<GRegion*>(gf);
@@ -760,21 +722,18 @@ void frameFieldBackgroundMesh3D::build_vertex_to_element_table(){
}
}
-//------------------------------------------------------------------------
const MElement* backgroundMesh3D::getElement(unsigned int i)const{
GRegion *gr = dynamic_cast<GRegion*>(gf);
return gr->getMeshElement(i);
}
-//------------------------------------------------------------------------
unsigned int backgroundMesh3D::getNumMeshElements()const{
GRegion *gr = dynamic_cast<GRegion*>(gf);
return gr->getNumMeshElements();
}
-//------------------------------------------------------------------------------------------
// this function fills the multimap "graph": vertex to direct neighbors, or indirect neighbors, depending on the "max_recursion_level".
void frameFieldBackgroundMesh3D::build_neighbors(const int &max_recursion_level){
@@ -818,7 +777,6 @@ void frameFieldBackgroundMesh3D::build_neighbors(const int &max_recursion_level)
}
}
-//------------------------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::get_recursive_neighbors(set<MVertex*> &start, set<MVertex*> &visited, set<MElement*> &visited_elements, multimap<int,MVertex*> &proximity, int max_level, int level){
level++;
@@ -857,7 +815,6 @@ void frameFieldBackgroundMesh3D::get_recursive_neighbors(set<MVertex*> &start, s
}
-//------------------------------------------------------------------------------------------
double frameFieldBackgroundMesh3D::compare_to_neighbors(SPoint3 current, STensor3 &ref, multimap<double,MVertex*>::iterator itbegin, multimap<double,MVertex*>::iterator itend, SVector3 &mean_axis,double &mean_angle, vector<double> &vectorial_smoothness){
for (int i=0;i<3;i++) mean_axis(i)=0.;
@@ -942,7 +899,6 @@ double frameFieldBackgroundMesh3D::compare_to_neighbors(SPoint3 current, STensor
return smoothness_scalar;
}
-//------------------------------------------------------------------------------------------
STensor3 frameFieldBackgroundMesh3D::apply_rotation(const SVector3 &axis, const double &angle, const STensor3 &thecross){
double rotmat[3][3];
@@ -1024,7 +980,6 @@ STensor3 frameFieldBackgroundMesh3D::apply_rotation(const SVector3 &axis, const
// 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){
@@ -1048,7 +1003,6 @@ void frameFieldBackgroundMesh3D::get_rotation_matrix(const double &angle_to_go,
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){
@@ -1085,7 +1039,6 @@ void frameFieldBackgroundMesh3D::get_min_rotation_matrix(const STensor3 &referen
return;
}
-//------------------------------------------------------------------------------------------
// compute the angle and axis of rotation between two (unit-orthogonal) cross fields
// using crossfield vectors permutations defined by modulo and trip
@@ -1151,7 +1104,6 @@ void frameFieldBackgroundMesh3D::get_rotation_angle_and_axis(const STensor3 &ref
return;
}
-//------------------------------------------------------------------------
void frameFieldBackgroundMesh3D::exportVectorialSmoothness(const string &filename){
FILE *f = Fopen (filename.c_str(),"w");
@@ -1178,5 +1130,4 @@ void frameFieldBackgroundMesh3D::exportVectorialSmoothness(const string &filenam
fclose(f);
}
-//------------------------------------------------------------------------------------------
diff --git a/Mesh/BackgroundMesh3D.h b/Mesh/BackgroundMesh3D.h
index 7aeb0b3bb5..51226b62c3 100644
--- a/Mesh/BackgroundMesh3D.h
+++ b/Mesh/BackgroundMesh3D.h
@@ -38,7 +38,6 @@ using namespace std;
-//------------------------------------------------------------------------------------------
class montripletbis{
public:
@@ -53,7 +52,6 @@ class montripletbis{
vector<int> vec;
};
-//------------------------------------------------------------------------------------------
// difference with BackgroundMesh2D: no copy of components, working directly on the vertices and elements of GRegion
@@ -83,7 +81,6 @@ class backgroundMesh3D : public BGMBase {
virtual MVertex* get_nearest_neighbor(double x, double y, double z, double &distance );
};
-//------------------------------------------------------------------------
class frameFieldBackgroundMesh3D : public backgroundMesh3D{
diff --git a/Mesh/BackgroundMeshManager.cpp b/Mesh/BackgroundMeshManager.cpp
index 1aa93c3ad5..c863cbc426 100644
--- a/Mesh/BackgroundMeshManager.cpp
+++ b/Mesh/BackgroundMeshManager.cpp
@@ -8,13 +8,11 @@
#include "BackgroundMesh3D.h"
-//------------------------------------------------------------------------
map<GEntity*,BGMBase*> BGMManager::data = 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==false)){// need to change...
@@ -23,7 +21,6 @@ void BGMManager::set_use_cross_field(bool b){
BGMManager::use_cross_field = b;
}
-//------------------------------------------------------------------------
BGMBase* BGMManager::get(GRegion* gf){
map<GEntity*,BGMBase*>::iterator itfind = data.find(gf);
@@ -42,7 +39,6 @@ BGMBase* BGMManager::get(GRegion* gf){
return bgm;
}
-//------------------------------------------------------------------------
BGMBase* BGMManager::get(GFace* gf){
map<GEntity*,BGMBase*>::iterator itfind = data.find(gf);
@@ -61,11 +57,9 @@ BGMBase* BGMManager::get(GFace* gf){
return bgm;
}
-//------------------------------------------------------------------------
BGMBase* BGMManager::current2D(){return latest2Dbgm;};
-//------------------------------------------------------------------------
diff --git a/Mesh/BackgroundMeshTools.cpp b/Mesh/BackgroundMeshTools.cpp
index bed3c28f5b..b9a24773cc 100644
--- a/Mesh/BackgroundMeshTools.cpp
+++ b/Mesh/BackgroundMeshTools.cpp
@@ -12,7 +12,6 @@
#include <iostream>
-//------------------------------------------------------------------------
static double max_surf_curvature(const GEdge *ge, double u)
{
@@ -32,7 +31,6 @@ static double max_surf_curvature(const GEdge *ge, double u)
}
-//------------------------------------------------------------------------
static double max_edge_curvature(const GVertex *gv)
{
@@ -50,7 +48,6 @@ static double max_edge_curvature(const GVertex *gv)
return val;
}
-//------------------------------------------------------------------------
// the mesh vertex is classified on a model vertex. we compute the
// maximum of the curvature of model faces surrounding this point if
@@ -86,7 +83,6 @@ static double LC_MVertex_CURV(GEntity *ge, double U, double V)
return lc;
}
-//------------------------------------------------------------------------
SMetric3 max_edge_curvature_metric(const GEdge *ge, double u)
{
@@ -98,7 +94,6 @@ SMetric3 max_edge_curvature_metric(const GEdge *ge, double u)
return buildMetricTangentToCurve(t,l_t,l_n);
}
-//------------------------------------------------------------------------
static SMetric3 metric_based_on_surface_curvature(const GEdge *ge, double u, bool iso_surf)
{
@@ -143,7 +138,6 @@ static SMetric3 metric_based_on_surface_curvature(const GEdge *ge, double u, boo
}
}
-//------------------------------------------------------------------------
static SMetric3 metric_based_on_surface_curvature(const GVertex *gv, bool iso_surf)
{
@@ -172,7 +166,6 @@ static SMetric3 metric_based_on_surface_curvature(const GVertex *gv, bool iso_su
return mesh_size;
}
-//------------------------------------------------------------------------
SMetric3 LC_MVertex_CURV_ANISO(GEntity *ge, double U, double V)
{
@@ -187,7 +180,6 @@ SMetric3 LC_MVertex_CURV_ANISO(GEntity *ge, double U, double V)
return SMetric3();
}
-//------------------------------------------------------------------------
// compute the mesh size at a given vertex due to prescribed sizes at
// mesh vertices
@@ -225,11 +217,6 @@ static double LC_MVertex_PNTS(GEntity *ge, double U, double V)
}
}
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
SMetric3 buildMetricTangentToCurve(SVector3 &t, double l_t, double l_n)
{
@@ -254,7 +241,6 @@ SMetric3 buildMetricTangentToCurve(SVector3 &t, double l_t, double l_n)
return Metric;
}
-//------------------------------------------------------------------------
SMetric3 buildMetricTangentToSurface(SVector3 &t1, SVector3 &t2,
double l_t1, double l_t2, double l_n)
@@ -272,7 +258,6 @@ SMetric3 buildMetricTangentToSurface(SVector3 &t1, SVector3 &t2,
return Metric;
}
-//------------------------------------------------------------------------
// This is the only function that is used by the meshers
double BGM_MeshSize(GEntity *ge, double U, double V,
@@ -320,7 +305,6 @@ double BGM_MeshSize(GEntity *ge, double U, double V,
}
-//------------------------------------------------------------------------
// anisotropic version of the background field
SMetric3 BGM_MeshMetric(GEntity *ge,
@@ -365,21 +349,18 @@ SMetric3 BGM_MeshMetric(GEntity *ge,
}
-//------------------------------------------------------------------------
bool Extend1dMeshIn2dSurfaces()
{
return CTX::instance()->mesh.lcExtendFromBoundary ? true : false;
}
-//------------------------------------------------------------------------
bool Extend2dMeshIn3dVolumes()
{
return CTX::instance()->mesh.lcExtendFromBoundary ? true : false;
}
-//------------------------------------------------------------------------
SMetric3 max_edge_curvature_metric(const GVertex *gv)
{
@@ -411,7 +392,6 @@ SMetric3 max_edge_curvature_metric(const GVertex *gv)
return val;
}
-//------------------------------------------------------------------------
SMetric3 metric_based_on_surface_curvature(const GFace *gf, double u, double v,
bool surface_isotropic,
@@ -446,5 +426,4 @@ SMetric3 metric_based_on_surface_curvature(const GFace *gf, double u, double v,
return curvMetric;
}
-//------------------------------------------------------------------------
diff --git a/Mesh/BackgroundMeshTools.h b/Mesh/BackgroundMeshTools.h
index dccae2c8de..74a80753db 100644
--- a/Mesh/BackgroundMeshTools.h
+++ b/Mesh/BackgroundMeshTools.h
@@ -10,7 +10,6 @@ class GVertex;
class GEdge;
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);
@@ -22,7 +21,6 @@ SMetric3 max_edge_curvature_metric(const GVertex *gv);
SMetric3 max_edge_curvature_metric(const GEdge *ge, double u, double &l);
SMetric3 metric_based_on_surface_curvature(const GFace *gf, double u, double v, bool surface_isotropic = false,double d_normal = 1.e12,double d_tangent_max = 1.e12);
-//-------------------------------------------------------------
//
//static double LC_MVertex_CURV(GEntity *ge, double U, double V);
//SMetric3 LC_MVertex_CURV_ANISO(GEntity *ge, double U, double V);
diff --git a/Mesh/Field.cpp b/Mesh/Field.cpp
index fd50f7e586..4cfd48f114 100644
--- a/Mesh/Field.cpp
+++ b/Mesh/Field.cpp
@@ -2401,15 +2401,12 @@ void FieldManager::setBackgroundMesh(int iView)
-//--------------------------------------------------
GenericField::GenericField(){};
-//--------------------------------------------------
GenericField::~GenericField(){};
-//--------------------------------------------------
double GenericField::operator() (double x, double y, double z, GEntity *ge){
std::vector<double> sizes(cbs.size());
@@ -2429,12 +2426,12 @@ double GenericField::operator() (double x, double y, double z, GEntity *ge){
return (*std::min_element(sizes.begin(),sizes.end()));
}
-//--------------------------------------------------
+
void GenericField::setCallbackWithData(ptrfunction fct, void *data){
user_data.push_back(data);
cbs.push_back(fct);
}
-//--------------------------------------------------
+
diff --git a/Mesh/pointInsertion.cpp b/Mesh/pointInsertion.cpp
index ccfc4d352b..6060a240e8 100644
--- a/Mesh/pointInsertion.cpp
+++ b/Mesh/pointInsertion.cpp
@@ -26,13 +26,11 @@
using namespace std;
-//------------------------------------------------------------------------
bool old_algo_hexa(){
- return false;
+ return true;
}
-//------------------------------------------------------------------------
template<typename T>
void print_nodal_info(string filename, map<MVertex*, T> &mapp){
@@ -48,7 +46,6 @@ void print_nodal_info(string filename, map<MVertex*, T> &mapp){
out.close();
}
-//------------------------------------------------------------------------
bool shoot(const SPoint2 &start, const SPoint2 &dir, const double &h, SPoint2 &res){
@@ -63,7 +60,6 @@ bool shoot(const SPoint2 &start, const SPoint2 &dir, const double &h, SPoint2 &r
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,
@@ -127,7 +123,7 @@ bool computeFourNeighbors (frameFieldBackgroundMesh2D *bgm, MVertex *v_center, /
// 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++){
@@ -191,7 +187,6 @@ bool computeFourNeighbors (frameFieldBackgroundMesh2D *bgm, MVertex *v_center, /
return true;
}
-//------------------------------------------------------------------------
void computeTwoNeighbors(frameFieldBackgroundMesh3D *bgm, MVertex *parent, vector<MVertex*> &spawns, SVector3 dir, double h){
@@ -214,7 +209,6 @@ void computeTwoNeighbors(frameFieldBackgroundMesh3D *bgm, MVertex *parent, vecto
}
-//------------------------------------------------------------------------
void computeSixNeighbors(frameFieldBackgroundMesh3D *bgm, MVertex *parent, vector<MVertex*> &spawns, STensor3 dir, double h){
@@ -238,16 +232,13 @@ void computeSixNeighbors(frameFieldBackgroundMesh3D *bgm, MVertex *parent, vecto
}
}
-//------------------------------------------------------------------------
double Filler2D::time_bgm_and_smoothing = 0.;
double Filler2D::time_insertion = 0.;
-//------------------------------------------------------------------------
Filler2D::Filler2D(){}
-//------------------------------------------------------------------------
Filler2D::~Filler2D(){
cout << "FILLER2D timing:" << endl;
@@ -256,7 +247,6 @@ Filler2D::~Filler2D(){
cout << " ------- TOTAL 2D TIME (new) : " << time_bgm_and_smoothing+time_insertion << " s." << endl;
}
-//------------------------------------------------------------------------
void Filler2D::pointInsertion2D(GFace* gf, vector<MVertex*> &packed, vector<SMetric3> &metrics){
// NB/ do not use the mesh in GFace, use the one in backgroundMesh2D !!!
@@ -462,7 +452,6 @@ void Filler2D::pointInsertion2D(GFace* gf, vector<MVertex*> &packed, vector<SMe
}
-//------------------------------------------------------------------------
bool Filler3D::treat_region(GRegion *gr){
@@ -801,23 +790,19 @@ bool Filler3D::treat_region(GRegion *gr){
return true;
}
-//------------------------------------------------------------------------
int Filler3D::get_nbr_new_vertices(){
return new_vertices.size();
}
-//------------------------------------------------------------------------
MVertex* Filler3D::get_new_vertex(int i){
return new_vertices[i];
}
-//------------------------------------------------------------------------
Filler3D::Filler3D(){}
-//------------------------------------------------------------------------
Filler3D::~Filler3D(){
cout << "FILLER3D timing:" << endl;
@@ -827,17 +812,14 @@ Filler3D::~Filler3D(){
cout << " ------- CUMULATIVE TOTAL 3D TIME (new) : " << time_meshing+time_smoothing+time_insert_points << " s." << endl;
}
-//------------------------------------------------------------------------
std::vector<MVertex*> Filler3D::new_vertices;
-//------------------------------------------------------------------------
double Filler3D::time_smoothing = 0.;
double Filler3D::time_insert_points = 0.;
double Filler3D::time_meshing = 0.;
-//------------------------------------------------------------------------
diff --git a/Mesh/pointInsertion.h b/Mesh/pointInsertion.h
index 655b76b8c9..74f3c7557e 100644
--- a/Mesh/pointInsertion.h
+++ b/Mesh/pointInsertion.h
@@ -23,7 +23,6 @@ using namespace std;
extern bool old_algo_hexa();
-//------------------------------------------------------------------------
class Filler2D{
public:
@@ -34,7 +33,6 @@ class Filler2D{
static double time_bgm_and_smoothing,time_insertion;
};
-//------------------------------------------------------------------------
class Filler3D{
private:
@@ -52,7 +50,6 @@ class Filler3D{
-//------------------------------------------------------------------------------------------
//template<class T>
//bool readValue(string filename, string keystr, T &value){
diff --git a/Mesh/pointInsertionRTreeTools.cpp b/Mesh/pointInsertionRTreeTools.cpp
index 868d107714..d8845e1ad1 100644
--- a/Mesh/pointInsertionRTreeTools.cpp
+++ b/Mesh/pointInsertionRTreeTools.cpp
@@ -8,7 +8,6 @@
#include "GEntity.h"
-//------------------------------------------------------------------------
surfacePointWithExclusionRegion::surfacePointWithExclusionRegion (MVertex *v, SPoint2 p[4][NUMDIR], SPoint2 &_mp, SMetric3 & meshMetric, surfacePointWithExclusionRegion *father){
_v = v;
@@ -29,7 +28,6 @@ surfacePointWithExclusionRegion::surfacePointWithExclusionRegion (MVertex *v, SP
}
}
-//------------------------------------------------------------------------
bool surfacePointWithExclusionRegion::inExclusionZone (const SPoint2 &p){
double mat[2][2];
@@ -55,7 +53,6 @@ bool surfacePointWithExclusionRegion::inExclusionZone (const SPoint2 &p){
return false;
}
-//------------------------------------------------------------------------
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());
@@ -64,7 +61,6 @@ void surfacePointWithExclusionRegion::minmax (double _min[2], double _max[2]) c
_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){
fprintf(f,"SP(%g,%g,%g){%d};\n",_center.x(),_center.y(),0.0,i);
@@ -76,14 +72,12 @@ void surfacePointWithExclusionRegion::print (FILE *f, int i){
}
-//------------------------------------------------------------------------
my_wrapper::my_wrapper (SPoint2 sp) : _tooclose (false), _p(sp) {}
-//------------------------------------------------------------------------
bool rtree_callback(surfacePointWithExclusionRegion *neighbour,void* point){
@@ -98,7 +92,6 @@ bool rtree_callback(surfacePointWithExclusionRegion *neighbour,void* point){
}
-//------------------------------------------------------------------------
bool inExclusionZone (SPoint2 &p,
RTree<surfacePointWithExclusionRegion*,double,2,double> &rtree,
@@ -138,7 +131,6 @@ frameFieldBackgroundMesh3D* Wrapper3D::bgmesh = NULL;
bool compareSmoothnessVertexPairs::vectorial = false;
-//------------------------------------------------------------------------
double infinity_distance_3D(const MVertex *v1,const MVertex *v2,STensor3 &cf){
SPoint3 p1 = v1->point();
@@ -162,7 +154,6 @@ double infinity_distance_3D(const MVertex *v1,const MVertex *v2,STensor3 &cf){
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){
min[0] = x - sqrt3*h;
@@ -173,7 +164,6 @@ void fill_min_max(double x,double y,double z,double h,double *min,double *max){
max[2] = z + sqrt3*h;
};
-//------------------------------------------------------------------------
bool rtree_callback_3D(MVertex* neighbour,void* w){
Wrapper3D* wrapper;
@@ -198,7 +188,6 @@ bool rtree_callback_3D(MVertex* neighbour,void* w){
return true;
};
-//------------------------------------------------------------------------
bool far_from_boundary_3D(frameFieldBackgroundMesh3D *bgm, MVertex* v, double h){
// check if the box (v->point +- k2*h) is in domain
@@ -217,7 +206,6 @@ bool far_from_boundary_3D(frameFieldBackgroundMesh3D *bgm, MVertex* v, double h)
return true;
};
-//------------------------------------------------------------------------
// vient de l'ancien code hexa, mais... kesskessai ?
//int code_kesskessai(int tag){
@@ -241,5 +229,4 @@ bool far_from_boundary_3D(frameFieldBackgroundMesh3D *bgm, MVertex* v, double h)
// return limit;
//}
-//------------------------------------------------------------------------
diff --git a/Mesh/pointInsertionRTreeTools.h b/Mesh/pointInsertionRTreeTools.h
index 69d00dc900..32daa4e422 100644
--- a/Mesh/pointInsertionRTreeTools.h
+++ b/Mesh/pointInsertionRTreeTools.h
@@ -29,7 +29,6 @@ static const double DIRS [NUMDIR] = {0.0};
-//------------------------------------------------------------------------
class surfacePointWithExclusionRegion {
@@ -56,7 +55,6 @@ class surfacePointWithExclusionRegion {
void print (FILE *f, int i);
};
-//------------------------------------------------------------------------
class my_wrapper {
@@ -66,7 +64,6 @@ class my_wrapper {
my_wrapper (SPoint2 sp);
};
-//------------------------------------------------------------------------
struct smoothness_point_pair{
@@ -74,7 +71,6 @@ struct smoothness_point_pair{
surfacePointWithExclusionRegion* ptr;
};
-//------------------------------------------------------------------------
class compareSurfacePointWithExclusionRegionPtr_Smoothness
@@ -93,7 +89,6 @@ class compareSurfacePointWithExclusionRegionPtr_Smoothness
};
-//------------------------------------------------------------------------
class compareSurfacePointWithExclusionRegionPtr
@@ -108,19 +103,16 @@ class compareSurfacePointWithExclusionRegionPtr
};
-//------------------------------------------------------------------------
extern bool rtree_callback(surfacePointWithExclusionRegion *neighbour,void* point);
-//------------------------------------------------------------------------
extern bool inExclusionZone (SPoint2 &p, RTree<surfacePointWithExclusionRegion*,double,2,double> &rtree, std::vector<surfacePointWithExclusionRegion*> & all );
-//------------------------------------------------------------------------
@@ -162,7 +154,6 @@ class Wrapper3D{
double* get_size(){return size;};
};
-//------------------------------------------------------------------------
@@ -172,7 +163,6 @@ extern bool far_from_boundary_3D(frameFieldBackgroundMesh3D *bgm, MVertex* v, do
//extern int code_kesskessai(int tag);
extern void fill_min_max(double x,double y,double z,double h,double *min,double *max);
-//------------------------------------------------------------------------
@@ -195,7 +185,6 @@ class smoothness_vertex_pair{
int dir,layer;
};
-//------------------------------------------------------------------------
class compareSmoothnessVertexPairs
@@ -262,7 +251,6 @@ class compareSmoothnessVertexPairs
};
-//------------------------------------------------------------------------
class listOfPoints{
public:
@@ -279,7 +267,6 @@ class listOfPoints{
virtual bool empty()=0;
};
-//------------------------------------------------------------------------
class listOfPointsScalarSmoothness : public listOfPoints{
public:
@@ -312,7 +299,6 @@ class listOfPointsScalarSmoothness : public listOfPoints{
set<smoothness_vertex_pair*, compareSmoothnessVertexPairs> points;
};
-//------------------------------------------------------------------------
class listOfPointsVectorialSmoothness : public listOfPointsScalarSmoothness{
public:
@@ -329,7 +315,6 @@ class listOfPointsVectorialSmoothness : public listOfPointsScalarSmoothness{
set<smoothness_vertex_pair*, compareSmoothnessVertexPairs> points;
};
-//------------------------------------------------------------------------
class listOfPointsFifo : public listOfPoints{
public:
diff --git a/Mesh/surfaceFiller.cpp b/Mesh/surfaceFiller.cpp
index 36f57cec04..aae6d520d0 100644
--- a/Mesh/surfaceFiller.cpp
+++ b/Mesh/surfaceFiller.cpp
@@ -373,7 +373,7 @@ bool compute4neighbors (GFace *gf, // the surface
// printf("L = %12.5E D = %12.5E ERR = %12.5E\n",L,D,100*fabs(D-L)/(D+L));
}
- if (1 && goNonLinear){//---------------------------------------------------//
+ 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++){ //
@@ -418,7 +418,6 @@ bool compute4neighbors (GFace *gf, // the surface
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){
@@ -470,7 +469,6 @@ double get_smoothness(MVertex *v, GFace *gf, const map<MVertex*,double> &vertice
return res;
}
-// ---------------------------------------------------------------------------------------------
void print_nodal_info_int(string filename, map<MVertex*, int> &mapp){
ofstream out(filename.c_str());
@@ -485,7 +483,6 @@ void print_nodal_info_int(string filename, map<MVertex*, int> &mapp){
out.close();
}
-// ---------------------------------------------------------------------------------------------
void print_nodal_info_double(string filename, map<MVertex*, double> &mapp){
ofstream out(filename.c_str());
@@ -500,7 +497,6 @@ void print_nodal_info_double(string filename, map<MVertex*, double> &mapp){
out.close();
}
-// ---------------------------------------------------------------------------------------------
void export_point(surfacePointWithExclusionRegion *sp, int DIR, FILE *crossf, GFace *gf){
// get the unit normal at that point
@@ -550,7 +546,6 @@ void export_point(surfacePointWithExclusionRegion *sp, int DIR, FILE *crossf, GF
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){
@@ -688,7 +683,6 @@ bool get_local_sizes_and_directions(const MVertex *v_center, const SPoint2 &midp
}
-// ---------------------------------------------------------------------------------------------
// using fifo based on smoothness criteria
void packingOfParallelogramsSmoothness(GFace* gf, std::vector<MVertex*> &packed, std::vector<SMetric3> &metrics){
@@ -909,7 +903,6 @@ void packingOfParallelogramsSmoothness(GFace* gf, std::vector<MVertex*> &packed
}
-// ---------------------------------------------------------------------------------------------
// fills a surface with points in order to build a nice
diff --git a/Mesh/yamakawa.cpp b/Mesh/yamakawa.cpp
index d3051fdde3..83b54b9323 100644
--- a/Mesh/yamakawa.cpp
+++ b/Mesh/yamakawa.cpp
@@ -25,7 +25,6 @@
-// --------------------------------------------------------------------
void export_gregion_mesh(GRegion *gr, string filename){
@@ -114,7 +113,6 @@ void export_gregion_mesh(GRegion *gr, string filename){
}
-// --------------------------------------------------------------------
template <class T>
void export_the_clique_graphviz_format(cliques_compatibility_graph<T> &cl, int clique_number,string filename){
@@ -217,18 +215,15 @@ void export_the_clique_graphviz_format(cliques_compatibility_graph<T> &cl, int c
-//--------------------------------------------------------------------------------------
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>
void clique_stop_criteria<T>::export_corresponding_mesh(const graph_data_no_hash &clique)const{
@@ -322,7 +317,6 @@ void clique_stop_criteria<T>::export_corresponding_mesh(const graph_data_no_hash
}
-//--------------------------------------------------------------------------------------
template<class T>
bool clique_stop_criteria<T>::stop(const graph_data_no_hash &clique)const{
@@ -378,7 +372,6 @@ bool clique_stop_criteria<T>::stop(const graph_data_no_hash &clique)const{
return false;
}
-//--------------------------------------------------------------------------------------
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):debug(false), max_nb_cliques(_max_nb_cliques), nb_hex_potentiels(_nb_hex_potentiels), max_clique_size(0), position(0), total_nodes_number(0), cancel_search(false), hex_ranks(_hex_ranks), G(_g),criteria(csc),export_clique_graph(fct),found_the_ultimate_max_clique(false){
@@ -388,13 +381,11 @@ cliques_compatibility_graph<T>::cliques_compatibility_graph(graph &_g, const map
};
-//--------------------------------------------------------------------------------------
template<class T>
cliques_compatibility_graph<T>::~cliques_compatibility_graph(){
};
-//--------------------------------------------------------------------------------------
template<class T>
void cliques_compatibility_graph<T>::find_cliques(){
@@ -411,7 +402,6 @@ void cliques_compatibility_graph<T>::find_cliques(){
};
-//--------------------------------------------------------------------------------------
template<class T>
void cliques_compatibility_graph<T>::export_cliques(){
@@ -425,7 +415,6 @@ void cliques_compatibility_graph<T>::export_cliques(){
}
};
-//--------------------------------------------------------------------------------------
template<class T>
void cliques_compatibility_graph<T>::store_clique(int n){
@@ -548,7 +537,6 @@ void cliques_compatibility_graph<T>::store_clique(int n){
};
-//--------------------------------------------------------------------------------------
template<class T>
void cliques_compatibility_graph<T>::find_cliques(graph_data &s, int n){
@@ -660,7 +648,6 @@ void cliques_compatibility_graph<T>::find_cliques(graph_data &s, int n){
}
-//--------------------------------------------------------------------------------------
template<class T>
void cliques_compatibility_graph<T>::erase_entry(graph_data &s, T &u, hash_key &key){
@@ -675,7 +662,6 @@ void cliques_compatibility_graph<T>::erase_entry(graph_data &s, T &u, hash_key &
}
}
-//--------------------------------------------------------------------------------------
template<class T>
void cliques_compatibility_graph<T>::choose_u(const graph_data &s, T &u, hash_key &u_key){
@@ -722,7 +708,6 @@ void cliques_compatibility_graph<T>::choose_u(const graph_data &s, T &u, hash_ke
return;
}
-//--------------------------------------------------------------------------------------
template<class T>
void cliques_compatibility_graph<T>::split_set_BW(const T &u, const hash_key &u_key, const graph_data &s, graph_data &white, graph_data &black){
@@ -738,7 +723,6 @@ void cliques_compatibility_graph<T>::split_set_BW(const T &u, const hash_key &u_
}
}
-//--------------------------------------------------------------------------------------
template<class T>
@@ -752,7 +736,6 @@ void cliques_compatibility_graph<T>::fill_black_set(const T &u, const hash_key &
}
}
-//--------------------------------------------------------------------------------------
// the maximum score (int) will be chosen...
template<class T>
@@ -775,7 +758,6 @@ double cliques_compatibility_graph<T>::function_to_maximize_for_u(const T &u, co
return counter;
}
-//--------------------------------------------------------------------------------------
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){
@@ -800,8 +782,6 @@ bool cliques_compatibility_graph<T>::compatibility(const T &u, const hash_key &u
return (found_it);
}
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
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){
@@ -826,25 +806,21 @@ bool cliques_losses_graph<T>::compatibility(const T &u, const hash_key &u_key, c
return (!found_it);
}
-//--------------------------------------------------------------------------------------
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(){
};
-//--------------------------------------------------------------------------------------
-// --------------------------------------------------------------------
bool compare_hex_ptr_by_quality (Hex *a,Hex *b) { return (a->get_quality()>(b->get_quality())); }
@@ -1036,7 +1012,6 @@ bool PEEntity::operator<(const PEEntity& t) const{
// return (hash==l);
//}
-// --------------------------------------------------------------------
PELine::~PELine(){};
@@ -1050,7 +1025,6 @@ PELine::PELine(const vector<const MVertex*> &_v):PEEntity(_v){
size_t PELine::get_max_nb_vertices()const{return 2;};
-// --------------------------------------------------------------------
PETriangle::~PETriangle(){};
@@ -1067,7 +1041,6 @@ PETriangle::PETriangle(const vector<const MVertex*> &_v):PEEntity(_v){
size_t PETriangle::get_max_nb_vertices()const{return 3;};
-// --------------------------------------------------------------------
PEQuadrangle::~PEQuadrangle(){};
@@ -5762,7 +5735,6 @@ void PostOp::erase_vertex_to_pyramids(MElement* element){
}
}
-// --------------------------------------------------------------------
void Recombinator_Graph::pattern1(GRegion* gr){
int size_init = hex_to_tet.size();
@@ -5839,7 +5811,6 @@ void Recombinator_Graph::pattern1(GRegion* gr){
cout << "Nb of hex found, pattern1: " << hex_to_tet.size()-size_init << endl;
}
-// --------------------------------------------------------------------
void Recombinator_Graph::pattern2(GRegion* gr){
int size_init = hex_to_tet.size();
@@ -5892,7 +5863,6 @@ void Recombinator_Graph::pattern2(GRegion* gr){
cout << "Nb of hex found, pattern2: " << hex_to_tet.size()-size_init << endl;
}
-// --------------------------------------------------------------------
void Recombinator_Graph::pattern3(GRegion* gr){
int size_init = hex_to_tet.size();
@@ -6018,7 +5988,6 @@ void Recombinator_Graph::pattern3(GRegion* gr){
cout << "Nb of hex found, pattern3: " << hex_to_tet.size()-size_init << endl;
}
-// --------------------------------------------------------------------
// check if hex is ok, and insert in "potential" table
void Recombinator_Graph::fill_tet_to_hex_table(Hex *hex){
@@ -6150,7 +6119,6 @@ void Recombinator_Graph::fill_tet_to_hex_table(Hex *hex){
}
}
-// --------------------------------------------------------------------
void Recombinator_Graph::buildGraphOnly(unsigned int max_nb_cliques,string filename){
GRegion* gr;
@@ -6166,7 +6134,6 @@ void Recombinator_Graph::buildGraphOnly(unsigned int max_nb_cliques,string filen
}
}
-// --------------------------------------------------------------------
void Recombinator_Graph::buildGraphOnly(GRegion* gr, unsigned int max_nb_cliques,string filename){
printf("................HEXAHEDRA................\n");
@@ -6196,7 +6163,6 @@ void Recombinator_Graph::buildGraphOnly(GRegion* gr, unsigned int max_nb_cliques
}
-// --------------------------------------------------------------------
void Recombinator_Graph::execute(unsigned int max_nb_cliques,string filename){
GRegion* gr;
@@ -6214,7 +6180,6 @@ void Recombinator_Graph::execute(unsigned int max_nb_cliques,string filename){
}
}
-// --------------------------------------------------------------------
void Recombinator_Graph::execute_blossom(unsigned int max_nb_cliques,string filename){
GRegion* gr;
@@ -6233,7 +6198,6 @@ void Recombinator_Graph::execute_blossom(unsigned int max_nb_cliques,string file
}
-// --------------------------------------------------------------------
Recombinator_Graph::~Recombinator_Graph(){
for (iter it = triangular_faces.begin();it!=triangular_faces.end();it++){
delete it->second;
@@ -6243,7 +6207,6 @@ Recombinator_Graph::~Recombinator_Graph(){
}
}
-// --------------------------------------------------------------------
void Recombinator_Graph::createBlossomInfo(){
@@ -6263,7 +6226,6 @@ void Recombinator_Graph::createBlossomInfo(){
}
}
-// --------------------------------------------------------------------
void Recombinator_Graph::createBlossomInfo(GRegion *gr){
@@ -6372,7 +6334,6 @@ void Recombinator_Graph::createBlossomInfo(GRegion *gr){
}
-// --------------------------------------------------------------------
void Recombinator_Graph::execute_blossom(GRegion* gr, unsigned int max_nb_cliques,string filename){
@@ -6471,7 +6432,6 @@ void Recombinator_Graph::execute_blossom(GRegion* gr, unsigned int max_nb_clique
// modify_surfaces(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){
@@ -6492,7 +6452,6 @@ PETriangle* Recombinator_Graph::get_triangle(MElement *element, int i, int j, in
return t;
}
-// --------------------------------------------------------------------
void Recombinator_Graph::execute(GRegion* gr, unsigned int max_nb_cliques,string filename){
printf("................HEXAHEDRA................\n");
@@ -6574,7 +6533,6 @@ void Recombinator_Graph::execute(GRegion* gr, unsigned int max_nb_cliques,string
// modify_surfaces(gr);
}
-// --------------------------------------------------------------------
void Recombinator_Graph::merge_clique(GRegion* gr, cliques_losses_graph<Hex*> &cl,int clique_number){
@@ -6704,13 +6662,11 @@ void Recombinator_Graph::merge_clique(GRegion* gr, cliques_losses_graph<Hex*> &c
}
-// --------------------------------------------------------------------
void Recombinator_Graph::merge(GRegion* gr){
throw;
}
-// --------------------------------------------------------------------
void Recombinator_Graph::export_tets(set<MElement*> &tetset, Hex* hex, string s){
stringstream ss;
@@ -6743,7 +6699,6 @@ void Recombinator_Graph::export_tets(set<MElement*> &tetset, Hex* hex, string s)
out.close();
}
-// --------------------------------------------------------------------
void Recombinator_Graph::export_single_hex_tet(Hex* hex,string s){
stringstream ss;
@@ -6776,7 +6731,6 @@ void Recombinator_Graph::export_single_hex_tet(Hex* hex,string s){
out.close();
}
-// --------------------------------------------------------------------
void Recombinator_Graph::export_single_hex_all(Hex* hex,string s){
export_single_hex(hex, s);
@@ -6784,7 +6738,6 @@ void Recombinator_Graph::export_single_hex_all(Hex* hex,string s){
export_single_hex_faces(hex, s);
}
-// --------------------------------------------------------------------
void Recombinator_Graph::export_single_hex(Hex* hex,string s){
stringstream ss;
@@ -6813,7 +6766,6 @@ void Recombinator_Graph::export_single_hex(Hex* hex,string s){
}
-// --------------------------------------------------------------------
void Recombinator_Graph::export_single_hex_faces(Hex* hex,string s){
stringstream ss;
@@ -6846,7 +6798,6 @@ void Recombinator_Graph::export_single_hex_faces(Hex* hex,string s){
out.close();
}
-// --------------------------------------------------------------------
void Recombinator_Graph::export_hex_init_degree(GRegion *gr, const std::map<Hex*,int> &init_degree, const vector<Hex*> &chosen_hex){
@@ -6880,7 +6831,6 @@ void Recombinator_Graph::export_hex_init_degree(GRegion *gr, const std::map<Hex*
out.close();
}
-// --------------------------------------------------------------------
void Recombinator_Graph::export_hexmesh_so_far(int &file){
stringstream ss;
@@ -6899,7 +6849,6 @@ void Recombinator_Graph::export_hexmesh_so_far(int &file){
}
-// --------------------------------------------------------------------
void Recombinator_Graph::export_all_hex(int &file, GRegion *gr){
stringstream ss;
@@ -6940,7 +6889,6 @@ void Recombinator_Graph::export_all_hex(int &file, GRegion *gr){
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){
@@ -6961,7 +6909,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
return false;
}
- // --------------------------------------------------------------------
// fills incompatibility_graph if two hex share a common (non-sliver!) tet
void Recombinator_Graph::create_indirect_neighbors_graph(){
@@ -7013,7 +6960,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
}
- // --------------------------------------------------------------------
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<std::multimap<unsigned long long, Hex* >::const_iterator, std::multimap<unsigned long long, Hex* >::const_iterator> range = list.equal_range(hex->get_hash());
@@ -7026,7 +6972,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
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::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());
@@ -7041,7 +6986,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
- // --------------------------------------------------------------------
Recombinator_Graph::citer Recombinator_Graph::find_the_triangle(PETriangle *t, const trimap &list){
std::pair<citer, citer> range = list.equal_range(t->get_hash());
@@ -7051,7 +6995,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
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());
@@ -7061,7 +7004,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
return list.end();
}
- // --------------------------------------------------------------------
void Recombinator_Graph::export_direct_neighbor_table(int max){
stringstream ss;
@@ -7106,7 +7048,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
out.close();
}
- // --------------------------------------------------------------------
// if two hex are not connected in the incompatibility_graph, they are compatible
void Recombinator_Graph::create_losses_graph(GRegion *gr){
@@ -7130,7 +7071,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
cout << "#hex potentiels recensés par les patterns de recombinaison: " << hex_to_tet.size() << endl;
};
- // --------------------------------------------------------------------
// TODO: check only the direct neighbors !!! change the algo pour ne as parcourir les hex qui ont un tet commun. cad Filter au niveau des faces... juste les faces extérieures de l'hex !!! et attention aux slivers, du coup... c'est sans doute la source du pb...
@@ -7205,7 +7145,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
- // --------------------------------------------------------------------
void Recombinator_Graph::evaluate_hex_couple(Hex* hex, Hex* other_hex){
@@ -7311,7 +7250,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
// }
}
- // --------------------------------------------------------------------
bool Recombinator_Graph::post_check_validation(Hex* current_hex){
// post check...
@@ -7370,7 +7308,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
return true;
}
- // --------------------------------------------------------------------
void Recombinator_Graph::add_face(const MVertex *a,const MVertex* b,const MVertex *c,std::multimap<unsigned long long, pair<PETriangle*,int> > &f){
vector<const MVertex*> v;
@@ -7387,7 +7324,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
}
- // --------------------------------------------------------------------
void Recombinator_Graph::add_face(const MVertex *a,const MVertex* b,const MVertex *c,Hex *hex){
vector<const MVertex*> v;
@@ -7408,7 +7344,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
faces_to_hex[q].insert(hex);
}
- // --------------------------------------------------------------------
void Recombinator_Graph::add_edges(Hex *hex){
MVertex *a,*b,*c,*d;
@@ -7431,7 +7366,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
fill_edges_table(d,a,e,h,hex);
}
- // --------------------------------------------------------------------
void Recombinator_Graph::fill_edges_table(const MVertex *a, const MVertex *b, const MVertex *c, const MVertex *d, Hex *hex){
vector<const MVertex* > v;
@@ -7467,7 +7401,6 @@ bool Recombinator_Graph::is_not_good_enough(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());
@@ -7482,7 +7415,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
return incompatibility_graph.end();
}
- // --------------------------------------------------------------------
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());
@@ -7498,7 +7430,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
- // --------------------------------------------------------------------
bool Recombinator_Graph::find_hex_couple_in_graph(Hex* hex, Hex* other_hex){
graph::iterator it = find_hex_in_graph(hex);
@@ -7510,7 +7441,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
- // --------------------------------------------------------------------
void Recombinator_Graph::add_graph_entry(Hex* hex, Hex* other_hex){
@@ -7528,7 +7458,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
- // --------------------------------------------------------------------
void Recombinator_Graph::compute_hex_ranks(){
@@ -7554,7 +7483,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
}
- // --------------------------------------------------------------------
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++){
@@ -7565,7 +7493,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
}
- // --------------------------------------------------------------------
void Recombinator_Graph::add_face_connectivity(MElement *tet, int i, int j, int k){
vector<const MVertex*> v;
@@ -7581,7 +7508,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
delete t;
}
- // --------------------------------------------------------------------
void Recombinator_Graph::compute_hex_ranks_blossom(){
@@ -7630,7 +7556,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
}
}
- // --------------------------------------------------------------------
bool Recombinator_Graph::find_face_in_blossom_info(MVertex *a, MVertex *b, MVertex *c, MVertex *d){
PETriangle *t1,*t2;
@@ -7650,7 +7575,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
return false;
}
- // --------------------------------------------------------------------
PETriangle* Recombinator_Graph::get_triangle(MVertex*a, MVertex* b, MVertex *c){
vector<const MVertex*> v;
@@ -7663,7 +7587,6 @@ bool Recombinator_Graph::is_not_good_enough(Hex* hex){
return (it_find_tri->second);
}
- // --------------------------------------------------------------------
bool Recombinator_Graph::is_blossom_pair(PETriangle *t1, PETriangle *t2){
tripair::iterator itfind = blossom_info.find(t1);
diff --git a/Mesh/yamakawa.h b/Mesh/yamakawa.h
index 3ad1d7de04..e11f7680b2 100644
--- a/Mesh/yamakawa.h
+++ b/Mesh/yamakawa.h
@@ -20,11 +20,9 @@
using namespace std;
-//--------------------------------------------------------------------------------------
extern void export_gregion_mesh(GRegion *gr, string filename);
-//--------------------------------------------------------------------------------------
class PEEntity{
protected:
@@ -68,7 +66,6 @@ class PEQuadrangle : public PEEntity{
size_t get_max_nb_vertices() const;
};
-//--------------------------------------------------------------------------------------
template<class T>
class clique_stop_criteria{
@@ -85,7 +82,6 @@ class clique_stop_criteria{
const unsigned int total_number_tet;
};
-//--------------------------------------------------------------------------------------
template<class T>
class cliques_compatibility_graph{
@@ -150,7 +146,6 @@ class cliques_compatibility_graph{
};
-//--------------------------------------------------------------------------------------
template<class T>
class cliques_losses_graph : public cliques_compatibility_graph<T> {
@@ -174,7 +169,6 @@ class cliques_losses_graph : public cliques_compatibility_graph<T> {
graph &G;
};
-//--------------------------------------------------------------------------------------
class Hex{
--
GitLab