ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-16 02:28:34 +05:00
Code Issues Packages Projects Releases Wiki Activity
ab21216f10
smesh/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx

1089 lines
36 KiB
C++
Raw Normal View History

Integration improvements 0020310 and 0020431.
2009-08-27 13:26:22 +06:00
// Copyright (C) 2007-2008 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
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : StdMeshers_RadialQuadrangle_1D2D.cxx
// Module : SMESH
// Created : Fri Oct 20 11:37:07 2006
// Author : Edward AGAPOV (eap)
//
#include "StdMeshers_RadialQuadrangle_1D2D.hxx"
//#include "StdMeshers_ProjectionUtils.hxx"
#include "StdMeshers_NumberOfLayers.hxx"
#include "StdMeshers_LayerDistribution.hxx"
//#include "StdMeshers_Prism_3D.hxx"
#include "StdMeshers_Regular_1D.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMESHDS_SubMesh.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_subMesh.hxx"
#include "SMESH_subMeshEventListener.hxx"
#include "utilities.h"
#include <BRepAdaptor_Curve.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
//#include <BRepTools.hxx>
#include <BRep_Tool.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
//#include <TopoDS_Shell.hxx>
//#include <TopoDS_Solid.hxx>
//#include <TopTools_MapOfShape.hxx>
//#include <gp.hxx>
//#include <gp_Pnt.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Line.hxx>
#include <TColgp_SequenceOfPnt.hxx>
#include <TColgp_SequenceOfPnt2d.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
using namespace std;
#define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }
#define gpXYZ(n) gp_XYZ(n->X(),n->Y(),n->Z())
//typedef StdMeshers_ProjectionUtils TAssocTool;
//=======================================================================
//function : StdMeshers_RadialQuadrangle_1D2D
//purpose :
//=======================================================================
StdMeshers_RadialQuadrangle_1D2D::StdMeshers_RadialQuadrangle_1D2D(int hypId,
int studyId,
SMESH_Gen* gen)
:SMESH_2D_Algo(hypId, studyId, gen)
{
_name = "RadialQuadrangle_1D2D";
_shapeType = (1 << TopAbs_FACE); // 1 bit per shape type
_compatibleHypothesis.push_back("LayerDistribution2D");
_compatibleHypothesis.push_back("NumberOfLayers2D");
myNbLayerHypo = 0;
myDistributionHypo = 0;
_requireDescretBoundary = false;
}
//================================================================================
/*!
* \brief Destructor
*/
//================================================================================
StdMeshers_RadialQuadrangle_1D2D::~StdMeshers_RadialQuadrangle_1D2D()
{}
//=======================================================================
//function : CheckHypothesis
//purpose :
//=======================================================================
bool StdMeshers_RadialQuadrangle_1D2D::CheckHypothesis
(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
SMESH_Hypothesis::Hypothesis_Status& aStatus)
{
// check aShape
myNbLayerHypo = 0;
myDistributionHypo = 0;
list <const SMESHDS_Hypothesis * >::const_iterator itl;
const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
if ( hyps.size() == 0 ) {
aStatus = SMESH_Hypothesis::HYP_MISSING;
return false; // can't work with no hypothesis
}
if ( hyps.size() > 1 ) {
aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
return false;
}
const SMESHDS_Hypothesis *theHyp = hyps.front();
string hypName = theHyp->GetName();
if (hypName == "NumberOfLayers2D") {
myNbLayerHypo = static_cast<const StdMeshers_NumberOfLayers *>(theHyp);
aStatus = SMESH_Hypothesis::HYP_OK;
return true;
}
if (hypName == "LayerDistribution2D") {
myDistributionHypo = static_cast<const StdMeshers_LayerDistribution *>(theHyp);
aStatus = SMESH_Hypothesis::HYP_OK;
return true;
}
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
return true;
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape)
{
TopExp_Explorer exp;
SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
myHelper = new SMESH_MesherHelper( aMesh );
myHelper->IsQuadraticSubMesh( aShape );
myLayerPositions.clear();
TopoDS_Edge E1,E2,E3;
Handle(Geom_Curve) C1,C2,C3;
double f1,l1,f2,l2,f3,l3;
int nbe = 0;
for ( exp.Init( aShape, TopAbs_EDGE ); exp.More(); exp.Next() ) {
nbe++;
TopoDS_Edge E = TopoDS::Edge( exp.Current() );
if(nbe==1) {
E1 = E;
C1 = BRep_Tool::Curve(E,f1,l1);
}
else if(nbe==2) {
E2 = E;
C2 = BRep_Tool::Curve(E,f2,l2);
}
else if(nbe==3) {
E3 = E;
C3 = BRep_Tool::Curve(E,f3,l3);
}
}
if(nbe>3)
return error(COMPERR_BAD_SHAPE);
gp_Pnt P0,P1;
// points for rotation
TColgp_SequenceOfPnt Points;
// angles for rotation
TColStd_SequenceOfReal Angles;
// Nodes1 and Nodes2 - nodes along radiuses
// CNodes - nodes on circle edge
std::vector< const SMDS_MeshNode* > Nodes1, Nodes2, CNodes;
SMDS_MeshNode * NC;
// parameters edge nodes on face
TColgp_SequenceOfPnt2d Pnts2d1, Pnts2d2;
gp_Pnt2d PC;
int faceID = meshDS->ShapeToIndex(aShape);
TopoDS_Face F = TopoDS::Face(aShape);
Handle(Geom_Surface) S = BRep_Tool::Surface(F);
//cout<<"RadialQuadrangle_1D2D::Compute nbe = "<<nbe<<endl;
TopoDS_Edge CircEdge, LinEdge1, LinEdge2;
if(nbe==1) {
// C1 must be a circle
Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1);
if( aCirc.IsNull() )
return error(COMPERR_BAD_SHAPE);
CircEdge = E1;
bool ok = _gen->Compute( aMesh, CircEdge, false, MeshDim_1D );
if( !ok ) return false;
std::map< double, const SMDS_MeshNode* > theNodes;
GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes);
CNodes.clear();
std::map< double, const SMDS_MeshNode* >::iterator itn = theNodes.begin();
const SMDS_MeshNode* NF = (*itn).second;
CNodes.push_back( (*itn).second );
double fang = (*itn).first;
itn++;
for(; itn != theNodes.end(); itn++ ) {
CNodes.push_back( (*itn).second );
double ang = (*itn).first - fang;
if( ang>PI ) ang = ang - 2*PI;
if( ang<-PI ) ang = ang + 2*PI;
Angles.Append( ang );
}
P1 = gp_Pnt( NF->X(), NF->Y(), NF->Z() );
P0 = aCirc->Location();
myLayerPositions.clear();
computeLayerPositions(P0,P1);
exp.Init( CircEdge, TopAbs_VERTEX );
TopoDS_Vertex V1 = TopoDS::Vertex( exp.Current() );
gp_Pnt2d p2dV = BRep_Tool::Parameters( V1, TopoDS::Face(aShape) );
NC = meshDS->AddNode(P0.X(), P0.Y(), P0.Z());
GeomAPI_ProjectPointOnSurf PPS(P0,S);
double U0,V0;
PPS.Parameters(1,U0,V0);
meshDS->SetNodeOnFace(NC, faceID, U0, V0);
PC = gp_Pnt2d(U0,V0);
gp_Vec aVec(P0,P1);
gp_Vec2d aVec2d(PC,p2dV);
Nodes1.resize( myLayerPositions.size()+1 );
Nodes2.resize( myLayerPositions.size()+1 );
int i = 0;
for(; i<myLayerPositions.size(); i++) {
gp_Pnt P( P0.X() + aVec.X()*myLayerPositions[i],
P0.Y() + aVec.Y()*myLayerPositions[i],
P0.Z() + aVec.Z()*myLayerPositions[i] );
Points.Append(P);
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
Nodes1[i] = node;
Nodes2[i] = node;
double U = PC.X() + aVec2d.X()*myLayerPositions[i];
double V = PC.Y() + aVec2d.Y()*myLayerPositions[i];
meshDS->SetNodeOnFace( node, faceID, U, V );
Pnts2d1.Append(gp_Pnt2d(U,V));
Pnts2d2.Append(gp_Pnt2d(U,V));
}
Nodes1[Nodes1.size()-1] = NF;
Nodes2[Nodes1.size()-1] = NF;
}
else if(nbe==2) {
// one curve must be a half of circle and other curve must be
// a segment of line
Handle(Geom_TrimmedCurve) tc = Handle(Geom_TrimmedCurve)::DownCast(C1);
while( !tc.IsNull() ) {
C1 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C1);
}
tc = Handle(Geom_TrimmedCurve)::DownCast(C2);
while( !tc.IsNull() ) {
C2 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C2);
}
Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1);
Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast(C2);
CircEdge = E1;
LinEdge1 = E2;
double fp = f1;
double lp = l1;
if( aCirc.IsNull() ) {
aCirc = Handle(Geom_Circle)::DownCast(C2);
CircEdge = E2;
LinEdge1 = E1;
fp = f2;
lp = l2;
aLine = Handle(Geom_Line)::DownCast(C3);
}
if( aCirc.IsNull() ) {
// not circle
return error(COMPERR_BAD_SHAPE);
}
if( fabs(fabs(lp-fp)-PI) > Precision::Confusion() ) {
// not half of circle
return error(COMPERR_BAD_SHAPE);
}
if( aLine.IsNull() ) {
// other curve not line
return error(COMPERR_BAD_SHAPE);
}
SMESH_subMesh* sm1 = aMesh.GetSubMesh(LinEdge1);
if( sm1 ) {
SMESHDS_SubMesh* sdssm1 = sm1->GetSubMeshDS();
if( sdssm1 ) {
if( sm1->GetSubMeshDS()->NbNodes()>0 ) {
SMESH_subMesh* sm = aMesh.GetSubMesh(F);
SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
smError.reset(new SMESH_ComputeError(COMPERR_ALGO_FAILED,
"Invalid set of hypothesises",this));
return false;
}
}
}
bool ok = _gen->Compute( aMesh, CircEdge, false, MeshDim_1D );
if( !ok ) return false;
std::map< double, const SMDS_MeshNode* > theNodes;
GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes);
CNodes.clear();
std::map< double, const SMDS_MeshNode* >::iterator itn = theNodes.begin();
const SMDS_MeshNode* NF = (*itn).second;
CNodes.push_back( (*itn).second );
double fang = (*itn).first;
itn++;
const SMDS_MeshNode* NL;
int nbn = 1;
for(; itn != theNodes.end(); itn++ ) {
nbn++;
if( nbn == theNodes.size() )
NL = (*itn).second;
CNodes.push_back( (*itn).second );
double ang = (*itn).first - fang;
if( ang>PI ) ang = ang - 2*PI;
if( ang<-PI ) ang = ang + 2*PI;
Angles.Append( ang );
}
P1 = gp_Pnt( NF->X(), NF->Y(), NF->Z() );
gp_Pnt P2( NL->X(), NL->Y(), NL->Z() );
P0 = aCirc->Location();
myLayerPositions.clear();
computeLayerPositions(P0,P1);
gp_Vec aVec(P0,P1);
int edgeID = meshDS->ShapeToIndex(LinEdge1);
// check orientation
Handle(Geom_Curve) Crv = BRep_Tool::Curve(LinEdge1,fp,lp);
gp_Pnt Ptmp;
Crv->D0(fp,Ptmp);
bool ori = true;
if( P1.Distance(Ptmp) > Precision::Confusion() )
ori = false;
// get UV points for edge
gp_Pnt2d PF,PL;
BRep_Tool::UVPoints( LinEdge1, TopoDS::Face(aShape), PF, PL );
PC = gp_Pnt2d( (PF.X()+PL.X())/2, (PF.Y()+PL.Y())/2 );
gp_Vec2d V2d;
if(ori) V2d = gp_Vec2d(PC,PF);
else V2d = gp_Vec2d(PC,PL);
// add nodes on edge
double cp = (fp+lp)/2;
double dp2 = (lp-fp)/2;
NC = meshDS->AddNode(P0.X(), P0.Y(), P0.Z());
meshDS->SetNodeOnEdge(NC, edgeID, cp);
Nodes1.resize( myLayerPositions.size()+1 );
Nodes2.resize( myLayerPositions.size()+1 );
int i = 0;
for(; i<myLayerPositions.size(); i++) {
gp_Pnt P( P0.X() + aVec.X()*myLayerPositions[i],
P0.Y() + aVec.Y()*myLayerPositions[i],
P0.Z() + aVec.Z()*myLayerPositions[i] );
Points.Append(P);
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
Nodes1[i] = node;
double param;
if(ori)
param = fp + dp2*(1-myLayerPositions[i]);
else
param = cp + dp2*myLayerPositions[i];
meshDS->SetNodeOnEdge(node, edgeID, param);
P = gp_Pnt( P0.X() - aVec.X()*myLayerPositions[i],
P0.Y() - aVec.Y()*myLayerPositions[i],
P0.Z() - aVec.Z()*myLayerPositions[i] );
node = meshDS->AddNode(P.X(), P.Y(), P.Z());
Nodes2[i] = node;
if(!ori)
param = fp + dp2*(1-myLayerPositions[i]);
else
param = cp + dp2*myLayerPositions[i];
meshDS->SetNodeOnEdge(node, edgeID, param);
// parameters on face
gp_Pnt2d P2d( PC.X() + V2d.X()*myLayerPositions[i],
PC.Y() + V2d.Y()*myLayerPositions[i] );
Pnts2d1.Append(P2d);
P2d = gp_Pnt2d( PC.X() - V2d.X()*myLayerPositions[i],
PC.Y() - V2d.Y()*myLayerPositions[i] );
Pnts2d2.Append(P2d);
}
Nodes1[ myLayerPositions.size() ] = NF;
Nodes2[ myLayerPositions.size() ] = NL;
// create 1D elements on edge
std::vector< const SMDS_MeshNode* > tmpNodes;
tmpNodes.resize(2*Nodes1.size()+1);
for(i=0; i<Nodes2.size(); i++)
tmpNodes[Nodes2.size()-i-1] = Nodes2[i];
tmpNodes[Nodes2.size()] = NC;
for(i=0; i<Nodes1.size(); i++)
tmpNodes[Nodes2.size()+1+i] = Nodes1[i];
for(i=1; i<tmpNodes.size(); i++) {
SMDS_MeshEdge* ME = myHelper->AddEdge( tmpNodes[i-1], tmpNodes[i] );
if(ME) meshDS->SetMeshElementOnShape(ME, edgeID);
}
}
else { // nbe==3
// one curve must be a part of circle and other curves must be
// segments of line
Handle(Geom_TrimmedCurve) tc = Handle(Geom_TrimmedCurve)::DownCast(C1);
while( !tc.IsNull() ) {
C1 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C1);
}
tc = Handle(Geom_TrimmedCurve)::DownCast(C2);
while( !tc.IsNull() ) {
C2 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C2);
}
tc = Handle(Geom_TrimmedCurve)::DownCast(C3);
while( !tc.IsNull() ) {
C3 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C3);
}
Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1);
Handle(Geom_Line) aLine1 = Handle(Geom_Line)::DownCast(C2);
Handle(Geom_Line) aLine2 = Handle(Geom_Line)::DownCast(C3);
CircEdge = E1;
LinEdge1 = E2;
LinEdge2 = E3;
double fp = f1;
double lp = l1;
if( aCirc.IsNull() ) {
aCirc = Handle(Geom_Circle)::DownCast(C2);
CircEdge = E2;
LinEdge1 = E3;
LinEdge2 = E1;
fp = f2;
lp = l2;
aLine1 = Handle(Geom_Line)::DownCast(C3);
aLine2 = Handle(Geom_Line)::DownCast(C1);
if( aCirc.IsNull() ) {
aCirc = Handle(Geom_Circle)::DownCast(C3);
CircEdge = E3;
LinEdge1 = E1;
LinEdge2 = E2;
fp = f3;
lp = l3;
aLine1 = Handle(Geom_Line)::DownCast(C1);
aLine2 = Handle(Geom_Line)::DownCast(C2);
}
}
if( aCirc.IsNull() ) {
// not circle
return error(COMPERR_BAD_SHAPE);
}
if( aLine1.IsNull() || aLine2.IsNull() ) {
// other curve not line
return error(COMPERR_BAD_SHAPE);
}
SMESH_subMesh* sm1 = aMesh.GetSubMesh(LinEdge1);
SMESH_subMesh* sm2 = aMesh.GetSubMesh(LinEdge2);
if( sm1 && sm2 ) {
SMESHDS_SubMesh* sdssm1 = sm1->GetSubMeshDS();
SMESHDS_SubMesh* sdssm2 = sm2->GetSubMeshDS();
if( sdssm1 && sdssm2 ) {
if( sm1->GetSubMeshDS()->NbNodes()>0 || sm2->GetSubMeshDS()->NbNodes()>0 ) {
SMESH_subMesh* sm = aMesh.GetSubMesh(F);
SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
smError.reset(new SMESH_ComputeError(COMPERR_ALGO_FAILED,
"Invalid set of hypothesises",this));
return false;
}
}
}
bool ok = _gen->Compute( aMesh, CircEdge, false, MeshDim_1D );
if( !ok ) return false;
std::map< double, const SMDS_MeshNode* > theNodes;
GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes);
CNodes.clear();
std::map< double, const SMDS_MeshNode* >::iterator itn = theNodes.begin();
const SMDS_MeshNode* NF = (*itn).second;
CNodes.push_back( (*itn).second );
double fang = (*itn).first;
itn++;
const SMDS_MeshNode* NL;
int nbn = 1;
for(; itn != theNodes.end(); itn++ ) {
nbn++;
if( nbn == theNodes.size() )
NL = (*itn).second;
CNodes.push_back( (*itn).second );
double ang = (*itn).first - fang;
if( ang>PI ) ang = ang - 2*PI;
if( ang<-PI ) ang = ang + 2*PI;
Angles.Append( ang );
}
P1 = gp_Pnt( NF->X(), NF->Y(), NF->Z() );
gp_Pnt P2( NL->X(), NL->Y(), NL->Z() );
P0 = aCirc->Location();
myLayerPositions.clear();
computeLayerPositions(P0,P1);
exp.Init( LinEdge1, TopAbs_VERTEX );
TopoDS_Vertex V1 = TopoDS::Vertex( exp.Current() );
exp.Next();
TopoDS_Vertex V2 = TopoDS::Vertex( exp.Current() );
gp_Pnt PE1 = BRep_Tool::Pnt(V1);
gp_Pnt PE2 = BRep_Tool::Pnt(V2);
if( ( P1.Distance(PE1) > Precision::Confusion() ) &&
( P1.Distance(PE2) > Precision::Confusion() ) ) {
TopoDS_Edge E = LinEdge1;
LinEdge1 = LinEdge2;
LinEdge2 = E;
}
TopoDS_Vertex VC;
if( ( P1.Distance(PE1) > Precision::Confusion() ) &&
( P2.Distance(PE1) > Precision::Confusion() ) ) {
VC = V1;
}
else VC = V2;
int vertID = meshDS->ShapeToIndex(VC);
// LinEdge1
int edgeID = meshDS->ShapeToIndex(LinEdge1);
gp_Vec aVec(P0,P1);
// check orientation
Handle(Geom_Curve) Crv = BRep_Tool::Curve(LinEdge1,fp,lp);
gp_Pnt Ptmp;
Crv->D0(fp,Ptmp);
bool ori = false;
if( P1.Distance(Ptmp) > Precision::Confusion() )
ori = true;
// get UV points for edge
gp_Pnt2d PF,PL;
BRep_Tool::UVPoints( LinEdge1, TopoDS::Face(aShape), PF, PL );
gp_Vec2d V2d;
if(ori) {
V2d = gp_Vec2d(PF,PL);
PC = PF;
}
else {
V2d = gp_Vec2d(PL,PF);
PC = PL;
}
NC = meshDS->AddNode(P0.X(), P0.Y(), P0.Z());
meshDS->SetNodeOnVertex(NC, vertID);
double dp = lp-fp;
Nodes1.resize( myLayerPositions.size()+1 );
int i = 0;
for(; i<myLayerPositions.size(); i++) {
gp_Pnt P( P0.X() + aVec.X()*myLayerPositions[i],
P0.Y() + aVec.Y()*myLayerPositions[i],
P0.Z() + aVec.Z()*myLayerPositions[i] );
Points.Append(P);
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
Nodes1[i] = node;
double param;
if(!ori)
param = fp + dp*(1-myLayerPositions[i]);
else
param = fp + dp*myLayerPositions[i];
meshDS->SetNodeOnEdge(node, edgeID, param);
// parameters on face
gp_Pnt2d P2d( PC.X() + V2d.X()*myLayerPositions[i],
PC.Y() + V2d.Y()*myLayerPositions[i] );
Pnts2d1.Append(P2d);
}
Nodes1[ myLayerPositions.size() ] = NF;
// create 1D elements on edge
SMDS_MeshEdge* ME = myHelper->AddEdge( NC, Nodes1[0] );
if(ME) meshDS->SetMeshElementOnShape(ME, edgeID);
for(i=1; i<Nodes1.size(); i++) {
SMDS_MeshEdge* ME = myHelper->AddEdge( Nodes1[i-1], Nodes1[i] );
if(ME) meshDS->SetMeshElementOnShape(ME, edgeID);
}
// LinEdge2
edgeID = meshDS->ShapeToIndex(LinEdge1);
aVec = gp_Vec(P0,P2);
// check orientation
Crv = BRep_Tool::Curve(LinEdge2,fp,lp);
Crv->D0(fp,Ptmp);
ori = false;
if( P2.Distance(Ptmp) > Precision::Confusion() )
ori = true;
// get UV points for edge
BRep_Tool::UVPoints( LinEdge2, TopoDS::Face(aShape), PF, PL );
if(ori) {
V2d = gp_Vec2d(PF,PL);
PC = PF;
}
else {
V2d = gp_Vec2d(PL,PF);
PC = PL;
}
dp = lp-fp;
Nodes2.resize( myLayerPositions.size()+1 );
for(i=0; i<myLayerPositions.size(); i++) {
gp_Pnt P( P0.X() + aVec.X()*myLayerPositions[i],
P0.Y() + aVec.Y()*myLayerPositions[i],
P0.Z() + aVec.Z()*myLayerPositions[i] );
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
Nodes2[i] = node;
double param;
if(!ori)
param = fp + dp*(1-myLayerPositions[i]);
else
param = fp + dp*myLayerPositions[i];
meshDS->SetNodeOnEdge(node, edgeID, param);
// parameters on face
gp_Pnt2d P2d( PC.X() + V2d.X()*myLayerPositions[i],
PC.Y() + V2d.Y()*myLayerPositions[i] );
Pnts2d2.Append(P2d);
}
Nodes2[ myLayerPositions.size() ] = NL;
// create 1D elements on edge
ME = myHelper->AddEdge( NC, Nodes2[0] );
if(ME) meshDS->SetMeshElementOnShape(ME, edgeID);
for(i=1; i<Nodes2.size(); i++) {
SMDS_MeshEdge* ME = myHelper->AddEdge( Nodes2[i-1], Nodes2[i] );
if(ME) meshDS->SetMeshElementOnShape(ME, edgeID);
}
}
// create nodes and mesh elements on face
// find axis of rotation
gp_Pnt P2 = gp_Pnt( CNodes[1]->X(), CNodes[1]->Y(), CNodes[1]->Z() );
gp_Vec Vec1(P0,P1);
gp_Vec Vec2(P0,P2);
gp_Vec Axis = Vec1.Crossed(Vec2);
// create elements
int i = 1;
//cout<<"Angles.Length() = "<<Angles.Length()<<" Points.Length() = "<<Points.Length()<<endl;
//cout<<"Nodes1.size() = "<<Nodes1.size()<<" Pnts2d1.Length() = "<<Pnts2d1.Length()<<endl;
for(; i<Angles.Length(); i++) {
std::vector< const SMDS_MeshNode* > tmpNodes;
tmpNodes.reserve(Nodes1.size());
gp_Trsf aTrsf;
gp_Ax1 theAxis(P0,gp_Dir(Axis));
aTrsf.SetRotation( theAxis, Angles.Value(i) );
gp_Trsf2d aTrsf2d;
aTrsf2d.SetRotation( PC, Angles.Value(i) );
// create nodes
int j = 1;
for(; j<=Points.Length(); j++) {
double cx,cy,cz;
Points.Value(j).Coord( cx, cy, cz );
aTrsf.Transforms( cx, cy, cz );
SMDS_MeshNode* node = myHelper->AddNode( cx, cy, cz );
// find parameters on face
Pnts2d1.Value(j).Coord( cx, cy );
aTrsf2d.Transforms( cx, cy );
// set node on face
meshDS->SetNodeOnFace( node, faceID, cx, cy );
tmpNodes[j-1] = node;
}
// create faces
tmpNodes[Points.Length()] = CNodes[i];
// quad
for(j=0; j<Nodes1.size()-1; j++) {
SMDS_MeshFace* MF = myHelper->AddFace( tmpNodes[j], Nodes1[j],
Nodes1[j+1], tmpNodes[j+1] );
if(MF) meshDS->SetMeshElementOnShape(MF, faceID);
}
// tria
SMDS_MeshFace* MF = myHelper->AddFace( NC, Nodes1[0], tmpNodes[0] );
if(MF) meshDS->SetMeshElementOnShape(MF, faceID);
for(j=0; j<Nodes1.size(); j++) {
Nodes1[j] = tmpNodes[j];
}
}
// create last faces
// quad
for(i=0; i<Nodes1.size()-1; i++) {
SMDS_MeshFace* MF = myHelper->AddFace( Nodes2[i], Nodes1[i],
Nodes1[i+1], Nodes2[i+1] );
if(MF) meshDS->SetMeshElementOnShape(MF, faceID);
}
// tria
SMDS_MeshFace* MF = myHelper->AddFace( NC, Nodes1[0], Nodes2[0] );
if(MF) meshDS->SetMeshElementOnShape(MF, faceID);
// to delete helper at exit from Compute()
std::auto_ptr<SMESH_MesherHelper> helperDeleter( myHelper );
return true;
}
//================================================================================
//================================================================================
/*!
* \brief Class computing layers distribution using data of
* StdMeshers_LayerDistribution hypothesis
*/
//================================================================================
//================================================================================
class TNodeDistributor: public StdMeshers_Regular_1D
{
list <const SMESHDS_Hypothesis *> myUsedHyps;
public:
// -----------------------------------------------------------------------------
static TNodeDistributor* GetDistributor(SMESH_Mesh& aMesh)
{
const int myID = -1000;
map < int, SMESH_1D_Algo * > & algoMap = aMesh.GetGen()->_map1D_Algo;
map < int, SMESH_1D_Algo * >::iterator id_algo = algoMap.find( myID );
if ( id_algo == algoMap.end() )
return new TNodeDistributor( myID, 0, aMesh.GetGen() );
return static_cast< TNodeDistributor* >( id_algo->second );
}
// -----------------------------------------------------------------------------
bool Compute( vector< double > & positions,
gp_Pnt pIn,
gp_Pnt pOut,
SMESH_Mesh& aMesh,
const StdMeshers_LayerDistribution* hyp)
{
double len = pIn.Distance( pOut );
if ( len <= DBL_MIN ) return error("Too close points of inner and outer shells");
if ( !hyp || !hyp->GetLayerDistribution() )
return error( "Invalid LayerDistribution hypothesis");
myUsedHyps.clear();
myUsedHyps.push_back( hyp->GetLayerDistribution() );
TopoDS_Edge edge = BRepBuilderAPI_MakeEdge( pIn, pOut );
SMESH_Hypothesis::Hypothesis_Status aStatus;
if ( !StdMeshers_Regular_1D::CheckHypothesis( aMesh, edge, aStatus ))
return error( "StdMeshers_Regular_1D::CheckHypothesis() failed "
"with LayerDistribution hypothesis");
BRepAdaptor_Curve C3D(edge);
double f = C3D.FirstParameter(), l = C3D.LastParameter();
list< double > params;
if ( !StdMeshers_Regular_1D::computeInternalParameters( aMesh, C3D, len, f, l, params, false ))
return error("StdMeshers_Regular_1D failed to compute layers distribution");
positions.clear();
positions.reserve( params.size() );
for (list<double>::iterator itU = params.begin(); itU != params.end(); itU++)
positions.push_back( *itU / len );
return true;
}
protected:
// -----------------------------------------------------------------------------
TNodeDistributor( int hypId, int studyId, SMESH_Gen* gen)
: StdMeshers_Regular_1D( hypId, studyId, gen)
{
}
// -----------------------------------------------------------------------------
virtual const list <const SMESHDS_Hypothesis *> &
GetUsedHypothesis(SMESH_Mesh &, const TopoDS_Shape &, const bool)
{
return myUsedHyps;
}
// -----------------------------------------------------------------------------
};
//================================================================================
/*!
* \brief Compute positions of nodes between the internal and the external surfaces
* \retval bool - is a success
*/
//================================================================================
bool StdMeshers_RadialQuadrangle_1D2D::computeLayerPositions(const gp_Pnt& pIn,
const gp_Pnt& pOut)
{
if ( myNbLayerHypo )
{
int nbSegments = myNbLayerHypo->GetNumberOfLayers();
myLayerPositions.resize( nbSegments - 1 );
for ( int z = 1; z < nbSegments; ++z )
myLayerPositions[ z - 1 ] = double( z )/ double( nbSegments );
return true;
}
if ( myDistributionHypo ) {
SMESH_Mesh * mesh = myHelper->GetMesh();
if ( !TNodeDistributor::GetDistributor(*mesh)->Compute( myLayerPositions, pIn, pOut,
*mesh, myDistributionHypo ))
{
error( TNodeDistributor::GetDistributor(*mesh)->GetComputeError() );
return false;
}
}
RETURN_BAD_RESULT("Bad hypothesis");
}
//=======================================================================
//function : Evaluate
//purpose :
//=======================================================================
bool StdMeshers_RadialQuadrangle_1D2D::Evaluate(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
MapShapeNbElems& aResMap)
{
if( aShape.ShapeType() != TopAbs_FACE ) {
return false;
}
SMESH_subMesh * smf = aMesh.GetSubMesh(aShape);
MapShapeNbElemsItr anIt = aResMap.find(smf);
if( anIt != aResMap.end() ) {
return false;
}
myLayerPositions.clear();
gp_Pnt P0(0,0,0);
gp_Pnt P1(100,0,0);
computeLayerPositions(P0,P1);
TopoDS_Edge E1,E2,E3;
Handle(Geom_Curve) C1,C2,C3;
double f1,l1,f2,l2,f3,l3;
int nbe = 0;
TopExp_Explorer exp;
for ( exp.Init( aShape, TopAbs_EDGE ); exp.More(); exp.Next() ) {
nbe++;
TopoDS_Edge E = TopoDS::Edge( exp.Current() );
if(nbe==1) {
E1 = E;
C1 = BRep_Tool::Curve(E,f1,l1);
}
else if(nbe==2) {
E2 = E;
C2 = BRep_Tool::Curve(E,f2,l2);
}
else if(nbe==3) {
E3 = E;
C3 = BRep_Tool::Curve(E,f3,l3);
}
}
TopoDS_Edge CircEdge, LinEdge1, LinEdge2;
int nb0d=0, nb2d_tria=0, nb2d_quad=0;
bool isQuadratic = false;
if(nbe==1) {
// C1 must be a circle
Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1);
if( !aCirc.IsNull() ) {
bool ok = _gen->Evaluate( aMesh, CircEdge, aResMap );
if(ok) {
SMESH_subMesh * sm = aMesh.GetSubMesh(CircEdge);
MapShapeNbElemsItr anIt = aResMap.find(sm);
std::vector<int> aVec = (*anIt).second;
isQuadratic = aVec[SMDSEntity_Quad_Edge]>aVec[SMDSEntity_Edge];
if(isQuadratic) {
// main nodes
nb0d = (aVec[SMDSEntity_Node]+1) * myLayerPositions.size();
// radial medium nodes
nb0d += (aVec[SMDSEntity_Node]+1) * (myLayerPositions.size()+1);
// other medium nodes
nb0d += (aVec[SMDSEntity_Node]+1) * myLayerPositions.size();
}
else {
nb0d = (aVec[SMDSEntity_Node]+1) * myLayerPositions.size();
}
nb2d_tria = aVec[SMDSEntity_Node] + 1;
nb2d_quad = nb0d;
}
}
}
else if(nbe==2) {
// one curve must be a half of circle and other curve must be
// a segment of line
Handle(Geom_TrimmedCurve) tc = Handle(Geom_TrimmedCurve)::DownCast(C1);
while( !tc.IsNull() ) {
C1 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C1);
}
tc = Handle(Geom_TrimmedCurve)::DownCast(C2);
while( !tc.IsNull() ) {
C2 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C2);
}
Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1);
Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast(C2);
CircEdge = E1;
LinEdge1 = E2;
double fp = f1;
double lp = l1;
if( aCirc.IsNull() ) {
aCirc = Handle(Geom_Circle)::DownCast(C2);
CircEdge = E2;
LinEdge1 = E1;
fp = f2;
lp = l2;
aLine = Handle(Geom_Line)::DownCast(C3);
}
bool ok = !aCirc.IsNull() && !aLine.IsNull();
if( fabs(fabs(lp-fp)-PI) > Precision::Confusion() ) {
// not half of circle
ok = false;
}
SMESH_subMesh* sm1 = aMesh.GetSubMesh(LinEdge1);
MapShapeNbElemsItr anIt = aResMap.find(sm1);
if( anIt!=aResMap.end() ) {
ok = false;
}
if(ok) {
ok = _gen->Evaluate( aMesh, CircEdge, aResMap );
}
if(ok) {
SMESH_subMesh * sm = aMesh.GetSubMesh(CircEdge);
MapShapeNbElemsItr anIt = aResMap.find(sm);
std::vector<int> aVec = (*anIt).second;
isQuadratic = aVec[SMDSEntity_Quad_Edge]>aVec[SMDSEntity_Edge];
if(isQuadratic) {
// main nodes
nb0d = aVec[SMDSEntity_Node] * myLayerPositions.size();
// radial medium nodes
nb0d += aVec[SMDSEntity_Node] * (myLayerPositions.size()+1);
// other medium nodes
nb0d += (aVec[SMDSEntity_Node]+1) * myLayerPositions.size();
}
else {
nb0d = aVec[SMDSEntity_Node] * myLayerPositions.size();
}
nb2d_tria = aVec[SMDSEntity_Node] + 1;
nb2d_quad = nb2d_tria * myLayerPositions.size();
// add evaluation for edges
std::vector<int> aResVec(SMDSEntity_Last);
for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aResVec[i] = 0;
if(isQuadratic) {
aResVec[SMDSEntity_Node] = 4*myLayerPositions.size() + 3;
aResVec[SMDSEntity_Quad_Edge] = 2*myLayerPositions.size() + 2;
}
else {
aResVec[SMDSEntity_Node] = 2*myLayerPositions.size() + 1;
aResVec[SMDSEntity_Edge] = 2*myLayerPositions.size() + 2;
}
sm = aMesh.GetSubMesh(LinEdge1);
aResMap.insert(std::make_pair(sm,aResVec));
}
}
else { // nbe==3
// one curve must be a part of circle and other curves must be
// segments of line
Handle(Geom_TrimmedCurve) tc = Handle(Geom_TrimmedCurve)::DownCast(C1);
while( !tc.IsNull() ) {
C1 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C1);
}
tc = Handle(Geom_TrimmedCurve)::DownCast(C2);
while( !tc.IsNull() ) {
C2 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C2);
}
tc = Handle(Geom_TrimmedCurve)::DownCast(C3);
while( !tc.IsNull() ) {
C3 = tc->BasisCurve();
tc = Handle(Geom_TrimmedCurve)::DownCast(C3);
}
Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1);
Handle(Geom_Line) aLine1 = Handle(Geom_Line)::DownCast(C2);
Handle(Geom_Line) aLine2 = Handle(Geom_Line)::DownCast(C3);
CircEdge = E1;
LinEdge1 = E2;
LinEdge2 = E3;
double fp = f1;
double lp = l1;
if( aCirc.IsNull() ) {
aCirc = Handle(Geom_Circle)::DownCast(C2);
CircEdge = E2;
LinEdge1 = E3;
LinEdge2 = E1;
fp = f2;
lp = l2;
aLine1 = Handle(Geom_Line)::DownCast(C3);
aLine2 = Handle(Geom_Line)::DownCast(C1);
if( aCirc.IsNull() ) {
aCirc = Handle(Geom_Circle)::DownCast(C3);
CircEdge = E3;
LinEdge1 = E1;
LinEdge2 = E2;
fp = f3;
lp = l3;
aLine1 = Handle(Geom_Line)::DownCast(C1);
aLine2 = Handle(Geom_Line)::DownCast(C2);
}
}
bool ok = !aCirc.IsNull() && !aLine1.IsNull() && !aLine1.IsNull();
SMESH_subMesh* sm = aMesh.GetSubMesh(LinEdge1);
MapShapeNbElemsItr anIt = aResMap.find(sm);
if( anIt!=aResMap.end() ) {
ok = false;
}
sm = aMesh.GetSubMesh(LinEdge2);
anIt = aResMap.find(sm);
if( anIt!=aResMap.end() ) {
ok = false;
}
if(ok) {
ok = _gen->Evaluate( aMesh, CircEdge, aResMap );
}
if(ok) {
SMESH_subMesh * sm = aMesh.GetSubMesh(CircEdge);
MapShapeNbElemsItr anIt = aResMap.find(sm);
std::vector<int> aVec = (*anIt).second;
isQuadratic = aVec[SMDSEntity_Quad_Edge]>aVec[SMDSEntity_Edge];
if(isQuadratic) {
// main nodes
nb0d = aVec[SMDSEntity_Node] * myLayerPositions.size();
// radial medium nodes
nb0d += aVec[SMDSEntity_Node] * (myLayerPositions.size()+1);
// other medium nodes
nb0d += (aVec[SMDSEntity_Node]+1) * myLayerPositions.size();
}
else {
nb0d = aVec[SMDSEntity_Node] * myLayerPositions.size();
}
nb2d_tria = aVec[SMDSEntity_Node] + 1;
nb2d_quad = nb2d_tria * myLayerPositions.size();
// add evaluation for edges
std::vector<int> aResVec(SMDSEntity_Last);
for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aResVec[i] = 0;
if(isQuadratic) {
aResVec[SMDSEntity_Node] = 2*myLayerPositions.size() + 1;
aResVec[SMDSEntity_Quad_Edge] = myLayerPositions.size() + 1;
}
else {
aResVec[SMDSEntity_Node] = myLayerPositions.size();
aResVec[SMDSEntity_Edge] = myLayerPositions.size() + 1;
}
sm = aMesh.GetSubMesh(LinEdge1);
aResMap.insert(std::make_pair(sm,aResVec));
sm = aMesh.GetSubMesh(LinEdge2);
aResMap.insert(std::make_pair(sm,aResVec));
}
}
std::vector<int> aResVec(SMDSEntity_Last);
for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aResVec[i] = 0;
SMESH_subMesh * sm = aMesh.GetSubMesh(aShape);
//cout<<"nb0d = "<<nb0d<<" nb2d_tria = "<<nb2d_tria<<" nb2d_quad = "<<nb2d_quad<<endl;
if(nb0d>0) {
aResVec[0] = nb0d;
if(isQuadratic) {
aResVec[SMDSEntity_Quad_Triangle] = nb2d_tria;
aResVec[SMDSEntity_Quad_Quadrangle] = nb2d_quad;
}
else {
aResVec[SMDSEntity_Triangle] = nb2d_tria;
aResVec[SMDSEntity_Quadrangle] = nb2d_quad;
}
aResMap.insert(std::make_pair(sm,aResVec));
return true;
}
// invalid case
aResMap.insert(std::make_pair(sm,aResVec));
SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
smError.reset( new SMESH_ComputeError(COMPERR_ALGO_FAILED,
"Submesh can not be evaluated",this));
return false;
}
Reference in New Issue Copy Permalink