void
nedffamc231(int dummy,...)
#endif
{
med_int *fid;
char *maa;
med_int *lon1;
char *fam;
med_int *lon2;
med_int *num;
med_int *attr_ident;
med_int *attr_val;
char *attr_desc;
med_int *lon3;
med_int *n_attr;
char *groupe ;
med_int *lon4;
med_int *n_groupe;
med_err *fret;
med_int ret=-1;
char * fn1, *fn2, *fn3, *fn4;
va_list params;
va_start(params,dummy);
fid = va_arg(params, med_int* );
maa = va_arg(params, char* );
lon1 = va_arg(params, med_int* );
fam = va_arg(params, char* );
lon2 = va_arg(params, med_int* );
num = va_arg(params, med_int* );
attr_ident = va_arg(params, med_int* );
attr_val = va_arg(params, med_int* );
attr_desc = va_arg(params, char* );
lon3 = va_arg(params, med_int* );
n_attr = va_arg(params, med_int* );
groupe = va_arg(params, char* );
lon4 = va_arg(params, med_int* );
n_groupe = va_arg(params, med_int* );
fret = va_arg(params, med_err* );
fn1 = _MED2cstring(maa, (int) * lon1);
fn2 = _MED1cstring(fam, (int) * lon2,MED_TAILLE_NOM);
fn3 = _MED1cstring(attr_desc,(int) * lon3,
(int) *n_attr*MED_TAILLE_DESC);
fn4 = _MED1cstring(groupe, (int) * lon4,
(int) *n_groupe*MED_TAILLE_LNOM);
if (!fn1 || !fn2 || !fn3 || !fn4)
goto ERROR;
if( MEDfamCr((med_idt) *fid,fn1,fn2,(med_int) *num,
(med_int *) attr_ident,
(med_int *) attr_val, fn3, (med_int) *n_attr, fn4,
(med_int) *n_groupe) < 0 )
goto ERROR;
_MEDcstringFree(fn1);
_MEDcstringFree(fn2);
_MEDcstringFree(fn3);
_MEDcstringFree(fn4);
ret=0;
ERROR:
va_end(params);
*fret = ret;
return;
}
int GModel::readMED(const std::string &name)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_LECTURE);
if(fid < 0) {
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
med_int v[3], vf[3];
MEDversionDonner(&v[0], &v[1], &v[2]);
MEDversionLire(fid, &vf[0], &vf[1], &vf[2]);
Msg::Info("Reading MED file V%d.%d.%d using MED library V%d.%d.%d",
vf[0], vf[1], vf[2], v[0], v[1], v[2]);
if(vf[0] < 2 || (vf[0] == 2 && vf[1] < 2)){
Msg::Error("Cannot read MED file older than V2.2");
return 0;
}
std::vector<std::string> meshNames;
for(int i = 0; i < MEDnMaa(fid); i++){
char meshName[MED_TAILLE_NOM + 1], meshDesc[MED_TAILLE_DESC + 1];
med_int spaceDim;
med_maillage meshType;
#if (MED_MAJOR_NUM == 3)
med_int meshDim, nStep;
char dtUnit[MED_SNAME_SIZE + 1];
char axisName[3 * MED_SNAME_SIZE + 1], axisUnit[3 * MED_SNAME_SIZE + 1];
med_sorting_type sortingType;
med_axis_type axisType;
if(MEDmeshInfo(fid, i + 1, meshName, &spaceDim, &meshDim, &meshType, meshDesc,
dtUnit, &sortingType, &nStep, &axisType, axisName, axisUnit) < 0){
#else
if(MEDmaaInfo(fid, i + 1, meshName, &spaceDim, &meshType, meshDesc) < 0){
#endif
Msg::Error("Unable to read mesh information");
return 0;
}
meshNames.push_back(meshName);
}
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
int ret = 1;
for(unsigned int i = 0; i < meshNames.size(); i++){
// we use the filename as a kind of "partition" indicator, allowing to
// complete a model part by part (used e.g. in DDM, since MED does not store
// a partition index)
GModel *m = findByName(meshNames[i], name);
if(!m) m = new GModel(meshNames[i]);
ret = m->readMED(name, i);
if(!ret) return 0;
}
return ret;
}
int GModel::readMED(const std::string &name, int meshIndex)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_LECTURE);
if(fid < 0){
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
int numMeshes = MEDnMaa(fid);
if(meshIndex >= numMeshes){
Msg::Info("Could not find mesh %d in MED file", meshIndex);
return 0;
}
checkPointMaxNumbers();
GModel::setCurrent(this); // make sure we increment max nums in this model
// read mesh info
char meshName[MED_TAILLE_NOM + 1], meshDesc[MED_TAILLE_DESC + 1];
med_int spaceDim, nStep = 1;
med_maillage meshType;
#if (MED_MAJOR_NUM == 3)
med_int meshDim;
char dtUnit[MED_SNAME_SIZE + 1];
char axisName[3 * MED_SNAME_SIZE + 1], axisUnit[3 * MED_SNAME_SIZE + 1];
med_sorting_type sortingType;
med_axis_type axisType;
if(MEDmeshInfo(fid, meshIndex + 1, meshName, &spaceDim, &meshDim, &meshType, meshDesc,
dtUnit, &sortingType, &nStep, &axisType, axisName, axisUnit) < 0){
#else
if(MEDmaaInfo(fid, meshIndex + 1, meshName, &spaceDim, &meshType, meshDesc) < 0){
#endif
Msg::Error("Unable to read mesh information");
return 0;
}
// FIXME: we should support multi-step MED3 meshes (probably by
// storing each mesh as a separate model, with a naming convention
// e.g. meshName_step%d). This way we could also handle multi-mesh
// time sequences in MED3.
if(nStep > 1)
Msg::Warning("Discarding %d last meshes in multi-step MED mesh", nStep - 1);
setName(meshName);
setFileName(name);
if(meshType == MED_NON_STRUCTURE){
Msg::Info("Reading %d-D unstructured mesh <<%s>>", spaceDim, meshName);
}
else{
Msg::Error("Reading structured MED meshes is not supported");
return 0;
}
med_int vf[3];
MEDversionLire(fid, &vf[0], &vf[1], &vf[2]);
// read nodes
#if (MED_MAJOR_NUM == 3)
med_bool changeOfCoord, geoTransform;
med_int numNodes = MEDmeshnEntity(fid, meshName, MED_NO_DT, MED_NO_IT, MED_NODE,
MED_NO_GEOTYPE, MED_COORDINATE, MED_NO_CMODE,
&changeOfCoord, &geoTransform);
#else
med_int numNodes = MEDnEntMaa(fid, meshName, MED_COOR, MED_NOEUD, MED_NONE,
MED_NOD);
#endif
if(numNodes < 0){
Msg::Error("Could not read number of MED nodes");
return 0;
}
if(numNodes == 0){
Msg::Error("No nodes in MED mesh");
return 0;
}
std::vector<MVertex*> verts(numNodes);
std::vector<med_float> coord(spaceDim * numNodes);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshNodeCoordinateRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE,
&coord[0]) < 0){
#else
std::vector<char> coordName(spaceDim * MED_TAILLE_PNOM + 1);
std::vector<char> coordUnit(spaceDim * MED_TAILLE_PNOM + 1);
med_repere rep;
if(MEDcoordLire(fid, meshName, spaceDim, &coord[0], MED_FULL_INTERLACE,
MED_ALL, 0, 0, &rep, &coordName[0], &coordUnit[0]) < 0){
#endif
Msg::Error("Could not read MED node coordinates");
return 0;
}
std::vector<med_int> nodeTags(numNodes);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_NODE,
MED_NO_GEOTYPE, &nodeTags[0]) < 0)
#else
if(MEDnumLire(fid, meshName, &nodeTags[0], numNodes, MED_NOEUD, MED_NONE) < 0)
#endif
nodeTags.clear();
for(int i = 0; i < numNodes; i++)
verts[i] = new MVertex(coord[spaceDim * i],
(spaceDim > 1) ? coord[spaceDim * i + 1] : 0.,
(spaceDim > 2) ? coord[spaceDim * i + 2] : 0.,
0, nodeTags.empty() ? 0 : nodeTags[i]);
// read elements (loop over all possible MSH element types)
for(int mshType = 0; mshType < MSH_NUM_TYPE; mshType++){
med_geometrie_element type = msh2medElementType(mshType);
if(type == MED_NONE) continue;
#if (MED_MAJOR_NUM == 3)
med_bool changeOfCoord;
med_bool geoTransform;
med_int numEle = MEDmeshnEntity(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, MED_CONNECTIVITY, MED_NODAL, &changeOfCoord,
&geoTransform);
#else
med_int numEle = MEDnEntMaa(fid, meshName, MED_CONN, MED_MAILLE, type, MED_NOD);
#endif
if(numEle <= 0) continue;
int numNodPerEle = type % 100;
std::vector<med_int> conn(numEle * numNodPerEle);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshElementConnectivityRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, MED_NODAL, MED_FULL_INTERLACE, &conn[0]) < 0){
#else
if(MEDconnLire(fid, meshName, spaceDim, &conn[0], MED_FULL_INTERLACE, 0, MED_ALL,
MED_MAILLE, type, MED_NOD) < 0){
#endif
Msg::Error("Could not read MED elements");
return 0;
}
std::vector<med_int> fam(numEle, 0);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityFamilyNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, &fam[0]) < 0){
#else
if(MEDfamLire(fid, meshName, &fam[0], numEle, MED_MAILLE, type) < 0){
#endif
Msg::Info("No family number for elements: using 0 as default family number");
}
std::vector<med_int> eleTags(numEle);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, &eleTags[0]) < 0)
#else
if(MEDnumLire(fid, meshName, &eleTags[0], numEle, MED_MAILLE, type) < 0)
#endif
eleTags.clear();
std::map<int, std::vector<MElement*> > elements;
MElementFactory factory;
for(int j = 0; j < numEle; j++){
std::vector<MVertex*> v(numNodPerEle);
for(int k = 0; k < numNodPerEle; k++)
v[k] = verts[conn[numNodPerEle * j + med2mshNodeIndex(type, k)] - 1];
MElement *e = factory.create(mshType, v, eleTags.empty() ? 0 : eleTags[j]);
if(e) elements[-fam[j]].push_back(e);
}
_storeElementsInEntities(elements);
}
_associateEntityWithMeshVertices();
_storeVerticesInEntities(verts);
// read family info
med_int numFamilies = MEDnFam(fid, meshName);
if(numFamilies < 0){
Msg::Error("Could not read MED families");
return 0;
}
for(int i = 0; i < numFamilies; i++){
#if (MED_MAJOR_NUM == 3)
med_int numAttrib = (vf[0] == 2) ? MEDnFamily23Attribute(fid, meshName, i + 1) : 0;
med_int numGroups = MEDnFamilyGroup(fid, meshName, i + 1);
#else
med_int numAttrib = MEDnAttribut(fid, meshName, i + 1);
med_int numGroups = MEDnGroupe(fid, meshName, i + 1);
#endif
if(numAttrib < 0 || numGroups < 0){
Msg::Error("Could not read MED groups or attributes");
return 0;
}
std::vector<med_int> attribId(numAttrib + 1);
std::vector<med_int> attribVal(numAttrib + 1);
std::vector<char> attribDes(MED_TAILLE_DESC * numAttrib + 1);
std::vector<char> groupNames(MED_TAILLE_LNOM * numGroups + 1);
char familyName[MED_TAILLE_NOM + 1];
med_int familyNum;
#if (MED_MAJOR_NUM == 3)
if(vf[0] == 2){ // MED2 file
if(MEDfamily23Info(fid, meshName, i + 1, familyName, &attribId[0],
&attribVal[0], &attribDes[0], &familyNum,
&groupNames[0]) < 0){
Msg::Error("Could not read info for MED2 family %d", i + 1);
continue;
}
}
else{
if(MEDfamilyInfo(fid, meshName, i + 1, familyName, &familyNum,
&groupNames[0]) < 0){
Msg::Error("Could not read info for MED3 family %d", i + 1);
continue;
}
}
#else
if(MEDfamInfo(fid, meshName, i + 1, familyName, &familyNum, &attribId[0],
&attribVal[0], &attribDes[0], &numAttrib, &groupNames[0],
&numGroups) < 0){
Msg::Error("Could not read info for MED family %d", i + 1);
continue;
}
#endif
// family tags are unique (for all dimensions)
GEntity *ge;
if((ge = getRegionByTag(-familyNum))){}
else if((ge = getFaceByTag(-familyNum))){}
else if((ge = getEdgeByTag(-familyNum))){}
else ge = getVertexByTag(-familyNum);
if(ge){
elementaryNames[std::pair<int, int>(ge->dim(), -familyNum)] = familyName;
if(numGroups > 0){
for(int j = 0; j < numGroups; j++){
char tmp[MED_TAILLE_LNOM + 1];
strncpy(tmp, &groupNames[j * MED_TAILLE_LNOM], MED_TAILLE_LNOM);
tmp[MED_TAILLE_LNOM] = '\0';
// don't use same physical number across dimensions, as e.g. getdp
// does not support this
int pnum = setPhysicalName(tmp, ge->dim(), getMaxPhysicalNumber(-1) + 1);
if(std::find(ge->physicals.begin(), ge->physicals.end(), pnum) ==
ge->physicals.end())
ge->physicals.push_back(pnum);
}
}
}
}
// check if we need to read some post-processing data later
#if (MED_MAJOR_NUM == 3)
bool postpro = (MEDnField(fid) > 0) ? true : false;
#else
bool postpro = (MEDnChamp(fid, 0) > 0) ? true : false;
#endif
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
return postpro ? 2 : 1;
}
template<class T>
static void fillElementsMED(med_int family, std::vector<T*> &elements,
std::vector<med_int> &conn, std::vector<med_int> &fam,
med_geometrie_element &type)
{
if(elements.empty()) return;
type = msh2medElementType(elements[0]->getTypeForMSH());
if(type == MED_NONE){
Msg::Warning("Unsupported element type in MED format");
return;
}
for(unsigned int i = 0; i < elements.size(); i++){
elements[i]->setVolumePositive();
for(int j = 0; j < elements[i]->getNumVertices(); j++)
conn.push_back(elements[i]->getVertex(med2mshNodeIndex(type, j))->getIndex());
fam.push_back(family);
}
}
static void writeElementsMED(med_idt &fid, char *meshName, std::vector<med_int> &conn,
std::vector<med_int> &fam, med_geometrie_element type)
{
if(fam.empty()) return;
#if (MED_MAJOR_NUM == 3)
if(MEDmeshElementWr(fid, meshName, MED_NO_DT, MED_NO_IT, 0., MED_CELL, type,
MED_NODAL, MED_FULL_INTERLACE, (med_int)fam.size(),
&conn[0], MED_FALSE, 0, MED_FALSE, 0, MED_TRUE, &fam[0]) < 0)
#else
if(MEDelementsEcr(fid, meshName, (med_int)3, &conn[0], MED_FULL_INTERLACE,
0, MED_FAUX, 0, MED_FAUX, &fam[0], (med_int)fam.size(),
MED_MAILLE, type, MED_NOD) < 0)
#endif
Msg::Error("Could not write MED elements");
}
int GModel::writeMED(const std::string &name, bool saveAll, double scalingFactor)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_CREATION);
if(fid < 0){
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
// write header
if(MEDfichDesEcr(fid, (char*)"MED file generated by Gmsh") < 0){
Msg::Error("Unable to write MED descriptor");
return 0;
}
char *meshName = (char*)getName().c_str();
// Gmsh always writes 3D unstructured meshes
#if (MED_MAJOR_NUM == 3)
char dtUnit[MED_SNAME_SIZE + 1] = "";
char axisName[3 * MED_SNAME_SIZE + 1] = "";
char axisUnit[3 * MED_SNAME_SIZE + 1] = "";
if(MEDmeshCr(fid, meshName, 3, 3, MED_UNSTRUCTURED_MESH, "Mesh created with Gmsh",
dtUnit, MED_SORT_DTIT, MED_CARTESIAN, axisName, axisUnit) < 0){
#else
if(MEDmaaCr(fid, meshName, 3, MED_NON_STRUCTURE,
(char*)"Mesh created with Gmsh") < 0){
#endif
Msg::Error("Could not create MED mesh");
return 0;
}
// if there are no physicals we save all the elements
if(noPhysicalGroups()) saveAll = true;
// index the vertices we save in a continuous sequence (MED
// connectivity is given in terms of vertex indices)
indexMeshVertices(saveAll);
// get a vector containing all the geometrical entities in the
// model (the ordering of the entities must be the same as the one
// used during the indexing of the vertices)
std::vector<GEntity*> entities;
getEntities(entities);
std::map<GEntity*, int> families;
// write the families
{
// always create a "0" family, with no groups or attributes
#if (MED_MAJOR_NUM == 3)
if(MEDfamilyCr(fid, meshName, "F_0", 0, 0, "") < 0)
#else
if(MEDfamCr(fid, meshName, (char*)"F_0", 0, 0, 0, 0, 0, 0, 0) < 0)
#endif
Msg::Error("Could not create MED family 0");
// create one family per elementary entity, with one group per
// physical entity and no attributes
for(unsigned int i = 0; i < entities.size(); i++){
if(saveAll || entities[i]->physicals.size()){
int num = - ((int)families.size() + 1);
families[entities[i]] = num;
std::ostringstream fs;
fs << entities[i]->dim() << "D_" << entities[i]->tag();
std::string familyName = "F_" + fs.str();
std::string groupName;
for(unsigned j = 0; j < entities[i]->physicals.size(); j++){
std::string tmp = getPhysicalName
(entities[i]->dim(), entities[i]->physicals[j]);
if(tmp.empty()){ // create unique name
std::ostringstream gs;
gs << entities[i]->dim() << "D_" << entities[i]->physicals[j];
groupName += "G_" + gs.str();
}
else
groupName += tmp;
groupName.resize((j + 1) * MED_TAILLE_LNOM, ' ');
}
#if (MED_MAJOR_NUM == 3)
if(MEDfamilyCr(fid, meshName, familyName.c_str(),
(med_int)num, (med_int)entities[i]->physicals.size(),
groupName.c_str()) < 0)
#else
if(MEDfamCr(fid, meshName, (char*)familyName.c_str(),
(med_int)num, 0, 0, 0, 0, (char*)groupName.c_str(),
(med_int)entities[i]->physicals.size()) < 0)
#endif
Msg::Error("Could not create MED family %d", num);
}
}
}
// write the nodes
{
std::vector<med_float> coord;
std::vector<med_int> fam;
for(unsigned int i = 0; i < entities.size(); i++){
for(unsigned int j = 0; j < entities[i]->mesh_vertices.size(); j++){
MVertex *v = entities[i]->mesh_vertices[j];
if(v->getIndex() >= 0){
coord.push_back(v->x() * scalingFactor);
coord.push_back(v->y() * scalingFactor);
coord.push_back(v->z() * scalingFactor);
fam.push_back(0); // we never create node families
}
}
}
if(fam.empty()){
Msg::Error("No nodes to write in MED mesh");
return 0;
}
#if (MED_MAJOR_NUM == 3)
if(MEDmeshNodeWr(fid, meshName, MED_NO_DT, MED_NO_IT, 0., MED_FULL_INTERLACE,
(med_int)fam.size(), &coord[0], MED_FALSE, "", MED_FALSE, 0,
MED_TRUE, &fam[0]) < 0)
#else
char coordName[3 * MED_TAILLE_PNOM + 1] =
"x y z ";
char coordUnit[3 * MED_TAILLE_PNOM + 1] =
"unknown unknown unknown ";
if(MEDnoeudsEcr(fid, meshName, (med_int)3, &coord[0], MED_FULL_INTERLACE,
MED_CART, coordName, coordUnit, 0, MED_FAUX, 0, MED_FAUX,
&fam[0], (med_int)fam.size()) < 0)
#endif
Msg::Error("Could not write nodes");
}
// write the elements
{
{ // points
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(viter it = firstVertex(); it != lastVertex(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->points, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // lines
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(eiter it = firstEdge(); it != lastEdge(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->lines, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // triangles
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(fiter it = firstFace(); it != lastFace(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->triangles, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // quads
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(fiter it = firstFace(); it != lastFace(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->quadrangles, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // tets
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->tetrahedra, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // hexas
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->hexahedra, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // prisms
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->prisms, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // pyramids
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->pyramids, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
}
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
return 1;
}
#else
int GModel::readMED(const std::string &name)
{
Msg::Error("Gmsh must be compiled with MED support to read '%s'",
name.c_str());
return 0;
}
int main (int argc, char **argv)
{
med_idt fid;
char maa[MED_TAILLE_NOM+1] = "maillage_test19";
char desc[MED_TAILLE_DESC+1]="un maillage pour test19.med";
med_int mdim=2;
/* Donnees de tests pour MEDgro2FamCr()
Les noeuds/mailles sont numerotes de 1 a 5 et les
groupes de 1 a 3.
Au depart, on a :
- G1 : 1,2
- G2 : 3,4,6
- G3 : 1,4
Au retour, on foit avoir 4 familles de noeuds + 4 familles de mailles
+ la famille 0 dans le fichier :
- F0 : 5 - groupes : aucun groupe par defaut (convention habituelle).
- F1 : 1 - groupes : G1,G3
- F2 : 2 - groupes : G1
- F3 : 3,6 - groupes : G2
- F4 : 4 - groupes : G2,G3
*/
med_int ngroup = 3;
med_int nent = 6;
char nom_groupes[MED_TAILLE_LNOM*3+1];
/* 0 1 2 3 4 5 6 */
med_int entites[7] = { 1,2, 3,4,6, 1,4};
med_int index[4] = { 1, 3, 6, 8};
int i;
char nom_famille0[MED_TAILLE_NOM+1] = "FAMILLE0";
/* on fait la meme distribution pour des mailles */
med_int ngeo = 3;
med_geometrie_element geo[3] = {MED_SEG2,MED_TRIA3,MED_TETRA4};
/* MED_SEG2 : M1,M2,M3 - MED_TRI3 : M4,M5 - MED_TETRA4 : M6 */
med_int index_geo[4] = {1,4,6,7};
/* Creation du fichier test19.med */
if ((fid = MEDouvrir("test19.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test19.med");
return -1;
}
printf("Creation du fichier test19.med \n");
/* Creation du maillage */
if (MEDmaaCr(fid,maa,mdim,MED_NON_STRUCTURE,desc) < 0) {
MESSAGE("Erreur a la creation du maillage");
return -1;
}
printf("Creation du maillage \n");
/* on teste la fonction MEDgro2fam() */
/* on definit les noms des groupes */
strcpy(nom_groupes,"GROUPE 1");
for (i=8;i<MED_TAILLE_LNOM;i++)
nom_groupes[i] = ' ';
nom_groupes[MED_TAILLE_LNOM] = '\0';
strcat(nom_groupes,"GROUPE 2");
for (i=8;i<MED_TAILLE_LNOM;i++)
nom_groupes[MED_TAILLE_LNOM+i] = ' ';
nom_groupes[2*MED_TAILLE_LNOM] = '\0';
strcat(nom_groupes,"GROUPE 3");
for (i=8;i<MED_TAILLE_LNOM;i++)
nom_groupes[2*MED_TAILLE_LNOM+i] = ' ';
nom_groupes[3*MED_TAILLE_LNOM] = '\0';
/* On cree la famille 0 */
if (MEDfamCr(fid,maa,nom_famille0,0,NULL,NULL,NULL,0,NULL,0) < 0) {
MESSAGE("Erreur a la creation de la famille 0");
return -1;
}
printf("Creation de la famille 0 \n");
/*
* On definit et on archive les familles de noeuds dans test.19.med
*/
if (MEDgro2famCr(fid,maa,nom_groupes,index,ngroup,entites,nent,
MED_NOEUD,NULL,NULL,0) < 0) {
MESSAGE("Erreur a la creation des familles de noeuds ");
return -1;
}
printf("On constuit les familles de noeuds et on les stocke dans test19.med \n");
/*
* On fait la meme chose pour des mailles de differents types
*/
if (MEDgro2famCr(fid,maa,nom_groupes,index,ngroup,entites,nent,
MED_MAILLE,geo,index_geo,ngeo) < 0) {
MESSAGE("Erreur a la creation des familles d'elements ");
return -1;
}
printf("On constuit les familles d'elements et on les stocke dans test19.med \n");
/* Fermeture du fichier */
if (MEDfermer(fid) <0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
printf("Fermeture du fichier \n");
return 0;
}
int main (int argc, char **argv)
{
med_idt fid;
char maa[MED_TAILLE_NOM+1] ="maa1";
med_int mdim = 2;
char nomfam[MED_TAILLE_NOM+1]="";
med_int numfam;
char attdes[MED_TAILLE_DESC+1]="";
med_int natt;
med_int attide;
med_int attval;
med_int ngro;
char gro[MED_TAILLE_LNOM+1]="";
int i;
int nfame = 3;
int nfamn = 2;
/* Creation du fichier "test8.med" */
if ((fid = MEDouvrir("test8.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test8.med");
return -1;
}
/* Creation d'un maillage */
if (MEDmaaCr(fid,maa,2,MED_NON_STRUCTURE,
"un maillage pour test8") < 0) {
MESSAGE("Erreur a la creation du maillage");
return -1;
}
/* Ecriture des familles */
/* Conventions appliquees dans MED :
- Toujours creer une famille de numero 0 ne comportant aucun attribut
ni groupe (famille de reference pour les noeuds ou les elements
qui ne sont rattaches a aucun groupe ni attribut)
- Les numeros de familles de noeuds sont > 0
- Les numeros de familles des elements sont < 0
- Rien d'imposer sur les noms de familles.
*/
/* Creation de la famille 0 */
strcpy(nomfam,"FAMILLE_0");
numfam = 0;
if (MEDfamCr(fid,maa,nomfam,numfam,&attide,&attval,attdes,0,
gro,0) < 0) {
MESSAGE("Erreur a la creation de la famille 0");
return -1;
}
/* Creation pour correspondre aux cas test precedent de :
- 3 familles d'elements (-1,-2,-3)
- 2 familles de noeuds (1,2) */
nfame = 3;
for (i=0;i<nfame;i++) {
numfam = -(i+1);
sprintf(nomfam,"%s"IFORMAT,"FAMILLE_ELEMENT_",-numfam);
attide = 1;
attval = numfam*100;
natt = 1;
strcpy(attdes,"description attribut");
strcpy(gro,"groupe1");
ngro = 1;
printf("%s - "IFORMAT" - "IFORMAT" - "IFORMAT" - "IFORMAT" \n",nomfam,numfam,attide,attval,
ngro);
if (MEDfamCr(fid,maa,nomfam,numfam,&attide,&attval,attdes,
natt,gro,ngro) < 0) {
MESSAGE("Erreur a la creation de la famille :");
SSCRUTE(nomfam); ISCRUTE(numfam);
return -1;
}
}
nfamn = 2;
for (i=0;i<nfamn;i++) {
numfam = i+1;
sprintf(nomfam,"%s"IFORMAT,"FAMILLE_NOEUD_",numfam);
attide = 1;
attval = numfam*100;
natt = 1;
strcpy(attdes,"description attribut");
strcpy(gro,"groupe1");
ngro = 1;
if (MEDfamCr(fid,maa,nomfam,numfam,&attide,&attval,attdes,
natt,gro,ngro) < 0) {
MESSAGE("Erreur a la creation de la famille :");
SSCRUTE(nomfam); ISCRUTE(numfam);
return -1;
}
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier :");
return -1;
}
return 0;
}