ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

introduce biquadratic quadratic pentahedron (18 nodes)

Browse Source
This commit is contained in:
Paul RASCLE 2017-09-07 14:04:57 +02:00
parent 76430457f1
commit 2077baef82
38 changed files with 636 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
idl/SMESH_Mesh.idl
View File

@ -191,6 +191,7 @@ module SMESH
Entity_TriQuad_Hexa,
Entity_Penta,
Entity_Quad_Penta,
Entity_BiQuad_Penta,
Entity_Hexagonal_Prism,
Entity_Polyhedra,
Entity_Quad_Polyhedra,

16
src/Controls/SMESH_Controls.cxx
View File

@ -616,7 +616,8 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(aVal,Max(L7,L8));
break;
}
case SMDSEntity_Quad_Penta: { // quadratic pentas
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta: { // quadratic pentas
double L1 = getDistance(P( 1 ),P( 7 )) + getDistance(P( 7 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 8 )) + getDistance(P( 8 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
@ -1619,7 +1620,7 @@ double Length2D::GetValue( long theElementId )
}
break;
case SMDSEntity_Pyramid:
if (len == 5){ // piramids
if (len == 5){ // pyramid
double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 4 ));
@ -1634,7 +1635,7 @@ double Length2D::GetValue( long theElementId )
}
break;
case SMDSEntity_Penta:
if (len == 6) { // pentaidres
if (len == 6) { // pentahedron
double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 1 ));
@ -1670,7 +1671,7 @@ double Length2D::GetValue( long theElementId )
}
break;
case SMDSEntity_Quad_Tetra:
if (len == 10){ // quadratic tetraidrs
if (len == 10){ // quadratic tetrahedron
double L1 = getDistance(P( 1 ),P( 5 )) + getDistance(P( 5 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 6 )) + getDistance(P( 6 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 7 )) + getDistance(P( 7 ),P( 1 ));
@ -1681,7 +1682,7 @@ double Length2D::GetValue( long theElementId )
}
break;
case SMDSEntity_Quad_Pyramid:
if (len == 13){ // quadratic piramids
if (len == 13){ // quadratic pyramid
double L1 = getDistance(P( 1 ),P( 6 )) + getDistance(P( 6 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 7 )) + getDistance(P( 7 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 8 )) + getDistance(P( 8 ),P( 4 ));
@ -1695,7 +1696,8 @@ double Length2D::GetValue( long theElementId )
}
break;
case SMDSEntity_Quad_Penta:
if (len == 15){ // quadratic pentaidres
case SMDSEntity_BiQuad_Penta:
if (len >= 15){ // quadratic pentahedron
double L1 = getDistance(P( 1 ),P( 7 )) + getDistance(P( 7 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 8 )) + getDistance(P( 8 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
@ -1711,7 +1713,7 @@ double Length2D::GetValue( long theElementId )
break;
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
if (len >= 20) { // quadratic hexaider
if (len >= 20) { // quadratic hexahedron
double L1 = getDistance(P( 1 ),P( 9 )) + getDistance(P( 9 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 10 )) + getDistance(P( 10 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 11 )) + getDistance(P( 11 ),P( 4 ));

5
src/DriverCGNS/DriverCGNS_Write.cxx
View File

@ -130,6 +130,11 @@ namespace
interlaces[SMDSEntity_Quad_Penta] = ids;
cgTypes [SMDSEntity_Quad_Penta] = CGNS_ENUMV( PENTA_15 );
}
{
static int ids[] = { 0,2,1,3,5,4,8,7,6,9,11,10,14,13,12,15,16,17 }; // TODO: check CGNS ORDER
interlaces[SMDSEntity_BiQuad_Penta] = ids;
cgTypes [SMDSEntity_BiQuad_Penta] = CGNS_ENUMV( PENTA_18 );
}
{
static int ids[] = { 0,3,2,1,4,7,6,5 };
interlaces[SMDSEntity_Hexa] = ids;

1
src/DriverMED/DriverMED_W_Field.cxx
View File

@ -393,6 +393,7 @@ namespace DriverMED // Implemetation of fuctions declared in DriverMED.hxx
theVec[ SMDSEntity_TriQuad_Hexa ] = MED::eHEXA27 ;
theVec[ SMDSEntity_Penta ] = MED::ePENTA6 ;
theVec[ SMDSEntity_Quad_Penta ] = MED::ePENTA15 ;
theVec[ SMDSEntity_BiQuad_Penta ] = MED::ePENTA18 ;
theVec[ SMDSEntity_Hexagonal_Prism ] = MED::eOCTA12 ;
theVec[ SMDSEntity_Polyhedra ] = MED::ePOLYEDRE;
//theVec[ SMDSEntity_Quad_Polyhedra ] = MED::ePOLYEDRE; // !!

2
src/MEDWrapper/Base/MED_Common.hxx
View File

@ -70,7 +70,7 @@ namespace MED{
typedef enum {ePOINT1=1, eSEG2=102, eSEG3=103, eTRIA3=203,
eQUAD4=204, eTRIA6=206, eTRIA7=207, eQUAD8=208, eQUAD9=209,eTETRA4=304,
ePYRA5=305, ePENTA6=306, eHEXA8=308, eOCTA12=312, eTETRA10=310,
ePYRA13=313, ePENTA15=315, eHEXA20=320, eHEXA27=327,
ePYRA13=313, ePENTA15=315, ePENTA18=318, eHEXA20=320, eHEXA27=327,
ePOLYGONE=400, ePOLYGON2=420, ePOLYEDRE=500, eNONE=0,
eBALL=1101 /*no such a type in med.h, it's just a trick*/,
eAllGeoType=-1 } EGeometrieElement;

1
src/SMDS/SMDSAbs_ElementType.hxx
View File

@ -98,6 +98,7 @@ enum SMDSAbs_EntityType {
SMDSEntity_TriQuad_Hexa,
SMDSEntity_Penta,
SMDSEntity_Quad_Penta,
SMDSEntity_BiQuad_Penta,
SMDSEntity_Hexagonal_Prism,
SMDSEntity_Polyhedra,
SMDSEntity_Quad_Polyhedra,

146
src/SMDS/SMDS_Mesh.cxx
View File

@ -4210,7 +4210,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
//=======================================================================
//function : AddVolume
//purpose :
//purpose : 2d order Pentahedron (prism) with 15 nodes
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
@ -4238,7 +4238,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//=======================================================================
//function : AddVolumeWithID
//purpose :
//purpose : 2d order Pentahedron (prism) with 15 nodes
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
int n4, int n5, int n6,
@ -4267,7 +4267,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
//=======================================================================
//function : AddVolumeWithID
//purpose : 2d order Pentahedron with 15 nodes
//purpose : 2d order Pentahedron (prism) with 15 nodes
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
@ -4334,6 +4334,146 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
return volvtk;
}
//=======================================================================
//function : AddVolume
//purpose : 2d order Pentahedron (prism) with 18 nodes
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346)
{
int ID = myElementIDFactory->GetFreeID();
SMDS_MeshVolume * v =
SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n12, n23, n31,
n45, n56, n64, n14, n25, n36, n1245, n2356, n1346, ID);
if(v==NULL) myElementIDFactory->ReleaseID(ID);
return v;
}
//=======================================================================
//function : AddVolumeWithID
//purpose : 2d order Pentahedron (prism) with 18 nodes
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
int n4, int n5, int n6,
int n12,int n23,int n31,
int n45,int n56,int n64,
int n14,int n25,int n36,
int n1245, int n2356, int n1346, int ID)
{
return SMDS_Mesh::AddVolumeWithID
((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) ,
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) ,
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) ,
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) ,
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) ,
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6) ,
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n64),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n36),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1245),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2356),
(SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1346),
ID);
}
//=======================================================================
//function : AddVolumeWithID
//purpose : 2d order Pentahedron (prism) with 18 nodes
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346,
int ID)
{
if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n12 || !n23 ||
!n31 || !n45 || !n56 || !n64 || !n14 || !n25 || !n36 || !n1245 || !n2356 || !n1346)
return 0;
if(hasConstructionFaces()) {
// creation quadratic faces - not implemented
return 0;
}
// --- retrieve nodes ID
myNodeIds.resize(15);
myNodeIds[0] = n1->getVtkId();
myNodeIds[1] = n2->getVtkId();
myNodeIds[2] = n3->getVtkId();
myNodeIds[3] = n4->getVtkId();
myNodeIds[4] = n5->getVtkId();
myNodeIds[5] = n6->getVtkId();
myNodeIds[6] = n12->getVtkId();
myNodeIds[7] = n23->getVtkId();
myNodeIds[8] = n31->getVtkId();
myNodeIds[9] = n45->getVtkId();
myNodeIds[10] = n56->getVtkId();
myNodeIds[11] = n64->getVtkId();
myNodeIds[12] = n14->getVtkId();
myNodeIds[13] = n25->getVtkId();
myNodeIds[14] = n36->getVtkId();
myNodeIds[15] = n1245->getVtkId();
myNodeIds[16] = n2356->getVtkId();
myNodeIds[17] = n1346->getVtkId();
SMDS_VtkVolume *volvtk = myVolumePool->getNew();
volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
{
this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
myVolumePool->destroy(volvtk);
return 0;
}
adjustmyCellsCapacity(ID);
myCells[ID] = volvtk;
myInfo.myNbBiQuadPrisms++;
// if (!registerElement(ID, volvtk)) {
// RemoveElement(volvtk, false);
// volvtk = NULL;
// }
return volvtk;
}
//=======================================================================
//function : AddVolume

47
src/SMDS/SMDS_Mesh.hxx
View File

@ -454,6 +454,53 @@ public:
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36);
// 2d order Pentahedron with 18 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
int n4, int n5, int n6,
int n12,int n23,int n31,
int n45,int n56,int n64,
int n14,int n25,int n36,
int n1245, int n2356, int n1346,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346);
// 2d oreder Hexahedrons with 20 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int n6, int n7, int n8,

12
src/SMDS/SMDS_MeshCell.cxx
View File

@ -66,6 +66,7 @@ VTKCellType SMDS_MeshCell::toVtkType (SMDSAbs_EntityType smdsType)
vtkTypes[ SMDSEntity_TriQuad_Hexa ] = VTK_TRIQUADRATIC_HEXAHEDRON;
vtkTypes[ SMDSEntity_Penta ] = VTK_WEDGE;
vtkTypes[ SMDSEntity_Quad_Penta ] = VTK_QUADRATIC_WEDGE;
vtkTypes[ SMDSEntity_BiQuad_Penta ] = VTK_BIQUADRATIC_QUADRATIC_WEDGE;
vtkTypes[ SMDSEntity_Hexagonal_Prism ] = VTK_HEXAGONAL_PRISM;
vtkTypes[ SMDSEntity_Polyhedra ] = VTK_POLYHEDRON;
//vtkTypes[ SMDSEntity_Quad_Polyhedra ] = ;
@ -153,9 +154,13 @@ const std::vector< int >& SMDS_MeshCell::toVtkOrder(SMDSAbs_EntityType smdsType)
toVtkInterlaces[SMDSEntity_Penta].assign( &ids[0], &ids[0]+6 );
}
{
const int ids[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
const int ids[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14}; // TODO: check
toVtkInterlaces[SMDSEntity_Quad_Penta].assign( &ids[0], &ids[0]+15 );
}
{
const int ids[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17};// TODO: check
toVtkInterlaces[SMDSEntity_BiQuad_Penta].assign( &ids[0], &ids[0]+18 );
}
{
const int ids[] = {0,5,4,3,2,1,6,11,10,9,8,7};
toVtkInterlaces[SMDSEntity_Hexagonal_Prism].assign( &ids[0], &ids[0]+12 );
@ -254,6 +259,10 @@ const std::vector<int>& SMDS_MeshCell::reverseSmdsOrder(SMDSAbs_EntityType smdsT
reverseInterlaces[SMDSEntity_Quad_Penta].assign( &ids[0], &ids[0]+15 );
}
{
const int ids[] = {0,2,1,3,5,4, 8,7,6,11,10,9,12,14,13,15,16,17};
reverseInterlaces[SMDSEntity_BiQuad_Penta].assign( &ids[0], &ids[0]+18 );
}
{
const int ids[] = {0,5,4,3,2,1,6,11,10,9,8,7};
reverseInterlaces[SMDSEntity_Hexagonal_Prism].assign( &ids[0], &ids[0]+12 );
}
@ -414,6 +423,7 @@ SMDSAbs_ElementType SMDS_MeshCell::toSmdsType(SMDSAbs_EntityType entityType)
case SMDSEntity_TriQuad_Hexa:
case SMDSEntity_Penta:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
case SMDSEntity_Hexagonal_Prism:
case SMDSEntity_Polyhedra:
case SMDSEntity_Quad_Polyhedra: return SMDSAbs_Volume;

10
src/SMDS/SMDS_MeshInfo.hxx
View File

@ -64,6 +64,8 @@ public:
inline int NbPrisms (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline int NbHexPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriQuadHexas() const { return myNbTriQuadHexas; }
int NbQuadPrisms() const { return myNbQuadPrisms; }
int NbBiQuadPrisms() const { return myNbBiQuadPrisms; }
int NbPolyhedrons() const { return myNbPolyhedrons; }
protected:
@ -94,7 +96,7 @@ private:
int myNbTetras , myNbQuadTetras ;
int myNbHexas , myNbQuadHexas, myNbTriQuadHexas;
int myNbPyramids, myNbQuadPyramids;
int myNbPrisms , myNbQuadPrisms ;
int myNbPrisms , myNbQuadPrisms, myNbBiQuadPrisms;
int myNbHexPrism;
int myNbPolyhedrons;
@ -113,7 +115,7 @@ inline SMDS_MeshInfo::SMDS_MeshInfo():
myNbTetras (0), myNbQuadTetras (0),
myNbHexas (0), myNbQuadHexas (0), myNbTriQuadHexas(0),
myNbPyramids (0), myNbQuadPyramids(0),
myNbPrisms (0), myNbQuadPrisms (0),
myNbPrisms (0), myNbQuadPrisms (0), myNbBiQuadPrisms(0),
myNbHexPrism (0),
myNbPolyhedrons(0)
{
@ -297,7 +299,7 @@ SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
break;
case SMDSAbs_Volume:
nb = ( myNbTetras+ myNbPyramids+ myNbPrisms+ myNbHexas+ myNbHexPrism+
myNbQuadTetras+ myNbQuadPyramids+ myNbQuadPrisms+ myNbQuadHexas+ myNbTriQuadHexas+
myNbQuadTetras+ myNbQuadPyramids+ myNbQuadPrisms+ myNbBiQuadPrisms + myNbQuadHexas+ myNbTriQuadHexas+
myNbPolyhedrons );
break;
case SMDSAbs_Face:
@ -345,6 +347,7 @@ SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
case SMDSEntity_TriQuad_Hexa: return myNbTriQuadHexas;
case SMDSEntity_Penta: return myNbPrisms;
case SMDSEntity_Quad_Penta: return myNbQuadPrisms;
case SMDSEntity_BiQuad_Penta: return myNbBiQuadPrisms;
case SMDSEntity_Hexagonal_Prism: return myNbHexPrism;
case SMDSEntity_Polyhedra: return myNbPolyhedrons;
case SMDSEntity_0D: return myNb0DElements;
@ -414,6 +417,7 @@ SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
case SMDSEntity_Quad_Edge: myNbQuadEdges = nb; break;
case SMDSEntity_Quad_Hexa: myNbQuadHexas = nb; break;
case SMDSEntity_Quad_Penta: myNbQuadPrisms = nb; break;
case SMDSEntity_BiQuad_Penta: myNbBiQuadPrisms = nb; break;
case SMDSEntity_Quad_Pyramid: myNbQuadPyramids = nb; break;
case SMDSEntity_Quad_Quadrangle: myNbQuadQuadrangles = nb; break;
case SMDSEntity_Quad_Tetra: myNbQuadTetras = nb; break;

1
src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx
View File

@ -381,6 +381,7 @@ SMDSAbs_EntityType SMDS_QuadraticVolumeOfNodes::GetEntityType() const
case 10: aType = SMDSEntity_Quad_Tetra; break;
case 13: aType = SMDSEntity_Quad_Pyramid; break;
case 15: aType = SMDSEntity_Quad_Penta; break;
case 18: aType = SMDSEntity_BiQuad_Penta; break;
case 20:
default: aType = SMDSEntity_Quad_Hexa; break;
}

1
src/SMDS/SMDS_VtkCellIterator.cxx
View File

@ -115,6 +115,7 @@ SMDS_VtkCellIteratorToUNV::SMDS_VtkCellIteratorToUNV(SMDS_Mesh* mesh, int vtkCel
break;
}
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta: //TODO: check
{
static int id[] = { 0, 8, 2, 7, 1, 6, 12, 14, 13, 3, 11, 5, 10, 4, 9 };
ids = id;

24
src/SMDS/SMDS_VtkVolume.cxx
View File

@ -45,16 +45,17 @@ void SMDS_VtkVolume::init(const std::vector<vtkIdType>& nodeIds, SMDS_Mesh* mesh
vtkIdType aType = VTK_TETRA;
switch (nodeIds.size()) // cases are in order of usage frequency
{
case 4: aType = VTK_TETRA; break;
case 8: aType = VTK_HEXAHEDRON; break;
case 5: aType = VTK_PYRAMID; break;
case 6: aType = VTK_WEDGE; break;
case 10: aType = VTK_QUADRATIC_TETRA; break;
case 20: aType = VTK_QUADRATIC_HEXAHEDRON; break;
case 13: aType = VTK_QUADRATIC_PYRAMID; break;
case 15: aType = VTK_QUADRATIC_WEDGE; break;
case 12: aType = VTK_HEXAGONAL_PRISM; break;
case 27: aType = VTK_TRIQUADRATIC_HEXAHEDRON;break;
case 4: aType = VTK_TETRA; break;
case 8: aType = VTK_HEXAHEDRON; break;
case 5: aType = VTK_PYRAMID; break;
case 6: aType = VTK_WEDGE; break;
case 10: aType = VTK_QUADRATIC_TETRA; break;
case 20: aType = VTK_QUADRATIC_HEXAHEDRON; break;
case 13: aType = VTK_QUADRATIC_PYRAMID; break;
case 15: aType = VTK_QUADRATIC_WEDGE; break;
case 18: aType = VTK_BIQUADRATIC_QUADRATIC_WEDGE; break;
case 12: aType = VTK_HEXAGONAL_PRISM; break;
case 27: aType = VTK_TRIQUADRATIC_HEXAHEDRON; break;
default: aType = VTK_HEXAHEDRON;
}
myVtkID = mesh->getGrid()->InsertNextLinkedCell(aType, nodeIds.size(), (vtkIdType *) &nodeIds[0]);
@ -571,6 +572,9 @@ SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType() const
case VTK_QUADRATIC_WEDGE:
aType = SMDSEntity_Quad_Penta;
break;
case VTK_BIQUADRATIC_QUADRATIC_WEDGE:
aType = SMDSEntity_BiQuad_Penta;
break;
case VTK_QUADRATIC_HEXAHEDRON:
aType = SMDSEntity_Quad_Hexa;
break;

13
src/SMESH/SMESH_Mesh.cxx
View File

@ -1890,6 +1890,19 @@ int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const throw(SALOME_Exceptio
return _myMeshDS->GetMeshInfo().NbPrisms(order);
}
int SMESH_Mesh::NbQuadPrisms() const throw (SALOME_Exception)
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadPrisms();
}
int SMESH_Mesh::NbBiQuadPrisms() const throw (SALOME_Exception)
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadPrisms();
}
//================================================================================
/*!
* \brief Return number of hexagonal prisms in the mesh

2
src/SMESH/SMESH_Mesh.hxx
View File

@ -297,6 +297,8 @@ class SMESH_EXPORT SMESH_Mesh
int NbTriQuadraticHexas() const throw(SALOME_Exception);
int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbQuadPrisms() const throw(SALOME_Exception);
int NbBiQuadPrisms() const throw(SALOME_Exception);
int NbHexagonalPrisms() const throw(SALOME_Exception);
int NbPolyhedrons() const throw(SALOME_Exception);

18
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -1914,6 +1914,7 @@ namespace
break;
case SMDSEntity_Penta:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
connVariants = thePentaTo3; nbTet = 3; nbVariants = 6;
break;
default:
@ -9229,6 +9230,7 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
SMESH_MesherHelper& theHelper,
const bool theForce3d)
{
MESSAGE("convertElemToQuadratic");
int nbElem = 0;
if( !theSm ) return nbElem;
@ -9254,18 +9256,20 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
case SMDSEntity_Quad_Triangle:
case SMDSEntity_Quad_Quadrangle:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_Quad_Penta:
alreadyOK = !theHelper.GetIsBiQuadratic(); break;
case SMDSEntity_BiQuad_Triangle:
case SMDSEntity_BiQuad_Quadrangle:
case SMDSEntity_TriQuad_Hexa:
case SMDSEntity_BiQuad_Penta:
alreadyOK = theHelper.GetIsBiQuadratic();
hasCentralNodes = true;
break;
default:
alreadyOK = true;
}
// take into account already present modium nodes
// take into account already present medium nodes
switch ( aType ) {
case SMDSAbs_Volume:
theHelper.AddTLinks( static_cast< const SMDS_MeshVolume* >( elem )); break;
@ -9332,6 +9336,9 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], id, theForce3d);
break;
case SMDSEntity_Penta:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
MESSAGE("--- " << aGeomType);
NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], id, theForce3d);
break;
case SMDSEntity_Hexa:
@ -9362,6 +9369,7 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theToBiQuad)
{
MESSAGE("ConvertToQuadratic "<< theForce3d << " " << theToBiQuad);
SMESHDS_Mesh* meshDS = GetMeshDS();
SMESH_MesherHelper aHelper(*myMesh);
@ -9489,6 +9497,8 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theT
{
case SMDSEntity_Quad_Hexa: alreadyOK = !theToBiQuad; break;
case SMDSEntity_TriQuad_Hexa: alreadyOK = theToBiQuad; break;
case SMDSEntity_Quad_Penta: alreadyOK = !theToBiQuad; break;
case SMDSEntity_BiQuad_Penta: alreadyOK = theToBiQuad; break;
default: alreadyOK = true;
}
if ( alreadyOK )
@ -9526,8 +9536,14 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theT
nodes[3], nodes[4], id, theForce3d);
break;
case SMDSEntity_Penta:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
MESSAGE("--- " << type);
NewVolume = aHelper.AddVolume(nodes[0], nodes[1], nodes[2],
nodes[3], nodes[4], nodes[5], id, theForce3d);
for ( size_t i = 15; i < nodes.size(); ++i ) // rm central nodes
if ( nodes[i]->NbInverseElements() == 0 )
GetMeshDS()->RemoveFreeNode( nodes[i], /*sm=*/0, /*fromGroups=*/true );
break;
case SMDSEntity_Hexagonal_Prism:
default:

46
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -2179,13 +2179,30 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n14 = GetMediumNode( n1, n4, force3d, TopAbs_SOLID );
const SMDS_MeshNode* n25 = GetMediumNode( n2, n5, force3d, TopAbs_SOLID );
const SMDS_MeshNode* n36 = GetMediumNode( n3, n6, force3d, TopAbs_SOLID );
if ( myCreateBiQuadratic )
{
const SMDS_MeshNode* n1245 = GetCentralNode( n1,n2,n4,n5,n12,n25,n45,n14,force3d );
const SMDS_MeshNode* n1346 = GetCentralNode( n1,n3,n4,n6,n31,n36,n64,n14,force3d );
const SMDS_MeshNode* n2356 = GetCentralNode( n2,n3,n6,n5,n23,n36,n56,n25,force3d );
if(id)
elem = meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6,
n12, n23, n31, n45, n56, n64, n14, n25, n36, id);
if(id)
elem = meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6,
n12, n23, n31, n45, n56, n64, n14, n25, n36,
n1245, n2356, n1346, id);
else
elem = meshDS->AddVolume(n1, n2, n3, n4, n5, n6,
n12, n23, n31, n45, n56, n64, n14, n25, n36,
n1245, n2356, n1346);
}
else
elem = meshDS->AddVolume(n1, n2, n3, n4, n5, n6,
n12, n23, n31, n45, n56, n64, n14, n25, n36);
{
if(id)
elem = meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6,
n12, n23, n31, n45, n56, n64, n14, n25, n36, id);
else
elem = meshDS->AddVolume(n1, n2, n3, n4, n5, n6,
n12, n23, n31, n45, n56, n64, n14, n25, n36);
}
}
if ( mySetElemOnShape && myShapeID > 0 )
meshDS->SetMeshElementOnShape( elem, myShapeID );
@ -4866,6 +4883,7 @@ namespace { // Structures used by FixQuadraticElements()
void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
bool volumeOnly)
{
MESSAGE("FixQuadraticElements " << volumeOnly);
// setenv NO_FixQuadraticElements to know if FixQuadraticElements() is guilty of bad conversion
if ( getenv("NO_FixQuadraticElements") )
return;
@ -4893,6 +4911,7 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
}
else { // fix nodes in the solid and its faces
#ifdef _DEBUG_
MESSAGE("FIX SOLID " << nbSolids-- << " #" << GetMeshDS()->ShapeToIndex(s.Current()));
MSG("FIX SOLID " << nbSolids-- << " #" << GetMeshDS()->ShapeToIndex(s.Current()));
#endif
SMESH_MesherHelper h(*myMesh);
@ -4907,6 +4926,7 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
nbfaces = faces.Extent(); /*avoid "unused varianbles": */ nbfaces++, nbfaces--;
#endif
for ( TopTools_MapIteratorOfMapOfShape fIt( faces ); fIt.More(); fIt.Next() ) {
MESSAGE("FIX FACE " << nbfaces-- << " #" << GetMeshDS()->ShapeToIndex(fIt.Key()));
MSG("FIX FACE " << nbfaces-- << " #" << GetMeshDS()->ShapeToIndex(fIt.Key()));
SMESH_MesherHelper h(*myMesh);
h.SetSubShape( fIt.Key() );
@ -5263,10 +5283,11 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
// 4. Move nodes
// -------------
TIDSortedElemSet biQuadQuas, biQuadTris, triQuadHexa;
TIDSortedElemSet biQuadQuas, biQuadTris, triQuadHexa, biQuadPenta;
const bool toFixCentralNodes = ( myMesh->NbBiQuadQuadrangles() +
myMesh->NbBiQuadTriangles() +
myMesh->NbTriQuadraticHexas() );
myMesh->NbTriQuadraticHexas() +
myMesh->NbBiQuadPrisms());
double distXYZ[4];
faceHlp.ToFixNodeParameters( true );
@ -5302,6 +5323,7 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
case SMDSEntity_BiQuad_Quadrangle: biQuadQuas.insert( e ); break;
case SMDSEntity_BiQuad_Triangle: biQuadTris.insert( e ); break;
case SMDSEntity_TriQuad_Hexa: triQuadHexa.insert( e ); break;
case SMDSEntity_BiQuad_Penta: biQuadPenta.insert( e ); break;
default:;
}
}
@ -5452,6 +5474,16 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
nCenterCoords.X(), nCenterCoords.Y(), nCenterCoords.Z());
}
}
// treat tri-quadratic hexahedra
{
SMDS_VolumeTool volExp;
TIDSortedElemSet::iterator pentIt = biQuadPenta.begin();
for ( ; pentIt != biQuadPenta.end(); ++pentIt )
{
MESSAGE("---");
volExp.Set( *pentIt, /*ignoreCentralNodes=*/false );
}
}
#ifdef _DEBUG_
// avoid warning: defined but not used operator<<()
SMESH_Comment() << *links.begin() << *faces.begin();

39
src/SMESHDS/SMESHDS_Command.cxx
View File

@ -684,6 +684,43 @@ void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
myIntegers.push_back(n36);
myNumber++;
}
//=======================================================================
//function : AddVolume
//purpose :
//=======================================================================
void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
int n3, int n4, int n5,int n6,
int n12, int n23, int n31,
int n45, int n56, int n64,
int n14, int n25, int n36,
int n1245, int n2356, int n1346)
{
if ( myType != SMESHDS_AddBiQuadPentahedron) {
MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
return;
}
myIntegers.push_back(NewVolID);
myIntegers.push_back(n1);
myIntegers.push_back(n2);
myIntegers.push_back(n3);
myIntegers.push_back(n4);
myIntegers.push_back(n5);
myIntegers.push_back(n6);
myIntegers.push_back(n12);
myIntegers.push_back(n23);
myIntegers.push_back(n31);
myIntegers.push_back(n45);
myIntegers.push_back(n56);
myIntegers.push_back(n64);
myIntegers.push_back(n14);
myIntegers.push_back(n25);
myIntegers.push_back(n36);
myIntegers.push_back(n1245);
myIntegers.push_back(n2356);
myIntegers.push_back(n1346);
myNumber++;
}
//=======================================================================
//function : AddVolume
@ -735,7 +772,7 @@ void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
int n1234,int n1256,int n2367,int n3478,
int n1458,int n5678,int nCenter)
{
if ( myType != SMESHDS_AddQuadHexahedron) {
if ( myType != SMESHDS_AddTriQuadHexa) {
MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
return;
}

6
src/SMESHDS/SMESHDS_Command.hxx
View File

@ -83,6 +83,12 @@ class SMESHDS_EXPORT SMESHDS_Command
int n12, int n23, int n31,
int n45, int n56, int n64,
int n14, int n25, int n36);
void AddVolume(int NewVolID, int n1, int n2, int n3,
int n4, int n5, int n6,
int n12, int n23, int n31,
int n45, int n56, int n64,
int n14, int n25, int n36,
int n1245, int n2356, int n1346);
void AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
int n5, int n6, int n7, int n8,
int n12, int n23, int n34, int n41,

1
src/SMESHDS/SMESHDS_CommandType.hxx
View File

@ -58,6 +58,7 @@ enum SMESHDS_CommandType {
SMESHDS_Add0DElement,
SMESHDS_AddBiQuadTriangle,
SMESHDS_AddBiQuadQuadrangle,
SMESHDS_AddBiQuadPentahedron,
SMESHDS_AddTriQuadHexa,
SMESHDS_AddHexagonalPrism,
SMESHDS_AddBall

97
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -1862,7 +1862,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
//=======================================================================
//function : AddVolume
//purpose :
//purpose : 2nd order pentahedron (prism) with 15 nodes
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
@ -1893,7 +1893,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//=======================================================================
//function : AddVolumeWithID
//purpose :
//purpose : 2nd order pentahedron (prism) with 15 nodes
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
int n4, int n5, int n6,
@ -1909,10 +1909,96 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
n45,n56,n64,n14,n25,n36);
return anElem;
}
//=======================================================================
//function : AddVolumeWithID
//purpose : 2d order Pentahedron (prism) with 15 nodes
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID)
{
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n4->GetID(), n5->GetID(), n6->GetID(),
n12->GetID(), n23->GetID(), n31->GetID(),
n45->GetID(), n56->GetID(), n64->GetID(),
n14->GetID(), n25->GetID(), n36->GetID(),
ID);
}
//=======================================================================
//function : AddVolume
//purpose : 2nd order pentahedron (prism) with 18 nodes
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n12,n23,n31,
n45,n56,n64,n14,n25,n36,
n1245, n2356, n1346);
if(anElem)
myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
n3->GetID(), n4->GetID(), n5->GetID(), n6->GetID(),
n12->GetID(), n23->GetID(), n31->GetID(),
n45->GetID(), n56->GetID(), n64->GetID(),
n14->GetID(), n25->GetID(), n36->GetID(),
n1245->GetID(), n2356->GetID(), n1346->GetID());
return anElem;
}
//=======================================================================
//function : AddVolumeWithID
//purpose : 2nd order pentahedron (prism) with 18 nodes
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
int n4, int n5, int n6,
int n12,int n23,int n31,
int n45,int n56,int n64,
int n14,int n25,int n36,
int n1245, int n2356, int n1346,
int ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
n12,n23,n31,
n45,n56,n64,
n14,n25,n36,
n1245, n2356, n1346, ID);
if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n12,n23,n31,
n45,n56,n64,n14,n25,n36, n1245, n2356, n1346);
return anElem;
}
//=======================================================================
//function : AddVolumeWithID
//purpose : 2d order Pentahedron with 15 nodes
//purpose : 2d order Pentahedron with 18 nodes
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
@ -1929,6 +2015,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346,
int ID)
{
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
@ -1936,7 +2025,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
n12->GetID(), n23->GetID(), n31->GetID(),
n45->GetID(), n56->GetID(), n64->GetID(),
n14->GetID(), n25->GetID(), n36->GetID(),
ID);
n1245->GetID(), n2356->GetID(), n1346->GetID(), ID);
}

46
src/SMESHDS/SMESHDS_Mesh.hxx
View File

@ -389,6 +389,52 @@ public:
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36);
// 2d order Pentahedron with 18 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
int n4, int n5, int n6,
int n12,int n23,int n31,
int n45,int n56,int n64,
int n14,int n25,int n36,
int n1245, int n2356, int n1346,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346,
int ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * n45,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n64,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346);
// 2d order Hexahedrons with 20 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int n6, int n7, int n8,

21
src/SMESHDS/SMESHDS_Script.cxx
View File

@ -550,6 +550,27 @@ void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
//function : AddVolume
//purpose :
//=======================================================================
void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
int n5,int n6, int n12, int n23, int n31,
int n45, int n56, int n64,
int n14, int n25, int n36,
int n1245, int n2356, int n1346)
{
if(myIsEmbeddedMode){
myIsModified = true;
return;
}
getCommand(SMESHDS_AddBiQuadPentahedron)->AddVolume(NewVolID, n1,n2,n3,n4,n5,n6,
n12, n23, n31,
n45, n56, n64,
n14, n25, n36,
n1245, n2356, n1346);
}
//=======================================================================
//function : AddVolume
//purpose :
//=======================================================================
void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3,
int n4, int n5, int n6, int n7, int n8,
int n12, int n23, int n34, int n41,

6
src/SMESHDS/SMESHDS_Script.hxx
View File

@ -91,6 +91,12 @@ class SMESHDS_EXPORT SMESHDS_Script
int n12, int n23, int n31,
int n45, int n56, int n64,
int n14, int n25, int n36);
void AddVolume(int NewVolID, int n1, int n2, int n3,
int n4, int n5, int n6,
int n12, int n23, int n31,
int n45, int n56, int n64,
int n14, int n25, int n36,
int n1245, int n2356, int n1346);
void AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
int n5, int n6, int n7, int n8,
int n12, int n23, int n34, int n41,

9
src/SMESHGUI/SMESHGUI.cxx
View File

@ -603,6 +603,7 @@ namespace
notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
@ -626,6 +627,7 @@ namespace
"SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
"SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
"SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
"SMESH_BIQUADRATIC_PENTAHEDRONS",
"SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
};
// is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
@ -2124,7 +2126,7 @@ bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
info[SMDSEntity_Polyhedra] +
info[SMDSEntity_Hexagonal_Prism];
long nbBalls = info[SMDSEntity_Ball];
@ -3304,6 +3306,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
case SMESHOp::OpQuadraticTetrahedron:
case SMESHOp::OpQuadraticPyramid:
case SMESHOp::OpQuadraticPentahedron:
case SMESHOp::OpBiQuadraticPentahedron:
case SMESHOp::OpQuadraticHexahedron:
case SMESHOp::OpTriQuadraticHexahedron:
{
@ -3322,6 +3325,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
default: break;
@ -3954,6 +3958,7 @@ void SMESHGUI::initialize( CAM_Application* app )
createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
@ -4190,6 +4195,7 @@ void SMESHGUI::initialize( CAM_Application* app )
createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
@ -4335,6 +4341,7 @@ void SMESHGUI::initialize( CAM_Application* app )
createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );

13
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -380,6 +380,9 @@ SMESHGUI_AddQuadraticElementDlg::SMESHGUI_AddQuadraticElementDlg( SMESHGUI* theM
case SMDSEntity_Quad_Penta:
anElementName = QString("QUADRATIC_PENTAHEDRON");
break;
case SMDSEntity_BiQuad_Penta:
anElementName = QString("BIQUADRATIC_PENTAHEDRON");
break;
case SMDSEntity_Quad_Hexa:
anElementName = QString("QUADRATIC_HEXAHEDRON");
break;
@ -587,6 +590,12 @@ void SMESHGUI_AddQuadraticElementDlg::Init()
myNbCorners = 6;
myHelpFileName = "adding_quadratic_elements_page.html#?"; //Adding_pentahedrons
break;
case SMDSEntity_BiQuad_Penta:
aNumRows = 9;
myNbCorners = 6;
myNbMidFaceNodes = 3;
myHelpFileName = "adding_quadratic_elements_page.html#?"; //Adding_pentahedrons
break;
case SMDSEntity_Quad_Hexa:
aNumRows = 12;
myNbCorners = 8;
@ -707,6 +716,7 @@ bool SMESHGUI_AddQuadraticElementDlg::ClickOnApply()
case SMDSEntity_Quad_Tetra:
case SMDSEntity_Quad_Pyramid:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
for ( int row = 0; row < myNbCorners; row++ )
@ -790,6 +800,7 @@ bool SMESHGUI_AddQuadraticElementDlg::ClickOnApply()
case SMDSEntity_Quad_Tetra:
case SMDSEntity_Quad_Pyramid:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
anElementType = SMESH::VOLUME;
@ -1068,6 +1079,7 @@ void SMESHGUI_AddQuadraticElementDlg::SelectionIntoArgument()
case SMDSEntity_Quad_Tetra:
case SMDSEntity_Quad_Pyramid:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
anElementType = SMESH::VOLUME; break;
@ -1402,6 +1414,7 @@ void SMESHGUI_AddQuadraticElementDlg::UpdateTable( bool theConersValidity )
aLastColIds = LastPyramidIds;
break;
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
aFirstColIds = FirstPentahedronIds;
aLastColIds = LastPentahedronIds;
break;

1
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
View File

@ -332,6 +332,7 @@ SMESHGUI_ConvToQuadOp::DestinationMesh( const SMESH::SMESH_IDSource_var& idSourc
bool hasBiQuad = ( nbElemOfType[SMDSEntity_BiQuad_Triangle ] ||
nbElemOfType[SMDSEntity_BiQuad_Quadrangle ] ||
nbElemOfType[SMDSEntity_BiQuad_Penta ] ||
nbElemOfType[SMDSEntity_TriQuad_Hexa ] );
bool hasLinBiQuad = ( nbElemOfType[SMDSEntity_Triangle ] ||
nbElemOfType[SMDSEntity_Quadrangle ] ||

1
src/SMESHGUI/SMESHGUI_FilterDlg.cxx
View File

@ -1753,6 +1753,7 @@ static QList<int> entityTypes( const int theType )
typeIds.append( SMDSEntity_TriQuad_Hexa );
typeIds.append( SMDSEntity_Penta );
typeIds.append( SMDSEntity_Quad_Penta );
typeIds.append( SMDSEntity_BiQuad_Penta );
typeIds.append( SMDSEntity_Hexagonal_Prism );
typeIds.append( SMDSEntity_Polyhedra );
//typeIds.append( SMDSEntity_Quad_Polyhedra );

12
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
View File

@ -386,6 +386,8 @@ SMESHGUI_MeshInfo::SMESHGUI_MeshInfo( QWidget* parent )
a3DPriLin->setObjectName("nbLinearPrism");
QLabel* a3DPriQuad = createField();
a3DPriQuad->setObjectName("nbQuadraticPrism");
QLabel* a3DPriBiQuad = createField();
a3DPriBiQuad->setObjectName("nbBiQuadraticPrism");
QLabel* a3DHexPriLab = new QLabel( tr( "HEX_PRISMS_LAB" ), this );
QLabel* a3DHexPriTotal = createField();
a3DHexPriTotal->setObjectName("nbHexagonalPrism");
@ -397,7 +399,7 @@ SMESHGUI_MeshInfo::SMESHGUI_MeshInfo( QWidget* parent )
myWidgets[ index++ ] << a3DTetLab << a3DTetTotal << a3DTetLin << a3DTetQuad;
myWidgets[ index++ ] << a3DHexLab << a3DHexTotal << a3DHexLin << a3DHexQuad << a3DHexBiQuad;
myWidgets[ index++ ] << a3DPyrLab << a3DPyrTotal << a3DPyrLin << a3DPyrQuad;
myWidgets[ index++ ] << a3DPriLab << a3DPriTotal << a3DPriLin << a3DPriQuad;
myWidgets[ index++ ] << a3DPriLab << a3DPriTotal << a3DPriLin << a3DPriQuad << a3DPriBiQuad;
myWidgets[ index++ ] << a3DHexPriLab << a3DHexPriTotal;
myWidgets[ index++ ] << a3DPolLab << a3DPolTotal;
@ -491,6 +493,7 @@ SMESHGUI_MeshInfo::SMESHGUI_MeshInfo( QWidget* parent )
l->addWidget( a3DPriTotal, 24, 1 );
l->addWidget( a3DPriLin, 24, 2 );
l->addWidget( a3DPriQuad, 24, 3 );
l->addWidget( a3DPriBiQuad, 24, 4 );
l->addWidget( a3DHexPriLab, 25, 0 );
l->addWidget( a3DHexPriTotal, 25, 1 );
l->addWidget( a3DPolLab, 26, 0 );
@ -581,10 +584,10 @@ void SMESHGUI_MeshInfo::showInfo( SMESH::SMESH_IDSource_ptr obj )
long nbTetrahedrons = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra];
long nbHexahedrons = info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa];
long nbPyramids = info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid];
long nbPrisms = info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta];
long nbPrisms = info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta];
long nb3DLinear = info[SMDSEntity_Tetra] + info[SMDSEntity_Hexa] + info[SMDSEntity_Pyramid] + info[SMDSEntity_Penta] + info[SMDSEntity_Polyhedra] + info[SMDSEntity_Hexagonal_Prism];
long nb3DQuadratic = info[SMDSEntity_Quad_Tetra] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_Quad_Pyramid] + info[SMDSEntity_Quad_Penta];
long nb3DBiQuadratic = info[SMDSEntity_TriQuad_Hexa];
long nb3DBiQuadratic = info[SMDSEntity_TriQuad_Hexa] + info[SMDSEntity_BiQuad_Penta];
long nb3DTotal = nb3DLinear + nb3DQuadratic + nb3DBiQuadratic;
myWidgets[i3D][iTotal] ->setProperty( "text", QString::number( nb3DTotal ));
myWidgets[i3D][iLinear] ->setProperty( "text", QString::number( nb3DLinear ));
@ -603,6 +606,7 @@ void SMESHGUI_MeshInfo::showInfo( SMESH::SMESH_IDSource_ptr obj )
myWidgets[i3DPrisms][iTotal] ->setProperty( "text", QString::number( nbPrisms ));
myWidgets[i3DPrisms][iLinear] ->setProperty( "text", QString::number( info[SMDSEntity_Penta] ));
myWidgets[i3DPrisms][iQuadratic] ->setProperty( "text", QString::number( info[SMDSEntity_Quad_Penta] ));
myWidgets[i3DPrisms][iBiQuadratic] ->setProperty( "text", QString::number( info[SMDSEntity_BiQuad_Penta] ));
myWidgets[i3DHexaPrisms][iTotal] ->setProperty( "text", QString::number( info[SMDSEntity_Hexagonal_Prism] ));
myWidgets[i3DPolyhedrons][iTotal] ->setProperty( "text", QString::number( info[SMDSEntity_Polyhedra] ));
long nbElemTotal = info[SMDSEntity_0D] + info[SMDSEntity_Ball] + nbEdges + nb2DTotal + nb3DTotal;
@ -1374,6 +1378,7 @@ void SMESHGUI_SimpleElemInfo::information( const QList<long>& ids )
gtype = SMESHGUI_ElemInfo::tr( "HEXAHEDRON" ); break;
case SMDSEntity_Penta:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
gtype = SMESHGUI_ElemInfo::tr( "PRISM" ); break;
case SMDSEntity_Hexagonal_Prism:
gtype = SMESHGUI_ElemInfo::tr( "HEX_PRISM" ); break;
@ -1896,6 +1901,7 @@ void SMESHGUI_TreeElemInfo::information( const QList<long>& ids )
gtype = SMESHGUI_ElemInfo::tr( "HEXAHEDRON" ); break;
case SMDSEntity_Penta:
case SMDSEntity_Quad_Penta:
case SMDSEntity_BiQuad_Penta:
gtype = SMESHGUI_ElemInfo::tr( "PRISM" ); break;
case SMDSEntity_Hexagonal_Prism:
gtype = SMESHGUI_ElemInfo::tr( "HEX_PRISM" ); break;

17
src/SMESHGUI/SMESHGUI_MeshInfosBox.cxx
View File

@ -70,7 +70,7 @@ SMESHGUI_MeshInfosBox::SMESHGUI_MeshInfosBox(const bool full, QWidget* theParent
myNbHexa(0), myNbLinHexa(0), myNbQuadHexa(0), myNbBiQuadHexa(0),
myNbTetra(0),myNbLinTetra(0),myNbQuadTetra(0),
myNbPyra(0), myNbLinPyra(0), myNbQuadPyra(0),
myNbPrism(0),myNbLinPrism(0), myNbQuadPrism(0),
myNbPrism(0),myNbLinPrism(0), myNbQuadPrism(0), myNbBiQuadPrism(0),
myNbVolum(0), myNbLinVolum(0), myNbQuadVolum(0), myNbBiQuadVolum(0),
myNbHexaPrism(0),
myNbPolyh(0)
@ -309,6 +309,9 @@ SMESHGUI_MeshInfosBox::SMESHGUI_MeshInfosBox(const bool full, QWidget* theParent
myNbQuadPrism = new QLabel( this );
l->addWidget( myNbQuadPrism, row, 3 );
// --
myNbBiQuadPrism = new QLabel( this );
l->addWidget( myNbBiQuadPrism, row, 4 );
// --
row++; // increment row count
// ... hexa prisms
lab = new QLabel(COLONIZE(tr("SMESH_MESHINFO_HEXAPRISM")), this );
@ -460,6 +463,7 @@ void SMESHGUI_MeshInfosBox::SetMeshInfo(const SMESH::long_array& theInfo)
theInfo[SMDSEntity_TriQuad_Hexa] +
theInfo[SMDSEntity_Penta] +
theInfo[SMDSEntity_Quad_Penta] +
theInfo[SMDSEntity_BiQuad_Penta] +
theInfo[SMDSEntity_Hexagonal_Prism] +
theInfo[SMDSEntity_Polyhedra] ));
myNbLinVolum ->setText( QString("%1").arg( theInfo[SMDSEntity_Tetra] +
@ -471,7 +475,8 @@ void SMESHGUI_MeshInfosBox::SetMeshInfo(const SMESH::long_array& theInfo)
theInfo[SMDSEntity_Quad_Pyramid] +
theInfo[SMDSEntity_Quad_Hexa] +
theInfo[SMDSEntity_Quad_Penta] ));
myNbBiQuadVolum->setText( QString("%1").arg( theInfo[SMDSEntity_TriQuad_Hexa] ));
myNbBiQuadVolum->setText( QString("%1").arg( theInfo[SMDSEntity_TriQuad_Hexa] +
theInfo[SMDSEntity_BiQuad_Penta] ));
if ( myFull )
{
@ -514,9 +519,11 @@ void SMESHGUI_MeshInfosBox::SetMeshInfo(const SMESH::long_array& theInfo)
myNbQuadPyra ->setText( QString("%1").arg( theInfo[SMDSEntity_Quad_Pyramid] ));
// prisms
myNbPrism ->setText( QString("%1").arg( theInfo[SMDSEntity_Penta] +
theInfo[SMDSEntity_Quad_Penta] ));
myNbLinPrism ->setText( QString("%1").arg( theInfo[SMDSEntity_Penta] ));
myNbQuadPrism->setText( QString("%1").arg( theInfo[SMDSEntity_Quad_Penta] ));
theInfo[SMDSEntity_Quad_Penta] +
theInfo[SMDSEntity_BiQuad_Penta] ));
myNbLinPrism ->setText( QString("%1").arg( theInfo[SMDSEntity_Penta] ));
myNbQuadPrism ->setText( QString("%1").arg( theInfo[SMDSEntity_Quad_Penta] ));
myNbBiQuadPrism->setText( QString("%1").arg( theInfo[SMDSEntity_BiQuad_Penta] ));
// octahedra
myNbHexaPrism->setText( QString("%1").arg( theInfo[ SMDSEntity_Hexagonal_Prism ]));
// polyedres

1
src/SMESHGUI/SMESHGUI_MeshInfosBox.h
View File

@ -84,6 +84,7 @@ private:
QLabel* myNbPrism;
QLabel* myNbLinPrism;
QLabel* myNbQuadPrism;
QLabel* myNbBiQuadPrism;
QLabel* myNbVolum;
QLabel* myNbLinVolum;
QLabel* myNbQuadVolum;

7
src/SMESHGUI/SMESHGUI_Operations.h
View File

@ -146,9 +146,10 @@ namespace SMESHOp {
OpQuadraticTetrahedron = 4105, // MENU MODIFICATION - ADD - QUADRATIC TETRAHEDRON
OpQuadraticPyramid = 4106, // MENU MODIFICATION - ADD - QUADRATIC PYRAMID
OpQuadraticPentahedron = 4107, // MENU MODIFICATION - ADD - QUADRATIC PENTAHEDRON
OpQuadraticHexahedron = 4108, // MENU MODIFICATION - ADD - QUADRATIC HEXAHEDRON
OpTriQuadraticHexahedron = 4109, // MENU MODIFICATION - ADD - TRIQUADRATIC HEXAHEDRON
OpQuadraticPolygon = 4110, // MENU MODIFICATION - ADD - QUADRATIC POLYGON
OpBiQuadraticPentahedron = 4108, // MENU MODIFICATION - ADD - BIQUADRATIC PENTAHEDRON
OpQuadraticHexahedron = 4110, // MENU MODIFICATION - ADD - QUADRATIC HEXAHEDRON
OpTriQuadraticHexahedron = 4111, // MENU MODIFICATION - ADD - TRIQUADRATIC HEXAHEDRON
OpQuadraticPolygon = 4112, // MENU MODIFICATION - ADD - QUADRATIC POLYGON
OpRemoveNodes = 4200, // MENU MODIFICATION - REMOVE - NODE
OpRemoveElements = 4201, // MENU MODIFICATION - REMOVE - ELEMENTS
OpRemoveOrphanNodes = 4202, // MENU MODIFICATION - REMOVE - ORPHAN NODES

4
src/SMESHGUI/SMESH_images.ts
View File

@ -211,6 +211,10 @@
<source>ICON_DLG_QUADRATIC_PENTAHEDRON</source>
<translation>mesh_quad_pentahedron.png</translation>
</message>
<message>
<source>ICON_DLG_BIQUADRATIC_PENTAHEDRON</source>
<translation>mesh_quad_pentahedron.png</translation>
</message>
<message>
<source>ICON_DLG_QUADRATIC_PYRAMID</source>
<translation>mesh_quad_pyramid.png</translation>

28
src/SMESHGUI/SMESH_msg_en.ts
View File

@ -892,6 +892,10 @@
<source>MEN_QUADRATIC_PENTAHEDRON</source>
<translation>Quadratic Pentahedron</translation>
</message>
<message>
<source>MEN_BIQUADRATIC_PENTAHEDRON</source>
<translation>BiQuadratic Pentahedron</translation>
</message>
<message>
<source>MEN_QUADRATIC_PYRAMID</source>
<translation>Quadratic Pyramid</translation>
@ -1370,6 +1374,10 @@ Please enter correct values and try again</translation>
<source>SMESH_ADD_QUADRATIC_PENTAHEDRON_TITLE</source>
<translation>Add Quadratic Pentahedron</translation>
</message>
<message>
<source>SMESH_ADD_BIQUADRATIC_PENTAHEDRON_TITLE</source>
<translation>Add BiQuadratic Pentahedron</translation>
</message>
<message>
<source>SMESH_ADD_QUADRATIC_PYRAMID_TITLE</source>
<translation>Add Quadratic Pyramid</translation>
@ -2530,10 +2538,18 @@ Check algorithm documentation for supported geometry</translation>
<source>SMESH_QUADRATIC_PENTAHEDRON</source>
<translation>Quadratic Pentahedron</translation>
</message>
<message>
<source>SMESH_BIQUADRATIC_PENTAHEDRON</source>
<translation>BiQuadratic Pentahedron</translation>
</message>
<message>
<source>SMESH_QUADRATIC_PENTAHEDRONS</source>
<translation>Quadratic Pentahedrons</translation>
</message>
<message>
<source>SMESH_BIQUADRATIC_PENTAHEDRONS</source>
<translation>BiQuadratic Pentahedrons</translation>
</message>
<message>
<source>SMESH_QUADRATIC_PYRAMID</source>
<translation>Quadratic Pyramid</translation>
@ -3386,6 +3402,10 @@ Use Display Entity menu command to show them.
<source>STB_QUADRATIC_PENTAHEDRON</source>
<translation>Quadratic Pentahedron</translation>
</message>
<message>
<source>STB_BIQUADRATIC_PENTAHEDRON</source>
<translation>BiQuadratic Pentahedron</translation>
</message>
<message>
<source>STB_QUADRATIC_PYRAMID</source>
<translation>Quadratic Pyramid</translation>
@ -4062,6 +4082,10 @@ Use Display Entity menu command to show them.
<source>TOP_QUADRATIC_PENTAHEDRON</source>
<translation>Quadratic Pentahedron</translation>
</message>
<message>
<source>TOP_BIQUADRATIC_PENTAHEDRON</source>
<translation>BiQuadratic Pentahedron</translation>
</message>
<message>
<source>TOP_QUADRATIC_PYRAMID</source>
<translation>Quadratic Pyramid</translation>
@ -4899,6 +4923,10 @@ Please, create VTK viewer and try again</translation>
<source>SMESH_ADD_QUADRATIC_PENTAHEDRON</source>
<translation>Add Quadratic Pentahedron</translation>
</message>
<message>
<source>SMESH_ADD_BIQUADRATIC_PENTAHEDRON</source>
<translation>Add BiQuadratic Pentahedron</translation>
</message>
<message>
<source>SMESH_ADD_QUADRATIC_PYRAMID</source>
<translation>Add Quadratic Pyramid</translation>

28
src/SMESHGUI/SMESH_msg_fr.ts
View File

@ -872,6 +872,10 @@
<source>MEN_QUADRATIC_PENTAHEDRON</source>
<translation>Pentaèdre quadratique</translation>
</message>
<message>
<source>MEN_BIQUADRATIC_PENTAHEDRON</source>
<translation>Pentaèdre biquadratique</translation>
</message>
<message>
<source>MEN_QUADRATIC_PYRAMID</source>
<translation>Pyramide quadratique</translation>
@ -1350,6 +1354,10 @@ Merci de les corriger, puis essayez de nouveau</translation>
<source>SMESH_ADD_QUADRATIC_PENTAHEDRON_TITLE</source>
<translation>Ajouter un pentaèdre quadratique</translation>
</message>
<message>
<source>SMESH_ADD_BIQUADRATIC_PENTAHEDRON_TITLE</source>
<translation>Ajouter un pentaèdre biquadratique</translation>
</message>
<message>
<source>SMESH_ADD_QUADRATIC_PYRAMID_TITLE</source>
<translation>Ajouter une pyramide quadratique</translation>
@ -2510,10 +2518,18 @@ Référez-vous à la documentation sur l&apos;algorithme et la géométrie suppo
<source>SMESH_QUADRATIC_PENTAHEDRON</source>
<translation>Pentaèdre quadratique</translation>
</message>
<message>
<source>SMESH_BIQUADRATIC_PENTAHEDRON</source>
<translation>Pentaèdre biquadratique</translation>
</message>
<message>
<source>SMESH_QUADRATIC_PENTAHEDRONS</source>
<translation>Pentaèdres quadratiques</translation>
</message>
<message>
<source>SMESH_BIQUADRATIC_PENTAHEDRONS</source>
<translation>Pentaèdres biquadratiques</translation>
</message>
<message>
<source>SMESH_QUADRATIC_PYRAMID</source>
<translation>Pyramide quadratique</translation>
@ -3367,6 +3383,10 @@ Utilisez le menu &quot;Visualiser une entité&quot; pour les afficher.
<source>STB_QUADRATIC_PENTAHEDRON</source>
<translation>Pentaèdre quadratique</translation>
</message>
<message>
<source>STB_BIQUADRATIC_PENTAHEDRON</source>
<translation>Pentaèdre biquadratique</translation>
</message>
<message>
<source>STB_QUADRATIC_PYRAMID</source>
<translation>Pyramide quadratique</translation>
@ -4043,6 +4063,10 @@ Utilisez le menu &quot;Visualiser une entité&quot; pour les afficher.
<source>TOP_QUADRATIC_PENTAHEDRON</source>
<translation>Pentaèdre quadratique</translation>
</message>
<message>
<source>TOP_BIQUADRATIC_PENTAHEDRON</source>
<translation>Pentaèdre biquadratique</translation>
</message>
<message>
<source>TOP_QUADRATIC_PYRAMID</source>
<translation>Pyramide quadratique</translation>
@ -4880,6 +4904,10 @@ Ouvrez une fenêtre VTK et essayez de nouveau</translation>
<source>SMESH_ADD_QUADRATIC_PENTAHEDRON</source>
<translation>Ajouter un pentaèdre quadratique</translation>
</message>
<message>
<source>SMESH_ADD_BIQUADRATIC_PENTAHEDRON</source>
<translation>Ajouter un pentaèdre biquadratique</translation>
</message>
<message>
<source>SMESH_ADD_QUADRATIC_PYRAMID</source>
<translation>Ajouter une pyramide quadratique</translation>

2
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -922,7 +922,7 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
"Entity_Polygon", "Entity_Quad_Polygon", "Entity_Tetra", "Entity_Quad_Tetra",
"Entity_Pyramid", "Entity_Quad_Pyramid",
"Entity_Hexa", "Entity_Quad_Hexa", "Entity_TriQuad_Hexa",
"Entity_Penta", "Entity_Quad_Penta", "Entity_Hexagonal_Prism",
"Entity_Penta", "Entity_Quad_Penta", "Entity_BiQuad_Penta", "Entity_Hexagonal_Prism",
"Entity_Polyhedra", "Entity_Quad_Polyhedra", "Entity_Ball" };
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];

1
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -234,6 +234,7 @@ namespace SMESH
case Entity_TriQuad_Hexa: myStream<<"Entity_TriQuad_Hexa"; break;
case Entity_Penta: myStream<<"Entity_Penta"; break;
case Entity_Quad_Penta: myStream<<"Entity_Quad_Penta"; break;
case Entity_BiQuad_Penta: myStream<<"Entity_BiQuad_Penta"; break;
case Entity_Hexagonal_Prism: myStream<<"Entity_Hexagonal_Prism"; break;
case Entity_Polyhedra: myStream<<"Entity_Polyhedra"; break;
case Entity_Quad_Polyhedra: myStream<<"Entity_Quad_Polyhedra"; break;

1
src/Tools/Verima/Stats/Type_Maille.py
View File

@ -20,6 +20,7 @@ dicoDimENtite= { 'Entity_Node':0,
'Entity_Quad_Pyramid':1,
'Entity_Penta ':1,
'Entity_Quad_Penta':1,
'Entity_BiQuad_Penta':1,
'Entity_Hexagonal_Prism':1,
'Entity_Polyhedra':1,
'Entity_Quad_Polyhedra':1,