// File : DriverMED_W_SMESHDS_Mesh.cxx
// Module : SMESH
-using namespace std;
#include "DriverMED_W_SMESHDS_Mesh.h"
#include "DriverMED_W_SMDS_Mesh.h"
+#include "DriverMED_Family.h"
+
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
-#include <TopExp.hxx>
-#include <vector>
#include "utilities.h"
+#include "MEDA_Wrapper.hxx"
+#include <sstream>
+
+#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)
{
- ;
}
DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
{
- ;
}
void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
{
- myMesh = aMesh;
+ myMesh = aMesh;
}
void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
{
- myFile = aFile;
+ myFile = aFile;
}
void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
{
- myFileId = aFileId;
+ myFileId = aFileId;
}
void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
{
- myMeshId = aMeshId;
+ myMeshId = aMeshId;
}
-void DriverMED_W_SMESHDS_Mesh::Write()
+void DriverMED_W_SMESHDS_Mesh::SetMeshName(string theMeshName)
{
+ myMeshName = theMeshName;
+}
- string myClass = string("SMDS_Mesh");
- string myExtension = string("MED");
+void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_Group* theGroup)
+{
+ myGroups.push_back(theGroup);
+}
- DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
+void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
+{
+ myAllSubMeshes = true;
+}
- myWriter->SetMesh(myMesh);
- // myWriter->SetFile(myFile);
- myWriter->SetMeshId(myMeshId);
- myWriter->SetFileId(myFileId);
+void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
+{
+ mySubMeshes[theID] = theSubMesh;
+}
- myWriter->Write();
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
+{
+ myDoGroupOfNodes = true;
+}
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges()
+{
+ myDoGroupOfEdges = true;
}
-void DriverMED_W_SMESHDS_Mesh::Add()
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces()
{
+ myDoGroupOfFaces = true;
+}
- med_err ret = 0;
- int i, j, k, l;
- int numero;
- char message[200];
- bool 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);
- }
+void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
+{
+ myDoGroupOfVolumes = true;
+}
- /****************************************************************************
- * 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;
-
- int inode = 0;
- SMDS_Iterator<const SMDS_MeshNode *> * myItNodes=myMesh->nodesIterator();
- while(myItNodes->more())
- {
- const SMDS_MeshNode * node = myItNodes->next();
- 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++;
- }
+void DriverMED_W_SMESHDS_Mesh::Write()
+{
+ string myClass = string("SMDS_Mesh");
+ string myExtension = string("MED");
- 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;
- }
- }
+ DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
- 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);
-
- /* 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;
-
- int nb_of_nodes, nb_of_faces, nb_of_edges;
- vector < int >elem_Id[MED_NBR_GEOMETRIE_MAILLE];
-
- nb_of_edges = myMesh->NbEdges();
- SMDS_Iterator<const SMDS_MeshEdge *> * itEdges=myMesh->edgesIterator();
- while(itEdges->more())
- {
- const SMDS_MeshEdge * elem = itEdges->next();
-
- nb_of_nodes = elem->NbNodes();
-
- 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;
- }
- }
- }
+ myWriter->SetMesh(myMesh);
+ // myWriter->SetFile(myFile);
+ myWriter->SetMeshId(myMeshId);
+ myWriter->SetFileId(myFileId);
- nb_of_faces = myMesh->NbFaces();
- SMDS_Iterator<const SMDS_MeshFace *> * itFaces=myMesh->facesIterator();
- while(itFaces->more())
- {
- const SMDS_MeshElement * elem = itFaces->next();
-
- nb_of_nodes = elem->NbNodes();
-
- switch (nb_of_nodes)
- {
- case 3:
- {
- elem_Id[3].push_back(elem->GetID());
- nmailles[3]++;
- break;
- }
- case 4:
- {
- elem_Id[5].push_back(elem->GetID());
- nmailles[5]++;
- break;
- }
- case 6:
- {
- elem_Id[4].push_back(elem->GetID());
- nmailles[4]++;
- break;
- }
- }
+ myWriter->Write();
+}
+void DriverMED_W_SMESHDS_Mesh::Add()
+{
+ if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
+ INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
+ return;
+ }
+ try{
+ using namespace MEDA;
+ using namespace boost;
+
+ MESSAGE("Add - myFile : "<<myFile);
+ TWrapper aMed(myFile);
+
+ // Creating the MED mesh for corresponding SMDS structure
+ //-------------------------------------------------------
+ string aMeshName;
+ if (myMeshId != -1) {
+ ostringstream aMeshNameStr;
+ aMeshNameStr<<myMeshId;
+ aMeshName = aMeshNameStr.str();
+ } else {
+ aMeshName = myMeshName;
+ }
+ const int SMDS_MESH_DIM = 3;
+ PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(SMDS_MESH_DIM,aMeshName);
+ MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
+ aMed.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("Add - aFamilyInfo");
+ map<const SMDS_MeshElement *, int> anElemFamMap;
+ list<DriverMED_FamilyPtr> aFamilies;
+ if (myAllSubMeshes) {
+ SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast<SMESHDS_Mesh*>(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);
+ } else {
+ aFamilies = DriverMED_Family::MakeFamilies
+ (mySubMeshes, myGroups,
+ myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
+ }
+ list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
+
+ for (; aFamsIter != aFamilies.end(); aFamsIter++)
+ {
+ PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo);
+ aMed.SetFamilyInfo(aFamilyInfo);
+ int aFamId = (*aFamsIter)->GetId();
+
+ const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
+ set<const SMDS_MeshElement *>::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
+ //----------------------------------------------------
+ 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();
+ anElemNums[iNode] = aNode->GetID();
+ //cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl;
+
+ if (anElemFamMap.find(aNode) != anElemFamMap.end())
+ aFamilyNums[iNode] = anElemFamMap[aNode];
+ else
+ 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";
+
+ 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() = "<<aNbElems);
+ aMed.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;
+
+ // Storing SMDS Edges
+ if(med_int aNbElems = myMesh->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] = aNode->GetID();
}
-
- SMDS_Iterator<const SMDS_MeshVolume *> * itVolumes=myMesh->volumesIterator();
- while(itVolumes->more())
- {
- const SMDS_MeshElement * elem = itVolumes->next();
-
- nb_of_nodes = elem->NbNodes();
- switch (nb_of_nodes)
- {
- case 8:
- {
- elem_Id[9].push_back(elem->GetID());
- nmailles[9]++;
- break;
- }
- case 4 :
- {
- elem_Id[7].push_back(elem->GetID());
- nmailles[7]++;
- break;
- }
- }
+ anElemNums[iElem] = anElem->GetID();
+ //cout<<anElem->GetID()<<": ";
+ //for(med_int iNode = 0; iNode < aNbNodes; iNode++)
+ // cout<<(*aConnectivity)[iConn+iNode]<<", ";
+ //cout<<endl;
+
+ 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);
+ }
+
+ // 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;
}
-
- /****************************************************************************
- * 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_Iterator<const SMDS_MeshNode *> * itNodes=myMesh->nodesIterator();
- while(itNodes->more())
- {
- const SMDS_MeshNode * node = itNodes->next();
-
- 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 * 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();
- }
- }
- 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++;
+ MED::TIntVector aVector(aNbNodes);
+ for(med_int iNode = 0; aNodesIter->more(); iNode++){
+ const SMDS_MeshElement* aNode = aNodesIter->next();
+ aVector[iNode] = aNode->GetID();
}
- 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 */
-
- if (ret == 0)
- {
- int nbFamillesElts = 0;
- SMESHDS_Mesh * mySMESHDSMesh = dynamic_cast<SMESHDS_Mesh *>(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);
-
- SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
- SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
- bool plein = false;
- while(ite->more())
- {
- mapFamille[ite->next()->GetID()] = -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);*/
- nomele = "";
- numele = (med_int *) malloc(sizeof(med_int) * nmailles[i]);
- nufael = (med_int *) malloc(sizeof(med_int) * nmailles[i]);
- nbNodes = typmai[i] % 100;
-
- for (j = 0; j < nmailles[i]; j++)
- {
- myId = elem_Id[i][j];
- const SMDS_MeshElement * elem =
- myMesh->FindElement(myId);
- //*(numele+j) = myId;
- *(numele + j) = indice++;
-
- SMDS_Iterator<const SMDS_MeshElement *> * itk=elem->nodesIterator();
- for (k = 0; itk->more(); k++)
- {
- *(connectivite + j * taille + k) =
- mapNoeud[itk->next()->GetID()];
- }
- delete itk;
-
- 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");
+ 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] = 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] = aVector[iNode];
+ }
+ anElemNums->push_back(anElem->GetID());
+ //cout<<anElem->GetID()<<": ";
+ //for(med_int iNode = 0; iNode < aNbNodes; iNode++)
+ // cout<<(*aConnectivity)[aSize+iNode]<<", ";
+ //cout<<endl;
+
+ 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 = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
+ aMed.SetCellInfo(aCellInfo);
+ }
+ if(med_int aNbElems = aQuadElemNums.size()){
+ PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ MED_QUAD4,
+ SMDS_MED_CONNECTIVITY,
+ aQuadConn,
+ aQuadFamilyNums,
+ aQuadElemNums);
+ MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
+ aMed.SetCellInfo(aCellInfo);
+ }
+ }
+
+ // 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;
}
- /****************************************************************************
- * FERMETURE DU FICHIER *
- ****************************************************************************/
-
- ret = MEDfermer(myFileId);
-
- if (ret != 0)
- fprintf(stderr, ">> ERREUR : erreur a la fermeture du fichier %s\n",
- file2Read);
- MESSAGE("fichier ferme");
-
-}
-
-void DriverMED_W_SMESHDS_Mesh::CreateFamily(char *nommaa, char *famille, int i,
- med_int k)
-{
-
- med_int ngro = 0;
- med_int natt;
-
- natt = 1;
- char attdes[MED_TAILLE_DESC + 1];
- char gro[MED_TAILLE_LNOM + 1];
- char fam2[MED_TAILLE_LNOM + 1];
-
- strcpy(attdes, "");
- strcpy(gro, "");
- strcpy(fam2, famille);
-
- med_int *attide = new med_int[1];
- med_int *attval = new med_int[1];
- attide[0] = k;
- attval[0] = k;
-
- //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;
-
+ 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] = aVector[0];
+ (*aConnectivity)[aSize+1] = aVector[3];
+ (*aConnectivity)[aSize+2] = aVector[2];
+ (*aConnectivity)[aSize+3] = aVector[1];
+ (*aConnectivity)[aSize+4] = aVector[4];
+ default:
+ for(med_int 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);
+ }
+
+ 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 = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
+ aMed.SetCellInfo(aCellInfo);
+ }
+ if(med_int aNbElems = anPyraElemNums.size()){
+ PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ MED_PYRA5,
+ SMDS_MED_CONNECTIVITY,
+ aPyraConn,
+ aPyraFamilyNums,
+ anPyraElemNums);
+ MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
+ aMed.SetCellInfo(aCellInfo);
+ }
+ if(med_int aNbElems = anPentaElemNums.size()){
+ PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ MED_PENTA6,
+ SMDS_MED_CONNECTIVITY,
+ aPentaConn,
+ aPentaFamilyNums,
+ anPentaElemNums);
+ MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
+ aMed.SetCellInfo(aCellInfo);
+ }
+ if(med_int aNbElems = aHexaElemNums.size()){
+ PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ MED_HEXA8,
+ SMDS_MED_CONNECTIVITY,
+ aHexaConn,
+ aHexaFamilyNums,
+ aHexaElemNums);
+ MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
+ aMed.SetCellInfo(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();
}