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=d44e27675bb8f39d19d0416a4d17358af9043876;hp=5b77395aa7603aa328f51419e0ba24ac0a7ddc9d;hb=aa67cc96d730566d202d1014d97b7f0b3a4d71f4;hpb=c3bf92bd87b770fd81631a3853f7f5bb1ac6a4e8 diff --git a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx index 5b77395aa..d44e27675 100644 --- a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx +++ b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx @@ -1,86 +1,95 @@ -// SMESH DriverMED : driver to read and write 'med' files +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + +// SMESH DriverMED : driver to read and write 'med' files // 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) +DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh(): + myAllSubMeshes (false), + myDoGroupOfNodes (false), + myDoGroupOfEdges (false), + myDoGroupOfFaces (false), + myDoGroupOfVolumes (false) +{} + +void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName, + MED::EVersion theId) { - myFile = aFile; + myMed = CrWrapper(theFileName,theId); + Driver_SMESHDS_Mesh::SetFile(theFileName); } -void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId) +void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName) { - myFileId = aFileId; + return SetFile(theFileName,MED::eV2_2); } -void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId) +string DriverMED_W_SMESHDS_Mesh::GetVersionString(const MED::EVersion theVersion, int theNbDigits) { - myMeshId = aMeshId; + TInt majeur, mineur, release; + majeur = mineur = release = 0; + if ( theVersion == eV2_1 ) + MED::GetVersionRelease(majeur, mineur, release); + else + MED::GetVersionRelease(majeur, mineur, release); + ostringstream name; + if ( theNbDigits > 0 ) + name << majeur; + if ( theNbDigits > 1 ) + name << "." << mineur; + if ( theNbDigits > 2 ) + name << "." << release; + return name.str(); } -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 +124,215 @@ 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); +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; + + + //------------------------------------------------------- + /*! + * \brief Class helping to use either SMDS_0DElementIterator, + * SMDS_EdgeIterator, SMDS_FaceIterator or SMDS_VolumeIterator + * in the same code + */ + //------------------------------------------------------- + struct TElemIterator + { + virtual const SMDS_MeshElement* next() = 0; + virtual ~TElemIterator() {} + }; + typedef boost::shared_ptr PElemIterator; + + template< class SMDSIteratorPtr > class TypedElemIterator: public TElemIterator + { + SMDSIteratorPtr myItPtr; + public: + TypedElemIterator(SMDSIteratorPtr it): myItPtr(it) {} + virtual const SMDS_MeshElement* next() { + if ( myItPtr->more() ) return myItPtr->next(); + else return 0; + } + }; + typedef TypedElemIterator< SMDS_0DElementIteratorPtr > T0DElementIterator; + typedef TypedElemIterator< SMDS_EdgeIteratorPtr > TEdgeIterator; + typedef TypedElemIterator< SMDS_FaceIteratorPtr > TFaceIterator; + typedef TypedElemIterator< SMDS_VolumeIteratorPtr > TVolumeIterator; + + //------------------------------------------------------- + /*! + * \brief Structure describing element type + */ + //------------------------------------------------------- + struct TElemTypeData + { + EEntiteMaillage _entity; + EGeometrieElement _geomType; + TInt _nbElems; + SMDSAbs_ElementType _smdsType; + + TElemTypeData (EEntiteMaillage entity, EGeometrieElement geom, TInt nb, SMDSAbs_ElementType type) + : _entity(entity), _geomType(geom), _nbElems( nb ), _smdsType( type ) {} + }; + + + typedef NCollection_DataMap< Standard_Address, int > TElemFamilyMap; + //typedef map TElemFamilyMap; + + //================================================================================ + /*! + * \brief Fills element to famaly ID map for element type. + * Removes all families of anElemType + */ + //================================================================================ + + void fillElemFamilyMap( TElemFamilyMap & anElemFamMap, + list & aFamilies, + const SMDSAbs_ElementType anElemType) + { + anElemFamMap.Clear(); + //anElemFamMap.clear(); + list::iterator aFamsIter = aFamilies.begin(); + while ( aFamsIter != aFamilies.end() ) + { + if ((*aFamsIter)->GetType() != anElemType) { + aFamsIter++; + } + else { + int aFamId = (*aFamsIter)->GetId(); + const set& anElems = (*aFamsIter)->GetElements(); + set::const_iterator anElemsIter = anElems.begin(); + for (; anElemsIter != anElems.end(); anElemsIter++) + { + anElemFamMap.Bind( (Standard_Address)*anElemsIter, aFamId ); + //anElemFamMap[*anElemsIter] = aFamId; + } + // remove a family from the list + aFamilies.erase( aFamsIter++ ); + } + } + } - myWriter->Write(); + //================================================================================ + /*! + * \brief For an element, return family ID found in the map or a default one + */ + //================================================================================ + + int getFamilyId( const TElemFamilyMap & anElemFamMap, + const SMDS_MeshElement* anElement, + const int aDefaultFamilyId) + { + if ( anElemFamMap.IsBound( (Standard_Address) anElement )) + return anElemFamMap( (Standard_Address) anElement ); +// TElemFamilyMap::iterator elem_famNum = anElemFamMap.find( anElement ); +// if ( elem_famNum != anElemFamMap.end() ) +// return elem_famNum->second; + return aDefaultFamilyId; + } } -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; + // PAL16857(SMESH not conform to the MED convention): + if ( aMeshDimension == 2 && anIsZDimension ) // 2D only if mesh is in XOY plane + aMeshDimension = 3; + // PAL18941(a saved study with a mesh belong Z is opened and the mesh is belong X) + if ( aMeshDimension == 1 && !anIsXDimension ) // 1D only if mesh is along OX + if ( anIsYDimension ) { + aMeshDimension = 2; + anIsXDimension = true; + } else { + aMeshDimension = 3; + } + } + + SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator(/*idInceasingOrder=*/true); + 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 - //----------------------------------- - int myNodesDefaultFamilyId = 0; - int myEdgesDefaultFamilyId = 0; - int myFacesDefaultFamilyId = 0; + // Storing SMDS groups and sub-meshes as med families + //---------------------------------------------------- + int myNodesDefaultFamilyId = 0; + int my0DElementsDefaultFamilyId = 0; + int myEdgesDefaultFamilyId = 0; + int myFacesDefaultFamilyId = 0; int myVolumesDefaultFamilyId = 0; - if (myDoGroupOfNodes) + int nbNodes = myMesh->NbNodes(); + int nb0DElements = myMesh->Nb0DElements(); + int nbEdges = myMesh->NbEdges(); + int nbFaces = myMesh->NbFaces(); + int nbVolumes = myMesh->NbVolumes(); + if (myDoGroupOfNodes && nbNodes) myNodesDefaultFamilyId = REST_NODES_FAMILY; - if (myDoGroupOfEdges) + if (myDoGroupOfEdges && nbEdges) myEdgesDefaultFamilyId = REST_EDGES_FAMILY; - if (myDoGroupOfFaces) + if (myDoGroupOfFaces && nbFaces) myFacesDefaultFamilyId = REST_FACES_FAMILY; - if (myDoGroupOfVolumes) + if (myDoGroupOfVolumes && nbVolumes) myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY; - MESSAGE("Add - aFamilyInfo"); - map anElemFamMap; + MESSAGE("Perform - aFamilyInfo"); + //cout << " DriverMED_Family::MakeFamilies() " << endl; 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, - myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes); + (myMesh->SubMeshes(), myGroups, + myDoGroupOfNodes && nbNodes, + myDoGroupOfEdges && nbEdges, + myDoGroupOfFaces && nbFaces, + myDoGroupOfVolumes && nbVolumes); } else { aFamilies = DriverMED_Family::MakeFamilies (mySubMeshes, myGroups, - myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes); + myDoGroupOfNodes && nbNodes, + myDoGroupOfEdges && nbEdges, + myDoGroupOfFaces && nbFaces, + myDoGroupOfVolumes && nbVolumes); } - list::iterator aFamsIter = aFamilies.begin(); - - for (; aFamsIter != aFamilies.end(); aFamsIter++) + //cout << " myMed->SetFamilyInfo() " << endl; + list::iterator aFamsIter; + for (aFamsIter = aFamilies.begin(); aFamsIter != aFamilies.end(); aFamsIter++) { - PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo); - aMed.SetFamilyInfo(aFamilyInfo); - int aFamId = (*aFamsIter)->GetId(); - - const set& anElems = (*aFamsIter)->GetElements(); - set::iterator anElemsIter = anElems.begin(); - for (; anElemsIter != anElems.end(); anElemsIter++) - { - anElemFamMap[*anElemsIter] = aFamId; - } -// delete (*aFamsIter); + PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(myMed,aMeshInfo); + myMed->SetFamilyInfo(aFamilyInfo); } // 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(); - 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()<NbNodes(); + //cout << " myMed->CrNodeInfo() aNbNodes = " << aNbNodes << endl; + PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo, aNbNodes, + theMode, theSystem, theIsElemNum, theIsElemNames); + + //cout << " fillElemFamilyMap( SMDSAbs_Node )" << endl; + // find family numbers for nodes + TElemFamilyMap anElemFamMap; + fillElemFamilyMap( anElemFamMap, aFamilies, SMDSAbs_Node ); + + for (TInt iNode = 0; aCoordHelperPtr->Next(); iNode++) + { + // coordinates + TCoordSlice aTCoordSlice = aNodeInfo->GetCoordSlice( iNode ); + for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){ + aTCoordSlice[iCoord] = aCoordHelperPtr->GetCoord(iCoord); + } + // node number + int aNodeID = aCoordHelperPtr->GetID(); + aNodeInfo->SetElemNum( iNode, aNodeID ); +#ifdef _EDF_NODE_IDS_ + aNodeIdMap[aNodeID] = iNode+1; +#endif + // family number + const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode(); + int famNum = getFamilyId( anElemFamMap, aNode, myNodesDefaultFamilyId ); + aNodeInfo->SetFamNum( iNode, famNum ); } + anElemFamMap.Clear(); - 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"; - - const med_repere SMDS_COORDINATE_SYSTEM = MED_CART; - - PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo, - SMDS_COORDINATE_SYSTEM, - aCoordinates, - aCoordNames, - aCoordUnits, - aFamilyNums, - anElemNums); - MESSAGE("Add - aNodeInfo->GetNbElem() = "<NbEdges()){ - 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){ - 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(); - - if (anElemFamMap.find(anElem) != anElemFamMap.end()) - aFamilyNums[iElem] = anElemFamMap[anElem]; - else - aFamilyNums[iElem] = myEdgesDefaultFamilyId; - } - - PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, - SMDS_MED_ENTITY, - MED_SEG2, - SMDS_MED_CONNECTIVITY, - aConnectivity, - aFamilyNums, - anElemNums); - aMed.SetCellInfo(aCellInfo); + // coordinate names and units + for (TInt iCoord = 0; iCoord < aMeshDimension; iCoord++) { + aNodeInfo->SetCoordName( iCoord, aCoordHelperPtr->GetName(iCoord)); + aNodeInfo->SetCoordUnit( iCoord, aCoordHelperPtr->GetUnit(iCoord)); } - // Storing SMDS Faces - if(med_int aNbElems = myMesh->NbFaces()){ - SMDS_FaceIteratorPtr anIter = myMesh->facesIterator(); - - med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,SMDS_MESH_DIM); - MED::TIntVector anTriaElemNums; - anTriaElemNums.reserve(aNbElems); - MED::TIntVector aTriaFamilyNums; - aTriaFamilyNums.reserve(aNbElems); - MED::TIntVector aTriaConn; - aTriaConn.reserve(aNbElems*aNbTriaConn); - - med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,SMDS_MESH_DIM); - MED::TIntVector aQuadElemNums; - aQuadElemNums.reserve(aNbElems); - MED::TIntVector aQuadFamilyNums; - aQuadFamilyNums.reserve(aNbElems); - MED::TIntVector aQuadConn; - aQuadConn.reserve(aNbElems*aNbQuadConn); - - for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){ - const SMDS_MeshFace* anElem = anIter->next(); - med_int aNbNodes = anElem->NbNodes(); - SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); - med_int 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; - } - MED::TIntVector aVector(aNbNodes); - for(med_int iNode = 0; aNodesIter->more(); iNode++){ - const SMDS_MeshElement* aNode = aNodesIter->next(); - aVector[iNode] = aNode->GetID(); - } - - med_int aSize = aConnectivity->size(); - aConnectivity->resize(aSize+aNbConnectivity); - // There is some differnce 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]]; - default: - for(med_int iNode = 0; iNode < aNbNodes; iNode++) - (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]]; - } - anElemNums->push_back(anElem->GetID()); - - if (anElemFamMap.find(anElem) != anElemFamMap.end()) - aFamilyNums->push_back(anElemFamMap[anElem]); - 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 = "<GetNbElem() = "<SetNodeInfo(aNodeInfo); + aNodeInfo.reset(); // free memory used for arrays + + + // Storing SMDS elements to the MED file for the MED mesh + //------------------------------------------------------- + // Write one element type at once in order to minimize memory usage (PAL19276) + + const SMDS_MeshInfo& nbElemInfo = myMesh->GetMeshInfo(); + + // poly elements are not supported by med-2.1 + bool polyTypesSupported = myMed->CrPolygoneInfo(aMeshInfo,eMAILLE,ePOLYGONE,0,0); + TInt nbPolygonNodes = 0, nbPolyhedronNodes = 0, nbPolyhedronFaces = 0; + + // collect info on all geom types + + list< TElemTypeData > aTElemTypeDatas; + + EEntiteMaillage anEntity = eMAILLE; +#ifdef _ELEMENTS_BY_DIM_ + anEntity = eNOEUD_ELEMENT; +#endif + aTElemTypeDatas.push_back(TElemTypeData(anEntity, + ePOINT1, + nbElemInfo.Nb0DElements(), + SMDSAbs_0DElement)); +#ifdef _ELEMENTS_BY_DIM_ + anEntity = eARETE; +#endif + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eSEG2, + nbElemInfo.NbEdges( ORDER_LINEAR ), + SMDSAbs_Edge)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eSEG3, + nbElemInfo.NbEdges( ORDER_QUADRATIC ), + SMDSAbs_Edge)); +#ifdef _ELEMENTS_BY_DIM_ + anEntity = eFACE; +#endif + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eTRIA3, + nbElemInfo.NbTriangles( ORDER_LINEAR ), + SMDSAbs_Face)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eTRIA6, + nbElemInfo.NbTriangles( ORDER_QUADRATIC ), + SMDSAbs_Face)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eQUAD4, + nbElemInfo.NbQuadrangles( ORDER_LINEAR ), + SMDSAbs_Face)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eQUAD8, + nbElemInfo.NbQuadrangles( ORDER_QUADRATIC ), + SMDSAbs_Face)); + if ( polyTypesSupported ) { + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + ePOLYGONE, + nbElemInfo.NbPolygons(), + SMDSAbs_Face)); + // we need one more loop on poly elements to count nb of their nodes + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + ePOLYGONE, + nbElemInfo.NbPolygons(), + SMDSAbs_Face)); + } +#ifdef _ELEMENTS_BY_DIM_ + anEntity = eMAILLE; +#endif + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eTETRA4, + nbElemInfo.NbTetras( ORDER_LINEAR ), + SMDSAbs_Volume)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eTETRA10, + nbElemInfo.NbTetras( ORDER_QUADRATIC ), + SMDSAbs_Volume)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + ePYRA5, + nbElemInfo.NbPyramids( ORDER_LINEAR ), + SMDSAbs_Volume)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + ePYRA13, + nbElemInfo.NbPyramids( ORDER_QUADRATIC ), + SMDSAbs_Volume)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + ePENTA6, + nbElemInfo.NbPrisms( ORDER_LINEAR ), + SMDSAbs_Volume)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + ePENTA15, + nbElemInfo.NbPrisms( ORDER_QUADRATIC ), + SMDSAbs_Volume)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eHEXA8, + nbElemInfo.NbHexas( ORDER_LINEAR ), + SMDSAbs_Volume)); + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + eHEXA20, + nbElemInfo.NbHexas( ORDER_QUADRATIC ), + SMDSAbs_Volume)); + if ( polyTypesSupported ) { + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + ePOLYEDRE, + nbElemInfo.NbPolyhedrons(), + SMDSAbs_Volume)); + // we need one more loop on poly elements to count nb of their nodes + aTElemTypeDatas.push_back( TElemTypeData(anEntity, + ePOLYEDRE, + nbElemInfo.NbPolyhedrons(), + SMDSAbs_Volume)); } - // Storing SMDS Volumes - if(med_int aNbElems = myMesh->NbVolumes()){ - SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator(); - - med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,SMDS_MESH_DIM); - MED::TIntVector anTetraElemNums; - anTetraElemNums.reserve(aNbElems); - MED::TIntVector aTetraFamilyNums; - aTetraFamilyNums.reserve(aNbElems); - MED::TIntVector aTetraConn; - aTetraConn.reserve(aNbElems*aNbTetraConn); - - med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,SMDS_MESH_DIM); - MED::TIntVector anPyraElemNums; - anPyraElemNums.reserve(aNbElems); - MED::TIntVector aPyraFamilyNums; - aPyraFamilyNums.reserve(aNbElems); - MED::TIntVector aPyraConn; - aPyraConn.reserve(aNbElems*aNbPyraConn); - - med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,SMDS_MESH_DIM); - MED::TIntVector anPentaElemNums; - anPentaElemNums.reserve(aNbElems); - MED::TIntVector aPentaFamilyNums; - aPentaFamilyNums.reserve(aNbElems); - MED::TIntVector aPentaConn; - aPentaConn.reserve(aNbElems*aNbPentaConn); - - med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,SMDS_MESH_DIM); - MED::TIntVector aHexaElemNums; - aHexaElemNums.reserve(aNbElems); - MED::TIntVector aHexaFamilyNums; - aHexaFamilyNums.reserve(aNbElems); - MED::TIntVector aHexaConn; - aHexaConn.reserve(aNbElems*aNbHexaConn); - - for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){ - const SMDS_MeshVolume* anElem = anIter->next(); - med_int aNbNodes = anElem->NbNodes(); - SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); - med_int aNbConnectivity; - MED::TIntVector* anElemNums; - MED::TIntVector* aFamilyNums; - 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; - } - - MED::TIntVector aVector(aNbNodes); - for(med_int iNode = 0; aNodesIter->more(); iNode++){ - const SMDS_MeshElement* aNode = aNodesIter->next(); - aVector[iNode] = aNode->GetID(); - } - med_int aSize = aConnectivity->size(); - aConnectivity->resize(aSize+aNbConnectivity); - // There is some difference between SMDS and MED in cells mapping - switch(aNbNodes){ - case 5: - (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]]; - (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[3]]; - (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[2]]; - (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[1]]; - (*aConnectivity)[aSize+4] = aNodeIdMap[aVector[4]]; - default: - for(med_int iNode = 0; iNode < aNbNodes; iNode++) - (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]]; - } - anElemNums->push_back(anElem->GetID()); - - if (anElemFamMap.find(anElem) != anElemFamMap.end()) - aFamilyNums->push_back(anElemFamMap[anElem]); - else - aFamilyNums->push_back(myVolumesDefaultFamilyId); - } + vector< bool > isElemFamMapBuilt( SMDSAbs_NbElementTypes, false ); - 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 = "<_geomType << " nb = " <_nbElems<< endl; + // Treat POLYGONs + // --------------- + if ( aElemTypeData->_geomType == ePOLYGONE ) + { + if ( nbPolygonNodes == 0 ) { + // Count nb of nodes + while ( const SMDS_MeshElement* anElem = elemIterator->next() ) { + if ( anElem->IsPoly() ) { + nbPolygonNodes += anElem->NbNodes(); + if ( ++iElem == aElemTypeData->_nbElems ) + break; + } + } + } + else { + // Store in med file + PPolygoneInfo aPolygoneInfo = myMed->CrPolygoneInfo(aMeshInfo, + aElemTypeData->_entity, + aElemTypeData->_geomType, + aElemTypeData->_nbElems, + nbPolygonNodes, + theConnMode, theIsElemNum, + theIsElemNames); + TElemNum & index = *(aPolygoneInfo->myIndex.get()); + index[0] = 1; + + while ( const SMDS_MeshElement* anElem = elemIterator->next() ) + { + if ( !anElem->IsPoly() ) + continue; + + // index + TInt aNbNodes = anElem->NbNodes(); + index[ iElem+1 ] = index[ iElem ] + aNbNodes; + + // connectivity + TConnSlice aTConnSlice = aPolygoneInfo->GetConnSlice( iElem ); + for(TInt iNode = 0; iNode < aNbNodes; iNode++) { + const SMDS_MeshElement* aNode = anElem->GetNode( iNode ); +#ifdef _EDF_NODE_IDS_ + aTConnSlice[ iNode ] = aNodeIdMap[aNode->GetID()]; +#else + aTConnSlice[ iNode ] = aNode->GetID(); +#endif + } + // element number + aPolygoneInfo->SetElemNum( iElem, anElem->GetID() ); + + // family number + int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId ); + aPolygoneInfo->SetFamNum( iElem, famNum ); + + if ( ++iElem == aPolygoneInfo->GetNbElem() ) + break; + } + // if(TInt aNbElems = aPolygoneElemNums.size()) + // // add one element in connectivities, + // // referenced by the last element in indices + // aPolygoneConn.push_back(0); + //cout << " SetPolygoneInfo(aPolygoneInfo)" << endl; + myMed->SetPolygoneInfo(aPolygoneInfo); + } + + } + + // Treat POLYEDREs + // ---------------- + else if (aElemTypeData->_geomType == ePOLYEDRE ) + { + if ( nbPolyhedronNodes == 0 ) { + // Count nb of nodes + while ( const SMDS_MeshElement* anElem = elemIterator->next() ) { + const SMDS_PolyhedralVolumeOfNodes* aPolyedre = + dynamic_cast( anElem ); + if ( aPolyedre ) { + nbPolyhedronNodes += aPolyedre->NbNodes(); + nbPolyhedronFaces += aPolyedre->NbFaces(); + if ( ++iElem == aElemTypeData->_nbElems ) + break; + } + } + } + else { + // Store in med file + PPolyedreInfo aPolyhInfo = myMed->CrPolyedreInfo(aMeshInfo, + aElemTypeData->_entity, + aElemTypeData->_geomType, + aElemTypeData->_nbElems, + nbPolyhedronFaces+1, + nbPolyhedronNodes, + theConnMode, + theIsElemNum, + theIsElemNames); + TElemNum & index = *(aPolyhInfo->myIndex.get()); + TElemNum & faces = *(aPolyhInfo->myFaces.get()); + TElemNum & conn = *(aPolyhInfo->myConn.get()); + index[0] = 1; + faces[0] = 1; + + TInt iFace = 0, iNode = 0; + while ( const SMDS_MeshElement* anElem = elemIterator->next() ) + { + const SMDS_PolyhedralVolumeOfNodes* aPolyedre = + dynamic_cast( anElem ); + if ( !aPolyedre ) + continue; + + // index + TInt aNbFaces = aPolyedre->NbFaces(); + index[ iElem+1 ] = index[ iElem ] + aNbFaces; + + // face index + for (TInt f = 1; f <= aNbFaces; ++f, ++iFace ) { + int aNbFaceNodes = aPolyedre->NbFaceNodes( f ); + faces[ iFace+1 ] = faces[ iFace ] + aNbFaceNodes; + } + // connectivity + SMDS_ElemIteratorPtr nodeIt = anElem->nodesIterator(); + while ( nodeIt->more() ) { + const SMDS_MeshElement* aNode = nodeIt->next(); +#ifdef _EDF_NODE_IDS_ + conn[ iNode ] = aNodeIdMap[aNode->GetID()]; +#else + conn[ iNode ] = aNode->GetID(); +#endif + ++iNode; + } + // element number + aPolyhInfo->SetElemNum( iElem, anElem->GetID() ); + + // family number + int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId ); + aPolyhInfo->SetFamNum( iElem, famNum ); + + if ( ++iElem == aPolyhInfo->GetNbElem() ) + break; + } + //cout << " SetPolyedreInfo(aPolyhInfo )" << endl; + myMed->SetPolyedreInfo(aPolyhInfo); + } + } // if (aElemTypeData->_geomType == ePOLYEDRE ) + + else + { + // Treat standard types + // --------------------- + + // allocate data arrays + PCellInfo aCellInfo = myMed->CrCellInfo( aMeshInfo, + aElemTypeData->_entity, + aElemTypeData->_geomType, + aElemTypeData->_nbElems, + theConnMode, + theIsElemNum, + theIsElemNames); + // build map of family numbers for this type + if ( !isElemFamMapBuilt[ aElemTypeData->_smdsType ]) + { + //cout << " fillElemFamilyMap()" << endl; + fillElemFamilyMap( anElemFamMap, aFamilies, aElemTypeData->_smdsType ); + isElemFamMapBuilt[ aElemTypeData->_smdsType ] = true; + } + + TInt aNbNodes = MED::GetNbNodes(aElemTypeData->_geomType); + while ( const SMDS_MeshElement* anElem = elemIterator->next() ) + { + if ( anElem->NbNodes() != aNbNodes || anElem->IsPoly() ) + continue; // other geometry + + // connectivity + TConnSlice aTConnSlice = aCellInfo->GetConnSlice( iElem ); + for (TInt iNode = 0; iNode < aNbNodes; iNode++) { + const SMDS_MeshElement* aNode = anElem->GetNode( iNode ); +#ifdef _EDF_NODE_IDS_ + aTConnSlice[ iNode ] = aNodeIdMap[aNode->GetID()]; +#else + aTConnSlice[ iNode ] = aNode->GetID(); +#endif + } + // element number + aCellInfo->SetElemNum( iElem, anElem->GetID() ); + + // family number + int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId ); + aCellInfo->SetFamNum( iElem, famNum ); + + if ( ++iElem == aCellInfo->GetNbElem() ) + break; + } + // store data in a file + //cout << " SetCellInfo(aCellInfo)" << endl; + myMed->SetCellInfo(aCellInfo); } - } - }catch(const std::exception& exc){ + + } // loop on geom types + + + } + catch(const std::exception& exc) { INFOS("Follow exception was cought:\n\t"<