Skip to content

Commit

Permalink
Merge pull request #1651 from arcaneframework/dev/gg-add-edges-in-wri…
Browse files Browse the repository at this point in the history 
…temeshconnectivity

Dump infos on Edge items in MeshUtils::writeMeshConnectivity()
  • Loading branch information
@grospelliergilles
grospelliergilles authored Sep 29, 2024
2 parents 9c74045 + 05e38fa commit 84987ba
Showing 1 changed file with 93 additions and 83 deletions.
176 changes: 93 additions & 83 deletions arcane/src/arcane/core/MeshUtils.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,7 +14,6 @@
#include "arcane/utils/CheckedConvert.h"
#include "arcane/utils/List.h"
#include "arcane/utils/ScopedPtr.h"
#include "arcane/utils/Iterator.h"
#include "arcane/utils/OStringStream.h"
#include "arcane/utils/StringBuilder.h"
#include "arcane/utils/ITraceMng.h"
Expand Down Expand Up @@ -780,19 +779,19 @@ writeMeshInfos(IMesh* mesh, const String& file_name)

namespace
{
void
_sortByUniqueIds(IMesh* mesh, eItemKind ik, Array<Item>& items_internal)
template <typename ItemType> void
_sortByUniqueIds(IMesh* mesh, eItemKind ik, Array<ItemType>& items)
{
ItemGroup all_items(mesh->itemFamily(ik)->allItems());
items_internal.resize(all_items.size());
items.resize(all_items.size());

Integer index = 0;
ENUMERATE_ITEM (i, all_items) {
Item item = *i;
items_internal[index] = item;
ENUMERATE_ (ItemType, i, all_items) {
ItemType item = *i;
items[index] = item;
++index;
}
std::sort(std::begin(items_internal), std::end(items_internal), ItemCompare());
std::sort(std::begin(items), std::end(items), ItemCompare());
}

void
Expand All @@ -809,8 +808,22 @@ namespace
}
}

template <typename SubItemType> void
_writeSubItems(std::ostream& ofile, const char* item_name, ItemConnectedListViewT<SubItemType> sub_list)
{
Int32 n = sub_list.size();
if (n == 0)
return;
ofile << "<" << item_name << " count='" << n << "'>";
for (SubItemType sub_item : sub_list)
ofile << ' ' << sub_item.uniqueId();
ofile << "</" << item_name << ">";
}
} // namespace

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void MeshUtils::
writeMeshConnectivity(IMesh* mesh, const String& file_name)
{
Expand All @@ -825,115 +838,112 @@ writeMeshConnectivity(IMesh* mesh, const String& file_name)

ofile << "<?xml version='1.0' ?>\n";
ofile << "<mesh-connectivity>\n";
UniqueArray<Item> nodes_internal;
UniqueArray<Item> edges_internal;
UniqueArray<Item> faces_internal;
UniqueArray<Item> cells_internal;
UniqueArray<Node> nodes;
UniqueArray<Edge> edges;
UniqueArray<Face> faces;
UniqueArray<Cell> cells;

_sortByUniqueIds(mesh, IK_Node, nodes_internal);
_sortByUniqueIds(mesh, IK_Edge, edges_internal);
_sortByUniqueIds(mesh, IK_Face, faces_internal);
_sortByUniqueIds(mesh, IK_Cell, cells_internal);
_sortByUniqueIds(mesh, IK_Node, nodes);
_sortByUniqueIds(mesh, IK_Edge, edges);
_sortByUniqueIds(mesh, IK_Face, faces);
_sortByUniqueIds(mesh, IK_Cell, cells);

// Écrit les noeuds
{
ofile << "<nodes count='" << nodes_internal.size() << "'>\n";
for (Integer i = 0, n = nodes_internal.size(); i < n; ++i) {
Node item(nodes_internal[i]);
Integer item_nb_cell = item.nbCell();
ofile << "<nodes count='" << nodes.size() << "'>\n";
for (Node item : nodes) {
ofile << " <node uid='" << item.uniqueId() << "' owner='" << item.owner() << "'>";
{
// Infos sur les mailles
ofile << "<cells count='" << item_nb_cell << "'>";
for (CellEnumerator i_cell(item.cells()); i_cell(); ++i_cell)
ofile << ' ' << i_cell->uniqueId();
ofile << "</cells>";
}
_writeSubItems(ofile, "cells", item.cells());
_writeSubItems(ofile, "faces", item.faces());
_writeSubItems(ofile, "edges", item.edges());
ofile << "</node>\n";
}
ofile << "</nodes>\n";
}

// Écrit les arêtes
{
ofile << "<edges count='" << edges.size() << "'>\n";
for (Edge edge : edges) {
ofile << " <edge uid='" << edge.uniqueId() << "' owner='" << edge.owner() << "'>";
_writeSubItems(ofile, "nodes", edge.nodes());
_writeSubItems(ofile, "cells", edge.cells());
_writeSubItems(ofile, "faces", edge.faces());
ofile << "</edge>\n";
}
ofile << "</edges>\n";
}

ofile << "<faces count='" << faces_internal.size() << "'>\n";
for (Integer i = 0, is = faces_internal.size(); i < is; ++i) {
Face item(faces_internal[i]);
Integer item_nb_node = item.nbNode();
// Écrit les faces
{
ofile << "<faces count='" << faces.size() << "'>\n";
for (Face face : faces) {
// Integer item_nb_face = item.nbFace();
ofile << " <face uid='" << item.uniqueId()
<< "' typeid='" << item.type()
<< "' owner='" << item.owner() << "'>";
{
// Infos sur les noeuds
ofile << "<nodes count='" << item_nb_node << "'>";
for (NodeEnumerator i_node(item.nodes()); i_node(); ++i_node)
ofile << ' ' << i_node->uniqueId();
ofile << "</nodes>";
}
ofile << " <face uid='" << face.uniqueId()
<< "' typeid='" << face.type()
<< "' owner='" << face.owner() << "'>";
_writeSubItems(ofile, "nodes", face.nodes());
_writeSubItems(ofile, "edges", face.edges());
{
// Infos sur les mailles
ofile << "<cells";
Cell back_cell = item.backCell();
Cell back_cell = face.backCell();
if (!back_cell.null())
ofile << " back='" << back_cell.uniqueId() << "'";
Cell front_cell = item.frontCell();
Cell front_cell = face.frontCell();
if (!front_cell.null())
ofile << " front='" << front_cell.uniqueId() << "'";
ofile << "/>";
}
// Infos sur les facess
if (item.isSlaveFace()) {
ofile << "<faces count='" << item.slaveFaces().size() << "'>";
for (FaceEnumerator i_face(item.slaveFaces()); i_face(); ++i_face)
ofile << ' ' << i_face->uniqueId();
ofile << "</faces>";
}
if (item.isMasterFace()) {

// Infos sur les maitres/esclaves
if (face.isSlaveFace())
_writeSubItems(ofile, "slave-faces", face.slaveFaces());
if (face.isMasterFace()) {
ofile << "<faces count='1'>";
ofile << ' ' << item.masterFace().uniqueId();
ofile << ' ' << face.masterFace().uniqueId();
ofile << "</faces>";
}

ofile << "</face>\n";
}
ofile << "</faces>\n";
}

ofile << "<cells count='" << cells_internal.size() << "'>\n";
// Écrit les mailles
{
ofile << "<cells count='" << cells.size() << "'>\n";
// Pour les mailles autour d'une maille.
// Une maille est autour d'une autre, si elle est connectée par
// au moins un noeud
Int64UniqueArray ghost_cells_layer1;
ghost_cells_layer1.reserve(100);
for (Integer i = 0, is = cells_internal.size(); i < is; ++i) {
Cell item(cells_internal[i]);
Integer item_nb_node = item.nbNode();
Integer item_nb_face = item.nbFace();
ofile << " <cell uid='" << item.uniqueId()
<< "' typeid='" << item.type()
<< "' owner='" << item.owner() << "'>";
ghost_cells_layer1.clear();
for (Cell cell : cells) {
ofile << " <cell uid='" << cell.uniqueId()
<< "' typeid='" << cell.type()
<< "' owner='" << cell.owner() << "'>";
_writeSubItems(ofile, "nodes", cell.nodes());
_writeSubItems(ofile, "edges", cell.edges());
_writeSubItems(ofile, "faces", cell.faces());

{
ofile << "<nodes count='" << item_nb_node << "'>";
for (NodeEnumerator i_node(item.nodes()); i_node(); ++i_node) {
Node node(*i_node);
ofile << ' ' << node.uniqueId();
for (CellEnumerator i_node_cell(node.cells()); i_node_cell(); ++i_node_cell) {
ghost_cells_layer1.add(i_node_cell->uniqueId().asInt64());
ghost_cells_layer1.clear();
for (Node node : cell.nodes()) {
for (Cell sub_cell : node.cells()) {
ghost_cells_layer1.add(sub_cell.uniqueId().asInt64());
}
}
ofile << "</nodes>";
}
{
ofile << "<faces count='" << item_nb_face << "'>";
for (FaceEnumerator i_face(item.faces()); i_face(); ++i_face)
ofile << ' ' << i_face->uniqueId();
ofile << "</faces>";
}
{
std::sort(std::begin(ghost_cells_layer1), std::end(ghost_cells_layer1));
auto new_end = std::unique(std::begin(ghost_cells_layer1), std::end(ghost_cells_layer1));
ghost_cells_layer1.resize(arcaneCheckArraySize(new_end - std::begin(ghost_cells_layer1)));
ofile << "<ghost1 count='" << ghost_cells_layer1.size() << "'>";
for (auto j : ghost_cells_layer1)
ofile << ' ' << j;
ofile << "</ghost1>\n";

{
// Trie la liste des mailles fantômes et retire les doublons.
std::sort(std::begin(ghost_cells_layer1), std::end(ghost_cells_layer1));
auto new_end = std::unique(std::begin(ghost_cells_layer1), std::end(ghost_cells_layer1));
ghost_cells_layer1.resize(arcaneCheckArraySize(new_end - std::begin(ghost_cells_layer1)));
ofile << "<ghost1 count='" << ghost_cells_layer1.size() << "'>";
for (auto j : ghost_cells_layer1)
ofile << ' ' << j;
ofile << "</ghost1>\n";
}
}
ofile << "</cell>\n";
}
Expand Down

0 comments on commit 84987ba

Please sign in to comment.