diff --git a/Geo/CMakeLists.txt b/Geo/CMakeLists.txt
index 0db6bd169210e9005e99a3c63a2df9351e75e9cc..4ed98e91e6e4d97f60a2de3fabfd815ca77a6c0e 100644
--- a/Geo/CMakeLists.txt
+++ b/Geo/CMakeLists.txt
@@ -29,6 +29,7 @@ set(SRC
ExtrudeParams.cpp
Geo.cpp
GeoStringInterface.cpp GeoInterpolation.cpp
+ gmshLevelset.cpp
findLinks.cpp
SOrientedBoundingBox.cpp
GeomMeshMatcher.cpp
diff --git a/Geo/GModel.cpp b/Geo/GModel.cpp
index 5d05bc505be428eae6c0aa71691ca7b80b3e4fd1..6005e3357e71a7f17c230f3d09882eea3148b478 100644
--- a/Geo/GModel.cpp
+++ b/Geo/GModel.cpp
@@ -1800,7 +1800,6 @@ GModel *GModel::buildCutGModel(gLevelset *ls, bool cutElem, bool saveTri)
cutGM->_storeElementsInEntities(elements[i]);
cutGM->_associateEntityWithMeshVertices();
-
cutGM->_storeVerticesInEntities(vertexMap);
for(int i = 0; i < 4; i++)
diff --git a/Geo/MElementCut.cpp b/Geo/MElementCut.cpp
index f54b09c65b972c5618db6f81523e3b91c40cbff5..3f2a3ca74463c25615973062421cccdc2f973873 100644
--- a/Geo/MElementCut.cpp
+++ b/Geo/MElementCut.cpp
@@ -8,9 +8,9 @@
#include "GModel.h"
#include "MElement.h"
#include "MElementCut.h"
+#include "gmshLevelset.h"
#if defined(HAVE_DINTEGRATION)
-#include "DILevelset.h"
#include "Integration3D.h"
#endif
diff --git a/contrib/DiscreteIntegration/DILevelset.cpp b/Geo/gmshLevelset.cpp
similarity index 94%
rename from contrib/DiscreteIntegration/DILevelset.cpp
rename to Geo/gmshLevelset.cpp
index 2ce725106798f1c5bfe2a8387534f78274a2877d..c784cf167be50e7af291692cbdcb9a0e14d3aa47 100644
--- a/contrib/DiscreteIntegration/DILevelset.cpp
+++ b/Geo/gmshLevelset.cpp
@@ -1,11 +1,8 @@
-#ifndef LEVELSET_CC
-#define LEVELSET_CC
-
-#include "DILevelset.h"
+#include "gmshLevelset.h"
#include <queue>
#include <stack>
#include "fullMatrix.h"
-
+#include "mathEvaluator.h"
inline double det3(double d11, double d12, double d13, double d21, double d22, double d23, double d31, double d32, double d33) {
return d11 * (d22 * d33 - d23 * d32) - d21 * (d12 * d33 - d13 * d32) + d31 * (d12 * d23 - d13 * d22);
@@ -305,7 +302,7 @@ gLevelsetPoints::gLevelsetPoints(const gLevelsetPoints &lv) : gLevelsetPrimitive
points = lv.points;
}
-double gLevelsetPoints::operator()(const double &x, const double &y, const double &z) const{
+double gLevelsetPoints::operator()(const double x, const double y, const double z) const{
if(mapP.empty()) printf("Levelset Points : call computeLS() before calling operator()\n");
@@ -465,11 +462,49 @@ void gLevelsetQuadric::init(){
C = 0.;
}
-double gLevelsetQuadric::operator()(const double &x, const double &y, const double &z) const{
+double gLevelsetQuadric::operator()(const double x, const double y, const double z) const{
return(A[0][0] * x * x + 2. * A[0][1] * x * y + 2. * A[0][2] * x * z + A[1][1] * y * y
+ 2. * A[1][2] * y * z + A[2][2] * z * z + B[0] * x + B[1] * y + B[2] * z + C);
}
+gLevelsetMathEval::gLevelsetMathEval(std::string f, int tag) : gLevelsetPrimitive(tag) {
+ std::vector<std::string> expressions(1, f);
+ std::vector<std::string> variables(3);
+ variables[0] = "x";
+ variables[1] = "y";
+ variables[2] = "z";
+ _expr = new mathEvaluator(expressions, variables);
+}
+
+double gLevelsetMathEval::operator() (const double x, const double y, const double z) const {
+ std::vector<double> values(3), res(1);
+ values[0] = x;
+ values[1] = y;
+ values[2] = z;
+ if(_expr->eval(values, res)) return res[0];
+ return 1.;
+}
+
+#if defined (HAVE_POST)
+gLevelsetPostView::gLevelsetPostView(int index, int tag) : gLevelsetPrimitive(tag), _viewIndex(index){
+ if(_viewIndex >= 0 && _viewIndex < (int)PView::list.size()){
+ PView *view = PView::list[_viewIndex];
+ _octree = new OctreePost(view);
+ }
+ else{
+ Msg::Error("Unknown View[%d] in PostView levelset", _viewIndex);
+ _octree = 0;
+ }
+}
+#endif
+
+double gLevelsetPostView::operator () (const double x, const double y, const double z) const {
+ if(!_octree) return 1.;
+ double val = 1.;
+ _octree->searchScalar(x, y, z, &val, 0);
+ return val;
+}
+
gLevelsetGenCylinder::gLevelsetGenCylinder(const double *pt, const double *dir, const double &R,
int tag) : gLevelsetQuadric(tag) {
A[0][0] = 1.;
@@ -634,4 +669,3 @@ gLevelsetConrod::gLevelsetConrod(const double *pt, const double *dir1, const dou
}
gLevelsetConrod::gLevelsetConrod(const gLevelsetConrod &lv) : gLevelsetImproved(lv){}
-#endif
diff --git a/Geo/gmshLevelset.h b/Geo/gmshLevelset.h
index 75d39688e89efd83ea799f989c2cd5451c44adb8..9beef8585c70ec2d96d734c9a3b40636c0982878 100644
--- a/Geo/gmshLevelset.h
+++ b/Geo/gmshLevelset.h
@@ -7,74 +7,494 @@
#define _GMSH_LEVELSET_H_
#include <string>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h> // for abs()
#include <vector>
+#include "fullMatrix.h"
+#include "MVertex.h"
#include "GmshConfig.h"
+#include "mathEvaluator.h"
+
+#if defined(HAVE_POST)
+#include "PView.h"
+#include "OctreePost.h"
+#endif
-#if defined(HAVE_DINTEGRATION)
+// PRIMITIVE LEVELSET
+#define UNKNOWN 0
+#define SPHERE 1
+#define PLANE 2
+#define GENCYLINDER 3
+#define ELLIPS 4
+#define CONE 5
+#define QUADRIC 6
+#define BOX 7
+#define CYLINDER 8
+#define CONROD 9
+#define LSMESH 10
+#define LSPOINTS 11 // don't define 'POINTS' as it's reserved by win32
-#include "DILevelset.h"
-#include "mathEvaluator.h"
+// TOOLS
+#define CUT 12
+#define UNION 13
+#define INTER 14
+#define CRACK 15
+
+
+class gLevelset
+{
+protected:
+ static const short insideDomain = -1; // negative values of the levelset are inside the domain.
+ int tag_; // must be greater than 0
+public:
+ gLevelset() : tag_(-1) {}
+ gLevelset(const gLevelset &);
+ virtual ~gLevelset(){}
+ virtual gLevelset * clone() const{printf("Error virtual fct called gLevelset::clone()"); return 0;}
+ virtual double operator() (const double x, const double y, const double z) const = 0;
+ bool isInsideDomain (const double &x, const double &y, const double &z) const {return this->operator()(x,y,z) * insideDomain > 0.;}
+ bool isOutsideDomain (const double &x, const double &y, const double &z) const {return this->operator()(x,y,z) * insideDomain < 0.;}
+ bool isOnBorder (const double &x, const double &y, const double &z) const {return this->operator()(x,y,z) == 0.;}
+ virtual std::vector<const gLevelset *> getChildren() const = 0;
+ virtual double choose (double d1, double d2) const = 0;
+ virtual int type() const = 0;
+ virtual bool isPrimitive() const = 0;
+ void setTag(int t) { tag_ = t; }
+ virtual int getTag() const { return tag_; }
+ void getPrimitives(std::vector<const gLevelset *> &primitives) const;
+ void getPrimitivesPO(std::vector<const gLevelset *> &primitives) const;
+ void getRPN(std::vector<const gLevelset *> &gLsRPN) const;
+ double H (const double &x, const double &y, const double &z) const {
+ if (isInsideDomain(x,y,z) || isOnBorder(x,y,z)) return 1.0;
+ return 0.0;
+ }
+ void print() const {
+ printf("LS : ");
+ switch(type()) {
+ case SPHERE : printf("SPHERE"); break;
+ case PLANE : printf("PLANE"); break;
+ case GENCYLINDER : printf("GENCYLINDER"); break;
+ case ELLIPS : printf("ELLIPS"); break;
+ case CONE : printf("CONE"); break;
+ case QUADRIC : printf("QUADRIC"); break;
+ case BOX : printf("BOX"); break;
+ case CYLINDER : printf("CYLINDER"); break;
+ case CONROD : printf("CONROD"); break;
+ case CUT : printf("CUT"); break;
+ case UNION : printf("UNION"); break;
+ case INTER : printf("INTER"); break;
+ case LSMESH: printf("LSMESH"); break;
+ case LSPOINTS: printf("LSPOINTS"); break;
+ }
+ printf(" Tag=%d\n", getTag());
+ }
+};
+
+// ----------------------------------------------------------------------------------------------------------
+// PRIMITIVES
+class gLevelsetPrimitive : public gLevelset
+{
+public:
+ gLevelsetPrimitive() : gLevelset() {}
+ gLevelsetPrimitive(const gLevelsetPrimitive &lv) : gLevelset(lv) {}
+ gLevelsetPrimitive(int tag) {
+ if (tag < 1) {
+ printf("Tag of the levelset (%d) must be greater than 0.\n", tag);
+ tag = abs(tag);
+ }
+ tag_ = tag;
+ }
+ virtual double operator () (const double x, const double y, const double z) const = 0;
+ std::vector<const gLevelset *> getChildren() const { std::vector<const gLevelset *> p; return p; }
+ double choose (double d1, double d2) const {
+ printf("Cannot use function \"choose\" with a primitive!\n");
+ return d1;
+ }
+ virtual int type() const = 0;
+ bool isPrimitive() const {return true;}
+
+};
+
+class gLevelsetSphere : public gLevelsetPrimitive
+{
+protected:
+ double xc, yc, zc, r;
+public:
+ gLevelsetSphere (const double &x, const double &y, const double &z, const double &R, int tag) : gLevelsetPrimitive(tag), xc(x), yc(y), zc(z), r(R) {}
+ virtual double operator () (const double x, const double y, const double z) const
+ {return sqrt((xc - x) * (xc - x) + (yc - y) * (yc - y) + (zc - z) * (zc - z)) - r;}
+ int type() const {return SPHERE;}
+};
+
+class gLevelsetPlane : public gLevelsetPrimitive
+{
+protected:
+ double a, b, c, d;
+public:
+ // define the plane _a*x+_b*y+_c*z+_d, with outward normal (a,b,c)
+ gLevelsetPlane (const double _a, const double _b, const double _c, const double _d, int tag) : gLevelsetPrimitive(tag), a(_a), b(_b), c(_c), d(_d) {}
+ // define the plane passing through the point pt and with outward normal norm
+ gLevelsetPlane (const double *pt, const double *norm, int tag);
+ // define the plane passing through the 3 points pt1,pt2,pt3 and with outward normal (pt1,pt2)x(pt1,pt3)
+ gLevelsetPlane (const double *pt1, const double *pt2, const double *pt3, int tag);
+ // copy constructor
+ gLevelsetPlane(const gLevelsetPlane &lv);
+ virtual gLevelset * clone() const{return new gLevelsetPlane(*this);}
+ // return negative value inward and positive value outward
+ virtual double operator() (const double x, const double y, const double z) const
+ {return a * x + b * y + c * z + d;}
+ int type() const {return PLANE;}
+};
+
+class gLevelsetPoints : public gLevelsetPrimitive
+{
+protected:
+ fullMatrix<double> points;
+ fullMatrix<double> surf;
+ fullMatrix<double> matAInv;
+ double delta;
+ std::map<SPoint3,double> mapP;
+ fullMatrix<double> generateRbfMat(int p, int index,
+ const fullMatrix<double> &nodes1,
+ const fullMatrix<double> &nodes2) const;
+ void RbfOp(int p, int index,
+ const fullMatrix<double> &cntrs,
+ const fullMatrix<double> &nodes,
+ fullMatrix<double> &D,
+ bool isLocal = false) const;
+ void evalRbfDer(int p, int index,
+ const fullMatrix<double> &cntrs,
+ const fullMatrix<double> &nodes,
+ const fullMatrix<double> &fValues,
+ fullMatrix<double> &fApprox, bool isLocal = false) const;
+ void setup_level_set(const fullMatrix<double> &cntrs,
+ fullMatrix<double> &level_set_nodes,
+ fullMatrix<double> &level_set_funvals);
+
+public:
+ // define the data points
+ gLevelsetPoints(fullMatrix<double> &_centers, int tag);
+ // copy constructor
+ gLevelsetPoints(const gLevelsetPoints &lv);
+ virtual gLevelset * clone() const{return new gLevelsetPoints(*this);}
+ // return negative value inward and positive value outward
+ virtual double operator() (const double x, const double y, const double z) const;
+ void computeLS(std::vector<MVertex*> &vert);
+ int type() const {return LSPOINTS;}
+};
+
+class gLevelsetQuadric : public gLevelsetPrimitive
+{
+protected:
+ double A[3][3], B[3], C;
+ void translate (const double transl[3]);
+ void rotate (const double rotate[3][3]);
+ void computeRotationMatrix (const double dir[3], double t[3][3]);
+ void computeRotationMatrix (const double dir1[3], const double dir2[3] , double t[3][3]);
+ void Ax (const double x[3], double res[3], double fact=1.0);
+ void xAx (const double x[3], double &res, double fact=1.0);
+ void init ();
+
+public:
+ gLevelsetQuadric() : gLevelsetPrimitive() {init(); }
+ gLevelsetQuadric(int tag) : gLevelsetPrimitive(tag) {init(); }
+ gLevelsetQuadric(const gLevelsetQuadric &);
+ virtual ~gLevelsetQuadric() {}
+ double operator () (const double x, const double y, const double z) const;
+ virtual int type() const = 0;
+};
+
+class gLevelsetGenCylinder : public gLevelsetQuadric
+{
+public:
+ gLevelsetGenCylinder (const double *pt, const double *dir, const double &R, int tag);
+ gLevelsetGenCylinder (const gLevelsetGenCylinder& );
+ virtual gLevelset * clone() const{return new gLevelsetGenCylinder(*this);}
+ int type() const {return GENCYLINDER;}
+};
+
+class gLevelsetEllipsoid : public gLevelsetQuadric
+{
+public:
+ gLevelsetEllipsoid (const double *pt, const double *dir, const double &a, const double &b, const double &c, int tag);
+ gLevelsetEllipsoid (const gLevelsetEllipsoid& );
+ virtual gLevelset * clone() const{return new gLevelsetEllipsoid(*this);}
+ int type() const {return ELLIPS;}
+};
+
+class gLevelsetCone : public gLevelsetQuadric
+{
+public:
+ gLevelsetCone (const double *pt, const double *dir, const double &angle, int tag);
+ gLevelsetCone (const gLevelsetCone& );
+ virtual gLevelset * clone() const{return new gLevelsetCone(*this);}
+ int type() const {return CONE;}
+};
+
+class gLevelsetGeneralQuadric : public gLevelsetQuadric
+{
+public:
+ gLevelsetGeneralQuadric (const double *pt, const double *dir, const double &x2, const double &y2, const double &z2,
+ const double &z, const double &c, int tag);
+ gLevelsetGeneralQuadric (const gLevelsetGeneralQuadric& );
+ virtual gLevelset * clone() const{return new gLevelsetGeneralQuadric(*this);}
+ int type() const {return QUADRIC;}
+};
class gLevelsetMathEval: public gLevelsetPrimitive
{
mathEvaluator *_expr;
public:
- gLevelsetMathEval(std::string f, int tag) : gLevelsetPrimitive(tag)
- {
- std::vector<std::string> expressions(1, f);
- std::vector<std::string> variables(3);
- variables[0] = "x";
- variables[1] = "y";
- variables[2] = "z";
- _expr = new mathEvaluator(expressions, variables);
- }
- ~gLevelsetMathEval(){ delete _expr; }
- virtual double operator () (const double &x, const double &y, const double &z) const
- {
- std::vector<double> values(3), res(1);
- values[0] = x;
- values[1] = y;
- values[2] = z;
- if(_expr->eval(values, res)) return res[0];
- return 1.;
- }
+ gLevelsetMathEval(std::string f, int tag);
+ ~gLevelsetMathEval(){ if (_expr) delete _expr; }
+ double operator () (const double x, const double y, const double z) const;
int type() const { return UNKNOWN; }
};
-#if defined(HAVE_POST)
-
-#include "PView.h"
-#include "OctreePost.h"
+#if defined(HAVE_POST)
class gLevelsetPostView : public gLevelsetPrimitive
{
int _viewIndex;
OctreePost *_octree;
public:
- gLevelsetPostView(int index, int tag) : gLevelsetPrimitive(tag), _viewIndex(index)
- {
- if(_viewIndex >= 0 && _viewIndex < (int)PView::list.size()){
- PView *view = PView::list[_viewIndex];
- _octree = new OctreePost(view);
- }
- else{
- Msg::Error("Unknown View[%d] in PostView levelset", _viewIndex);
- _octree = 0;
+ gLevelsetPostView(int index, int tag) ;
+ ~gLevelsetPostView(){ if(_octree) delete _octree;}
+ double operator () (const double x, const double y, const double z) const;
+ int type() const { return UNKNOWN; }
+};
+#endif
+
+
+// --------------------------------------------------------------------------------------------------------------
+// TOOLS
+class gLevelsetTools : public gLevelset
+{
+protected:
+ std::vector<const gLevelset *> children;
+public:
+ gLevelsetTools () {}
+ gLevelsetTools (std::vector<const gLevelset *> &p) {children = p;}
+ gLevelsetTools (const gLevelsetTools &);
+ ~gLevelsetTools () {
+ for(int i = 0; i < (int)children.size(); i++)
+ delete children[i];
+ }
+ double operator () (const double x, const double y, const double z) const {
+ double d = (*children[0])(x, y, z);
+ for (int i = 1; i < (int)children.size(); i++){
+ double dt = (*children[i])(x, y, z);
+ d = choose(d, dt);
}
+ return d;
}
- ~gLevelsetPostView(){ if(_octree) delete _octree; }
- virtual double operator () (const double &x, const double &y, const double &z) const
- {
- if(!_octree) return 1.;
- double val = 1.;
- _octree->searchScalar(x, y, z, &val, 0);
- return val;
+ std::vector<const gLevelset *> getChildren() const {
+ if(children.size() != 1) return children;
+ return children[0]->getChildren();
+ }
+ virtual double choose (double d1, double d2) const = 0;
+ virtual int type2() const = 0;
+ virtual int type() const {
+ if(children.size() != 1) return type2();
+ return children[0]->type();
+ }
+ bool isPrimitive() const {
+ if(children.size() != 1) return false;
+ return children[0]->isPrimitive();
+ }
+ int getTag() const {
+ if(children.size() != 1) return tag_;
+ return children[0]->getTag();
}
- int type() const { return UNKNOWN; }
};
-#endif
+class gLevelsetReverse : public gLevelset
+{
+protected:
+ const gLevelset *ls;
+public:
+ gLevelsetReverse (const gLevelset *p) : ls(p){}
+ double operator () (const double x, const double y, const double z) const {
+ return -(*ls)(x, y, z);
+ }
+ std::vector<const gLevelset *> getChildren() const {return ls->getChildren();}
+ bool isPrimitive() const {return ls->isPrimitive();}
+ virtual double choose (double d1, double d2) const {return -ls->choose(d1,d2);}
+ virtual int type() const {return ls->type();}
+ int getTag() const { return ls->getTag(); }
+};
+
+
+// This levelset takes the first levelset in the list as the object and the others as tools that cut it
+class gLevelsetCut : public gLevelsetTools
+{
+public:
+ gLevelsetCut (std::vector<const gLevelset *> &p) : gLevelsetTools(p) { }
+ double choose (double d1, double d2) const {
+ return (d1 > -d2) ? d1 : -d2; // greater of d1 and -d2
+ }
+ gLevelsetCut(const gLevelsetCut &lv):gLevelsetTools(lv){}
+ virtual gLevelset * clone() const{return new gLevelsetCut(*this);}
+ int type2() const {return CUT;}
+};
+
+// This levelset takes the minimum
+class gLevelsetUnion : public gLevelsetTools
+{
+public:
+ gLevelsetUnion (std::vector<const gLevelset *> &p) : gLevelsetTools(p) { }
+ gLevelsetUnion(const gLevelsetUnion &lv):gLevelsetTools(lv){}
+ virtual gLevelset * clone() const{return new gLevelsetUnion(*this);}
+
+ double choose (double d1, double d2) const {
+ return (d1 < d2) ? d1 : d2; // lesser of d1 and d2
+ }
+ int type2() const {return UNION;}
+};
+
+// This levelset takes the maximum
+class gLevelsetIntersection : public gLevelsetTools
+{
+public:
+ gLevelsetIntersection (std::vector<const gLevelset *> &p) : gLevelsetTools(p) { }
+ gLevelsetIntersection(const gLevelsetIntersection &lv):gLevelsetTools(lv) { }
+ virtual gLevelset *clone() const { return new gLevelsetIntersection(*this); }
+
+ double choose (double d1, double d2) const {
+ return (d1 > d2) ? d1 : d2; // greater of d1 and d2
+ }
+ int type2() const {return INTER;}
+};
+
+// Crack defined by a normal and a tangent levelset
+class gLevelsetCrack : public gLevelsetTools
+{
+public:
+ gLevelsetCrack (std::vector<const gLevelset *> &p) {
+ if (p.size() != 2)
+ printf("Error : gLevelsetCrack needs 2 levelsets\n");
+ children.push_back(p[0]);
+ children.push_back(new gLevelsetReverse(p[0]));
+ if(p[1]) children.push_back(p[1]);
+ }
+ double choose (double d1, double d2) const {
+ return (d1 > d2) ? d1 : d2; // greater of d1 and d2
+ }
+ int type2() const {return CRACK;}
+};
+
+// --------------------------------------------------------------------------------------------------------------
+// IMPROVED LEVELSET
+class gLevelsetImproved : public gLevelset
+{
+protected:
+ gLevelset *Ls;
+public:
+ gLevelsetImproved(){}
+ gLevelsetImproved(const gLevelsetImproved &lv);
+ double operator() (const double x, const double y, const double z) const {return (*Ls)(x, y, z);}
+ std::vector<const gLevelset *> getChildren() const { return Ls->getChildren(); }
+ double choose (double d1, double d2) const { return Ls->choose(d1, d2); }
+ virtual int type() const = 0;
+ bool isPrimitive() const {return Ls->isPrimitive();}
+};
+
+class gLevelsetBox : public gLevelsetImproved
+{
+public:
+ // create a box with parallel faces : pt is a corner of the box,
+ // dir1 is the direction of the first edge starting from pt,
+ // dir2 is the direction of the second edge starting from pt,
+ // dir3 is the direction of the third edge starting from pt,
+ // a is the length of the first edge starting from pt,
+ // b is the length of the second edge starting from pt,
+ // c is the length of the third edge starting from pt.
+ // tags of the faces are : face normal to dir3 and not including pt : tag+0
+ // face normal to dir3 and including pt : tag+1
+ // face normal to dir2 and including pt : tag+2
+ // face normal to dir2 and not including pt : tag+3
+ // face normal to dir1 and not including pt : tag+4
+ // face normal to dir1 and including pt : tag+5
+ gLevelsetBox(const double *pt, const double *dir1, const double *dir2, const double *dir3,
+ const double &a, const double &b, const double &c, int tag);
+ // create a box with the 8 vertices (pt1,...,pt8).
+ // check if the faces are planar.
+ // tags of the faces are : face(pt5,pt6,pt7,pt8) : tag+0
+ // face(pt1,pt4,pt3,pt2) : tag+1
+ // face(pt1,pt2,pt6,pt5) : tag+2
+ // face(pt3,pt4,pt8,pt7) : tag+3
+ // face(pt2,pt3,pt7,pt6) : tag+4
+ // face(pt1,pt5,pt8,pt4) : tag+5
+ gLevelsetBox(const double *pt1, const double *pt2, const double *pt3, const double *pt4,
+ const double *pt5, const double *pt6, const double *pt7, const double *pt8, int tag);
+ gLevelsetBox(const gLevelsetBox &);
+ virtual gLevelset * clone() const{return new gLevelsetBox(*this);}
+ int type() const {return BOX;}
+};
+
+class gLevelsetCylinder : public gLevelsetImproved
+{
+public:
+ // create a cylinder : pt is the point in the middle of the cylinder base,
+ // dir is the direction of the cylinder axis,
+ // R is the outer radius of the cylinder,
+ // H is the height of the cylinder.
+ // tags of the faces are : exterior face : tag+0
+ // plane face including pt : tag+1
+ // plane face opposite to pt : tag+2
+ gLevelsetCylinder (const double *pt, const double *dir, const double &R, const double &H, int tag);
+ // create a cylinder : pt is the point in the middle of the cylinder base,
+ // dir is the direction of the cylinder axis,
+ // R is the outer radius of the cylinder,
+ // r is the inner radius of the cylinder,
+ // H is the height of the cylinder.
+ // tags of the faces are : exterior face : tag+0
+ // plane face including pt : tag+1
+ // plane face opposite to pt : tag+2
+ // interior face : tag+3
+ gLevelsetCylinder (const double *pt, const double *dir, const double &R, const double &r, const double &H, int tag);
+ gLevelsetCylinder(const gLevelsetCylinder &);
+ virtual gLevelset * clone() const{return new gLevelsetCylinder(*this);}
+ int type() const {return CYLINDER;}
+};
+
+class gLevelsetConrod : public gLevelsetImproved
+{
+public:
+ // create a connecting rod : pt is the point in the middle of the first bore,
+ // dir1 is the direction of the rod,
+ // dir2 is the direction of the axis of the bore,
+ // H1 is height of the first cylinder,
+ // H2 is the height of the second cylinder,
+ // H3 is the height of the rod,
+ // R1 is the outer radius of the first cylinder,
+ // r1 is the inner radius of the first cylinder,
+ // R2 is the outer radius of the second cylinder,
+ // r2 is the inner radius of the second cylinder,
+ // L1 is the width of the rod in the plane passing through the middle of the first bore,
+ // L2 is the width of the rod in the plane passing through the middle of the second bore,
+ // E is the distance between the axis of the cylinders.
+ // tags of the faces are : bottom face (+dir2) of the bore : tag+2
+ // top face (-dir2) of the bore : tag+3
+ // rear face (-dir1xdir2) of the bore : tag+4
+ // front face (+dir1xdir2) of the bore : tag+5
+ // exterior face of the first cylinder : tag+6
+ // bottom face of the first cylinder : tag+7
+ // top face of the first cylinder : tag+8
+ // exterior face of the second cylinder : tag+9
+ // bottom face of the second cylinder : tag+10
+ // top face of the second cylinder : tag+11
+ // interior face of the first cylinder : tag+12
+ // interior face of the second cylinder : tag+13
+ gLevelsetConrod (const double *pt, const double *dir1, const double *dir2,
+ const double &H1, const double &H2, const double &H3,
+ const double &R1, const double &r1, const double &R2, const double &r2,
+ const double &L1, const double &L2, const double &E, int tag);
+ gLevelsetConrod(const gLevelsetConrod &);
+ virtual gLevelset * clone() const{return new gLevelsetConrod(*this);}
+ int type() const {return CONROD;}
+};
-#endif
#endif
diff --git a/Solver/FuncGradDisc.h b/Solver/FuncGradDisc.h
index 7021490625d2a166ce1c197c4d778198c30434f8..2b5b8c7e090402ab36aea485b60a7aa0e531ed05 100644
--- a/Solver/FuncGradDisc.h
+++ b/Solver/FuncGradDisc.h
@@ -12,7 +12,7 @@
#define _FUNCGRADDISC_H_
#include "simpleFunction.h"
-#include "DILevelset.h"
+#include "gmshLevelset.h"
#include "MVertex.h"
#include "GModel.h"
//#include "gLevelSetMesh.cpp"
diff --git a/Solver/FuncHeaviside.h b/Solver/FuncHeaviside.h
index 6a24f67f2db2a18604c2b3a2e00b4629e354ab83..06e321e9c5a1cc8e706dde2bb73bbd248b8e9368 100644
--- a/Solver/FuncHeaviside.h
+++ b/Solver/FuncHeaviside.h
@@ -12,8 +12,7 @@
#define _FUNCHEAVISIDE_H_
#include "simpleFunction.h"
-#include "DILevelset.h"
-
+#include "gmshLevelset.h"
class FuncHeaviside : public simpleFunctionOnElement<double> {
private :
diff --git a/Solver/elasticitySolver.cpp b/Solver/elasticitySolver.cpp
index 5e610e4982a0e6ad38eef03ec1f8d9934063def7..4eda845f761184246efd502e6278206e6f94cb36 100644
--- a/Solver/elasticitySolver.cpp
+++ b/Solver/elasticitySolver.cpp
@@ -18,7 +18,7 @@
#include "quadratureRules.h"
#include "solverField.h"
#include "MPoint.h"
-#include "DILevelset.h"
+#include "gmshLevelset.h"
#if defined(HAVE_POST)
#include "PView.h"
#include "PViewData.h"
diff --git a/Solver/filters.h b/Solver/filters.h
index 5e05b1745dddacbde373b66a0f2b2de6381f50a5..038aaeae7ac410510af4fd5740f5e86bd46dfb42 100644
--- a/Solver/filters.h
+++ b/Solver/filters.h
@@ -15,7 +15,7 @@
#include "dofManager.h"
#include "GModel.h"
#include "groupOfElements.h"
-#include "DILevelset.h"
+#include "gmshLevelset.h"
class FilterNodeEnriched
{
diff --git a/benchmarks/levelset/cube.geo b/benchmarks/levelset/cube.geo
index e93e0d127eb3565eb6cf6770e50bd592fd075d24..b69a57bbde2b4f9802c37e3123e087fffaf1e3d7 100644
--- a/benchmarks/levelset/cube.geo
+++ b/benchmarks/levelset/cube.geo
@@ -27,6 +27,6 @@ Levelset Cut (12) = {3,7};
Levelset Point(13)={{0.5,0,0},{0.5,0.5,0.},{0.5,1,0},{0.5,0,0.5},{0.5,0,0.8},{0.5,0.5,0.5},{0.5,0.5,1},{0.5,1,0.5},{1.5,1,1}};
-Levelset CutMeshTri {13};
+Levelset CutMeshTri {5};
diff --git a/contrib/DiscreteIntegration/CMakeLists.txt b/contrib/DiscreteIntegration/CMakeLists.txt
index d1af4a09f53d90f4044f2dc58319c9aa6f63ab4c..b9cae1f5421fae44960e78c6e0ef012d1e0ecab4 100644
--- a/contrib/DiscreteIntegration/CMakeLists.txt
+++ b/contrib/DiscreteIntegration/CMakeLists.txt
@@ -4,7 +4,6 @@
# bugs and problems to <gmsh@geuz.org>.
set(SRC
- DILevelset.cpp
Integration3D.cpp
recurCut.cpp
)
diff --git a/contrib/DiscreteIntegration/DILevelset.h b/contrib/DiscreteIntegration/DILevelset.h
deleted file mode 100644
index b84d85760f7f5c6861d433feaecd70deba2be8ff..0000000000000000000000000000000000000000
--- a/contrib/DiscreteIntegration/DILevelset.h
+++ /dev/null
@@ -1,462 +0,0 @@
-#ifndef _gLEVELSET_H_
-#define _gLEVELSET_H_
-
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h> // for abs()
-#include <vector>
-#include "fullMatrix.h"
-#include "MVertex.h"
-
-// PRIMITIVE LEVELSET
-#define UNKNOWN 0
-#define SPHERE 1
-#define PLANE 2
-#define GENCYLINDER 3
-#define ELLIPS 4
-#define CONE 5
-#define QUADRIC 6
-#define BOX 7
-#define CYLINDER 8
-#define CONROD 9
-#define LSMESH 10
-#define LSPOINTS 11 // don't define 'POINTS' as it's reserved by win32
-
-// TOOLS
-#define CUT 12
-#define UNION 13
-#define INTER 14
-#define CRACK 15
-
-class gLevelset
-{
-protected:
- static const short insideDomain = -1; // negative values of the levelset are inside the domain.
- int tag_; // must be greater than 0
-public:
- gLevelset() : tag_(-1) {}
- gLevelset(const gLevelset &);
- virtual ~gLevelset(){}
- virtual gLevelset * clone() const{printf("Error virtual fct called gLevelset::clone()"); return 0;}
- virtual double operator() (const double &x, const double &y, const double &z) const = 0;
- // inline double operator () (const SPoint3 &p) const {return this->operator()(p.x(),p.y(),p.z());}
- bool isInsideDomain (const double &x, const double &y, const double &z) const {return this->operator()(x,y,z) * insideDomain > 0.;}
- bool isOutsideDomain (const double &x, const double &y, const double &z) const {return this->operator()(x,y,z) * insideDomain < 0.;}
- bool isOnBorder (const double &x, const double &y, const double &z) const {return this->operator()(x,y,z) == 0.;}
- virtual std::vector<const gLevelset *> getChildren() const = 0;
- virtual double choose (double d1, double d2) const = 0;
- virtual int type() const = 0;
- virtual bool isPrimitive() const = 0;
- void setTag(int t) { tag_ = t; }
- virtual int getTag() const { return tag_; }
- void getPrimitives(std::vector<const gLevelset *> &primitives) const;
- void getPrimitivesPO(std::vector<const gLevelset *> &primitives) const;
- void getRPN(std::vector<const gLevelset *> &gLsRPN) const;
- double H (const double &x, const double &y, const double &z) const {
- if (isInsideDomain(x,y,z) || isOnBorder(x,y,z)) return 1.0;
- return 0.0;
- }
- void print() const {
- printf("LS : ");
- switch(type()) {
- case SPHERE : printf("SPHERE"); break;
- case PLANE : printf("PLANE"); break;
- case GENCYLINDER : printf("GENCYLINDER"); break;
- case ELLIPS : printf("ELLIPS"); break;
- case CONE : printf("CONE"); break;
- case QUADRIC : printf("QUADRIC"); break;
- case BOX : printf("BOX"); break;
- case CYLINDER : printf("CYLINDER"); break;
- case CONROD : printf("CONROD"); break;
- case CUT : printf("CUT"); break;
- case UNION : printf("UNION"); break;
- case INTER : printf("INTER"); break;
- case LSMESH: printf("LSMESH"); break;
- case LSPOINTS: printf("LSPOINTS"); break;
- }
- printf(" Tag=%d\n", getTag());
- }
-};
-
-// ----------------------------------------------------------------------------------------------------------
-// PRIMITIVES
-class gLevelsetPrimitive : public gLevelset
-{
-public:
- gLevelsetPrimitive() : gLevelset() {}
- gLevelsetPrimitive(const gLevelsetPrimitive &lv) : gLevelset(lv) {}
- gLevelsetPrimitive(int tag) {
- if (tag < 1) {
- printf("Tag of the levelset (%d) must be greater than 0.\n", tag);
- tag = abs(tag);
- }
- tag_ = tag;
- }
- virtual double operator () (const double &x, const double &y, const double &z) const = 0;
- std::vector<const gLevelset *> getChildren() const { std::vector<const gLevelset *> p; return p; }
- double choose (double d1, double d2) const {
- printf("Cannot use function \"choose\" with a primitive!\n");
- return d1;
- }
- virtual int type() const = 0;
- bool isPrimitive() const {return true;}
-
-};
-
-class gLevelsetSphere : public gLevelsetPrimitive
-{
-protected:
- double xc, yc, zc, r;
-public:
- gLevelsetSphere (const double &x, const double &y, const double &z, const double &R, int tag) : gLevelsetPrimitive(tag), xc(x), yc(y), zc(z), r(R) {}
- virtual double operator () (const double &x, const double &y, const double &z) const
- {return sqrt((xc - x) * (xc - x) + (yc - y) * (yc - y) + (zc - z) * (zc - z)) - r;}
- int type() const {return SPHERE;}
-};
-
-class gLevelsetPlane : public gLevelsetPrimitive
-{
-protected:
- double a, b, c, d;
-public:
- // define the plane _a*x+_b*y+_c*z+_d, with outward normal (a,b,c)
- gLevelsetPlane (const double _a, const double _b, const double _c, const double _d, int tag) : gLevelsetPrimitive(tag), a(_a), b(_b), c(_c), d(_d) {}
- // define the plane passing through the point pt and with outward normal norm
- gLevelsetPlane (const double *pt, const double *norm, int tag);
- // define the plane passing through the 3 points pt1,pt2,pt3 and with outward normal (pt1,pt2)x(pt1,pt3)
- gLevelsetPlane (const double *pt1, const double *pt2, const double *pt3, int tag);
- // copy constructor
- gLevelsetPlane(const gLevelsetPlane &lv);
- virtual gLevelset * clone() const{return new gLevelsetPlane(*this);}
- // return negative value inward and positive value outward
- virtual double operator() (const double &x, const double &y, const double &z) const
- {return a * x + b * y + c * z + d;}
- int type() const {return PLANE;}
-};
-
-class gLevelsetPoints : public gLevelsetPrimitive
-{
-protected:
- fullMatrix<double> points;
- fullMatrix<double> surf;
- fullMatrix<double> matAInv;
- double delta;
- std::map<SPoint3,double> mapP;
- fullMatrix<double> generateRbfMat(int p, int index,
- const fullMatrix<double> &nodes1,
- const fullMatrix<double> &nodes2) const;
- void RbfOp(int p, int index,
- const fullMatrix<double> &cntrs,
- const fullMatrix<double> &nodes,
- fullMatrix<double> &D,
- bool isLocal = false) const;
- void evalRbfDer(int p, int index,
- const fullMatrix<double> &cntrs,
- const fullMatrix<double> &nodes,
- const fullMatrix<double> &fValues,
- fullMatrix<double> &fApprox, bool isLocal = false) const;
- void setup_level_set(const fullMatrix<double> &cntrs,
- fullMatrix<double> &level_set_nodes,
- fullMatrix<double> &level_set_funvals);
-
-public:
- // define the data points
- gLevelsetPoints(fullMatrix<double> &_centers, int tag);
- // copy constructor
- gLevelsetPoints(const gLevelsetPoints &lv);
- virtual gLevelset * clone() const{return new gLevelsetPoints(*this);}
- // return negative value inward and positive value outward
- virtual double operator() (const double &x, const double &y, const double &z) const;
- void computeLS(std::vector<MVertex*> &vert);
- int type() const {return LSPOINTS;}
-};
-
-class gLevelsetQuadric : public gLevelsetPrimitive
-{
-protected:
- double A[3][3], B[3], C;
- void translate (const double transl[3]);
- void rotate (const double rotate[3][3]);
- void computeRotationMatrix (const double dir[3], double t[3][3]);
- void computeRotationMatrix (const double dir1[3], const double dir2[3] , double t[3][3]);
- void Ax (const double x[3], double res[3], double fact=1.0);
- void xAx (const double x[3], double &res, double fact=1.0);
- void init ();
-
-public:
- gLevelsetQuadric() : gLevelsetPrimitive() {init(); }
- gLevelsetQuadric(int tag) : gLevelsetPrimitive(tag) {init(); }
- gLevelsetQuadric(const gLevelsetQuadric &);
- virtual ~gLevelsetQuadric() {}
- double operator () (const double &x, const double &y, const double &z) const;
- virtual int type() const = 0;
-};
-
-class gLevelsetGenCylinder : public gLevelsetQuadric
-{
-public:
- gLevelsetGenCylinder (const double *pt, const double *dir, const double &R, int tag);
- gLevelsetGenCylinder (const gLevelsetGenCylinder& );
- virtual gLevelset * clone() const{return new gLevelsetGenCylinder(*this);}
- int type() const {return GENCYLINDER;}
-};
-
-class gLevelsetEllipsoid : public gLevelsetQuadric
-{
-public:
- gLevelsetEllipsoid (const double *pt, const double *dir, const double &a, const double &b, const double &c, int tag);
- gLevelsetEllipsoid (const gLevelsetEllipsoid& );
- virtual gLevelset * clone() const{return new gLevelsetEllipsoid(*this);}
- int type() const {return ELLIPS;}
-};
-
-class gLevelsetCone : public gLevelsetQuadric
-{
-public:
- gLevelsetCone (const double *pt, const double *dir, const double &angle, int tag);
- gLevelsetCone (const gLevelsetCone& );
- virtual gLevelset * clone() const{return new gLevelsetCone(*this);}
- int type() const {return CONE;}
-};
-
-class gLevelsetGeneralQuadric : public gLevelsetQuadric
-{
-public:
- gLevelsetGeneralQuadric (const double *pt, const double *dir, const double &x2, const double &y2, const double &z2,
- const double &z, const double &c, int tag);
- gLevelsetGeneralQuadric (const gLevelsetGeneralQuadric& );
- virtual gLevelset * clone() const{return new gLevelsetGeneralQuadric(*this);}
- int type() const {return QUADRIC;}
-};
-
-// --------------------------------------------------------------------------------------------------------------
-// TOOLS
-class gLevelsetTools : public gLevelset
-{
-protected:
- std::vector<const gLevelset *> children;
-public:
- gLevelsetTools () {}
- gLevelsetTools (std::vector<const gLevelset *> &p) {children = p;}
- gLevelsetTools (const gLevelsetTools &);
- ~gLevelsetTools () {
- for(int i = 0; i < (int)children.size(); i++)
- delete children[i];
- }
- double operator () (const double &x, const double &y, const double &z) const {
- double d = (*children[0])(x, y, z);
- for (int i = 1; i < (int)children.size(); i++){
- double dt = (*children[i])(x, y, z);
- d = choose(d, dt);
- }
- return d;
- }
- std::vector<const gLevelset *> getChildren() const {
- if(children.size() != 1) return children;
- return children[0]->getChildren();
- }
- virtual double choose (double d1, double d2) const = 0;
- virtual int type2() const = 0;
- virtual int type() const {
- if(children.size() != 1) return type2();
- return children[0]->type();
- }
- bool isPrimitive() const {
- if(children.size() != 1) return false;
- return children[0]->isPrimitive();
- }
- int getTag() const {
- if(children.size() != 1) return tag_;
- return children[0]->getTag();
- }
-};
-
-class gLevelsetReverse : public gLevelset
-{
-protected:
- const gLevelset *ls;
-public:
- gLevelsetReverse (const gLevelset *p) : ls(p){}
- double operator () (const double &x, const double &y, const double &z) const {
- return -(*ls)(x, y, z);
- }
- std::vector<const gLevelset *> getChildren() const {return ls->getChildren();}
- bool isPrimitive() const {return ls->isPrimitive();}
- virtual double choose (double d1, double d2) const {return -ls->choose(d1,d2);}
- virtual int type() const {return ls->type();}
- int getTag() const { return ls->getTag(); }
-};
-
-
-// This levelset takes the first levelset in the list as the object and the others as tools that cut it
-class gLevelsetCut : public gLevelsetTools
-{
-public:
- gLevelsetCut (std::vector<const gLevelset *> &p) : gLevelsetTools(p) { }
- double choose (double d1, double d2) const {
- return (d1 > -d2) ? d1 : -d2; // greater of d1 and -d2
- }
- gLevelsetCut(const gLevelsetCut &lv):gLevelsetTools(lv){}
- virtual gLevelset * clone() const{return new gLevelsetCut(*this);}
- int type2() const {return CUT;}
-};
-
-// This levelset takes the minimum
-class gLevelsetUnion : public gLevelsetTools
-{
-public:
- gLevelsetUnion (std::vector<const gLevelset *> &p) : gLevelsetTools(p) { }
- gLevelsetUnion(const gLevelsetUnion &lv):gLevelsetTools(lv){}
- virtual gLevelset * clone() const{return new gLevelsetUnion(*this);}
-
- double choose (double d1, double d2) const {
- return (d1 < d2) ? d1 : d2; // lesser of d1 and d2
- }
- int type2() const {return UNION;}
-};
-
-// This levelset takes the maximum
-class gLevelsetIntersection : public gLevelsetTools
-{
-public:
- gLevelsetIntersection (std::vector<const gLevelset *> &p) : gLevelsetTools(p) { }
- gLevelsetIntersection(const gLevelsetIntersection &lv):gLevelsetTools(lv) { }
- virtual gLevelset *clone() const { return new gLevelsetIntersection(*this); }
-
- double choose (double d1, double d2) const {
- return (d1 > d2) ? d1 : d2; // greater of d1 and d2
- }
- int type2() const {return INTER;}
-};
-
-// Crack defined by a normal and a tangent levelset
-class gLevelsetCrack : public gLevelsetTools
-{
-public:
- gLevelsetCrack (std::vector<const gLevelset *> &p) {
- if (p.size() != 2)
- printf("Error : gLevelsetCrack needs 2 levelsets\n");
- children.push_back(p[0]);
- children.push_back(new gLevelsetReverse(p[0]));
- if(p[1]) children.push_back(p[1]);
- }
- double choose (double d1, double d2) const {
- return (d1 > d2) ? d1 : d2; // greater of d1 and d2
- }
- int type2() const {return CRACK;}
-};
-
-// --------------------------------------------------------------------------------------------------------------
-// IMPROVED LEVELSET
-class gLevelsetImproved : public gLevelset
-{
-protected:
- gLevelset *Ls;
-public:
- gLevelsetImproved(){}
- gLevelsetImproved(const gLevelsetImproved &lv);
- double operator() (const double &x, const double &y, const double &z) const {return (*Ls)(x, y, z);}
- std::vector<const gLevelset *> getChildren() const { return Ls->getChildren(); }
- double choose (double d1, double d2) const { return Ls->choose(d1, d2); }
- virtual int type() const = 0;
- bool isPrimitive() const {return Ls->isPrimitive();}
-};
-
-class gLevelsetBox : public gLevelsetImproved
-{
-public:
- // create a box with parallel faces : pt is a corner of the box,
- // dir1 is the direction of the first edge starting from pt,
- // dir2 is the direction of the second edge starting from pt,
- // dir3 is the direction of the third edge starting from pt,
- // a is the length of the first edge starting from pt,
- // b is the length of the second edge starting from pt,
- // c is the length of the third edge starting from pt.
- // tags of the faces are : face normal to dir3 and not including pt : tag+0
- // face normal to dir3 and including pt : tag+1
- // face normal to dir2 and including pt : tag+2
- // face normal to dir2 and not including pt : tag+3
- // face normal to dir1 and not including pt : tag+4
- // face normal to dir1 and including pt : tag+5
- gLevelsetBox(const double *pt, const double *dir1, const double *dir2, const double *dir3,
- const double &a, const double &b, const double &c, int tag);
- // create a box with the 8 vertices (pt1,...,pt8).
- // check if the faces are planar.
- // tags of the faces are : face(pt5,pt6,pt7,pt8) : tag+0
- // face(pt1,pt4,pt3,pt2) : tag+1
- // face(pt1,pt2,pt6,pt5) : tag+2
- // face(pt3,pt4,pt8,pt7) : tag+3
- // face(pt2,pt3,pt7,pt6) : tag+4
- // face(pt1,pt5,pt8,pt4) : tag+5
- gLevelsetBox(const double *pt1, const double *pt2, const double *pt3, const double *pt4,
- const double *pt5, const double *pt6, const double *pt7, const double *pt8, int tag);
- gLevelsetBox(const gLevelsetBox &);
- virtual gLevelset * clone() const{return new gLevelsetBox(*this);}
- int type() const {return BOX;}
-};
-
-class gLevelsetCylinder : public gLevelsetImproved
-{
-public:
- // create a cylinder : pt is the point in the middle of the cylinder base,
- // dir is the direction of the cylinder axis,
- // R is the outer radius of the cylinder,
- // H is the height of the cylinder.
- // tags of the faces are : exterior face : tag+0
- // plane face including pt : tag+1
- // plane face opposite to pt : tag+2
- gLevelsetCylinder (const double *pt, const double *dir, const double &R, const double &H, int tag);
- // create a cylinder : pt is the point in the middle of the cylinder base,
- // dir is the direction of the cylinder axis,
- // R is the outer radius of the cylinder,
- // r is the inner radius of the cylinder,
- // H is the height of the cylinder.
- // tags of the faces are : exterior face : tag+0
- // plane face including pt : tag+1
- // plane face opposite to pt : tag+2
- // interior face : tag+3
- gLevelsetCylinder (const double *pt, const double *dir, const double &R, const double &r, const double &H, int tag);
- gLevelsetCylinder(const gLevelsetCylinder &);
- virtual gLevelset * clone() const{return new gLevelsetCylinder(*this);}
- int type() const {return CYLINDER;}
-};
-
-class gLevelsetConrod : public gLevelsetImproved
-{
-public:
- // create a connecting rod : pt is the point in the middle of the first bore,
- // dir1 is the direction of the rod,
- // dir2 is the direction of the axis of the bore,
- // H1 is height of the first cylinder,
- // H2 is the height of the second cylinder,
- // H3 is the height of the rod,
- // R1 is the outer radius of the first cylinder,
- // r1 is the inner radius of the first cylinder,
- // R2 is the outer radius of the second cylinder,
- // r2 is the inner radius of the second cylinder,
- // L1 is the width of the rod in the plane passing through the middle of the first bore,
- // L2 is the width of the rod in the plane passing through the middle of the second bore,
- // E is the distance between the axis of the cylinders.
- // tags of the faces are : bottom face (+dir2) of the bore : tag+2
- // top face (-dir2) of the bore : tag+3
- // rear face (-dir1xdir2) of the bore : tag+4
- // front face (+dir1xdir2) of the bore : tag+5
- // exterior face of the first cylinder : tag+6
- // bottom face of the first cylinder : tag+7
- // top face of the first cylinder : tag+8
- // exterior face of the second cylinder : tag+9
- // bottom face of the second cylinder : tag+10
- // top face of the second cylinder : tag+11
- // interior face of the first cylinder : tag+12
- // interior face of the second cylinder : tag+13
- gLevelsetConrod (const double *pt, const double *dir1, const double *dir2,
- const double &H1, const double &H2, const double &H3,
- const double &R1, const double &r1, const double &R2, const double &r2,
- const double &L1, const double &L2, const double &E, int tag);
- gLevelsetConrod(const gLevelsetConrod &);
- virtual gLevelset * clone() const{return new gLevelsetConrod(*this);}
- int type() const {return CONROD;}
-};
-
-
-#endif
diff --git a/contrib/DiscreteIntegration/Integration3D.h b/contrib/DiscreteIntegration/Integration3D.h
index f8a8afa14d862afcf4cb9964405e5f445d94fc50..c2c338fc077050a45928ae62cdd7e19cb87373d7 100644
--- a/contrib/DiscreteIntegration/Integration3D.h
+++ b/contrib/DiscreteIntegration/Integration3D.h
@@ -6,7 +6,7 @@
#include <set>
#include <map>
#include <cmath>
-#include "DILevelset.h"
+#include "gmshLevelset.h"
// Element type
#define DI_LIN 1
diff --git a/contrib/DiscreteIntegration/recurCut.h b/contrib/DiscreteIntegration/recurCut.h
index 132d333695bc09b42b079e43a9052c4bb8dd4207..aca3b61c4562cdbef859161db71315d208136a5b 100644
--- a/contrib/DiscreteIntegration/recurCut.h
+++ b/contrib/DiscreteIntegration/recurCut.h
@@ -1,7 +1,7 @@
#ifndef _RECUR_H_
#define _RECUR_H_
-#include "DILevelset.h"
+#include "gmshLevelset.h"
#include "Integration3D.h"
class RecurElement
diff --git a/gmshpy/gmshGeo.i b/gmshpy/gmshGeo.i
index a5eb3008a11bc50efe20793132158c699775441a..8d64807c13d22d3bb23769e55f579c2e284e5746 100644
--- a/gmshpy/gmshGeo.i
+++ b/gmshpy/gmshGeo.i
@@ -20,10 +20,7 @@
#include "discreteFace.h"
#include "discreteEdge.h"
#include "discreteVertex.h"
-#ifdef HAVE_DINTEGRATION
#include "gmshLevelset.h"
- #include "DILevelset.h"
-#endif
#include "MElement.h"
#include "MVertex.h"
#include "MTriangle.h"
@@ -81,8 +78,5 @@ namespace std {
%include "SPoint2.h"
%include "SBoundingBox3d.h"
%include "Curvature.h"
-#ifdef HAVE_DINTEGRATION
%include "gmshLevelset.h"
-%include "DILevelset.h"
-#endif