X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FDriverMED%2FDriverMED_W_SMESHDS_Mesh.cxx;h=634accfba901519605222d0dd4e09473207e7f69;hp=5b77395aa7603aa328f51419e0ba24ac0a7ddc9d;hb=c63ee099ad2b149bd70136839c973e8910137bc5;hpb=c3bf92bd87b770fd81631a3853f7f5bb1ac6a4e8 diff --git a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx index 5b77395aa..634accfba 100644 --- a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx +++ b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx @@ -17,70 +17,61 @@ // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // // // // File : DriverMED_W_SMESHDS_Mesh.cxx // Module : SMESH +#include + #include "DriverMED_W_SMESHDS_Mesh.h" #include "DriverMED_W_SMDS_Mesh.h" #include "DriverMED_Family.h" +#include "SMESHDS_Mesh.hxx" #include "SMDS_MeshElement.hxx" #include "SMDS_MeshNode.hxx" -#include "utilities.h" +#include "SMDS_PolyhedralVolumeOfNodes.hxx" -#include "MEDA_Wrapper.hxx" -#include +#include "utilities.h" #include "MED_Utilities.hxx" -DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh() - : - myMesh (NULL), - myFile (""), - myFileId (-1), - myMeshId (-1), - myAllSubMeshes (false), - myDoGroupOfNodes (false), - myDoGroupOfEdges (false), - myDoGroupOfFaces (false), - myDoGroupOfVolumes (false) -{ -} +#define _EDF_NODE_IDS_ +//#define _ELEMENTS_BY_DIM_ -DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh() -{ -} +using namespace std; +using namespace MED; -void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh) -{ - myMesh = aMesh; -} -void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile) -{ - myFile = aFile; -} +DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh(): + myAllSubMeshes (false), + myDoGroupOfNodes (false), + myDoGroupOfEdges (false), + myDoGroupOfFaces (false), + myDoGroupOfVolumes (false) +{} -void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId) +void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName, + MED::EVersion theId) { - myFileId = aFileId; + myMed = CrWrapper(theFileName,theId); + Driver_SMESHDS_Mesh::SetFile(theFileName); } -void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId) +void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName) { - myMeshId = aMeshId; + return SetFile(theFileName,MED::eV2_2); } -void DriverMED_W_SMESHDS_Mesh::SetMeshName(string theMeshName) +void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName) { myMeshName = theMeshName; } -void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_Group* theGroup) +void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_GroupBase* theGroup) { myGroups.push_back(theGroup); } @@ -115,33 +106,115 @@ void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes() myDoGroupOfVolumes = true; } -void DriverMED_W_SMESHDS_Mesh::Write() -{ - string myClass = string("SMDS_Mesh"); - string myExtension = string("MED"); - - DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh; - - myWriter->SetMesh(myMesh); - // myWriter->SetFile(myFile); - myWriter->SetMeshId(myMeshId); - myWriter->SetFileId(myFileId); - - myWriter->Write(); +namespace{ + typedef double (SMDS_MeshNode::* TGetCoord)() const; + typedef const char* TName; + typedef const char* TUnit; + + // name length in a mesh must be equal to 16 : + // 1234567890123456 + TName M = "m "; + TName X = "x "; + TName Y = "y "; + TName Z = "z "; + + TUnit aUnit[3] = {M,M,M}; + + // 3 dim + TGetCoord aXYZGetCoord[3] = { + &SMDS_MeshNode::X, + &SMDS_MeshNode::Y, + &SMDS_MeshNode::Z + }; + TName aXYZName[3] = {X,Y,Z}; + + // 2 dim + TGetCoord aXYGetCoord[2] = { + &SMDS_MeshNode::X, + &SMDS_MeshNode::Y + }; + TName aXYName[2] = {X,Y}; + + TGetCoord aYZGetCoord[2] = { + &SMDS_MeshNode::Y, + &SMDS_MeshNode::Z + }; + TName aYZName[2] = {Y,Z}; + + TGetCoord aXZGetCoord[2] = { + &SMDS_MeshNode::X, + &SMDS_MeshNode::Z + }; + TName aXZName[2] = {X,Z}; + + // 1 dim + TGetCoord aXGetCoord[1] = { + &SMDS_MeshNode::X + }; + TName aXName[1] = {X}; + + TGetCoord aYGetCoord[1] = { + &SMDS_MeshNode::Y + }; + TName aYName[1] = {Y}; + + TGetCoord aZGetCoord[1] = { + &SMDS_MeshNode::Z + }; + TName aZName[1] = {Z}; + + + class TCoordHelper{ + SMDS_NodeIteratorPtr myNodeIter; + const SMDS_MeshNode* myCurrentNode; + TGetCoord* myGetCoord; + TName* myName; + TUnit* myUnit; + public: + TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter, + TGetCoord* theGetCoord, + TName* theName, + TUnit* theUnit = aUnit): + myNodeIter(theNodeIter), + myGetCoord(theGetCoord), + myName(theName), + myUnit(theUnit) + {} + virtual ~TCoordHelper(){} + bool Next(){ + return myNodeIter->more() && + (myCurrentNode = myNodeIter->next()); + } + const SMDS_MeshNode* GetNode(){ + return myCurrentNode; + } + MED::TIntVector::value_type GetID(){ + return myCurrentNode->GetID(); + } + MED::TFloatVector::value_type GetCoord(TInt theCoodId){ + return (myCurrentNode->*myGetCoord[theCoodId])(); + } + MED::TStringVector::value_type GetName(TInt theDimId){ + return myName[theDimId]; + } + MED::TStringVector::value_type GetUnit(TInt theDimId){ + return myUnit[theDimId]; + } + }; + typedef boost::shared_ptr TCoordHelperPtr; + } -void DriverMED_W_SMESHDS_Mesh::Add() + +Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform() { + Status aResult = DRS_OK; if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) { INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!"); - return; + return DRS_FAIL; } try{ - using namespace MEDA; - using namespace boost; - - MESSAGE("Add - myFile : "<nodesIterator(); + double aBounds[6]; + if(aNodesIter->more()){ + const SMDS_MeshNode* aNode = aNodesIter->next(); + aBounds[0] = aBounds[1] = aNode->X(); + aBounds[2] = aBounds[3] = aNode->Y(); + aBounds[4] = aBounds[5] = aNode->Z(); + } + while(aNodesIter->more()){ + const SMDS_MeshNode* aNode = aNodesIter->next(); + aBounds[0] = min(aBounds[0],aNode->X()); + aBounds[1] = max(aBounds[1],aNode->X()); + + aBounds[2] = min(aBounds[2],aNode->Y()); + aBounds[3] = max(aBounds[3],aNode->Y()); + + aBounds[4] = min(aBounds[4],aNode->Z()); + aBounds[5] = max(aBounds[5],aNode->Z()); + } + + double EPS = 1.0E-7; + anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS; + anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS; + anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS; + aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension; + if(!aMeshDimension) + aMeshDimension = 3; + } + + SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator(); + switch(aMeshDimension){ + case 3: + aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName)); + break; + case 2: + if(anIsXDimension && anIsYDimension) + aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName)); + if(anIsYDimension && anIsZDimension) + aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName)); + if(anIsXDimension && anIsZDimension) + aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName)); + break; + case 1: + if(anIsXDimension) + aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName)); + if(anIsYDimension) + aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName)); + if(anIsZDimension) + aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName)); + break; + } + } + + + PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aMeshName); MESSAGE("Add - aMeshName : "<GetName()); - aMed.SetMeshInfo(aMeshInfo); + myMed->SetMeshInfo(aMeshInfo); // Storing SMDS groups and sub-meshes //----------------------------------- @@ -173,16 +308,12 @@ void DriverMED_W_SMESHDS_Mesh::Add() if (myDoGroupOfVolumes) myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY; - MESSAGE("Add - aFamilyInfo"); + MESSAGE("Perform - aFamilyInfo"); map anElemFamMap; list aFamilies; if (myAllSubMeshes) { - SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast(myMesh); - if (!aSMESHDSMesh) { - EXCEPTION(runtime_error,"Can not cast SMDS_Mesh to SMESHDS_Mesh"); - } aFamilies = DriverMED_Family::MakeFamilies - (aSMESHDSMesh->SubMeshes(), myGroups, + (myMesh->SubMeshes(), myGroups, myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes); } else { aFamilies = DriverMED_Family::MakeFamilies @@ -193,107 +324,168 @@ void DriverMED_W_SMESHDS_Mesh::Add() for (; aFamsIter != aFamilies.end(); aFamsIter++) { - PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo); - aMed.SetFamilyInfo(aFamilyInfo); + PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(myMed,aMeshInfo); + myMed->SetFamilyInfo(aFamilyInfo); int aFamId = (*aFamsIter)->GetId(); const set& anElems = (*aFamsIter)->GetElements(); - set::iterator anElemsIter = anElems.begin(); + set::const_iterator anElemsIter = anElems.begin(); for (; anElemsIter != anElems.end(); anElemsIter++) { anElemFamMap[*anElemsIter] = aFamId; } -// delete (*aFamsIter); } // Storing SMDS nodes to the MED file for the MED mesh //---------------------------------------------------- - typedef map TNodeIdMap; +#ifdef _EDF_NODE_IDS_ + typedef map TNodeIdMap; TNodeIdMap aNodeIdMap; - - med_int aNbElems = myMesh->NbNodes(); +#endif + TInt aNbElems = myMesh->NbNodes(); MED::TIntVector anElemNums(aNbElems); MED::TIntVector aFamilyNums(aNbElems); - MED::TFloatVector aCoordinates(aNbElems*SMDS_MESH_DIM); - SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator(); - for(med_int iNode = 0, iCoord = 0; aNodesIter->more(); iNode++, iCoord+=SMDS_MESH_DIM){ - const SMDS_MeshNode* aNode = aNodesIter->next(); - aCoordinates[iCoord] = aNode->X(); - aCoordinates[iCoord+1] = aNode->Y(); - aCoordinates[iCoord+2] = aNode->Z(); - TNodeIdMap::key_type aNodeId = aNode->GetID(); - anElemNums[iNode] = aNodeId; - aNodeIdMap[aNodeId] = iNode+1; - //cout<GetID()<<": "<X()<<", "<Y()<<", "<Z()<Next(); iNode++, aStartId += aMeshDimension){ + for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){ + aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord); + } + int aNodeID = aCoordHelperPtr->GetID(); + anElemNums[iNode] = aNodeID; +#ifdef _EDF_NODE_IDS_ + aNodeIdMap[aNodeID] = iNode+1; +#endif + const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode(); if (anElemFamMap.find(aNode) != anElemFamMap.end()) - aFamilyNums[iNode] = anElemFamMap[aNode]; + aFamilyNums[iNode] = anElemFamMap[aNode]; else - aFamilyNums[iNode] = myNodesDefaultFamilyId; + aFamilyNums[iNode] = myNodesDefaultFamilyId; } - MED::TStringVector aCoordNames(3); - aCoordNames[0] = "x"; aCoordNames[1] = "y"; aCoordNames[2] = "z"; - - MED::TStringVector aCoordUnits(3); - aCoordUnits[0] = "m"; aCoordUnits[1] = "m"; aCoordUnits[2] = "m"; + MED::TStringVector aCoordNames(aMeshDimension); + MED::TStringVector aCoordUnits(aMeshDimension); + for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){ + aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord); + aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord); + } - const med_repere SMDS_COORDINATE_SYSTEM = MED_CART; + const ERepere SMDS_COORDINATE_SYSTEM = eCART; - PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo, - SMDS_COORDINATE_SYSTEM, - aCoordinates, - aCoordNames, - aCoordUnits, - aFamilyNums, - anElemNums); - MESSAGE("Add - aNodeInfo->GetNbElem() = "<CrNodeInfo(aMeshInfo, + aCoordinates, + eFULL_INTERLACE, + SMDS_COORDINATE_SYSTEM, + aCoordNames, + aCoordUnits, + aFamilyNums, + anElemNums); + MESSAGE("Perform - aNodeInfo->GetNbElem() = "<SetNodeInfo(aNodeInfo); // Storing others SMDS elements to the MED file for the MED mesh //-------------------------------------------------------------- - const med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE; - const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD; + EEntiteMaillage SMDS_MED_ENTITY = eMAILLE; + const EConnectivite SMDS_MED_CONNECTIVITY = eNOD; // Storing SMDS Edges - if(med_int aNbElems = myMesh->NbEdges()){ + if(TInt aNbElems = myMesh->NbEdges()){ +#ifdef _ELEMENTS_BY_DIM_ + SMDS_MED_ENTITY = eARETE; +#endif + // count edges of diff types + int aNbSeg3 = 0, aNbSeg2 = 0; SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator(); - med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,SMDS_MESH_DIM); - MED::TIntVector anElemNums(aNbElems); - MED::TIntVector aFamilyNums(aNbElems); - MED::TIntVector aConnectivity(aNbElems*aNbConnectivity); - - for(med_int iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){ + while ( anIter->more() ) + if ( anIter->next()->NbNodes() == 3 ) + ++aNbSeg3; + aNbSeg2 = aNbElems - aNbSeg3; + + TInt aNbSeg2Conn = MED::GetNbNodes(eSEG2); + MED::TIntVector aSeg2ElemNums, aSeg2FamilyNums, aSeg2Conn; + aSeg2ElemNums .reserve( aNbSeg2 ); + aSeg2FamilyNums.reserve( aNbSeg2 ); + aSeg2Conn .reserve( aNbSeg2*aNbSeg2Conn ); + + TInt aNbSeg3Conn = MED::GetNbNodes(eSEG3); + MED::TIntVector aSeg3ElemNums, aSeg3FamilyNums, aSeg3Conn; + aSeg3ElemNums .reserve( aNbSeg3 ); + aSeg3FamilyNums.reserve( aNbSeg3 ); + aSeg3Conn .reserve( aNbSeg3*aNbSeg3Conn ); + + anIter = myMesh->edgesIterator(); + while ( anIter->more() ) { const SMDS_MeshEdge* anElem = anIter->next(); - SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); - for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){ - const SMDS_MeshElement* aNode = aNodesIter->next(); - aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()]; - } - anElemNums[iElem] = anElem->GetID(); + TInt aNbNodes = anElem->NbNodes(); - if (anElemFamMap.find(anElem) != anElemFamMap.end()) - aFamilyNums[iElem] = anElemFamMap[anElem]; + TInt aNbConnectivity; + MED::TIntVector* anElemNums; + MED::TIntVector* aFamilyNums; + MED::TIntVector* aConnectivity; + switch(aNbNodes){ + case 2: + aNbConnectivity = aNbSeg2Conn; + anElemNums = &aSeg2ElemNums; + aFamilyNums = &aSeg2FamilyNums; + aConnectivity = &aSeg2Conn; + break; + case 3: + aNbConnectivity = aNbSeg3Conn; + anElemNums = &aSeg3ElemNums; + aFamilyNums = &aSeg3FamilyNums; + aConnectivity = &aSeg3Conn; + break; + default: + break; + } + + for(TInt iNode = 0; iNode < aNbNodes; iNode++) { + const SMDS_MeshElement* aNode = anElem->GetNode( iNode ); +#ifdef _EDF_NODE_IDS_ + aConnectivity->push_back( aNodeIdMap[aNode->GetID()] ); +#else + aConnectivity->push_back( aNode->GetID() ); +#endif + } + + anElemNums->push_back(anElem->GetID()); + + map::iterator edge_fam = anElemFamMap.find( anElem ); + if ( edge_fam != anElemFamMap.end() ) + aFamilyNums->push_back( edge_fam->second ); else - aFamilyNums[iElem] = myEdgesDefaultFamilyId; + aFamilyNums->push_back( myFacesDefaultFamilyId ); } - PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, - SMDS_MED_ENTITY, - MED_SEG2, - SMDS_MED_CONNECTIVITY, - aConnectivity, - aFamilyNums, - anElemNums); - aMed.SetCellInfo(aCellInfo); + if ( aNbSeg2 ) { + PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, + SMDS_MED_ENTITY, + eSEG2, + aSeg2Conn, + SMDS_MED_CONNECTIVITY, + aSeg2FamilyNums, + aSeg2ElemNums); + myMed->SetCellInfo(aCellInfo); + } + if ( aNbSeg3 ) { + PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, + SMDS_MED_ENTITY, + eSEG3, + aSeg3Conn, + SMDS_MED_CONNECTIVITY, + aSeg3FamilyNums, + aSeg3ElemNums); + myMed->SetCellInfo(aCellInfo); + } } // Storing SMDS Faces - if(med_int aNbElems = myMesh->NbFaces()){ + if(TInt aNbElems = myMesh->NbFaces()){ SMDS_FaceIteratorPtr anIter = myMesh->facesIterator(); - - med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,SMDS_MESH_DIM); +#ifdef _ELEMENTS_BY_DIM_ + SMDS_MED_ENTITY = eFACE; +#endif + TInt aNbTriaConn = MED::GetNbNodes(eTRIA3); MED::TIntVector anTriaElemNums; anTriaElemNums.reserve(aNbElems); MED::TIntVector aTriaFamilyNums; @@ -301,7 +493,15 @@ void DriverMED_W_SMESHDS_Mesh::Add() MED::TIntVector aTriaConn; aTriaConn.reserve(aNbElems*aNbTriaConn); - med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,SMDS_MESH_DIM); + TInt aNbTria6Conn = MED::GetNbNodes(eTRIA6); + MED::TIntVector anTria6ElemNums; + anTria6ElemNums.reserve(aNbElems); + MED::TIntVector aTria6FamilyNums; + aTria6FamilyNums.reserve(aNbElems); + MED::TIntVector aTria6Conn; + aTria6Conn.reserve(aNbElems*aNbTria6Conn); + + TInt aNbQuadConn = MED::GetNbNodes(eQUAD4); MED::TIntVector aQuadElemNums; aQuadElemNums.reserve(aNbElems); MED::TIntVector aQuadFamilyNums; @@ -309,47 +509,98 @@ void DriverMED_W_SMESHDS_Mesh::Add() MED::TIntVector aQuadConn; aQuadConn.reserve(aNbElems*aNbQuadConn); - for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){ + TInt aNbQuad8Conn = MED::GetNbNodes(eQUAD8); + MED::TIntVector aQuad8ElemNums; + aQuad8ElemNums.reserve(aNbElems); + MED::TIntVector aQuad8FamilyNums; + aQuad8FamilyNums.reserve(aNbElems); + MED::TIntVector aQuad8Conn; + aQuad8Conn.reserve(aNbElems*aNbQuad8Conn); + + MED::TIntVector aPolygoneElemNums; + aPolygoneElemNums.reserve(aNbElems); + MED::TIntVector aPolygoneInds; + aPolygoneInds.reserve(aNbElems + 1); + aPolygoneInds.push_back(1); // reference on the first element in the connectivities + MED::TIntVector aPolygoneFamilyNums; + aPolygoneFamilyNums.reserve(aNbElems); + MED::TIntVector aPolygoneConn; + aPolygoneConn.reserve(aNbElems*aNbQuadConn); + + for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){ const SMDS_MeshFace* anElem = anIter->next(); - med_int aNbNodes = anElem->NbNodes(); + TInt aNbNodes = anElem->NbNodes(); SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); - med_int aNbConnectivity; + TInt aNbConnectivity; MED::TIntVector* anElemNums; MED::TIntVector* aFamilyNums; MED::TIntVector* aConnectivity; - switch(aNbNodes){ - case 3: - aNbConnectivity = aNbTriaConn; - anElemNums = &anTriaElemNums; - aFamilyNums = &aTriaFamilyNums; - aConnectivity = &aTriaConn; - break; - case 4: - aNbConnectivity = aNbQuadConn; - anElemNums = &aQuadElemNums; - aFamilyNums = &aQuadFamilyNums; - aConnectivity = &aQuadConn; - break; - } + if (anElem->IsPoly()) { + aNbConnectivity = aNbNodes; + anElemNums = &aPolygoneElemNums; + aFamilyNums = &aPolygoneFamilyNums; + aConnectivity = &aPolygoneConn; + } + else { + switch(aNbNodes){ + case 3: + aNbConnectivity = aNbTriaConn; + anElemNums = &anTriaElemNums; + aFamilyNums = &aTriaFamilyNums; + aConnectivity = &aTriaConn; + break; + case 4: + aNbConnectivity = aNbQuadConn; + anElemNums = &aQuadElemNums; + aFamilyNums = &aQuadFamilyNums; + aConnectivity = &aQuadConn; + break; + case 6: + aNbConnectivity = aNbTria6Conn; + anElemNums = &anTria6ElemNums; + aFamilyNums = &aTria6FamilyNums; + aConnectivity = &aTria6Conn; + break; + case 8: + aNbConnectivity = aNbQuad8Conn; + anElemNums = &aQuad8ElemNums; + aFamilyNums = &aQuad8FamilyNums; + aConnectivity = &aQuad8Conn; + break; + default: + break; + } + } MED::TIntVector aVector(aNbNodes); - for(med_int iNode = 0; aNodesIter->more(); iNode++){ + for(TInt iNode = 0; aNodesIter->more(); iNode++){ const SMDS_MeshElement* aNode = aNodesIter->next(); +#ifdef _EDF_NODE_IDS_ + aVector[iNode] = aNodeIdMap[aNode->GetID()]; +#else aVector[iNode] = aNode->GetID(); +#endif } - med_int aSize = aConnectivity->size(); + TInt aSize = aConnectivity->size(); aConnectivity->resize(aSize+aNbConnectivity); - // There is some differnce between SMDS and MED in cells mapping + // There is some differences between SMDS and MED in cells mapping switch(aNbNodes){ case 4: - (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]]; - (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[1]]; - (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[3]]; - (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[2]]; + (*aConnectivity)[aSize+0] = aVector[0]; + (*aConnectivity)[aSize+1] = aVector[1]; + (*aConnectivity)[aSize+2] = aVector[3]; + (*aConnectivity)[aSize+3] = aVector[2]; default: - for(med_int iNode = 0; iNode < aNbNodes; iNode++) - (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]]; + for(TInt iNode = 0; iNode < aNbNodes; iNode++) + (*aConnectivity)[aSize+iNode] = aVector[iNode]; } + + if (anElem->IsPoly()) { + // fill indices for polygonal element + TInt aPrevPos = aPolygoneInds.back(); + aPolygoneInds.push_back(aPrevPos + aNbNodes); + } + anElemNums->push_back(anElem->GetID()); if (anElemFamMap.find(anElem) != anElemFamMap.end()) @@ -357,35 +608,75 @@ void DriverMED_W_SMESHDS_Mesh::Add() else aFamilyNums->push_back(myFacesDefaultFamilyId); } - if(med_int aNbElems = anTriaElemNums.size()){ - PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, - SMDS_MED_ENTITY, - MED_TRIA3, - SMDS_MED_CONNECTIVITY, - aTriaConn, - aTriaFamilyNums, - anTriaElemNums); - MESSAGE("Add - anEntity = "<NbFaces(); + for (int iface = 1; iface <= aNbFaces; iface++) { + int aNbFaceNodes = aPolyedre->NbFaceNodes(iface); + for (int inode = 1; inode <= aNbFaceNodes; inode++) { + aNodeId = aPolyedre->GetFaceNode(iface, inode)->GetID(); +#ifdef _EDF_NODE_IDS_ + aPolyedreConn.push_back(aNodeIdMap[aNodeId]); +#else + aPolyedreConn.push_back(aNodeId); +#endif + } + TInt aPrevPos = aPolyedreFaces.back(); + aPolyedreFaces.push_back(aPrevPos + aNbFaceNodes); + } + TInt aPrevPos = aPolyedreInds.back(); + aPolyedreInds.push_back(aPrevPos + aNbFaces); + + } + else { + TInt aNbNodes = anElem->NbNodes(); + SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); + TInt aNbConnectivity; + MED::TIntVector* aConnectivity; + switch(aNbNodes){ + case 4: + aNbConnectivity = aNbTetraConn; + anElemNums = &anTetraElemNums; + aFamilyNums = &aTetraFamilyNums; + aConnectivity = &aTetraConn; + break; + case 5: + aNbConnectivity = aNbPyraConn; + anElemNums = &anPyraElemNums; + aFamilyNums = &aPyraFamilyNums; + aConnectivity = &aPyraConn; + break; + case 6: + aNbConnectivity = aNbPentaConn; + anElemNums = &anPentaElemNums; + aFamilyNums = &aPentaFamilyNums; + aConnectivity = &aPentaConn; + break; + case 8: + aNbConnectivity = aNbHexaConn; + anElemNums = &aHexaElemNums; + aFamilyNums = &aHexaFamilyNums; + aConnectivity = &aHexaConn; + break; + case 10: + aNbConnectivity = aNbTetra10Conn; + anElemNums = &anTetra10ElemNums; + aFamilyNums = &aTetra10FamilyNums; + aConnectivity = &aTetra10Conn; + break; + case 13: + aNbConnectivity = aNbPyra13Conn; + anElemNums = &anPyra13ElemNums; + aFamilyNums = &aPyra13FamilyNums; + aConnectivity = &aPyra13Conn; + break; + case 15: + aNbConnectivity = aNbPenta15Conn; + anElemNums = &anPenta15ElemNums; + aFamilyNums = &aPenta15FamilyNums; + aConnectivity = &aPenta15Conn; + break; + case 20: + aNbConnectivity = aNbHexa20Conn; + anElemNums = &aHexa20ElemNums; + aFamilyNums = &aHexa20FamilyNums; + aConnectivity = &aHexa20Conn; + } + + TInt aSize = aConnectivity->size(); + aConnectivity->resize(aSize + aNbConnectivity); + + MED::TIntVector aVector(aNbNodes); + for(TInt iNode = 0; aNodesIter->more(); iNode++){ + const SMDS_MeshElement* aNode = aNodesIter->next(); +#ifdef _EDF_NODE_IDS_ + aVector[iNode] = aNodeIdMap[aNode->GetID()]; +#else + aVector[iNode] = aNode->GetID(); +#endif + } + // There is some difference between SMDS and MED in cells mapping + switch(aNbNodes){ + case 5: + (*aConnectivity)[aSize+0] = aVector[0]; + (*aConnectivity)[aSize+1] = aVector[3]; + (*aConnectivity)[aSize+2] = aVector[2]; + (*aConnectivity)[aSize+3] = aVector[1]; + (*aConnectivity)[aSize+4] = aVector[4]; + default: + for(TInt iNode = 0; iNode < aNbNodes; iNode++) + (*aConnectivity)[aSize+iNode] = aVector[iNode]; + } + } + + anElemNums->push_back(anElem->GetID()); if (anElemFamMap.find(anElem) != anElemFamMap.end()) aFamilyNums->push_back(anElemFamMap[anElem]); @@ -478,58 +877,123 @@ void DriverMED_W_SMESHDS_Mesh::Add() aFamilyNums->push_back(myVolumesDefaultFamilyId); } - if(med_int aNbElems = anTetraElemNums.size()){ - PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, - SMDS_MED_ENTITY, - MED_TETRA4, - SMDS_MED_CONNECTIVITY, - aTetraConn, - aTetraFamilyNums, - anTetraElemNums); - MESSAGE("Add - anEntity = "<