Salome HOME
introduce biquadratic quadratic pentahedron (18 nodes)
authorPaul RASCLE <paul.rascle@edf.fr>
Thu, 7 Sep 2017 12:04:57 +0000 (14:04 +0200)
committerPaul RASCLE <paul.rascle@edf.fr>
Fri, 8 Sep 2017 15:10:31 +0000 (17:10 +0200)
38 files changed:
idl/SMESH_Mesh.idl
src/Controls/SMESH_Controls.cxx
src/DriverCGNS/DriverCGNS_Write.cxx
src/DriverMED/DriverMED_W_Field.cxx
src/MEDWrapper/Base/MED_Common.hxx
src/SMDS/SMDSAbs_ElementType.hxx
src/SMDS/SMDS_Mesh.cxx
src/SMDS/SMDS_Mesh.hxx
src/SMDS/SMDS_MeshCell.cxx
src/SMDS/SMDS_MeshInfo.hxx
src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx
src/SMDS/SMDS_VtkCellIterator.cxx
src/SMDS/SMDS_VtkVolume.cxx
src/SMESH/SMESH_Mesh.cxx
src/SMESH/SMESH_Mesh.hxx
src/SMESH/SMESH_MeshEditor.cxx
src/SMESH/SMESH_MesherHelper.cxx
src/SMESHDS/SMESHDS_Command.cxx
src/SMESHDS/SMESHDS_Command.hxx
src/SMESHDS/SMESHDS_CommandType.hxx
src/SMESHDS/SMESHDS_Mesh.cxx
src/SMESHDS/SMESHDS_Mesh.hxx
src/SMESHDS/SMESHDS_Script.cxx
src/SMESHDS/SMESHDS_Script.hxx
src/SMESHGUI/SMESHGUI.cxx
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
src/SMESHGUI/SMESHGUI_FilterDlg.cxx
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
src/SMESHGUI/SMESHGUI_MeshInfosBox.cxx
src/SMESHGUI/SMESHGUI_MeshInfosBox.h
src/SMESHGUI/SMESHGUI_Operations.h
src/SMESHGUI/SMESH_images.ts
src/SMESHGUI/SMESH_msg_en.ts
src/SMESHGUI/SMESH_msg_fr.ts
src/SMESH_I/SMESH_2smeshpy.cxx
src/SMESH_I/SMESH_DumpPython.cxx
src/Tools/Verima/Stats/Type_Maille.py

index d96d67d..f3feeae 100644 (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,
index 9485d98..9333e70 100644 (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 ));
index 3692ae5..14f1c10 100644 (file)
@@ -131,6 +131,11 @@ namespace
         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;
         cgTypes   [SMDSEntity_Hexa] = CGNS_ENUMV( HEXA_8 );
index e4a7e42..b012325 100644 (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; // !!
index 390e1d6..8030d84 100644 (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;
index 10ee0d5..491f4f0 100644 (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,
index 7c8e663..5a0be64 100644 (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
index d1d0b11..c1fea28 100644 (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,
index 6b7f04e..7175ae5 100644 (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,10 +154,14 @@ 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;
index d8bcf90..2042ba6 100644 (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;
index 92da9c6..f9c689a 100644 (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;
   }
index 2fc70ee..a0f0d37 100644 (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;
index 8f66ff0..bb5b3e9 100644 (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;
index cf9f77f..76987e5 100644 (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
index 91a1f2c..054616c 100644 (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);
   
index c477e72..d134559 100644 (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:
index 4d8f995..e9e21bc 100644 (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();
index 05aece9..3c2ae95 100644 (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;
   }
index 799de67..4af0053 100644 (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,
index 1d03cc2..f1a21ad 100644 (file)
@@ -58,6 +58,7 @@ enum SMESHDS_CommandType {
   SMESHDS_Add0DElement,
   SMESHDS_AddBiQuadTriangle,
   SMESHDS_AddBiQuadQuadrangle,
+  SMESHDS_AddBiQuadPentahedron,
   SMESHDS_AddTriQuadHexa,
   SMESHDS_AddHexagonalPrism,
   SMESHDS_AddBall
index e7a10d7..865e700 100644 (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);
 }
 
 
index 89d69e3..92f6318 100644 (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,
index f912b76..de368f1 100644 (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,
index 87a0810..7b3c2fc 100644 (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,
index afe1b1f..527386e 100644 (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 );
 
index c24dbc4..4193be4 100644 (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;
index 3afa881..77b0a8f 100644 (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 ] ||
index 4e7f6bf..6c6987c 100755 (executable)
@@ -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 );
index 299ba97..a05414b 100644 (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;
index 4bb587e..ff20b1f 100644 (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
index c6ecbb3..5671cf1 100644 (file)
@@ -84,6 +84,7 @@ private:
   QLabel* myNbPrism;
   QLabel* myNbLinPrism;
   QLabel* myNbQuadPrism;
+  QLabel* myNbBiQuadPrism;
   QLabel* myNbVolum;
   QLabel* myNbLinVolum;
   QLabel* myNbQuadVolum;
index 89f5347..63c9885 100644 (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
index 9531e40..3ccd58c 100644 (file)
             <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>
         </message>
index bd744f7..a7568a3 100644 (file)
         <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>
     </message>
@@ -1371,6 +1375,10 @@ Please enter correct values and try again</translation>
         <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>
     </message>
@@ -2531,10 +2539,18 @@ Check algorithm documentation for supported geometry</translation>
         <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>
     </message>
@@ -3387,6 +3403,10 @@ Use Display Entity menu command to show them.
         <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>
     </message>
@@ -4063,6 +4083,10 @@ Use Display Entity menu command to show them.
         <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>
     </message>
@@ -4900,6 +4924,10 @@ Please, create VTK viewer and try again</translation>
         <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>
     </message>
index 032411c..e307f16 100755 (executable)
         <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>
     </message>
@@ -1351,6 +1355,10 @@ Merci de les corriger, puis essayez de nouveau</translation>
         <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>
     </message>
@@ -2511,10 +2519,18 @@ Référez-vous à la documentation sur l&apos;algorithme et la géométrie suppo
         <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>
     </message>
@@ -3368,6 +3384,10 @@ Utilisez le menu &quot;Visualiser une entité&quot; pour les afficher.
         <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>
     </message>
@@ -4044,6 +4064,10 @@ Utilisez le menu &quot;Visualiser une entité&quot; pour les afficher.
         <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>
     </message>
@@ -4881,6 +4905,10 @@ Ouvrez une fenêtre VTK et essayez de nouveau</translation>
         <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>
     </message>
index f3a0a55..876365b 100644 (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 ];
index cc842f2..6298cb0 100644 (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;
index 7fc73a3..3185f4d 100644 (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,