ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-12 08:39:16 +05:00
Code Issues Packages Projects Releases Wiki Activity
cf8c1dc99e
smesh/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
jrt ef932e4d05 Correct some memory leaks
2003-09-05 11:45:54 +00:00

691 lines
16 KiB
C++
Raw Blame History

// SMESH DriverMED : driver to read and write 'med' files
//
// 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
//
//
//
// File : DriverMED_W_SMESHDS_Mesh.cxx
// Module : SMESH
using namespace std;
#include "DriverMED_W_SMESHDS_Mesh.h"
#include "DriverMED_W_SMDS_Mesh.h"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
#include <TopExp.hxx>
#include <vector>
#include "utilities.h"
DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
{
;
}
DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
{
;
}
void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
{
myMesh = aMesh;
}
void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
{
myFile = aFile;
}
void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
{
myFileId = aFileId;
}
void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
{
myMeshId = aMeshId;
}
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::Add()
{
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);
}
/****************************************************************************
* 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++;
}
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);
/* 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;
}
}
}
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;
}
}
}
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;
}
}
}
/****************************************************************************
* 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++;
}
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<6E>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");
}
/****************************************************************************
* 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;
}
Reference in New Issue View Git Blame Copy Permalink