// File : DriverMED_W_SMESHDS_Mesh.cxx
// Module : SMESH
-using namespace std;
+#include <sstream>
+
#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 "SMDS_MeshFacesIterator.hxx"
-#include "SMDS_MeshEdgesIterator.hxx"
-#include "SMDS_MeshNodesIterator.hxx"
-#include "SMDS_MeshVolumesIterator.hxx"
-#include "SMESHDS_SubMesh.hxx"
-#include "SMDS_MapIteratorOfExtendedMap.hxx"
-#include "SMDS_MapOfMeshElement.hxx"
-#include "SMDS_Position.hxx"
-
-#include <TopExp.hxx>
-#include <TopExp_Explorer.hxx>
-#include <TopoDS.hxx>
-#include <TopoDS_Iterator.hxx>
-#include <TopoDS_Compound.hxx>
-#include <TopoDS_CompSolid.hxx>
-#include <TopoDS_Solid.hxx>
-#include <TopoDS_Shell.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopoDS_Wire.hxx>
-#include <TopoDS_Edge.hxx>
-#include <TopoDS_Vertex.hxx>
-#include <TopoDS_Shape.hxx>
-#include <TopTools_MapOfShape.hxx>
-#include <TColStd_ListIteratorOfListOfInteger.hxx>
-
-
-#include <map>
-#include <set>
-#include <vector>
+#include "SMDS_PolyhedralVolumeOfNodes.hxx"
+
#include "utilities.h"
-DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh() {
- ;
-}
+#include "MED_Utilities.hxx"
-DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh() {
- ;
-}
+#define _EDF_NODE_IDS_
+//#define _ELEMENTS_BY_DIM_
-void DriverMED_W_SMESHDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
- myMesh = aMesh;
+using namespace std;
+using namespace MED;
+
+
+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)
+{
+ myMed = CrWrapper(theFileName,theId);
+ Driver_SMESHDS_Mesh::SetFile(theFileName);
}
-void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile) {
- myFile = aFile;
+void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
+{
+ return SetFile(theFileName,MED::eV2_2);
}
-void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId) {
- myFileId = aFileId;
+void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName)
+{
+ myMeshName = theMeshName;
}
-void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId) {
- myMeshId = aMeshId;
+void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_GroupBase* theGroup)
+{
+ myGroups.push_back(theGroup);
}
-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();
-
-
+void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
+{
+ myAllSubMeshes = true;
}
-void DriverMED_W_SMESHDS_Mesh::Add() {
-
- med_err ret = 0;
- int i,j,k,l;
- int numero;
- char message[200];
- Standard_Boolean ok;
- /* nombre d'objets MED */
- char nom_universel[MED_TAILLE_LNOM+1];
- med_int long_fichier_en_tete;
- char *fichier_en_tete;
- char version_hdf[10];
- char version_med[10];
- med_int nmaa,mdim,nnoe;
- med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE];
- med_int nare[MED_NBR_GEOMETRIE_ARETE];
- /* nom du maillage */
- char nommaa[MED_TAILLE_NOM+1];
- /* noeuds */
- med_float *coo;
- // PN : Initilialisation de nomcoo et unicoo pour lisibilite du maillage
- char nomcoo[3*MED_TAILLE_PNOM+1]="x y z ";
- char unicoo[3*MED_TAILLE_PNOM+1]="m m m ";
- char *nomnoe;
- med_int *numnoe;
- med_int *nufano;
- med_repere rep;
- med_booleen inonoe,inunoe;
- med_mode_switch mode_coo;
- char str[MED_TAILLE_PNOM+1];
- med_int nbNodes;
- /* elements */
- med_int nsup;
- med_int edim;
- med_int taille;
- med_int elem_id,myId;
- med_int *connectivite;
- char *nomele;
- med_int *numele;
- med_int *nufael;
- med_booleen inoele, inuele;
- med_connectivite typ_con;
- med_geometrie_element typgeo;
- med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2,
- MED_SEG3,MED_TRIA3,
- MED_TRIA6,MED_QUAD4,
- MED_QUAD8,MED_TETRA4,
- MED_TETRA10,MED_HEXA8,
- MED_HEXA20,MED_PENTA6,
- MED_PENTA15,MED_PYRA5,
- MED_PYRA13};
- med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
- med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
- char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1",
- "MED_SEG2",
- "MED_SEG3",
- "MED_TRIA3",
- "MED_TRIA6",
- "MED_QUAD4",
- "MED_QUAD8",
- "MED_TETRA4",
- "MED_TETRA10",
- "MED_HEXA8",
- "MED_HEXA20",
- "MED_PENTA6",
- "MED_PENTA15",
- "MED_PYRA5",
- "MED_PYRA13"};
- med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
- MED_QUAD4,MED_QUAD8};
- med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
- med_int nfaces[MED_NBR_GEOMETRIE_FACE];
- char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3","MED_TRIA6",
- "MED_QUAD4","MED_QUAD8"};
- med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};
- med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
- med_int naretes[MED_NBR_GEOMETRIE_ARETE];
- char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2","MED_SEG3"};
-
- typ_con = MED_NOD;
- mode_coo = MED_FULL_INTERLACE;
- numero = myMeshId;
-
- //---- provisoire : switch pour ecrire les familles de mailles
- int besoinfamilledemaille=1;
- //---- provisoire : switch pour ecrire les familles de mailles
-
- /****************************************************************************
- * OUVERTURE DU FICHIER EN ECRITURE *
- ****************************************************************************/
- char* file2Read = (char*)myFile.c_str();
-
- MESSAGE ( " file2Read " << file2Read )
-
- myFileId = MEDouvrir(file2Read,MED_REMP);
- if (myFileId < 0)
- {
- fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
- exit(EXIT_FAILURE);
- }
-
- /****************************************************************************
- * NOMBRES D'OBJETS MED *
- ****************************************************************************/
- MESSAGE("(****************************)");
- MESSAGE("(* INFORMATIONS GENERALES : *)");
- MESSAGE("(****************************)");
-
- /* calcul de la dimension */
- mdim=2;
- double epsilon=0.00001;
- double nodeRefX;
- double nodeRefY;
- double nodeRefZ;
-
- bool dimX = true;
- bool dimY = true;
- bool dimZ = true;
-
- SMDS_MeshNodesIterator myItNodes(myMesh);
- int inode = 0;
- for (;myItNodes.More();myItNodes.Next()) {
- const Handle(SMDS_MeshElement)& elem = myItNodes.Value();
- const Handle(SMDS_MeshNode)& node = myMesh->GetNode(1,elem);
- if ( inode == 0 ) {
- nodeRefX = fabs(node->X());
- nodeRefY = fabs(node->Y());
- nodeRefZ = fabs(node->Z());
- }
- SCRUTE( inode );
- SCRUTE( nodeRefX );
- SCRUTE( nodeRefY );
- SCRUTE( nodeRefZ );
-
- if ( inode !=0 ) {
- if ( (fabs(fabs(node->X()) - nodeRefX) > epsilon ) && dimX )
- dimX = false;
- if ( (fabs(fabs(node->Y()) - nodeRefY) > epsilon ) && dimY )
- dimY = false;
- if ( (fabs(fabs(node->Z()) - nodeRefZ) > epsilon ) && dimZ )
- dimZ = false;
- }
- if ( !dimX && !dimY && !dimZ ) {
- mdim = 3;
- break;
- }
- inode++;
- }
-
- if ( mdim != 3 ) {
- if ( dimX && dimY && dimZ )
- mdim = 0;
- else if ( !dimX ) {
- if ( dimY && dimZ )
- mdim = 1;
- else if (( dimY && !dimZ ) || ( !dimY && dimZ ) )
- mdim = 2;
- } else if ( !dimY ) {
- if ( dimX && dimZ )
- mdim = 1;
- else if (( dimX && !dimZ ) || ( !dimX && dimZ ) )
- mdim = 2;
- } else if ( !dimZ ) {
- if ( dimY && dimX )
- mdim = 1;
- else if (( dimY && !dimX ) || ( !dimY && dimX ) )
- mdim = 2;
- }
- }
-
- MESSAGE ( " mdim " << mdim );
-
- /* creation du maillage */
- //mdim=3;
- sprintf(nommaa,"Mesh %d",numero);
- SCRUTE(nommaa);
- ret = MEDmaaCr(myFileId,nommaa,mdim);
-
- ASSERT(ret == 0);
- SCRUTE( ret );
+void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
+{
+ mySubMeshes[theID] = theSubMesh;
+}
- /* Combien de noeuds ? */
- nnoe = myMesh->NbNodes();
- //SCRUTE(nnoe);
- /* Combien de mailles, faces ou aretes ? */
- for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
- nmailles[i]=0;
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
+{
+ myDoGroupOfNodes = true;
+}
- Standard_Integer nb_of_nodes, nb_of_faces, nb_of_edges;
- vector<int> elem_Id[MED_NBR_GEOMETRIE_MAILLE];
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges()
+{
+ myDoGroupOfEdges = true;
+}
- SMDS_MeshEdgesIterator itEdges(myMesh);
- nb_of_edges = myMesh->NbEdges();
- for (;itEdges.More();itEdges.Next()) {
- const Handle(SMDS_MeshElement)& elem = itEdges.Value();
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces()
+{
+ myDoGroupOfFaces = true;
+}
- nb_of_nodes = elem->NbNodes();
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
+{
+ myDoGroupOfVolumes = true;
+}
- switch (nb_of_nodes) {
- case 2 : {
- elem_Id[1].push_back(elem->GetID());
- nmailles[1]++;
- break;
- }
- case 3 : {
- elem_Id[2].push_back(elem->GetID());
- nmailles[2]++;
- break;
+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;
}
- }
-
-
- SMDS_MeshFacesIterator itFaces(myMesh);
- nb_of_faces = myMesh->NbFaces();
- for (;itFaces.More();itFaces.Next()) {
- const Handle(SMDS_MeshElement)& elem = itFaces.Value();
-
- nb_of_nodes = elem->NbNodes();
-
- switch (nb_of_nodes) {
- case 3 : {
- elem_Id[3].push_back(elem->GetID());
- nmailles[3]++;
- break;
+ MED::TIntVector::value_type GetID(){
+ return myCurrentNode->GetID();
}
- case 4 : {
- elem_Id[5].push_back(elem->GetID());
- nmailles[5]++;
- break;
+ MED::TFloatVector::value_type GetCoord(TInt theCoodId){
+ return (myCurrentNode->*myGetCoord[theCoodId])();
}
- case 6 : {
- elem_Id[4].push_back(elem->GetID());
- nmailles[4]++;
- break;
+ MED::TStringVector::value_type GetName(TInt theDimId){
+ return myName[theDimId];
}
+ MED::TStringVector::value_type GetUnit(TInt theDimId){
+ return myUnit[theDimId];
}
+ };
+ typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
+
+}
+
+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 DRS_FAIL;
}
-
- SMDS_MeshVolumesIterator itVolumes(myMesh);
- for (;itVolumes.More();itVolumes.Next()) {
- const Handle(SMDS_MeshElement)& elem = itVolumes.Value();
-
- nb_of_nodes = elem->NbNodes();
- switch (nb_of_nodes) {
- case 8 : {
- elem_Id[9].push_back(elem->GetID());
- nmailles[9]++;
- break;
- }
+ try{
+ MESSAGE("Perform - myFile : "<<myFile);
+
+ // Creating the MED mesh for corresponding SMDS structure
+ //-------------------------------------------------------
+ string aMeshName;
+ if (myMeshId != -1) {
+ ostringstream aMeshNameStr;
+ aMeshNameStr<<myMeshId;
+ aMeshName = aMeshNameStr.str();
+ } else {
+ aMeshName = myMeshName;
}
- }
+ // Mesh dimension definition
+ TInt aMeshDimension;
+ TCoordHelperPtr aCoordHelperPtr;
+ {
+ bool anIsXDimension = false;
+ bool anIsYDimension = false;
+ bool anIsZDimension = false;
+ {
+ SMDS_NodeIteratorPtr aNodesIter = myMesh->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;
+ }
- /****************************************************************************
- * ECRITURE DES NOEUDS *
- ****************************************************************************/
- MESSAGE("(************************)");
- MESSAGE("(* NOEUDS DU MAILLAGE : *)");
- MESSAGE("(************************)");
-
- /* Allocations memoires */
- /* table des coordonnees
- profil : (dimension * nombre de noeuds ) */
- coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim);
- /* table des numeros, des numeros de familles des noeuds
- profil : (nombre de noeuds) */
- numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
- nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
- /* table des noms des noeuds
- profil : (nnoe*MED_TAILLE_PNOM+1) */
- nomnoe ="";
-
- /* PN pour aster, il faut une famille 0 pour les noeuds et une autre pour les elements*/
- /* PN : Creation de la famille 0 */
- char * nomfam="FAMILLE_0";
- char *attdes="";
- char *gro=0;
- med_int ngro=0;
- med_int natt=1;
- med_int attide = 0;
- med_int attval=0;
- med_int numfam = 0;
- med_int attvalabs=1;
- ret = MEDfamCr(myFileId,nommaa,nomfam,numfam, &attide,&attval,attdes,natt,gro,ngro);
- ASSERT(ret == 0);
-
-
- /* PN : FIN Creation de la famille 0 */
-
- map < int, int > mapNoeud;
- typedef pair<set<int>::iterator, bool> IsFamily;
- int nbFamillesNoeud;
-
-
- i = 0;
- set<int> FamilySet;
- nbFamillesNoeud = 0;
- int verifienbnoeuds = 0;
- med_int* rien=0;
-
- SMDS_MeshNodesIterator itNodes(myMesh);
- for (;itNodes.More();itNodes.Next())
- {
- const Handle(SMDS_MeshElement)& elem = itNodes.Value();
- const Handle(SMDS_MeshNode)& node = myMesh->GetNode(1,elem);
-
- if(mdim==3){
- coo[i*3]=node->X();
- coo[i*3+1]=node->Y();
- coo[i*3+2]=node->Z();
- } else if(mdim==2) {
- if ( dimX ) {
- coo[i*2]=node->Y();
- coo[i*2+1]=node->Z();
- }
- if ( dimY ) {
- coo[i*2]=node->X();
- coo[i*2+1]=node->Z();
- }
- if ( dimZ ) {
- coo[i*2]=node->X();
- coo[i*2+1]=node->Y();
- }
- } else {
- if ( ! dimX ) {
- coo[i]=node->X();
- } else if ( ! dimY ) {
- coo[i]=node->Y();
- } else {
- coo[i]=node->Z();
- }
+ 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;
}
- mapNoeud[node->GetID()] = i+1;
-
- // renvoie 0 pour les noeuds internes du volume
- int numfamille=node->GetPosition()->GetShapeId();
- nufano[i]=numfamille;
-
- //SCRUTE(i);
- //SCRUTE(nufano[i]);
- //SCRUTE(coo[i*3]);
- //SCRUTE(coo[i*3+1]);
- //SCRUTE(coo[i*3+2]);
- if ( nufano[i] != 0 )
- {
- IsFamily deja = FamilySet.insert(nufano[i]); // insert if new, or gives existant
- if (deja.second) // actually inserted
- {
- char famille[MED_TAILLE_NOM+1];
- sprintf(famille,"F%d",nufano[i]);
- // CreateFamily(strdup(nommaa),strdup(famille),nufano[i],attvalabs++);
- attvalabs++;
- CreateFamily(strdup(nommaa),strdup(famille),nufano[i],numfamille);
- //MESSAGE("---famille-noeud--- "<<nbFamillesNoeud<<" "<<nufano[i]);
- nbFamillesNoeud++;
- }
- }
+ }
- i++;
- verifienbnoeuds ++;
+
+ PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aMeshName);
+ MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
+ myMed->SetMeshInfo(aMeshInfo);
+
+ // Storing SMDS groups and sub-meshes
+ //-----------------------------------
+ int myNodesDefaultFamilyId = 0;
+ int myEdgesDefaultFamilyId = 0;
+ int myFacesDefaultFamilyId = 0;
+ int myVolumesDefaultFamilyId = 0;
+ if (myDoGroupOfNodes)
+ myNodesDefaultFamilyId = REST_NODES_FAMILY;
+ if (myDoGroupOfEdges)
+ myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
+ if (myDoGroupOfFaces)
+ myFacesDefaultFamilyId = REST_FACES_FAMILY;
+ if (myDoGroupOfVolumes)
+ myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
+
+ MESSAGE("Perform - aFamilyInfo");
+ map<const SMDS_MeshElement *, int> anElemFamMap;
+ list<DriverMED_FamilyPtr> aFamilies;
+ if (myAllSubMeshes) {
+ aFamilies = DriverMED_Family::MakeFamilies
+ (myMesh->SubMeshes(), myGroups,
+ myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
+ } else {
+ aFamilies = DriverMED_Family::MakeFamilies
+ (mySubMeshes, myGroups,
+ myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
}
- ret = MEDnoeudsEcr(myFileId,nommaa,mdim,coo,mode_coo,MED_CART,
- nomcoo,unicoo,nomnoe,MED_FAUX,rien,MED_FAUX,
- nufano,nnoe,MED_REMP);
- ASSERT(ret == 0);
- MESSAGE("--- Creation de " << verifienbnoeuds << " noeuds");
- ASSERT(verifienbnoeuds == nnoe);
- MESSAGE("--- Creation de " << nbFamillesNoeud << " familles de noeuds");
-
- /* liberation memoire */
- free(coo);
- free(numnoe);
- free(nufano);
-
- /****************************************************************************
- * ECRITURE DES ELEMENTS *
- ****************************************************************************/
- MESSAGE("(**************************)");
- MESSAGE("(* ELEMENTS DU MAILLAGE : *)");
- MESSAGE("(**************************)");
-
- /* Ecriture des connectivites, noms, numeros des mailles */
+ list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
- if (ret == 0)
+ for (; aFamsIter != aFamilies.end(); aFamsIter++)
{
- int nbFamillesElts =0;
- Handle(SMESHDS_Mesh) mySMESHDSMesh = Handle(SMESHDS_Mesh)::DownCast(myMesh);
- TopTools_IndexedMapOfShape myIndexToShape;
- TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(),myIndexToShape);
-
- map < int, int > mapFamille;
-
- if (besoinfamilledemaille == 1)
- {
- int t;
- for (t =1; t <= myIndexToShape.Extent(); t++)
- {
- const TopoDS_Shape S = myIndexToShape(t);
- if (mySMESHDSMesh->HasMeshElements(S))
- {
- //MESSAGE ("********* Traitement de la Famille "<<-t);
-
- Handle(SMESHDS_SubMesh) SM = mySMESHDSMesh->MeshElements(S);
- const TColStd_ListOfInteger& indElt = SM->GetIDElements();
- TColStd_ListIteratorOfListOfInteger ite(indElt);
-
- bool plein=false;
- for (; ite.More(); ite.Next())
- {
- int eltId = ite.Value();
- mapFamille [eltId] = - t;
- plein=true;
- }
- if (plein)
- {
- nbFamillesElts++;
- char famille[MED_TAILLE_NOM+1];
- sprintf(famille,"E%d",t);
- CreateFamily(strdup(nommaa),strdup(famille),-t,attvalabs++);
- }
- }
- }
- }
-
- int indice=1;
- for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
- {
- if (nmailles[i] > 0 && ret == 0)
- {
- MESSAGE ( " Start "<<typmai[i]);
-
- /* dimension de la maille */
- edim = typmai[i] / 100;
- nsup = 0;
- if (mdim == 2 || mdim == 3)
- if (edim == 1) nsup = 1;
- if (mdim == 3)
- if (edim == 2) nsup = 1;
- //SCRUTE(nsup);
-
- taille = nsup+typmai[i]%100;
- //SCRUTE(taille);
-
- /* allocation memoire */
- connectivite = (med_int*)malloc(sizeof(med_int)* taille*nmailles[i]);
- nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM* nmailles[i]+1);
- numele = (med_int*)malloc(sizeof(med_int)* nmailles[i]);
- nufael = (med_int*)malloc(sizeof(med_int)* nmailles[i]);
- nomele="";
- nbNodes=typmai[i]%100;
-
- for (j=0;j<nmailles[i];j++)
- {
- myId = elem_Id[i][j];
- const Handle(SMDS_MeshElement)& elem = myMesh->FindElement(myId);
- //*(numele+j) = myId;
- *(numele+j) = indice ++;
-
- for (k=0; k<nbNodes; k++)
- {
- *(connectivite+j*taille+k) = mapNoeud[elem->GetConnection(k+1)];
- //SCRUTE(*(connectivite+j*taille+k));
- }
- if (nsup) *(connectivite+j*taille + nbNodes) = 0;
-
- if (besoinfamilledemaille == 1)
- {
- if (mapFamille.find(myId)!=mapFamille.end())
- {
- nufael[j]=mapFamille[myId];
- }
- else
- {
- nufael[j]=0;
- }
- }
- else
- {
- nufael[j]=0;
- }
-
- //SCRUTE(myId);
- //SCRUTE(j);
- //SCRUTE(nufael[j]);
- }
-
- /* ecriture des données */
-
- med_int* rien=0;
- ret=MEDelementsEcr( myFileId,nommaa,mdim,connectivite,mode_coo,nomele,MED_FAUX,numele,
- MED_VRAI,nufael,nmailles[i],MED_MAILLE,typmai[i],typ_con,MED_REMP);
- ASSERT(ret == 0);
- //SCRUTE(ret);
-
- if (ret < 0) MESSAGE(">> ERREUR : ecriture des mailles \n");
-
- /* liberation memoire */
- free(connectivite);
- free(numele);
- free(nufael);
- MESSAGE ( " End "<<typmai[i]);
- }
- };
- MESSAGE("--- Creation de " << nbFamillesElts << " familles d elements");
-
+ PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(myMed,aMeshInfo);
+ myMed->SetFamilyInfo(aFamilyInfo);
+ int aFamId = (*aFamsIter)->GetId();
+
+ const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
+ set<const SMDS_MeshElement *>::const_iterator anElemsIter = anElems.begin();
+ for (; anElemsIter != anElems.end(); anElemsIter++)
+ {
+ anElemFamMap[*anElemsIter] = aFamId;
+ }
+// delete (*aFamsIter);
}
- /****************************************************************************
- * FERMETURE DU FICHIER *
- ****************************************************************************/
-
- ret = MEDfermer(myFileId);
+ // Storing SMDS nodes to the MED file for the MED mesh
+ //----------------------------------------------------
+#ifdef _EDF_NODE_IDS_
+ typedef map<TInt,TInt> TNodeIdMap;
+ TNodeIdMap aNodeIdMap;
+#endif
+ TInt aNbElems = myMesh->NbNodes();
+ MED::TIntVector anElemNums(aNbElems);
+ MED::TIntVector aFamilyNums(aNbElems);
+ MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
+ for(TInt iNode = 0, aStartId = 0; aCoordHelperPtr->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];
+ else
+ aFamilyNums[iNode] = myNodesDefaultFamilyId;
+ }
- if (ret != 0)
- fprintf(stderr,">> ERREUR : erreur a la fermeture du fichier %s\n",file2Read);
- MESSAGE ("fichier ferme");
+ 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 ERepere SMDS_COORDINATE_SYSTEM = eCART;
+
+ PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo,
+ SMDS_COORDINATE_SYSTEM,
+ aCoordinates,
+ aCoordNames,
+ aCoordUnits,
+ aFamilyNums,
+ anElemNums);
+ MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems);
+ myMed->SetNodeInfo(aNodeInfo);
+
+
+ // Storing others SMDS elements to the MED file for the MED mesh
+ //--------------------------------------------------------------
+ EEntiteMaillage SMDS_MED_ENTITY = eMAILLE;
+ const EConnectivite SMDS_MED_CONNECTIVITY = eNOD;
+
+ // Storing SMDS Edges
+ if(TInt aNbElems = myMesh->NbEdges()){
+#ifdef _ELEMENTS_BY_DIM_
+ SMDS_MED_ENTITY = eARETE;
+#endif
+ SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
+ TInt aNbConnectivity = MED::GetNbNodes(eSEG2);
+ MED::TIntVector anElemNums(aNbElems);
+ MED::TIntVector aFamilyNums(aNbElems);
+ MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
+
+ for(TInt iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
+ const SMDS_MeshEdge* anElem = anIter->next();
+ SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
+ for(TInt iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
+ const SMDS_MeshElement* aNode = aNodesIter->next();
+#ifdef _EDF_NODE_IDS_
+ aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
+#else
+ aConnectivity[iConn+iNode] = aNode->GetID();
+#endif
+ }
+ anElemNums[iElem] = anElem->GetID();
-}
+ if (anElemFamMap.find(anElem) != anElemFamMap.end())
+ aFamilyNums[iElem] = anElemFamMap[anElem];
+ else
+ aFamilyNums[iElem] = myEdgesDefaultFamilyId;
+ }
+
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ eSEG2,
+ SMDS_MED_CONNECTIVITY,
+ aConnectivity,
+ aFamilyNums,
+ anElemNums);
+ myMed->SetCellInfo(aCellInfo);
+ }
-void DriverMED_W_SMESHDS_Mesh::CreateFamily(char* nommaa, char* famille, int i,med_int k) {
+ // Storing SMDS Faces
+ if(TInt aNbElems = myMesh->NbFaces()){
+ SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
+#ifdef _ELEMENTS_BY_DIM_
+ SMDS_MED_ENTITY = eFACE;
+#endif
+ TInt aNbTriaConn = MED::GetNbNodes(eTRIA3);
+ MED::TIntVector anTriaElemNums;
+ anTriaElemNums.reserve(aNbElems);
+ MED::TIntVector aTriaFamilyNums;
+ aTriaFamilyNums.reserve(aNbElems);
+ MED::TIntVector aTriaConn;
+ aTriaConn.reserve(aNbElems*aNbTriaConn);
+
+ TInt aNbQuadConn = MED::GetNbNodes(eQUAD4);
+ MED::TIntVector aQuadElemNums;
+ aQuadElemNums.reserve(aNbElems);
+ MED::TIntVector aQuadFamilyNums;
+ aQuadFamilyNums.reserve(aNbElems);
+ MED::TIntVector aQuadConn;
+ aQuadConn.reserve(aNbElems*aNbQuadConn);
+
+ 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();
+ TInt aNbNodes = anElem->NbNodes();
+ SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
+ TInt aNbConnectivity;
+ MED::TIntVector* anElemNums;
+ MED::TIntVector* aFamilyNums;
+ MED::TIntVector* aConnectivity;
+ 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;
+ default:
+ break;
+ }
+ }
+ 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
+ }
- med_int ngro=0;
- med_int natt;
+ TInt aSize = aConnectivity->size();
+ aConnectivity->resize(aSize+aNbConnectivity);
+ // There is some differences between SMDS and MED in cells mapping
+ switch(aNbNodes){
+ case 4:
+ (*aConnectivity)[aSize+0] = aVector[0];
+ (*aConnectivity)[aSize+1] = aVector[1];
+ (*aConnectivity)[aSize+2] = aVector[3];
+ (*aConnectivity)[aSize+3] = aVector[2];
+ default:
+ for(TInt iNode = 0; iNode < aNbNodes; iNode++)
+ (*aConnectivity)[aSize+iNode] = aVector[iNode];
+ }
- natt=1;
- char attdes[MED_TAILLE_DESC+1];
- char gro[MED_TAILLE_LNOM+1];
- char fam2[MED_TAILLE_LNOM+1];
+ if (anElem->IsPoly()) {
+ // fill indices for polygonal element
+ TInt aPrevPos = aPolygoneInds.back();
+ aPolygoneInds.push_back(aPrevPos + aNbNodes);
+ }
- strcpy(attdes,"");
- strcpy(gro,"");
- strcpy(fam2,famille);
+ anElemNums->push_back(anElem->GetID());
- med_int * attide=new med_int[1];
- med_int * attval=new med_int[1];
- attide[0] = k;
- attval[0] = k;
+ if (anElemFamMap.find(anElem) != anElemFamMap.end())
+ aFamilyNums->push_back(anElemFamMap[anElem]);
+ else
+ aFamilyNums->push_back(myFacesDefaultFamilyId);
+ }
+ if(TInt aNbElems = anTriaElemNums.size()){
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ eTRIA3,
+ SMDS_MED_CONNECTIVITY,
+ aTriaConn,
+ aTriaFamilyNums,
+ anTriaElemNums);
+ MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA3<<"; aNbElems = "<<aNbElems);
+ myMed->SetCellInfo(aCellInfo);
+ }
+ if(TInt aNbElems = aQuadElemNums.size()){
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ eQUAD4,
+ SMDS_MED_CONNECTIVITY,
+ aQuadConn,
+ aQuadFamilyNums,
+ aQuadElemNums);
+ MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD4<<"; aNbElems = "<<aNbElems);
+ myMed->SetCellInfo(aCellInfo);
+ }
+ if(TInt aNbElems = aPolygoneElemNums.size()){
+ // add one element in connectivities,
+ // referenced by the last element in indices
+ aPolygoneConn.push_back(0);
+
+ PPolygoneInfo aCellInfo = myMed->CrPolygoneInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ ePOLYGONE,
+ SMDS_MED_CONNECTIVITY,
+ aPolygoneConn,
+ aPolygoneInds,
+ aPolygoneFamilyNums,
+ aPolygoneElemNums);
+ MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYGONE<<"; aNbElems = "<<aNbElems);
+ myMed->SetPolygoneInfo(aCellInfo);
+ }
+ }
+ // Storing SMDS Volumes
+ if(TInt aNbElems = myMesh->NbVolumes()){
+ SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
+#ifdef _ELEMENTS_BY_DIM_
+ SMDS_MED_ENTITY = eMAILLE;
+#endif
+ TInt aNbTetraConn = MED::GetNbNodes(eTETRA4);
+ MED::TIntVector anTetraElemNums;
+ anTetraElemNums.reserve(aNbElems);
+ MED::TIntVector aTetraFamilyNums;
+ aTetraFamilyNums.reserve(aNbElems);
+ MED::TIntVector aTetraConn;
+ aTetraConn.reserve(aNbElems*aNbTetraConn);
+
+ TInt aNbPyraConn = MED::GetNbNodes(ePYRA5);
+ MED::TIntVector anPyraElemNums;
+ anPyraElemNums.reserve(aNbElems);
+ MED::TIntVector aPyraFamilyNums;
+ aPyraFamilyNums.reserve(aNbElems);
+ MED::TIntVector aPyraConn;
+ aPyraConn.reserve(aNbElems*aNbPyraConn);
+
+ TInt aNbPentaConn = MED::GetNbNodes(ePENTA6);
+ MED::TIntVector anPentaElemNums;
+ anPentaElemNums.reserve(aNbElems);
+ MED::TIntVector aPentaFamilyNums;
+ aPentaFamilyNums.reserve(aNbElems);
+ MED::TIntVector aPentaConn;
+ aPentaConn.reserve(aNbElems*aNbPentaConn);
+
+ TInt aNbHexaConn = MED::GetNbNodes(eHEXA8);
+ MED::TIntVector aHexaElemNums;
+ aHexaElemNums.reserve(aNbElems);
+ MED::TIntVector aHexaFamilyNums;
+ aHexaFamilyNums.reserve(aNbElems);
+ MED::TIntVector aHexaConn;
+ aHexaConn.reserve(aNbElems*aNbHexaConn);
+
+ MED::TIntVector aPolyedreElemNums;
+ aPolyedreElemNums.reserve(aNbElems);
+ MED::TIntVector aPolyedreInds;
+ aPolyedreInds.reserve(aNbElems + 1);
+ aPolyedreInds.push_back(1); // reference on the first element in the faces
+ MED::TIntVector aPolyedreFaces;
+ aPolyedreFaces.reserve(aNbElems + 1);
+ aPolyedreFaces.push_back(1); // reference on the first element in the connectivities
+ MED::TIntVector aPolyedreFamilyNums;
+ aPolyedreFamilyNums.reserve(aNbElems);
+ MED::TIntVector aPolyedreConn;
+ aPolyedreConn.reserve(aNbElems*aNbHexaConn);
+
+ for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
+ const SMDS_MeshVolume* anElem = anIter->next();
+
+ MED::TIntVector* anElemNums;
+ MED::TIntVector* aFamilyNums;
+
+ if (anElem->IsPoly()) {
+ const SMDS_PolyhedralVolumeOfNodes* aPolyedre =
+ (const SMDS_PolyhedralVolumeOfNodes*) anElem;
+ if (!aPolyedre) {
+ MESSAGE("Warning: bad volumic element");
+ continue;
+ }
+
+ anElemNums = &aPolyedreElemNums;
+ aFamilyNums = &aPolyedreFamilyNums;
+
+ TInt aNodeId, aNbFaces = aPolyedre->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;
+ }
+
+ 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]);
+ else
+ aFamilyNums->push_back(myVolumesDefaultFamilyId);
+ }
- //MESSAGE("-------- Creation de la Famille : "<< famille << "numero " << i << " --------------");
- med_int ret = MEDfamCr(myFileId, nommaa, fam2, i, attide, attval, attdes, natt, gro, ngro);
- ASSERT(ret==0);
- delete [] attide;
- delete [] attval;
+ if(TInt aNbElems = anTetraElemNums.size()){
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ eTETRA4,
+ SMDS_MED_CONNECTIVITY,
+ aTetraConn,
+ aTetraFamilyNums,
+ anTetraElemNums);
+ MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTETRA4<<"; aNbElems = "<<aNbElems);
+ myMed->SetCellInfo(aCellInfo);
+ }
+ if(TInt aNbElems = anPyraElemNums.size()){
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ ePYRA5,
+ SMDS_MED_CONNECTIVITY,
+ aPyraConn,
+ aPyraFamilyNums,
+ anPyraElemNums);
+ MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA5<<"; aNbElems = "<<aNbElems);
+ myMed->SetCellInfo(aCellInfo);
+ }
+ if(TInt aNbElems = anPentaElemNums.size()){
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ ePENTA6,
+ SMDS_MED_CONNECTIVITY,
+ aPentaConn,
+ aPentaFamilyNums,
+ anPentaElemNums);
+ MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA6<<"; aNbElems = "<<aNbElems);
+ myMed->SetCellInfo(aCellInfo);
+ }
+ if(TInt aNbElems = aHexaElemNums.size()){
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ eHEXA8,
+ SMDS_MED_CONNECTIVITY,
+ aHexaConn,
+ aHexaFamilyNums,
+ aHexaElemNums);
+ MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA8<<"; aNbElems = "<<aNbElems);
+ myMed->SetCellInfo(aCellInfo);
+ }
+ if(TInt aNbElems = aPolyedreElemNums.size()){
+ // add one element in connectivities,
+ // referenced by the last element in faces
+ aPolyedreConn.push_back(0);
+
+ PPolyedreInfo aCellInfo = myMed->CrPolyedreInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ ePOLYEDRE,
+ SMDS_MED_CONNECTIVITY,
+ aPolyedreConn,
+ aPolyedreFaces,
+ aPolyedreInds,
+ aPolyedreFamilyNums,
+ aPolyedreElemNums);
+ MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYEDRE<<"; aNbElems = "<<aNbElems);
+ myMed->SetPolyedreInfo(aCellInfo);
+ }
+ }
+ }catch(const std::exception& exc){
+ INFOS("Follow exception was cought:\n\t"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was cought !!!");
+ }
+ myMeshId = -1;
+ myGroups.clear();
+ mySubMeshes.clear();
+ return aResult;
}
-
-
-
