//
#include "StdMeshers_MEFISTO_2D.hxx"
+#include "SMDS_EdgePosition.hxx"
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMESH_Comment.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
-#include "SMESH_subMesh.hxx"
-#include "SMESH_Block.hxx"
#include "SMESH_MesherHelper.hxx"
-#include "SMESH_Comment.hxx"
-
+#include "SMESH_subMesh.hxx"
#include "StdMeshers_FaceSide.hxx"
-#include "StdMeshers_MaxElementArea.hxx"
#include "StdMeshers_LengthFromEdges.hxx"
+#include "StdMeshers_MaxElementArea.hxx"
+#include "StdMeshers_ViscousLayers2D.hxx"
+
+#include "utilities.h"
#include "Rn.h"
#include "aptrte.h"
-#include "SMDS_MeshElement.hxx"
-#include "SMDS_MeshNode.hxx"
-#include "SMDS_EdgePosition.hxx"
-#include "SMDS_FacePosition.hxx"
-
-#include "utilities.h"
-
+#include <BRepGProp.hxx>
#include <BRepTools.hxx>
#include <BRep_Tool.hxx>
+#include <GProp_GProps.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <TopoDS_Wire.hxx>
#include <gp_Pnt2d.hxx>
-#include <BRep_Tool.hxx>
-#include <GProp_GProps.hxx>
-#include <BRepGProp.hxx>
-
using namespace std;
+#ifdef _DEBUG_
+//#define DUMP_POINTS // to print coordinates of MEFISTO input
+#endif
+
//=============================================================================
/*!
*
_shapeType = (1 << TopAbs_FACE);
_compatibleHypothesis.push_back("MaxElementArea");
_compatibleHypothesis.push_back("LengthFromEdges");
+ _compatibleHypothesis.push_back("ViscousLayers2D");
_edgeLength = 0;
_maxElementArea = 0;
_hypMaxElementArea = NULL;
_hypLengthFromEdges = NULL;
- myTool = 0;
+ _helper = 0;
}
//=============================================================================
// helper builds quadratic mesh if necessary
SMESH_MesherHelper helper(aMesh);
- myTool = &helper;
- _quadraticMesh = myTool->IsQuadraticSubMesh(aShape);
- const bool ignoreMediumNodes = _quadraticMesh;
+ _helper = &helper;
+ _quadraticMesh = _helper->IsQuadraticSubMesh(aShape);
+ const bool skipMediumNodes = _quadraticMesh;
+
+ // build viscous layers if required
+ SMESH_ProxyMesh::Ptr proxyMesh = StdMeshers_ViscousLayers2D::Compute( aMesh, F );
+ if ( !proxyMesh )
+ return false;
// get all edges of a face
TError problem;
- TWireVector wires = StdMeshers_FaceSide::GetFaceWires( F, aMesh, ignoreMediumNodes, problem );
+ TWireVector wires =
+ StdMeshers_FaceSide::GetFaceWires( F, aMesh, skipMediumNodes, problem, proxyMesh );
int nbWires = wires.size();
if ( problem && !problem->IsOK() ) return error( problem );
if ( nbWires == 0 ) return error( "Problem in StdMeshers_FaceSide::GetFaceWires()");
TopTools_IndexedDataMapOfShapeListOfShape VWMap;
if ( wires.size() > 1 )
{
- F = TopoDS::Face( myTool->GetSubShape() );
+ F = TopoDS::Face( _helper->GetSubShape() );
TopExp::MapShapesAndAncestors( F, TopAbs_VERTEX, TopAbs_WIRE, VWMap );
int nbVertices = 0;
for ( int iW = 0; iW < wires.size(); ++iW )
case SMDS_TOP_EDGE:
// In order to detect degenerated faces easily, we replace
// nodes on a degenerated edge by node on the vertex of that edge
- if ( myTool->IsDegenShape( uvPt->node->getshapeId() ))
+ if ( _helper->IsDegenShape( uvPt->node->getshapeId() ))
{
int edgeID = uvPt->node->getshapeId();
- SMESH_subMesh* edgeSM = myTool->GetMesh()->GetSubMeshContaining( edgeID );
+ SMESH_subMesh* edgeSM = _helper->GetMesh()->GetSubMeshContaining( edgeID );
SMESH_subMeshIteratorPtr smIt = edgeSM->getDependsOnIterator( /*includeSelf=*/0,
/*complexShapeFirst=*/0);
if ( smIt->more() )
if ( iW && !VWMap.IsEmpty()) { // except outer wire
// avoid passing same uv point for a vertex common to 2 wires
int vID = mefistoToDS[m]->getshapeId();
- TopoDS_Vertex V = TopoDS::Vertex( myTool->GetMeshDS()->IndexToShape( vID ));
- if ( fixCommonVertexUV( uvslf[m], V, F, VWMap, *myTool->GetMesh(),
+ TopoDS_Vertex V = TopoDS::Vertex( _helper->GetMeshDS()->IndexToShape( vID ));
+ if ( fixCommonVertexUV( uvslf[m], V, F, VWMap, *_helper->GetMesh(),
scalex, scaley, _quadraticMesh )) {
myNodesOnCommonV.push_back( mefistoToDS[m] );
continue;
fixOverlappedLinkUV (uvslf[ mB ], uvslf[ m ], uvslf[ mA ]);
}
}
-// cout << "MEFISTO INPUT************" << endl;
-// for ( int i =0; i < m; ++i )
-// cout << i << ": \t" << uvslf[i].x << ", " << uvslf[i].y << " Node " << mefistoToDS[i]->GetID()<< endl;
+
+#ifdef DUMP_POINTS
+ cout << "MEFISTO INPUT************" << endl;
+ for ( int i =0; i < m; ++i )
+ cout << i << ": \t" << uvslf[i].x << ", " << uvslf[i].y
+ << " Node " << mefistoToDS[i]->GetID()<< endl;
+#endif
return true;
}
vector< const SMDS_MeshNode*>&mefistoToDS,
double scalex, double scaley)
{
- SMESHDS_Mesh * meshDS = myTool->GetMeshDS();
- int faceID = myTool->GetSubShapeID();
+ SMESHDS_Mesh * meshDS = _helper->GetMeshDS();
+ int faceID = _helper->GetSubShapeID();
- TopoDS_Face F = TopoDS::Face( myTool->GetSubShape() );
+ TopoDS_Face F = TopoDS::Face( _helper->GetSubShape() );
Handle(Geom_Surface) S = BRep_Tool::Surface( F );
Z n = mefistoToDS.size(); // nb input points
const SMDS_MeshNode * n3 = mefistoToDS[ nust[m++] - 1 ];
// avoid creating degenetrated faces
- bool isDegen = ( myTool->HasDegeneratedEdges() && ( n1 == n2 || n1 == n3 || n2 == n3 ));
+ bool isDegen = ( _helper->HasDegeneratedEdges() && ( n1 == n2 || n1 == n3 || n2 == n3 ));
if ( !isDegen )
{
SMDS_MeshElement * elt;
if (triangleIsWellOriented)
- elt = myTool->AddFace(n1, n2, n3);
+ elt = _helper->AddFace(n1, n2, n3);
else
- elt = myTool->AddFace(n1, n3, n2);
+ elt = _helper->AddFace(n1, n3, n2);
meshDS->SetMeshElementOnShape(elt, faceID);
}
m++;
std::list<const SMDS_MeshNode*> myNodesOnCommonV;
- SMESH_MesherHelper* myTool; // tool for working with quadratic elements
+ SMESH_MesherHelper* _helper; // tool for working with quadratic elements
};
#endif
#include "StdMeshers_Quadrangle_2D.hxx"
-#include "StdMeshers_FaceSide.hxx"
-
-#include "StdMeshers_QuadrangleParams.hxx"
-
+#include "SMDS_EdgePosition.hxx"
+#include "SMDS_FacePosition.hxx"
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMESH_Block.hxx"
+#include "SMESH_Comment.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
-#include "SMESH_subMesh.hxx"
#include "SMESH_MesherHelper.hxx"
-#include "SMESH_Block.hxx"
-#include "SMESH_Comment.hxx"
-
-#include "SMDS_MeshElement.hxx"
-#include "SMDS_MeshNode.hxx"
-#include "SMDS_EdgePosition.hxx"
-#include "SMDS_FacePosition.hxx"
+#include "SMESH_subMesh.hxx"
+#include "StdMeshers_FaceSide.hxx"
+#include "StdMeshers_QuadrangleParams.hxx"
+#include "StdMeshers_ViscousLayers2D.hxx"
#include <BRep_Tool.hxx>
#include <Geom_Surface.hxx>
StdMeshers_Quadrangle_2D::StdMeshers_Quadrangle_2D (int hypId, int studyId,
SMESH_Gen* gen)
- : SMESH_2D_Algo(hypId, studyId, gen)
+ : SMESH_2D_Algo(hypId, studyId, gen),
+ myHelper( 0 )
{
MESSAGE("StdMeshers_Quadrangle_2D::StdMeshers_Quadrangle_2D");
_name = "Quadrangle_2D";
_compatibleHypothesis.push_back("QuadrangleParams");
_compatibleHypothesis.push_back("QuadranglePreference");
_compatibleHypothesis.push_back("TrianglePreference");
- myHelper = 0;
+ _compatibleHypothesis.push_back("ViscousLayers2D");
}
//=============================================================================
*/
//=============================================================================
-bool StdMeshers_Quadrangle_2D::Compute (SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape)// throw (SALOME_Exception)
+bool StdMeshers_Quadrangle_2D::Compute (SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape)
{
- // PAL14921. Enable catching std::bad_alloc and Standard_OutOfMemory outside
- //Unexpect aCatchSalomeException);
+ const TopoDS_Face& F = TopoDS::Face(aShape);
+ Handle(Geom_Surface) S = BRep_Tool::Surface(F);
SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
aMesh.GetSubMesh(aShape);
SMESH_MesherHelper helper (aMesh);
myHelper = &helper;
+ myProxyMesh = StdMeshers_ViscousLayers2D::Compute( aMesh, F );
+ if ( !myProxyMesh )
+ return false;
+
_quadraticMesh = myHelper->IsQuadraticSubMesh(aShape);
myNeedSmooth = false;
int nbhoriz = Min(nbdown, nbup);
int nbvertic = Min(nbright, nbleft);
- const TopoDS_Face& F = TopoDS::Face(aShape);
- Handle(Geom_Surface) S = BRep_Tool::Surface(F);
-
// internal mesh nodes
int i, j, geomFaceID = meshDS->ShapeToIndex(F);
for (i = 1; i < nbhoriz - 1; i++) {
for (i = ilow; i < iup; i++) {
for (j = jlow; j < jup; j++) {
const SMDS_MeshNode *a, *b, *c, *d;
- a = quad->uv_grid[j * nbhoriz + i].node;
- b = quad->uv_grid[j * nbhoriz + i + 1].node;
+ a = quad->uv_grid[j * nbhoriz + i ].node;
+ b = quad->uv_grid[j * nbhoriz + i + 1].node;
c = quad->uv_grid[(j + 1) * nbhoriz + i + 1].node;
- d = quad->uv_grid[(j + 1) * nbhoriz + i].node;
+ d = quad->uv_grid[(j + 1) * nbhoriz + i ].node;
SMDS_MeshFace* face = myHelper->AddFace(a, b, c, d);
if (face) {
meshDS->SetMeshElementOnShape(face, geomFaceID);
}
if (!E1.IsNull() && !E2.IsNull() && !E3.IsNull())
{
- quad->side.push_back(new StdMeshers_FaceSide(F, E1, &aMesh, true, ignoreMediumNodes));
- quad->side.push_back(new StdMeshers_FaceSide(F, E2, &aMesh, true, ignoreMediumNodes));
- quad->side.push_back(new StdMeshers_FaceSide(F, E3, &aMesh, false,ignoreMediumNodes));
+ if ( myProxyMesh->GetProxySubMesh( E1 ) ||
+ myProxyMesh->GetProxySubMesh( E2 ) ||
+ myProxyMesh->GetProxySubMesh( E3 ) )
+
+ quad->side.push_back(new StdMeshers_FaceSide(F, E1, &aMesh, true,
+ ignoreMediumNodes, myProxyMesh));
+ quad->side.push_back(new StdMeshers_FaceSide(F, E2, &aMesh, true,
+ ignoreMediumNodes, myProxyMesh));
+ quad->side.push_back(new StdMeshers_FaceSide(F, E3, &aMesh, false,
+ ignoreMediumNodes, myProxyMesh));
const vector<UVPtStruct>& UVPSleft = quad->side[0]->GetUVPtStruct(true,0);
/* vector<UVPtStruct>& UVPStop = */quad->side[1]->GetUVPtStruct(false,1);
/* vector<UVPtStruct>& UVPSright = */quad->side[2]->GetUVPtStruct(true,1);
else if (nbEdgesInWire.front() == 4) // exactly 4 edges
{
for (; edgeIt != edges.end(); ++edgeIt, nbSides++)
- quad->side.push_back(new StdMeshers_FaceSide(F, *edgeIt, &aMesh,
- nbSides<TOP_SIDE, ignoreMediumNodes));
+ quad->side.push_back(new StdMeshers_FaceSide(F, *edgeIt, &aMesh, nbSides < TOP_SIDE,
+ ignoreMediumNodes, myProxyMesh));
}
else if (nbEdgesInWire.front() > 4) // more than 4 edges - try to unite some
{
if ( sideEdges.size() == 1 && BRep_Tool::Degenerated( sideEdges.front() ))
degenSides.push_back( nbSides );
- quad->side.push_back(new StdMeshers_FaceSide(F, sideEdges, &aMesh,
- nbSides<TOP_SIDE, ignoreMediumNodes));
+ quad->side.push_back(new StdMeshers_FaceSide(F, sideEdges, &aMesh, nbSides < TOP_SIDE,
+ ignoreMediumNodes, myProxyMesh));
++nbSides;
}
if ( !degenSides.empty() && nbSides - degenSides.size() == 4 )
}
}
quad->side.push_back(new StdMeshers_FaceSide(F, sideEdges, &aMesh,
- nbSides<TOP_SIDE, ignoreMediumNodes));
+ nbSides < TOP_SIDE,
+ ignoreMediumNodes, myProxyMesh));
++nbSides;
}
}
if ( myNeedSmooth )
UpdateDegenUV( quad );
- // nodes Id on "in" edges
- if (! quad->isEdgeOut[0]) {
- int j = 0;
- for (int i = 0; i < nbhoriz; i++) { // down
- int ij = j * nbhoriz + i;
- uv_grid[ij].node = uv_e0[i].node;
- }
+ // copy data of face boundary
+ /*if (! quad->isEdgeOut[0])*/ {
+ const int j = 0;
+ for (int i = 0; i < nbhoriz; i++) // down
+ uv_grid[ j * nbhoriz + i ] = uv_e0[i];
}
- if (! quad->isEdgeOut[1]) {
- int i = nbhoriz - 1;
- for (int j = 0; j < nbvertic; j++) { // right
- int ij = j * nbhoriz + i;
- uv_grid[ij].node = uv_e1[j].node;
- }
+ /*if (! quad->isEdgeOut[1])*/ {
+ const int i = nbhoriz - 1;
+ for (int j = 0; j < nbvertic; j++) // right
+ uv_grid[ j * nbhoriz + i ] = uv_e1[j];
}
- if (! quad->isEdgeOut[2]) {
- int j = nbvertic - 1;
- for (int i = 0; i < nbhoriz; i++) { // up
- int ij = j * nbhoriz + i;
- uv_grid[ij].node = uv_e2[i].node;
- }
+ /*if (! quad->isEdgeOut[2])*/ {
+ const int j = nbvertic - 1;
+ for (int i = 0; i < nbhoriz; i++) // up
+ uv_grid[ j * nbhoriz + i ] = uv_e2[i];
}
- if (! quad->isEdgeOut[3]) {
+ /*if (! quad->isEdgeOut[3])*/ {
int i = 0;
- for (int j = 0; j < nbvertic; j++) { // left
- int ij = j * nbhoriz + i;
- uv_grid[ij].node = uv_e3[j].node;
- }
+ for (int j = 0; j < nbvertic; j++) // left
+ uv_grid[ j * nbhoriz + i ] = uv_e3[j];
}
- // normalized 2d values on grid
+ // normalized 2d parameters on grid
for (int i = 0; i < nbhoriz; i++) {
for (int j = 0; j < nbvertic; j++) {
int ij = j * nbhoriz + i;
}
// 4 --- projection on 2d domain (u,v)
- gp_UV a0(uv_e0.front().u, uv_e0.front().v);
- gp_UV a1(uv_e0.back().u, uv_e0.back().v);
- gp_UV a2(uv_e2.back().u, uv_e2.back().v);
- gp_UV a3(uv_e2.front().u, uv_e2.front().v);
+ gp_UV a0 (uv_e0.front().u, uv_e0.front().v);
+ gp_UV a1 (uv_e0.back().u, uv_e0.back().v );
+ gp_UV a2 (uv_e2.back().u, uv_e2.back().v );
+ gp_UV a3 (uv_e2.front().u, uv_e2.front().v);
+
+ for (int i = 0; i < nbhoriz; i++)
+ {
+ gp_UV p0( uv_e0[i].u, uv_e0[i].v );
+ gp_UV p2( uv_e2[i].u, uv_e2[i].v );
+ for (int j = 0; j < nbvertic; j++)
+ {
+ gp_UV p1( uv_e1[j].u, uv_e1[j].v );
+ gp_UV p3( uv_e3[j].u, uv_e3[j].v );
- for (int i = 0; i < nbhoriz; i++) {
- for (int j = 0; j < nbvertic; j++) {
int ij = j * nbhoriz + i;
double x = uv_grid[ij].x;
double y = uv_grid[ij].y;
- double param_0 = uv_e0[0].normParam + x * (uv_e0.back().normParam - uv_e0[0].normParam); // sud
- double param_2 = uv_e2[0].normParam + x * (uv_e2.back().normParam - uv_e2[0].normParam); // nord
- double param_1 = uv_e1[0].normParam + y * (uv_e1.back().normParam - uv_e1[0].normParam); // est
- double param_3 = uv_e3[0].normParam + y * (uv_e3.back().normParam - uv_e3[0].normParam); // ouest
-
- //MESSAGE("params "<<param_0<<" "<<param_1<<" "<<param_2<<" "<<param_3);
- gp_UV p0 = quad->side[0]->Value2d(param_0).XY();
- gp_UV p1 = quad->side[1]->Value2d(param_1).XY();
- gp_UV p2 = quad->side[2]->Value2d(param_2).XY();
- gp_UV p3 = quad->side[3]->Value2d(param_3).XY();
gp_UV uv = CalcUV(x,y, a0,a1,a2,a3, p0,p1,p2,p3);
static void ShiftQuad(FaceQuadStruct* quad, const int num, bool)
{
- StdMeshers_FaceSide* side[4] = { quad->side[0], quad->side[1], quad->side[2], quad->side[3] };
+ StdMeshers_FaceSide* side[4] = { quad->side[0], quad->side[1],
+ quad->side[2], quad->side[3] };
for (int i = BOTTOM_SIDE; i < NB_SIDES; ++i) {
int id = (i + num) % NB_SIDES;
bool wasForward = (i < TOP_SIDE);
const gp_UV& a0, const gp_UV& a1,
const gp_UV& a2, const gp_UV& a3)
{
- const vector<UVPtStruct>& uv_eb = quad->side[0]->GetUVPtStruct(true,0);
- const vector<UVPtStruct>& uv_er = quad->side[1]->GetUVPtStruct(false,1);
- const vector<UVPtStruct>& uv_et = quad->side[2]->GetUVPtStruct(true,1);
- const vector<UVPtStruct>& uv_el = quad->side[3]->GetUVPtStruct(false,0);
+ // const vector<UVPtStruct>& uv_eb = quad->side[0]->GetUVPtStruct(true,0);
+ // const vector<UVPtStruct>& uv_er = quad->side[1]->GetUVPtStruct(false,1);
+ // const vector<UVPtStruct>& uv_et = quad->side[2]->GetUVPtStruct(true,1);
+ // const vector<UVPtStruct>& uv_el = quad->side[3]->GetUVPtStruct(false,0);
double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
double y = y0 + x * (y1 - y0);
- double param_b = uv_eb[0].normParam + x * (uv_eb.back().normParam - uv_eb[0].normParam);
- double param_t = uv_et[0].normParam + x * (uv_et.back().normParam - uv_et[0].normParam);
- double param_r = uv_er[0].normParam + y * (uv_er.back().normParam - uv_er[0].normParam);
- double param_l = uv_el[0].normParam + y * (uv_el.back().normParam - uv_el[0].normParam);
-
- gp_UV p0 = quad->side[BOTTOM_SIDE]->Value2d(param_b).XY();
- gp_UV p1 = quad->side[RIGHT_SIDE ]->Value2d(param_r).XY();
- gp_UV p2 = quad->side[TOP_SIDE ]->Value2d(param_t).XY();
- gp_UV p3 = quad->side[LEFT_SIDE ]->Value2d(param_l).XY();
+ gp_UV p0 = quad->side[BOTTOM_SIDE]->Value2d(x).XY();
+ gp_UV p1 = quad->side[RIGHT_SIDE ]->Value2d(y).XY();
+ gp_UV p2 = quad->side[TOP_SIDE ]->Value2d(x).XY();
+ gp_UV p3 = quad->side[LEFT_SIDE ]->Value2d(y).XY();
gp_UV uv = CalcUV(x,y, a0,a1,a2,a3, p0,p1,p2,p3);
#ifndef _SMESH_QUADRANGLE_2D_HXX_
#define _SMESH_QUADRANGLE_2D_HXX_
+#include "SMESH_Algo.hxx"
+#include "SMESH_ProxyMesh.hxx"
#include "SMESH_StdMeshers.hxx"
-
#include "StdMeshers_QuadrangleParams.hxx"
-#include "SMESH_Algo.hxx"
-#include "Utils_SALOME_Exception.hxx"
-
#include <TopoDS_Face.hxx>
+class SMDS_MeshNode;
class SMESH_Mesh;
class SMESH_MesherHelper;
+class SMESH_ProxyMesh;
class StdMeshers_FaceSide;
-class SMDS_MeshNode;
struct uvPtStruct;
bool myTrianglePreference;
- int myTriaVertexID;
+ int myTriaVertexID;
+
+ bool myNeedSmooth;
- StdMeshers_QuadType myQuadType;
+ StdMeshers_QuadType myQuadType;
- SMESH_MesherHelper* myHelper; // tool for working with quadratic elements
+ SMESH_MesherHelper* myHelper; // tool for working with quadratic elements
- bool myNeedSmooth;
+ SMESH_ProxyMesh::Ptr myProxyMesh;
};
#endif
using namespace std;
//================================================================================
-namespace VISCOUS
+namespace VISCOUS_3D
{
typedef int TGeomID;
* \brief Listener of events of 3D sub-meshes computed with viscous layers.
* It is used to clear an inferior dim sub-meshes modified by viscous layers
*/
- class _SrinkShapeListener : SMESH_subMeshEventListener
+ class _ShrinkShapeListener : SMESH_subMeshEventListener
{
- _SrinkShapeListener()
+ _ShrinkShapeListener()
: SMESH_subMeshEventListener(/*isDeletable=*/false,
- "StdMeshers_ViscousLayers::_SrinkShapeListener") {}
- static SMESH_subMeshEventListener* Get() { static _SrinkShapeListener l; return &l; }
+ "StdMeshers_ViscousLayers::_ShrinkShapeListener") {}
public:
+ static SMESH_subMeshEventListener* Get() { static _ShrinkShapeListener l; return &l; }
virtual void ProcessEvent(const int event,
const int eventType,
SMESH_subMesh* solidSM,
SMESH_subMeshEventListener::ProcessEvent(event,eventType,solidSM,data,hyp);
}
}
- static void ToClearSubMeshWithSolid( SMESH_subMesh* sm,
- const TopoDS_Shape& solid)
- {
- SMESH_subMesh* solidSM = sm->GetFather()->GetSubMesh( solid );
- SMESH_subMeshEventListenerData* data = solidSM->GetEventListenerData( Get());
- if ( data )
- {
- if ( find( data->mySubMeshes.begin(), data->mySubMeshes.end(), sm ) ==
- data->mySubMeshes.end())
- data->mySubMeshes.push_back( sm );
- }
- else
- {
- data = SMESH_subMeshEventListenerData::MakeData( /*dependent=*/sm );
- sm->SetEventListener( Get(), data, /*whereToListenTo=*/solidSM );
- }
- }
};
//--------------------------------------------------------------------------------
/*!
}
};
+ //================================================================================
+ /*!
+ * \brief sets a sub-mesh event listener to clear sub-meshes of sub-shapes of
+ * the main shape when sub-mesh of the main shape is cleared,
+ * for example to clear sub-meshes of FACEs when sub-mesh of a SOLID
+ * is cleared
+ */
+ //================================================================================
+
+ void ToClearSubWithMain( SMESH_subMesh* sub, const TopoDS_Shape& main)
+ {
+ SMESH_subMesh* mainSM = sub->GetFather()->GetSubMesh( main );
+ SMESH_subMeshEventListenerData* data =
+ mainSM->GetEventListenerData( _ShrinkShapeListener::Get());
+ if ( data )
+ {
+ if ( find( data->mySubMeshes.begin(), data->mySubMeshes.end(), sub ) ==
+ data->mySubMeshes.end())
+ data->mySubMeshes.push_back( sub );
+ }
+ else
+ {
+ data = SMESH_subMeshEventListenerData::MakeData( /*dependent=*/sub );
+ sub->SetEventListener( _ShrinkShapeListener::Get(), data, /*whereToListenTo=*/mainSM );
+ }
+ }
//--------------------------------------------------------------------------------
/*!
* \brief Simplex (triangle or tetrahedron) based on 1 (tria) or 2 (tet) nodes of
_nn[3]=_le2->_nodes[0];
}
};
-} // namespace VISCOUS
+} // namespace VISCOUS_3D
//================================================================================
// StdMeshers_ViscousLayers hypothesis
_name = StdMeshers_ViscousLayers::GetHypType();
_param_algo_dim = -3; // auxiliary hyp used by 3D algos
} // --------------------------------------------------------------------------------
-void StdMeshers_ViscousLayers::SetIgnoreFaces(const std::vector<int>& faceIds)
+void StdMeshers_ViscousLayers::SetBndShapesToIgnore(const std::vector<int>& faceIds)
+{
+ if ( faceIds != _ignoreBndShapeIds )
+ _ignoreBndShapeIds = faceIds, NotifySubMeshesHypothesisModification();
+} // --------------------------------------------------------------------------------
+bool StdMeshers_ViscousLayers::IsIgnoredShape(const int shapeID) const
{
- if ( faceIds != _ignoreFaceIds )
- _ignoreFaceIds = faceIds, NotifySubMeshesHypothesisModification();
+ return ( find( _ignoreBndShapeIds.begin(), _ignoreBndShapeIds.end(), shapeID )
+ != _ignoreBndShapeIds.end() );
} // --------------------------------------------------------------------------------
void StdMeshers_ViscousLayers::SetTotalThickness(double thickness)
{
const TopoDS_Shape& theShape,
const bool toMakeN2NMap) const
{
- using namespace VISCOUS;
+ using namespace VISCOUS_3D;
_ViscousBuilder bulder;
SMESH_ComputeErrorPtr err = bulder.Compute( theMesh, theShape );
if ( err && !err->IsOK() )
save << " " << _nbLayers
<< " " << _thickness
<< " " << _stretchFactor
- << " " << _ignoreFaceIds.size();
- for ( unsigned i = 0; i < _ignoreFaceIds.size(); ++i )
- save << " " << _ignoreFaceIds[i];
+ << " " << _ignoreBndShapeIds.size();
+ for ( unsigned i = 0; i < _ignoreBndShapeIds.size(); ++i )
+ save << " " << _ignoreBndShapeIds[i];
return save;
} // --------------------------------------------------------------------------------
std::istream & StdMeshers_ViscousLayers::LoadFrom(std::istream & load)
{
int nbFaces, faceID;
load >> _nbLayers >> _thickness >> _stretchFactor >> nbFaces;
- while ( _ignoreFaceIds.size() < nbFaces && load >> faceID )
- _ignoreFaceIds.push_back( faceID );
+ while ( _ignoreBndShapeIds.size() < nbFaces && load >> faceID )
+ _ignoreBndShapeIds.push_back( faceID );
return load;
} // --------------------------------------------------------------------------------
bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh* theMesh,
#endif
}
-using namespace VISCOUS;
+using namespace VISCOUS_3D;
//================================================================================
/*!
vector<TopoDS_Shape> ignoreFaces;
for ( unsigned i = 0; i < _sdVec.size(); ++i )
{
- vector<TGeomID> ids = _sdVec[i]._hyp->GetIgnoreFaces();
+ vector<TGeomID> ids = _sdVec[i]._hyp->GetBndShapesToIgnore();
for ( unsigned i = 0; i < ids.size(); ++i )
{
const TopoDS_Shape& s = getMeshDS()->IndexToShape( ids[i] );
_Shrinker1D& srinker = e2shrMap[ edgeIndex ];
eShri1D.insert( & srinker );
srinker.AddEdge( edge, helper );
+ VISCOUS_3D::ToClearSubWithMain( _mesh->GetSubMesh( edge->_sWOL ), data._solid );
// restore params of nodes on EGDE if the EDGE has been already
// srinked while srinking another FACE
srinker.RestoreParams();
dumpFunctionEnd();
}
// Set an event listener to clear FACE sub-mesh together with SOLID sub-mesh
- _SrinkShapeListener::ToClearSubMeshWithSolid( sm, data._solid );
+ VISCOUS_3D::ToClearSubWithMain( sm, data._solid );
if ( !getMeshDS()->IsEmbeddedMode() )
// Log node movement
public:
StdMeshers_ViscousLayers(int hypId, int studyId, SMESH_Gen* gen);
- // Set faces to exclude from treatment
- void SetIgnoreFaces(const std::vector<int>& faceIds);
- std::vector<int> GetIgnoreFaces() const { return _ignoreFaceIds; }
+ // Set boundary shapes to exclude from treatment, faces in 3D, edges in 2D
+ void SetBndShapesToIgnore(const std::vector<int>& shapeIds);
+ std::vector<int> GetBndShapesToIgnore() const { return _ignoreBndShapeIds; }
+ bool IsIgnoredShape(const int shapeID) const;
// Set total thickness of layers of prisms
void SetTotalThickness(double thickness);
private:
- std::vector<int> _ignoreFaceIds;
+ std::vector<int> _ignoreBndShapeIds;
int _nbLayers;
double _thickness;
double _stretchFactor;
};
+class SMESH_subMesh;
+namespace VISCOUS_3D
+{
+ // sets a sub-mesh event listener to clear sub-meshes of sub-shapes of
+ // the main shape when sub-mesh of the main shape is cleared,
+ // for example to clear sub-meshes of FACEs when sub-mesh of a SOLID
+ // is cleared
+ void ToClearSubWithMain( SMESH_subMesh* sub, const TopoDS_Shape& main);
+}
+
#endif
h->SetIgnoreFaces( idsWg->GetListOfIDs() );
}
}
+ else if( hypType()=="ViscousLayers2D" )
+ {
+ StdMeshers::StdMeshers_ViscousLayers2D_var h =
+ StdMeshers::StdMeshers_ViscousLayers2D::_narrow( hypothesis() );
+
+ h->SetVarParameter( params[0].text(), "SetTotalThickness" );
+ h->SetTotalThickness( params[0].myValue.toDouble() );
+ h->SetVarParameter( params[1].text(), "SetNumberLayers" );
+ h->SetNumberLayers ( params[1].myValue.toInt() );
+ h->SetVarParameter( params[2].text(), "SetStretchFactor" );
+ h->SetStretchFactor ( params[2].myValue.toDouble() );
+
+ if ( StdMeshersGUI_SubShapeSelectorWdg* idsWg =
+ widget< StdMeshersGUI_SubShapeSelectorWdg >( 3 ))
+ {
+ h->SetIgnoreEdges( idsWg->GetListOfIDs() );
+ }
+ }
else if( hypType()=="QuadrangleParams" )
{
StdMeshers::StdMeshers_QuadrangleParams_var h =
customWidgets()->append ( idsWg );
}
}
+ else if( hypType()=="ViscousLayers2D" )
+ {
+ StdMeshers::StdMeshers_ViscousLayers2D_var h =
+ StdMeshers::StdMeshers_ViscousLayers2D::_narrow( hyp );
+
+ item.myName = tr( "SMESH_TOTAL_THICKNESS" );
+ if(!initVariableName( hyp, item, "SetTotalThickness" ))
+ item.myValue = h->GetTotalThickness();
+ p.append( item );
+ customWidgets()->append (0);
+
+ item.myName = tr( "SMESH_NUMBER_OF_LAYERS" );
+ if(!initVariableName( hyp, item, "SetNumberLayers" ))
+ item.myValue = h->GetNumberLayers();
+ p.append( item );
+ customWidgets()->append (0);
+
+ item.myName = tr( "SMESH_STRETCH_FACTOR" );
+ if(!initVariableName( hyp, item, "SetStretchFactor" ))
+ item.myValue = h->GetStretchFactor();
+ p.append( item );
+ customWidgets()->append (0);
+
+ QString aMainEntry = SMESHGUI_GenericHypothesisCreator::getMainShapeEntry();
+ if ( !aMainEntry.isEmpty() )
+ {
+ item.myName = tr( "SMESH_EDGES_WO_LAYERS" );
+ p.append( item );
+
+ StdMeshersGUI_SubShapeSelectorWdg* idsWg =
+ new StdMeshersGUI_SubShapeSelectorWdg(0,TopAbs_EDGE);
+
+ idsWg->SetGeomShapeEntry( aMainEntry );
+ idsWg->SetMainShapeEntry( aMainEntry );
+ idsWg->SetListOfIDs( h->GetIgnoreEdges() );
+ idsWg->showPreview( true );
+ customWidgets()->append ( idsWg );
+ }
+ }
else if (hypType() == "QuadrangleParams")
{
StdMeshers::StdMeshers_QuadrangleParams_var h =
{
sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "parametric_precision" );
}
- else if( hypType()=="ViscousLayers" )
+ else if( hypType().startsWith( "ViscousLayers" ))
{
if (sb->objectName() == tr("SMESH_STRETCH_FACTOR"))
sb->RangeStepAndValidator( 1.0, VALUE_MAX, 0.1, "parametric_precision" );
sb->RangeStepAndValidator( VALUE_SMALL, VALUE_MAX, 1.0, "length_precision" );
}
}
-// else if ( QtxIntSpinBox* ib = w->inherits( "QtxIntSpinBox" ) ? ( QtxIntSpinBox* )w : 0)
-// {
-// if( hypType()=="ViscousLayers" )
-// {
-// }
-// }
}
//================================================================================
types.insert( "SegmentLengthAroundVertex", "SEGMENT_LENGTH_AROUND_VERTEX" );
types.insert( "MaxLength", "MAX_LENGTH" );
types.insert( "ViscousLayers", "VISCOUS_LAYERS" );
+ types.insert( "ViscousLayers2D", "VISCOUS_LAYERS" );
types.insert( "QuadrangleParams", "QUADRANGLE_PARAMS" );
types.insert( "CartesianParameters3D", "CARTESIAN_PARAMS" );
}
<message>
<source>SMESH_FACES_WO_LAYERS</source>
<translation>Faces without layers
+(inlets and oulets)</translation>
+ </message>
+ <message>
+ <source>SMESH_EDGES_WO_LAYERS</source>
+ <translation>Edges without layers
(inlets and oulets)</translation>
</message>
<message>
StdMeshers_Import_1D_i.hxx \
StdMeshers_Import_1D2D_i.hxx \
StdMeshers_ViscousLayers_i.hxx \
+ StdMeshers_ViscousLayers2D_i.hxx \
StdMeshers_CartesianParameters3D_i.hxx \
StdMeshers_Cartesian_3D_i.hxx
StdMeshers_Import_1D_i.cxx \
StdMeshers_Import_1D2D_i.cxx \
StdMeshers_ViscousLayers_i.cxx \
+ StdMeshers_ViscousLayers2D_i.cxx \
StdMeshers_CartesianParameters3D_i.cxx \
StdMeshers_Cartesian_3D_i.cxx
--- /dev/null
+// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : StdMeshers_ViscousLayers2D_i.cxx
+// Module : SMESH
+//
+#include "StdMeshers_ViscousLayers2D_i.hxx"
+
+#include "SMESH_Gen.hxx"
+#include "SMESH_Gen_i.hxx"
+#include "SMESH_PythonDump.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+#include <TCollection_AsciiString.hxx>
+
+#include CORBA_SERVER_HEADER(SMESH_Group)
+
+using namespace std;
+
+//=============================================================================
+/*!
+ * StdMeshers_ViscousLayers2D_i::StdMeshers_ViscousLayers2D_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_ViscousLayers2D_i::StdMeshers_ViscousLayers2D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ MESSAGE( "StdMeshers_ViscousLayers2D_i::StdMeshers_ViscousLayers2D_i" );
+ myBaseImpl = new ::StdMeshers_ViscousLayers2D( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_ViscousLayers2D_i::~StdMeshers_ViscousLayers2D_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_ViscousLayers2D_i::~StdMeshers_ViscousLayers2D_i()
+{
+ MESSAGE( "StdMeshers_ViscousLayers2D_i::~StdMeshers_ViscousLayers2D_i" );
+}
+
+//================================================================================
+/*!
+ * \brief
+ */
+//================================================================================
+
+void StdMeshers_ViscousLayers2D_i::SetIgnoreEdges(const ::SMESH::long_array& edgeIDs)
+throw ( SALOME::SALOME_Exception )
+{
+ vector<int> ids( edgeIDs.length() );
+ for ( unsigned i = 0; i < ids.size(); ++i )
+ if (( ids[i] = edgeIDs[i] ) < 1 )
+ THROW_SALOME_CORBA_EXCEPTION( "Invalid edge id", SALOME::BAD_PARAM );
+ GetImpl()->SetBndShapesToIgnore( ids );
+ SMESH::TPythonDump() << _this() << ".SetIgnoreEdges( " << edgeIDs << " )";
+}
+
+//================================================================================
+/*!
+ * \brief
+ */
+//================================================================================
+
+SMESH::long_array* StdMeshers_ViscousLayers2D_i::GetIgnoreEdges()
+{
+ vector<int> idsVec = GetImpl()->GetBndShapesToIgnore();
+ SMESH::long_array_var ids = new SMESH::long_array;
+ ids->length( idsVec.size() );
+ for ( unsigned i = 0; i < idsVec.size(); ++i )
+ ids[i] = idsVec[i];
+ return ids._retn();
+}
+
+//================================================================================
+/*!
+ * \brief
+ */
+//================================================================================
+
+void StdMeshers_ViscousLayers2D_i::SetTotalThickness(::CORBA::Double thickness)
+throw ( SALOME::SALOME_Exception )
+{
+ if ( thickness < 1e-100 )
+ THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
+ GetImpl()->SetTotalThickness(thickness);
+ SMESH::TPythonDump() << _this() << ".SetTotalThickness( " << SMESH::TVar(thickness) << " )";
+}
+
+//================================================================================
+/*!
+ * \brief
+ */
+//================================================================================
+
+::CORBA::Double StdMeshers_ViscousLayers2D_i::GetTotalThickness()
+{
+ return GetImpl()->GetTotalThickness();
+}
+
+//================================================================================
+/*!
+ * \brief
+ * \param nb -
+ */
+//================================================================================
+
+void StdMeshers_ViscousLayers2D_i::SetNumberLayers(::CORBA::Short nb)
+throw ( SALOME::SALOME_Exception )
+{
+ if ( nb < 1 )
+ THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
+ GetImpl()->SetNumberLayers( nb );
+ SMESH::TPythonDump() << _this() << ".SetNumberLayers( " << SMESH::TVar(nb) << " )";
+}
+
+//================================================================================
+/*!
+ * \brief
+ */
+//================================================================================
+
+::CORBA::Short StdMeshers_ViscousLayers2D_i::GetNumberLayers()
+{
+ return CORBA::Short( GetImpl()->GetNumberLayers() );
+}
+
+//================================================================================
+/*!
+ * \brief
+ * \param factor -
+ */
+//================================================================================
+
+void StdMeshers_ViscousLayers2D_i::SetStretchFactor(::CORBA::Double factor)
+throw ( SALOME::SALOME_Exception )
+{
+ if ( factor < 1 )
+ THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );
+ GetImpl()->SetStretchFactor(factor);
+ SMESH::TPythonDump() << _this() << ".SetStretchFactor( " << SMESH::TVar(factor) << " )";
+}
+
+//================================================================================
+/*!
+ * \brief
+ *
+ */
+//================================================================================
+
+::CORBA::Double StdMeshers_ViscousLayers2D_i::GetStretchFactor()
+{
+ return GetImpl()->GetStretchFactor();
+}
+
+//=============================================================================
+/*!
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_ViscousLayers2D* StdMeshers_ViscousLayers2D_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_ViscousLayers2D_i::GetImpl" );
+ return ( ::StdMeshers_ViscousLayers2D* )myBaseImpl;
+}
+
+//================================================================================
+/*!
+ * \brief Verify whether hypothesis supports given entity type
+ * \param type - dimension (see SMESH::Dimension enumeration)
+ * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
+ *
+ * Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
+ */
+//================================================================================
+
+CORBA::Boolean StdMeshers_ViscousLayers2D_i::IsDimSupported( SMESH::Dimension type )
+{
+ return type == SMESH::DIM_2D;
+}
+
+//================================================================================
+/*!
+ * \brief Sets sub-mesh event listeners to clear sub-meshes of edges
+ * shrinked by viscous layers
+ */
+//================================================================================
+
+void StdMeshers_ViscousLayers2D_i::UpdateAsMeshesRestored()
+{
+ GetImpl()->RestoreListeners();
+}
--- /dev/null
+// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : StdMeshers_ViscousLayers2D_i.hxx
+// Module : SMESH
+//
+#ifndef _SMESH_ViscousLayers2D_I_HXX_
+#define _SMESH_ViscousLayers2D_I_HXX_
+
+#include "SMESH_StdMeshers_I.hxx"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "StdMeshers_ViscousLayers_i.hxx"
+#include "StdMeshers_ViscousLayers2D.hxx"
+
+class SMESH_Gen;
+
+class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers2D_i:
+ public virtual POA_StdMeshers::StdMeshers_ViscousLayers2D,
+ public virtual SMESH_Hypothesis_i
+{
+ public:
+ // Constructor
+ StdMeshers_ViscousLayers2D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~StdMeshers_ViscousLayers2D_i();
+
+ void SetIgnoreEdges(const ::SMESH::long_array& edgeIDs) throw ( SALOME::SALOME_Exception );
+ SMESH::long_array* GetIgnoreEdges();
+
+ void SetTotalThickness(::CORBA::Double thickness) throw ( SALOME::SALOME_Exception );
+ ::CORBA::Double GetTotalThickness();
+
+ void SetNumberLayers(::CORBA::Short nb) throw ( SALOME::SALOME_Exception );
+ ::CORBA::Short GetNumberLayers();
+
+ void SetStretchFactor(::CORBA::Double factor) throw ( SALOME::SALOME_Exception );
+ ::CORBA::Double GetStretchFactor();
+
+ // Get implementation
+ ::StdMeshers_ViscousLayers2D* GetImpl();
+
+ // Verify whether hypothesis supports given entity type
+ CORBA::Boolean IsDimSupported( SMESH::Dimension type );
+
+ // Sets sub-mesh event listeners to clear sub-meshes of edges
+ // shrinked by viscous layers
+ virtual void UpdateAsMeshesRestored();
+};
+
+#endif
for ( unsigned i = 0; i < ids.size(); ++i )
if (( ids[i] = faceIDs[i] ) < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid face id", SALOME::BAD_PARAM );
- GetImpl()->SetIgnoreFaces( ids );
+ GetImpl()->SetBndShapesToIgnore( ids );
SMESH::TPythonDump() << _this() << ".SetIgnoreFaces( " << faceIDs << " )";
}
SMESH::long_array* StdMeshers_ViscousLayers_i::GetIgnoreFaces()
{
- vector<int> idsVec = GetImpl()->GetIgnoreFaces();
+ vector<int> idsVec = GetImpl()->GetBndShapesToIgnore();
SMESH::long_array_var ids = new SMESH::long_array;
ids->length( idsVec.size() );
for ( unsigned i = 0; i < idsVec.size(); ++i )
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
// File : StdMeshers_ViscousLayers_i.hxx
// Module : SMESH
//
#include "StdMeshers_Import_1D_i.hxx"
#include "StdMeshers_Import_1D2D_i.hxx"
#include "StdMeshers_ViscousLayers_i.hxx"
+#include "StdMeshers_ViscousLayers2D_i.hxx"
#include "StdMeshers_CartesianParameters3D_i.hxx"
template <class T> class StdHypothesisCreator_i:public HypothesisCreator_i<T>
aCreator = new StdHypothesisCreator_i<StdMeshers_ImportSource2D_i>;
else if (strcmp(aHypName, "ViscousLayers") == 0)
aCreator = new StdHypothesisCreator_i<StdMeshers_ViscousLayers_i>;
+ else if (strcmp(aHypName, "ViscousLayers2D") == 0)
+ aCreator = new StdHypothesisCreator_i<StdMeshers_ViscousLayers2D_i>;
else if (strcmp(aHypName, "CartesianParameters3D") == 0)
aCreator = new StdHypothesisCreator_i<StdMeshers_CartesianParameters3D_i>;
