Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Dump infos on Edge items in MeshUtils::writeMeshConnectivity() #1651

Merged
merged 1 commit into from
Sep 29, 2024
Merged

Dump infos on Edge items in MeshUtils::writeMeshConnectivity() #1651

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
176 changes: 93 additions & 83 deletions arcane/src/arcane/core/MeshUtils.cc
View file
Open in desktop
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
Loading