22#include <vtkUnstructuredGrid.h>
23#include <vtkUnstructuredGridReader.h>
25#include <vtkCellIterator.h>
26#include <vtkIdTypeArray.h>
27#include <vtkCellData.h>
28#include <vtkPointData.h>
29#include <vtkDataSetAttributes.h>
30#include <vtkArrayDispatch.h>
31#include <vtkDataArrayAccessor.h>
32#include <vtkPolyDataReader.h>
33#include <vtkPolyData.h>
34#include <vtkSmartPointer.h>
35#include <vtkCellArray.h>
36#include <vtkVersion.h>
37#if VTK_VERSION_NUMBER >= 900000000
38using vtkIdType_generic = vtkIdType
const;
40using vtkIdType_generic = vtkIdType;
44#include <arccore/base/String.h>
45#include <arccore/base/FatalErrorException.h>
46#include <vtkXMLUnstructuredGridReader.h>
47#include <vtkXMLPolyDataReader.h>
50#include "arcane/core/AbstractService.h"
51#include "arcane/core/ICaseMeshReader.h"
53#include "arcane/core/IMeshBuilder.h"
54#include "arcane/core/MeshBuildInfo.h"
55#include "arcane/core/IPrimaryMesh.h"
57#include "arcane/core/IMeshInitialAllocator.h"
58#include "arcane/core/IVariableMng.h"
60#include "arcane/utils/ITraceMng.h"
61#include "arcane/utils/UniqueArray.h"
62#include "arcane/utils/Real3.h"
63#include "arcane/mesh/CellFamily.h"
64#include "arcane/core/MeshVariableScalarRef.h"
65#include "arcane/core/MeshVariableArrayRef.h"
67#include "arcane/core/ItemAllocationInfo.h"
68#include "arcane/core/VariableBuildInfo.h"
70#include "arcane/utils/OStringStream.h"
72#include "arcane/core/IXmlDocumentHolder.h"
73#include "arcane/core/XmlNode.h"
74#include "arcane/core/internal/IVariableMngInternal.h"
75#include "arcane/core/datatype/DataTypeTraits.h"
77#include "arcane/std/VtkPolyhedralMeshIO_axl.h"
85namespace VtkPolyhedralTools
96 bool print_mesh_info =
false;
97 bool print_debug_info =
false;
101class VtkPolyhedralMeshIOService
108 , m_print_info_level(print_info_level)
118 VtkReader() =
default;
120 static String supportedVtkExtensions()
noexcept {
return "vtk,vtu";};
170 bool readHasFailed()
const noexcept {
return m_read_status.failure; }
173 vtkCellData* cellData();
174 vtkPointData* pointData();
175 vtkCellData* faceData();
177 bool isEmpty()
const noexcept {
return m_is_empty; }
178 bool doRead()
const noexcept {
return m_do_read; }
182 bool m_is_empty =
true;
183 bool m_do_read =
false;
187 vtkNew<vtkUnstructuredGridReader> m_vtk_grid_reader;
188 vtkNew<vtkXMLUnstructuredGridReader> m_vtk_xml_grid_reader;
189 vtkNew<vtkPolyDataReader> m_vtk_face_grid_reader;
190 vtkNew<vtkXMLPolyDataReader> m_vtk_xml_face_grid_reader;
191 vtkUnstructuredGrid* m_vtk_grid =
nullptr;
192 vtkPolyData* m_vtk_face_grid =
nullptr;
208 NodeUidToIndexMap m_node_uid_to_index;
210 vtkCellData* m_cell_data =
nullptr;
211 vtkPointData* m_point_data =
nullptr;
212 vtkCellData* m_face_data =
nullptr;
213 vtkCellArray* m_poly_data =
nullptr;
215 void _printMeshInfos()
const;
218 template <
typename Connectivity2DArray>
219 static void _flattenConnectivity(Connectivity2DArray connected_item_2darray,
Int32Span nb_connected_item_per_source_item,
Int64UniqueArray& connected_item_array);
220 void _readPlainTextVtkGrid(
const String& filename);
221 void _readXlmVtkGrid(
const String& filename);
222 void _checkVtkGrid()
const;
223 void _readPlainTextVtkFaceGrid(
const String& faces_filename);
224 void _readXmlVtkFaceGrid(
const String& faces_filename);
225 void _readfaceNodesInFaceMesh();
235 bool do_read = is_parallel_read ?
mesh->parallelMng()->isMasterIO() :
true;
236 using VtkReaderPtr = std::unique_ptr<VtkReader>;
237 VtkReaderPtr reader = std::make_unique<VtkReader>();
238 if (do_read) reader = std::make_unique<VtkReader>( filename, m_print_info_level );
239 if (reader->readHasFailed())
240 return reader->readStatus();
242 _fillItemAllocationInfo(item_allocation_info, *reader);
243 auto polyhedral_mesh_allocator =
mesh->initialAllocator()->polyhedralMeshAllocator();
244 polyhedral_mesh_allocator->allocateItems(item_allocation_info);
245 _readVariablesAndGroups(
mesh, *reader);
246 return reader->readStatus();
256 bool is_array =
false;
266 template <
template <
class>
class VariableRootType ,
template <
class>
class ArrayVariableRootType>
274class VtkPolyhedralCaseMeshReader
285 , m_read_info(read_info)
286 , m_print_info_level(print_info_level)
301 m_trace_mng->info() <<
"---Create Polyhedral mesh: " << pm->
name() <<
"---";
302 m_trace_mng->info() <<
"--Read mesh file " << m_read_info.fileName();
304 auto read_status = polyhedral_vtk_service.read(pm, m_read_info.fileName(),m_read_info.isParallelRead());
305 if (read_status.failure)
307 m_trace_mng->info() << read_status.info_message;
326 if (VtkPolyhedralMeshIOService::VtkReader::supportedVtkExtensions().contains(read_info.format()))
336 ServiceProperty(
"VtkPolyhedralCaseMeshReader",
ST_CaseOption),
342void VtkPolyhedralMeshIOService::
343_fillItemAllocationInfo(ItemAllocationInfo& item_allocation_info, VtkReader& vtk_reader)
345 auto nb_item_family = 4;
346 auto nb_connected_family = 3;
347 item_allocation_info.family_infos.resize(nb_item_family);
348 for (
auto& family_info : item_allocation_info.family_infos) {
349 family_info.connected_family_info.resize(nb_connected_family);
352 auto& cell_family_info = item_allocation_info.family_infos[0];
353 cell_family_info.name =
"Cell";
354 cell_family_info.item_kind =
IK_Cell;
355 cell_family_info.item_uids = vtk_reader.cellUids();
356 auto& node_family_info = item_allocation_info.family_infos[1];
357 node_family_info.name =
"Node";
358 node_family_info.item_kind =
IK_Node;
359 node_family_info.item_uids = vtk_reader.nodeUids();
360 auto& face_family_info = item_allocation_info.family_infos[2];
361 face_family_info.name =
"Face";
362 face_family_info.item_kind =
IK_Face;
363 face_family_info.item_uids = vtk_reader.faceUids();
364 auto& edge_family_info = item_allocation_info.family_infos[3];
365 edge_family_info.name =
"Edge";
366 edge_family_info.item_kind =
IK_Edge;
367 edge_family_info.item_uids = vtk_reader.edgeUids();
369 auto cell_connected_family_index = 0;
370 auto& cell_connected_node_family_info = cell_family_info.connected_family_info[cell_connected_family_index++];
371 cell_connected_node_family_info.name = node_family_info.name;
372 cell_connected_node_family_info.item_kind = node_family_info.item_kind;
373 cell_connected_node_family_info.connectivity_name =
"CellToNodes";
374 cell_connected_node_family_info.nb_connected_items_per_item = vtk_reader.cellNbNodes();
375 cell_connected_node_family_info.connected_items_uids = vtk_reader.cellNodes();
377 auto& cell_connected_face_family_info = cell_family_info.connected_family_info[cell_connected_family_index++];
378 cell_connected_face_family_info.name = face_family_info.name;
379 cell_connected_face_family_info.item_kind = face_family_info.item_kind;
380 cell_connected_face_family_info.connectivity_name =
"CellToFaces";
381 cell_connected_face_family_info.nb_connected_items_per_item = vtk_reader.cellNbFaces();
382 cell_connected_face_family_info.connected_items_uids = vtk_reader.cellFaces();
384 auto& cell_connected_edge_family_info = cell_family_info.connected_family_info[cell_connected_family_index++];
385 cell_connected_edge_family_info.name = edge_family_info.name;
386 cell_connected_edge_family_info.item_kind = edge_family_info.item_kind;
387 cell_connected_edge_family_info.connectivity_name =
"CellToEdges";
388 cell_connected_edge_family_info.nb_connected_items_per_item = vtk_reader.cellNbEdges();
389 cell_connected_edge_family_info.connected_items_uids = vtk_reader.cellEdges();
391 auto face_connected_family_index = 0;
392 auto& face_connected_cell_family_info = face_family_info.connected_family_info[face_connected_family_index++];
393 face_connected_cell_family_info.name = cell_family_info.name;
394 face_connected_cell_family_info.item_kind = cell_family_info.item_kind;
395 face_connected_cell_family_info.connectivity_name =
"FaceToCells";
396 face_connected_cell_family_info.nb_connected_items_per_item = vtk_reader.faceNbCells();
397 face_connected_cell_family_info.connected_items_uids = vtk_reader.faceCells();
399 auto& face_connected_node_family_info = face_family_info.connected_family_info[face_connected_family_index++];
400 face_connected_node_family_info.name = node_family_info.name;
401 face_connected_node_family_info.item_kind = node_family_info.item_kind;
402 face_connected_node_family_info.connectivity_name =
"FaceToNodes";
403 face_connected_node_family_info.nb_connected_items_per_item = vtk_reader.faceNbNodes();
404 face_connected_node_family_info.connected_items_uids = vtk_reader.faceNodes();
406 auto& face_connected_edge_family_info = face_family_info.connected_family_info[face_connected_family_index];
407 face_connected_edge_family_info.name = edge_family_info.name;
408 face_connected_edge_family_info.item_kind = edge_family_info.item_kind;
409 face_connected_edge_family_info.connectivity_name =
"FaceToEdges";
410 face_connected_edge_family_info.nb_connected_items_per_item = vtk_reader.faceNbEdges();
411 face_connected_edge_family_info.connected_items_uids = vtk_reader.faceEdges();
413 auto edge_connected_family_index = 0;
414 auto& edge_connected_cell_family_info = edge_family_info.connected_family_info[edge_connected_family_index++];
415 edge_connected_cell_family_info.name = cell_family_info.name;
416 edge_connected_cell_family_info.item_kind = cell_family_info.item_kind;
417 edge_connected_cell_family_info.connectivity_name =
"EdgeToCells";
418 edge_connected_cell_family_info.nb_connected_items_per_item = vtk_reader.edgeNbCells();
419 edge_connected_cell_family_info.connected_items_uids = vtk_reader.edgeCells();
421 auto& edge_connected_face_family_info = edge_family_info.connected_family_info[edge_connected_family_index++];
422 edge_connected_face_family_info.name = face_family_info.name;
423 edge_connected_face_family_info.item_kind = face_family_info.item_kind;
424 edge_connected_face_family_info.connectivity_name =
"EdgeToFaces";
425 edge_connected_face_family_info.nb_connected_items_per_item = vtk_reader.edgeNbFaces();
426 edge_connected_face_family_info.connected_items_uids = vtk_reader.edgeFaces();
428 auto& edge_connected_node_family_info = edge_family_info.connected_family_info[edge_connected_family_index++];
429 edge_connected_node_family_info.name = node_family_info.name;
430 edge_connected_node_family_info.item_kind = node_family_info.item_kind;
431 edge_connected_node_family_info.connectivity_name =
"EdgeToNodes";
432 edge_connected_node_family_info.nb_connected_items_per_item = vtk_reader.edgeNbNodes();
433 edge_connected_node_family_info.connected_items_uids = vtk_reader.edgeNodes();
435 auto node_connected_family_index = 0;
436 auto& node_connected_cell_family_info = node_family_info.connected_family_info[node_connected_family_index++];
437 node_connected_cell_family_info.name = cell_family_info.name;
438 node_connected_cell_family_info.item_kind = cell_family_info.item_kind;
439 node_connected_cell_family_info.connectivity_name =
"NodeToCells";
440 node_connected_cell_family_info.nb_connected_items_per_item = vtk_reader.nodeNbCells();
441 node_connected_cell_family_info.connected_items_uids = vtk_reader.nodeCells();
443 auto& node_connected_face_family_info = node_family_info.connected_family_info[node_connected_family_index++];
444 node_connected_face_family_info.name = face_family_info.name;
445 node_connected_face_family_info.item_kind = face_family_info.item_kind;
446 node_connected_face_family_info.connectivity_name =
"NodeToFaces";
447 node_connected_face_family_info.nb_connected_items_per_item = vtk_reader.nodeNbFaces();
448 node_connected_face_family_info.connected_items_uids = vtk_reader.nodeFaces();
450 auto& node_connected_edge_family_info = node_family_info.connected_family_info[node_connected_family_index++];
451 node_connected_edge_family_info.name = edge_family_info.name;
452 node_connected_edge_family_info.item_kind = edge_family_info.item_kind;
453 node_connected_edge_family_info.connectivity_name =
"NodeToEdges";
454 node_connected_edge_family_info.nb_connected_items_per_item = vtk_reader.nodeNbEdges();
455 node_connected_edge_family_info.connected_items_uids = vtk_reader.nodeEdges();
457 node_family_info.item_coordinates_variable_name =
"NodeCoord";
458 node_family_info.item_coordinates = vtk_reader.nodeCoords();
464void VtkPolyhedralMeshIOService::
468 OStringStream created_infos_str;
469 created_infos_str() <<
"<?xml version='1.0' ?>\n";
470 created_infos_str() <<
"<infos>";
472 if (
auto* cell_data = reader.cellData(); cell_data) {
475 std::iota(vtk_to_arcane_lids.begin(), vtk_to_arcane_lids.end(), 0);
477 for (
auto array_index = 0; array_index < cell_data->GetNumberOfArrays(); ++array_index) {
478 auto* cell_array = cell_data->GetArray(array_index);
481 if (String name = cell_array->GetName(); name.substring(0, 6) ==
"GROUP_") {
482 _createGroup(cell_array, name.substring(6), mesh, mesh->cellFamily(), vtk_to_arcane_lids.constSpan());
483 created_infos_str() <<
"<cell-group name='" << name.substring(6) <<
"'/>";
486 auto var_info = _createVariable(cell_array, name, mesh, mesh->cellFamily(), arcane_to_vtk_lids);
487 created_infos_str() <<
"<cell-variable name='" << name <<
"' "
488 <<
" data-type='" <<
dataTypeName(var_info.m_type) <<
"' "
489 <<
" is_array='" << std::boolalpha << var_info.is_array <<
"'/>";
491 if (m_print_info_level.print_debug_info) {
493 for (
auto tuple_index = 0; tuple_index < cell_array->GetNumberOfTuples(); ++tuple_index) {
494 for (
auto component_index = 0; component_index < cell_array->GetNumberOfComponents(); ++component_index) {
495 debug(
Trace::High) << cell_array->GetName() <<
"[" << tuple_index <<
"][" << component_index <<
"] = " << cell_array->GetComponent(tuple_index, component_index);
502 if (
auto* point_data = reader.pointData(); point_data) {
505 std::iota(vtk_to_arcane_lids.begin(), vtk_to_arcane_lids.end(), 0);
507 for (
auto array_index = 0; array_index < point_data->GetNumberOfArrays(); ++array_index) {
508 auto* point_array = point_data->GetArray(array_index);
509 if (String name = point_array->GetName(); name.substring(0, 6) ==
"GROUP_") {
510 _createGroup(point_array, name.substring(6), mesh, mesh->nodeFamily(), vtk_to_arcane_lids.constSpan());
511 created_infos_str() <<
"<node-group name='" << name.substring(6) <<
"'/>";
514 auto var_info = _createVariable(point_array, name, mesh, mesh->nodeFamily(), arcane_to_vtk_lids);
515 created_infos_str() <<
"<node-variable name='" << name <<
"' "
516 <<
" data-type='" <<
dataTypeName(var_info.m_type) <<
"' "
517 <<
" is_array='" << std::boolalpha << var_info.is_array <<
"'/>";
519 if (m_print_info_level.print_debug_info) {
521 for (
auto tuple_index = 0; tuple_index < point_array->GetNumberOfTuples(); ++tuple_index) {
522 for (
auto component_index = 0; component_index < point_array->GetNumberOfComponents(); ++component_index) {
523 debug(
Trace::High) << point_array->GetName() <<
"[" << tuple_index <<
"][" << component_index <<
"] = " << point_array->GetComponent(tuple_index, component_index);
530 if (
auto* face_data = reader.faceData(); face_data) {
534 _computeFaceVtkArcaneLidConversion(vtk_to_Arcane_lids, arcane_to_vtk_lids, reader, mesh);
535 for (
auto array_index = 0; array_index < face_data->GetNumberOfArrays(); ++array_index) {
536 auto* face_array = face_data->GetArray(array_index);
537 if (String name = face_array->GetName(); name.substring(0, 6) ==
"GROUP_") {
538 _createGroup(face_array, name.substring(6), mesh, mesh->faceFamily(), vtk_to_Arcane_lids);
539 created_infos_str() <<
"<face-group name='" << name <<
"'/>";
542 auto var_info = _createVariable(face_array, name, mesh, mesh->faceFamily(), arcane_to_vtk_lids);
543 created_infos_str() <<
"<face-variable name='" << name <<
"' "
544 <<
" data-type='" <<
dataTypeName(var_info.m_type) <<
"' "
545 <<
" is_array='" << std::boolalpha << var_info.is_array <<
"'/>";
547 if (m_print_info_level.print_debug_info) {
549 for (
auto tuple_index = 0; tuple_index < face_array->GetNumberOfTuples(); ++tuple_index) {
550 for (
auto component_index = 0; component_index < face_array->GetNumberOfComponents(); ++component_index) {
551 debug(
Trace::High) << face_array->GetName() <<
"[" << tuple_index <<
"][" << component_index <<
"] = " << face_array->GetComponent(tuple_index, component_index);
557 created_infos_str() <<
"</infos>";
560 auto* pm = mesh->parallelMng();
561 if (!reader.isEmpty() && pm->isMasterIO()) {
562 String str = created_infos_str.str();
565 bytes.resize(len + 1);
568 pm->broadcastMemoryBuffer(bytes, pm->masterIORank());
569 if (reader.isEmpty()) {
571 XmlNode doc_node = doc->documentNode();
572 _createEmptyVariablesAndGroups(mesh,doc_node);
580void VtkPolyhedralMeshIOService::
586 if (group_items->GetNumberOfComponents() != 1)
587 fatal() << String::format(
"Cannot create item group {0}. Group information in data property must be a scalar", group_name);
588 debug() <<
"Create group " << group_name;
590 arcane_lids.
reserve((
int)group_items->GetNumberOfValues());
591 using GroupDispatcher = vtkArrayDispatch::DispatchByValueType<vtkArrayDispatch::Integrals>;
592 auto group_creator = [&arcane_lids, &vtkToArcaneLid](
auto* array) {
593 vtkIdType numTuples = array->GetNumberOfTuples();
594 vtkDataArrayAccessor<std::remove_pointer_t<
decltype(array)>> array_accessor{ array };
596 for (vtkIdType tupleIdx = 0; tupleIdx < numTuples; ++tupleIdx) {
597 auto value = array_accessor.Get(tupleIdx, 0);
599 arcane_lids.push_back(vtkToArcaneLid[local_id]);
603 if (!GroupDispatcher::Execute(group_items, group_creator))
604 ARCANE_FATAL(
"Cannot create item group {0}. Group information in data property must be an integral type", group_name);
605 debug() <<
" local ids for item group " << group_name <<
" " << arcane_lids;
606 item_family->createGroup(group_name, arcane_lids);
612template <
typename vtkType>
615 using type = vtkType;
630template <
typename T>
using to_arcane_type_t =
typename ToArcaneType<T>::type;
639 if (item_values->GetNumberOfTuples() != item_family->
nbItem())
640 ARCANE_FATAL(
"Cannot create variable {0}, {1} values are given for {2} items in {3} family",
641 variable_name, item_values->GetNumberOfTuples(), item_family->
nbItem(), item_family->
name());
642 debug() <<
"Create mesh variable " << variable_name;
644 auto variable_creator = [
mesh, variable_name, item_family, arcane_to_vtk_lids,
this, &var_info](
auto* values) {
646 using ValueType =
typename std::remove_pointer_t<
decltype(values)>::ValueType;
647 auto* var =
new ItemVariableScalarRefT<to_arcane_type_t<ValueType>>{ vbi, item_family->itemKind() };
649 vtkDataArrayAccessor<std::remove_pointer_t<
decltype(values)>> values_accessor{ values };
651 (*var)[item] = (to_arcane_type_t<ValueType>)values_accessor.Get(arcane_to_vtk_lids[item.localId()], 0);
653 var_info.m_type = DataTypeTraitsT<to_arcane_type_t<ValueType>>::type();
654 var_info.is_array =
false;
656 auto array_variable_creator = [mesh, variable_name, item_family, arcane_to_vtk_lids,
this, &var_info](
auto* values) {
657 VariableBuildInfo vbi{ mesh, variable_name };
658 using ValueType =
typename std::remove_pointer_t<
decltype(values)>::ValueType;
659 auto* var =
new ItemVariableArrayRefT<to_arcane_type_t<ValueType>>{ vbi, item_family->itemKind() };
661 vtkDataArrayAccessor<std::remove_pointer_t<
decltype(values)>> values_accessor{ values };
662 var->resize(values->GetNumberOfComponents());
665 for (
auto& var_value : (*var)[item]) {
666 var_value = (to_arcane_type_t<ValueType>)values_accessor.Get(arcane_to_vtk_lids[item.localId()], index++);
669 var_info.m_type = DataTypeTraitsT<to_arcane_type_t<ValueType>>::type();
670 var_info.is_array =
true;
673 using ValueTypes = vtkTypeList_Create_6(
double,
float,
int,
long,
long long,
short);
674 using ArrayDispatcher = vtkArrayDispatch::DispatchByValueType<ValueTypes>;
676 bool is_variable_created =
false;
677 if (item_values->GetNumberOfComponents() == 1) {
678 is_variable_created = ArrayDispatcher::Execute(item_values, variable_creator);
682 is_variable_created = ArrayDispatcher::Execute(item_values, array_variable_creator);
684 if (!is_variable_created)
685 ARCANE_FATAL(
"Cannot create variable {0}, it's data type is not supported. Only real and integral types are supported", variable_name);
692void VtkPolyhedralMeshIOService::
695 auto face_nodes_unique_ids = reader.faceNodesInFaceMesh();
696 auto face_nb_nodes = reader.faceNbNodesInFaceMesh();
697 auto current_face_index = 0;
698 auto current_face_index_in_face_nodes = 0;
700 mesh->nodeFamily()->itemsUniqueIdToLocalId(face_nodes_local_ids, face_nodes_unique_ids);
701 for (
auto current_face_nb_node : face_nb_nodes) {
702 auto current_face_nodes = face_nodes_local_ids.subConstView(current_face_index_in_face_nodes, current_face_nb_node);
703 current_face_index_in_face_nodes += current_face_nb_node;
704 Node face_first_node{ mesh->nodeFamily()->view()[current_face_nodes[0]] };
705 face_vtk_to_arcane_lids[current_face_index] = MeshUtils::getFaceFromNodesLocalId(face_first_node, current_face_nodes).localId();
706 ++current_face_index;
709 for (
auto arcane_lid : face_vtk_to_arcane_lids) {
710 arcane_to_vtk_lids[arcane_lid] = vtk_lid;
718template <
template <
class>
class VariableRootType>
721 bool has_error =
false;
724 ARCANE_FATAL(
"Invalid data type name {0} for Variable creation in VtkPolyhedralMeshIOService");
726 switch (var_data_type){
737 ARCANE_FATAL(
"Handle only DT_Int32, DT_Int64, DT_Real in VtkPolyhedralMeshIOService");
744template <
template <
class>
class VariableRootType ,
template <
class>
class ArrayVariableRootType>
745void VtkPolyhedralMeshIOService::
748 ARCANE_CHECK_PTR(mesh);
750 for (XmlNode xnode : item_variables_node) {
751 String name = xnode.attrValue(
"name");
752 debug() <<
"Create mesh variable: " << name;
753 String data_type_name = xnode.attrValue(
"data-type");
754 bool is_array = xnode.attrValue(
"is_array") ==
"true";
755 VariableRef* var =
nullptr;
757 var = _createVar<ArrayVariableRootType>(mesh,name,data_type_name,item_kind);
760 var = _createVar<VariableRootType>(mesh,name, data_type_name,item_kind);
762 mesh->variableMng()->_internalApi()->addAutoDestroyVariable(var);
770void VtkPolyhedralMeshIOService::
773 for (XmlNode xnode : groups_node) {
774 String name = xnode.attrValue(
"name");
775 info() <<
"Building group: " << name;
776 item_family->createGroup(name);
785void VtkPolyhedralMeshIOService::
788 ARCANE_CHECK_PTR(mesh);
789 auto document_node = variable_and_group_info.documentElement();
790 _createEmptyVariables<ItemVariableScalarRefT,ItemVariableArrayRefT>(mesh, document_node.children(
"cell-variable"),
IK_Cell);
791 _createEmptyVariables<ItemVariableScalarRefT,ItemVariableArrayRefT>(mesh, document_node.children(
"node-variable"),
IK_Node);
792 _createEmptyVariables<ItemVariableScalarRefT,ItemVariableArrayRefT>(mesh, document_node.children(
"face-variable"),
IK_Face);
794 _createEmptyGroups(mesh, document_node.children(
"cell-group"), mesh->itemFamily(
IK_Cell));
795 _createEmptyGroups(mesh, document_node.children(
"node-group"), mesh->itemFamily(
IK_Node));
796 _createEmptyGroups(mesh, document_node.children(
"face-group"), mesh->itemFamily(
IK_Face));
802VtkPolyhedralMeshIOService::VtkReader::
804: m_filename{ filename }
805, m_print_info_level{ print_info_level }
809 if (filename.empty()) {
810 m_read_status.failure =
true;
811 m_read_status.failure_message =
"filename for polyhedral vtk mesh is empty.";
814 if (filename.endsWith(
"vtk"))
815 _readPlainTextVtkGrid(filename);
816 else if (filename.endsWith(
"vtu"))
817 _readXlmVtkGrid(filename);
819 m_read_status.failure =
true;
820 m_read_status.failure_message = String::format(
"Unsupported vtk extension for file {0}. Supported vtk extension for Polyhedral meshes are {1}",
821 filename,VtkReader::supportedVtkExtensions());
825 m_read_status.failure =
true;
826 m_read_status.failure_message = String::format(
"Cannot read vtk polyhedral file {0}. Vtk grid was not created.", filename);
829 if (m_vtk_grid->GetNumberOfCells() == 0) {
830 m_read_status.failure =
true;
831 m_read_status.failure_message = String::format(
"Cannot read vtk polyhedral file {0}. No cells were found.", filename);
834 if (!m_vtk_grid->GetFaces()) {
835 m_read_status.failure =
true;
836 m_read_status.failure_message = String::format(
"The given mesh vtk file {0} is not a polyhedral mesh, cannot read it", filename);
840 m_cell_data = m_vtk_grid->GetCellData();
841 m_point_data = m_vtk_grid->GetPointData();
844 String faces_filename = m_filename +
"faces.vtk";
845 std::ifstream ifile(faces_filename.localstr());
847 _readPlainTextVtkFaceGrid(faces_filename);
850 faces_filename = m_filename +
"faces.vtp";
851 ifile = std::ifstream{ faces_filename.localstr() };
853 _readXmlVtkFaceGrid(faces_filename);
858 faces_filename.split(faces_filename_and_extension,
'.');
861 m_read_status.info_message = String::format(
"Information no face mesh given {0}{1} (.vtk or .vtp) to define face variables or groups on faces.",
862 faces_filename_and_extension[0],
863 faces_filename_and_extension[1]);
866 if (m_vtk_face_grid) {
867 if (m_vtk_face_grid->GetNumberOfCells() == 0) {
868 m_read_status.failure =
true;
869 m_read_status.failure_message = m_read_status.failure_message + String::format(
" Error in reading face information for groups in mesh file {0} ", faces_filename);
872 m_face_data = m_vtk_face_grid->GetCellData();
873 m_poly_data = m_vtk_face_grid->GetPolys();
877 m_read_status.failure =
true;
878 m_read_status.failure_message = m_read_status.failure_message + String::format(
"Face data could not be built from file {0}{1} (.vtk or .vtu).",
879 faces_filename_and_extension[0],
880 faces_filename_and_extension[1]);
884 if (m_print_info_level.print_mesh_info)
894 if (!doRead())
return m_cell_uids;
895 if (m_cell_uids.empty()) {
897 m_cell_uids.reserve(m_vtk_grid->GetNumberOfCells());
898 m_cell_nb_nodes.reserve(m_vtk_grid->GetNumberOfCells());
899 m_cell_node_uids.reserve(10 * m_vtk_grid->GetNumberOfCells());
900 auto* cell_iter = m_vtk_grid->NewCellIterator();
901 cell_iter->InitTraversal();
902 while (!cell_iter->IsDoneWithTraversal()) {
903 m_cell_uids.push_back(cell_iter->GetCellId());
904 m_cell_nb_nodes.push_back(
Integer(cell_iter->GetNumberOfPoints()));
905 ArrayView<vtkIdType> cell_nodes{
Integer(cell_iter->GetNumberOfPoints()), cell_iter->GetPointIds()->GetPointer(0) };
906 std::for_each(cell_nodes.begin(), cell_nodes.end(), [
this](
auto uid) { this->m_cell_node_uids.push_back(uid); });
907 cell_iter->GoToNextCell();
919 if (!doRead())
return m_node_uids;
920 if (m_node_uids.empty()) {
922 auto nb_nodes = m_vtk_grid->GetNumberOfPoints();
923 m_node_uids.resize(nb_nodes);
924 m_node_nb_cells.resize(nb_nodes);
925 m_node_cell_uids.reserve(8 * nb_nodes);
926 m_node_uid_to_index.resize(nb_nodes);
927 for (
int node_index = 0; node_index < nb_nodes; ++node_index) {
928 Int64 node_uid = node_index;
929 m_node_uids[node_index] = node_uid;
930 auto cell_nodes = vtkIdList::New();
931 m_vtk_grid->GetPointCells(node_index, cell_nodes);
932 Int64Span cell_nodes_view((
Int64*)cell_nodes->GetPointer(0), cell_nodes->GetNumberOfIds());
933 m_node_cell_uids.addRange(cell_nodes_view);
934 m_node_nb_cells[node_index] = (
Int32)cell_nodes->GetNumberOfIds();
937 m_node_uid_to_index[node_uid] = node_index;
952 if (!doRead())
return m_face_uids;
953 if (!m_face_uids.empty())
956 auto* cell_iter = m_vtk_grid->NewCellIterator();
957 cell_iter->InitTraversal();
958 vtkIdType nb_face_estimation = 0;
959 while (!cell_iter->IsDoneWithTraversal()) {
960 vtkIdType cell_nb_faces = 0;
961 vtkIdType_generic * points{
nullptr };
962 m_vtk_grid->GetFaceStream(cell_iter->GetCellId(), cell_nb_faces, points);
963 nb_face_estimation += cell_nb_faces;
964 cell_iter->GoToNextCell();
966 m_face_uids.reserve(nb_face_estimation);
967 auto const* faces = m_vtk_grid->GetFaces();
972 ARCANE_FATAL(
"Mesh {0} is not polyhedral: faces are not defined", m_filename);
975 auto face_info_size = faces->GetNumberOfValues();
976 m_face_node_uids.reserve(face_info_size);
977 m_face_nb_nodes.reserve(nb_face_estimation);
978 m_face_cell_uids.reserve(2 * nb_face_estimation);
979 m_face_nb_cells.reserve(nb_face_estimation);
980 m_cell_face_uids.reserve(8 * m_cell_uids.size());
981 m_cell_nb_faces.resize(m_cell_uids.size(), 0);
982 m_cell_face_indexes.resize(m_cell_uids.size(), -1);
983 m_face_uid_indexes.resize(2 * nb_face_estimation, -1);
985 current_face_nodes.
reserve(10);
986 sorted_current_face_nodes.reserve(10);
987 UniqueArray<UniqueArray<Int64>> node_faces(m_node_uids.size());
988 UniqueArray<Int32> face_offsets;
989 face_offsets.reserve(nb_face_estimation);
990 face_offsets.push_back(0);
991 FaceUidToIndexMap face_uid_to_index;
992 face_uid_to_index.reserve(nb_face_estimation);
994 auto cell_face_index = 0;
995 auto global_face_index = 0;
996 auto face_uid_index = 0;
997 for (
int face_info_index = 0; face_info_index < face_info_size; cell_index++) {
998 auto current_cell_nb_faces =
Int32(faces->GetValue(face_info_index++));
999 m_cell_face_indexes[m_cell_uids[cell_index]] = cell_face_index;
1000 for (
auto face_index = 0; face_index < current_cell_nb_faces; ++face_index, ++global_face_index) {
1001 auto current_face_nb_nodes =
Int32(faces->GetValue(face_info_index++));
1002 m_cell_nb_faces[m_cell_uids[cell_index]] += 1;
1003 for (
int node_index = 0; node_index < current_face_nb_nodes; ++node_index) {
1004 current_face_nodes.push_back(faces->GetValue(face_info_index++));
1006 sorted_current_face_nodes.resize(current_face_nodes.size());
1007 auto is_front_cell = mesh_utils::reorderNodesOfFace(current_face_nodes, sorted_current_face_nodes);
1008 auto [is_face_found, existing_face_index] = _findFace(sorted_current_face_nodes, node_faces,
1009 m_node_uid_to_index, m_face_nb_nodes,
1010 face_uid_to_index, face_offsets, m_face_node_uids);
1011 if (!is_face_found) {
1012 for (
auto node_uid : current_face_nodes) {
1013 node_faces[m_node_uid_to_index[node_uid]].push_back(face_uid);
1015 m_cell_face_uids.push_back(face_uid);
1016 m_face_uids.push_back(face_uid);
1017 m_face_nb_nodes.push_back(current_face_nb_nodes);
1018 m_face_node_uids.addRange(sorted_current_face_nodes);
1019 m_face_nb_cells.push_back(1);
1020 m_face_uid_indexes[global_face_index] = face_uid_index;
1021 face_uid_to_index.push_back(face_uid_index);
1022 auto previous_offset = face_offsets.back();
1023 face_offsets.push_back(previous_offset + sorted_current_face_nodes.size());
1026 if (is_front_cell) {
1027 m_face_cell_uids.push_back(NULL_ITEM_UNIQUE_ID);
1028 m_face_cell_uids.push_back(m_cell_uids[cell_index]);
1031 m_face_cell_uids.push_back(m_cell_uids[cell_index]);
1032 m_face_cell_uids.push_back(NULL_ITEM_UNIQUE_ID);
1036 m_cell_face_uids.push_back(m_face_uids[existing_face_index]);
1037 m_face_nb_cells[existing_face_index] += 1;
1038 m_face_uid_indexes[global_face_index] = existing_face_index;
1040 if (is_front_cell) {
1041 if (m_face_cell_uids[2 * existing_face_index + 1] != NULL_ITEM_UNIQUE_ID) {
1042 ARCANE_FATAL(
"Problem in face orientation, face uid {0}, nodes {1}, same orientation in cell {2} and {3}. Change mesh file.",
1043 m_face_uids[existing_face_index],
1045 m_face_cell_uids[2 * existing_face_index + 1],
1046 m_cell_uids[cell_index]);
1048 m_face_cell_uids[2 * existing_face_index + 1] = m_cell_uids[cell_index];
1051 if (m_face_cell_uids[2 * existing_face_index] != NULL_ITEM_UNIQUE_ID) {
1052 ARCANE_FATAL(
"Problem in face orientation, face uid {0}, nodes {1}, same orientation in cell {2} and {3}. Change mesh file.",
1053 m_face_uids[existing_face_index],
1055 m_face_cell_uids[2 * existing_face_index],
1056 m_cell_uids[cell_index]);
1058 m_face_cell_uids[2 * existing_face_index] = m_cell_uids[cell_index];
1061 current_face_nodes.clear();
1062 sorted_current_face_nodes.clear();
1064 cell_face_index += m_cell_nb_faces[m_cell_uids[cell_index]];
1067 m_node_nb_faces.resize(m_node_uids.size(), 0);
1068 _flattenConnectivity(node_faces.constSpan(), m_node_nb_faces, m_node_face_uids);
1070 if (m_print_info_level.print_debug_info) {
1071 std::cout <<
"================FACE NODES ==============" << std::endl;
1072 std::copy(m_face_node_uids.begin(), m_face_node_uids.end(), std::ostream_iterator<Int64>(std::cout,
" "));
1073 std::cout << std::endl;
1074 std::copy(m_face_nb_nodes.begin(), m_face_nb_nodes.end(), std::ostream_iterator<Int64>(std::cout,
" "));
1075 std::cout << std::endl;
1076 std::copy(m_cell_face_indexes.begin(), m_cell_face_indexes.end(), std::ostream_iterator<Int64>(std::cout,
" "));
1077 std::cout << std::endl;
1089 if (!doRead())
return m_edge_uids;
1090 if (!m_edge_uids.empty())
1096 m_edge_uids.reserve(2 * m_vtk_grid->GetNumberOfPoints());
1097 auto const* faces = m_vtk_grid->GetFaces();
1102 ARCANE_FATAL(
"Mesh {0} is not polyhedral: faces are not defined", m_filename);
1105 auto nb_edge_estimation = 2 * m_edge_uids.capacity();
1106 m_edge_node_uids.reserve(nb_edge_estimation);
1107 auto face_info_size = faces->GetNumberOfValues();
1108 auto cell_index = 0;
1109 auto global_face_index = 0;
1110 auto new_edge_index = 0;
1111 UniqueArray<std::set<Int64>> edge_cells;
1112 UniqueArray<Int64UniqueArray> edge_faces;
1113 edge_cells.reserve(m_edge_uids.capacity());
1114 edge_faces.reserve(m_edge_uids.capacity());
1115 m_cell_nb_edges.resize(m_cell_uids.size(), 0);
1116 m_cell_edge_uids.reserve(20 * m_cell_uids.size());
1117 UniqueArray<std::set<Int64>> face_edges;
1118 face_edges.resize(m_face_uids.size());
1119 UniqueArray<std::set<Int64>> cell_edges;
1120 cell_edges.resize(m_cell_uids.size());
1121 UniqueArray<Int64UniqueArray> node_edges;
1122 node_edges.resize(m_node_uids.size());
1123 EdgeUidToIndexMap edge_uid_to_index;
1124 edge_uid_to_index.reserve(nb_edge_estimation);
1126 edge_offsets.
reserve(nb_edge_estimation);
1127 edge_offsets.push_back(0);
1128 m_edge_nb_nodes.reserve(nb_edge_estimation);
1129 for (
int face_info_index = 0; face_info_index < face_info_size; ++cell_index) {
1130 auto current_cell_nb_faces =
Int32(faces->GetValue(face_info_index++));
1131 for (
auto face_index = 0; face_index < current_cell_nb_faces; ++face_index, ++global_face_index) {
1132 auto current_face_nb_nodes =
Int32(faces->GetValue(face_info_index++));
1133 auto first_face_node_uid =
Int32(faces->GetValue(face_info_index));
1134 UniqueArray<Int64> current_edge(2), sorted_edge(2);
1135 for (
int node_index = 0; node_index < current_face_nb_nodes - 1; ++node_index) {
1136 current_edge = UniqueArray<Int64>{ faces->GetValue(face_info_index++), faces->GetValue(face_info_index) };
1137 mesh_utils::reorderNodesOfFace(current_edge, sorted_edge);
1138 auto [is_edge_found, existing_edge_index] = _findFace(sorted_edge, node_edges,
1139 m_node_uid_to_index,
1141 edge_uid_to_index, edge_offsets, m_edge_node_uids);
1142 if (!is_edge_found) {
1143 m_cell_nb_edges[cell_index] += 1;
1144 face_edges[m_face_uid_indexes[global_face_index]].insert(edge_uid);
1145 cell_edges[cell_index].insert(edge_uid);
1146 for (
auto node : current_edge) {
1147 node_edges[node].push_back(edge_uid);
1149 edge_cells.push_back(std::set{ m_cell_uids[cell_index] });
1150 edge_faces.push_back(
Int64UniqueArray{ m_cell_face_uids[m_cell_face_indexes[cell_index] + face_index] });
1151 m_edge_uids.push_back(edge_uid++);
1152 m_edge_node_uids.addRange(sorted_edge);
1153 edge_uid_to_index.push_back(new_edge_index);
1154 auto current_offset = edge_offsets.back();
1155 edge_offsets.push_back(current_offset + 2);
1156 m_edge_nb_nodes.push_back(2);
1160 edge_cells[existing_edge_index].insert(m_cell_uids[cell_index]);
1161 edge_faces[existing_edge_index].push_back(m_cell_face_uids[m_cell_face_indexes[cell_index] + face_index]);
1162 face_edges[m_face_uid_indexes[global_face_index]].insert(m_edge_uids[existing_edge_index]);
1163 cell_edges[cell_index].insert(m_edge_uids[existing_edge_index]);
1166 current_edge = UniqueArray<Int64>{ faces->GetValue(face_info_index++), first_face_node_uid };
1167 mesh_utils::reorderNodesOfFace(current_edge, sorted_edge);
1168 auto [is_edge_found, existing_edge_index] = _findFace(sorted_edge, node_edges,
1169 m_node_uid_to_index,
1171 edge_uid_to_index, edge_offsets, m_edge_node_uids);
1172 if (!is_edge_found) {
1173 m_cell_nb_edges[cell_index] += 1;
1174 edge_cells.push_back(std::set{ m_cell_uids[cell_index] });
1175 edge_faces.push_back(
Int64UniqueArray{ m_cell_face_uids[m_cell_face_indexes[cell_index] + face_index] });
1176 face_edges[m_face_uid_indexes[global_face_index]].insert(edge_uid);
1177 cell_edges[cell_index].insert(edge_uid);
1178 for (
auto node : current_edge) {
1179 node_edges[node].push_back(edge_uid);
1181 m_edge_uids.push_back(edge_uid++);
1182 m_edge_node_uids.addRange(sorted_edge);
1183 edge_uid_to_index.push_back(new_edge_index);
1184 auto current_offset = edge_offsets.back();
1185 edge_offsets.push_back(current_offset + 2);
1186 m_edge_nb_nodes.push_back(2);
1190 edge_cells[existing_edge_index].insert(m_cell_uids[cell_index]);
1191 edge_faces[existing_edge_index].push_back(m_cell_face_uids[m_cell_face_indexes[cell_index] + face_index]);
1192 face_edges[m_face_uid_indexes[global_face_index]].insert(m_edge_uids[existing_edge_index]);
1193 cell_edges[cell_index].insert(m_edge_uids[existing_edge_index]);
1198 m_edge_nb_cells.resize(m_edge_uids.size(), 0);
1199 _flattenConnectivity(edge_cells.constSpan(), m_edge_nb_cells, m_edge_cell_uids);
1202 m_edge_nb_faces.resize(m_edge_uids.size(), 0);
1203 _flattenConnectivity(edge_faces.constSpan(), m_edge_nb_faces, m_edge_face_uids);
1206 m_face_nb_edges.resize(m_face_uids.size(), 0);
1207 _flattenConnectivity(face_edges.constSpan(), m_face_nb_edges, m_face_edge_uids);
1210 m_cell_nb_edges.resize(m_cell_uids.size(), 0);
1211 _flattenConnectivity(cell_edges, m_cell_nb_edges, m_cell_edge_uids);
1214 m_node_nb_edges.resize(m_node_uids.size(), 0);
1215 _flattenConnectivity(node_edges, m_node_nb_edges, m_node_edge_uids);
1217 if (m_print_info_level.print_debug_info) {
1218 std::cout <<
"================EDGE NODES ==============" << std::endl;
1219 std::copy(m_edge_node_uids.begin(), m_edge_node_uids.end(), std::ostream_iterator<Int64>(std::cout,
" "));
1220 std::cout << std::endl;
1221 std::cout <<
"================FACE EDGES ==============" << std::endl;
1222 std::copy(m_face_nb_edges.begin(), m_face_nb_edges.end(), std::ostream_iterator<Int32>(std::cout,
" "));
1223 std::cout << std::endl;
1224 std::copy(m_face_edge_uids.begin(), m_face_edge_uids.end(), std::ostream_iterator<Int64>(std::cout,
" "));
1225 std::cout << std::endl;
1226 std::cout <<
"================CELL EDGES ==============" << std::endl;
1227 std::copy(m_cell_nb_edges.begin(), m_cell_nb_edges.end(), std::ostream_iterator<Int32>(std::cout,
" "));
1228 std::cout << std::endl;
1229 std::copy(m_cell_edge_uids.begin(), m_cell_edge_uids.end(), std::ostream_iterator<Int64>(std::cout,
" "));
1230 std::cout << std::endl;
1238std::pair<bool, Int32> VtkPolyhedralMeshIOService::VtkReader::
1240 const UniqueArray<Int64UniqueArray>& node_face_uids,
1241 const NodeUidToIndexMap& node_uid_to_index,
1243 const FaceUidToIndexMap& face_uid_to_index,
1244 const UniqueArray<Int32>& face_offsets,
1247 auto first_node_uid = sorted_face_nodes[0];
1248 auto first_node_index = node_uid_to_index[first_node_uid];
1250 for (
auto face_uid : node_face_uids[first_node_index]) {
1251 auto face_index = face_uid_to_index[face_uid];
1252 auto face_offset = face_offsets[face_index];
1253 auto face_nb_node = face_nb_nodes[face_index];
1254 if (face_nb_node == sorted_face_nodes.size()) {
1255 bool is_same_face =
true;
1256 for (
auto index = 0; index < face_nb_node; ++index) {
1257 if (sorted_face_nodes[index] != face_node_uids[face_offset + index]) {
1258 is_same_face =
false;
1262 return {
true, face_index };
1265 return {
false, -1 };
1271Integer VtkPolyhedralMeshIOService::VtkReader::
1274 if (m_node_uids.empty())
1276 return m_node_uids.size();
1285 if (m_cell_node_uids.empty())
1287 return m_cell_node_uids;
1296 if (m_cell_nb_nodes.empty())
1298 return m_cell_nb_nodes;
1307 if (m_face_node_uids.empty())
1309 return m_face_node_uids;
1318 if (m_face_nb_nodes.empty())
1320 return m_face_nb_nodes;
1327faceNodesInFaceMesh()
1329 if (m_face_node_uids_in_face_mesh.empty())
1330 _readfaceNodesInFaceMesh();
1331 return m_face_node_uids_in_face_mesh;
1338faceNbNodesInFaceMesh()
1340 if (m_face_nb_nodes_in_face_mesh.empty())
1341 _readfaceNodesInFaceMesh();
1342 return m_face_nb_nodes_in_face_mesh;
1351 if (m_edge_node_uids.empty())
1353 return m_edge_nb_nodes;
1362 if (m_edge_node_uids.empty())
1364 return m_edge_node_uids;
1373 if (m_face_cell_uids.empty())
1376 if (m_print_info_level.print_debug_info) {
1377 std::cout <<
"=================FACE CELLS================="
1379 std::copy(m_face_cell_uids.begin(), m_face_cell_uids.end(), std::ostream_iterator<Int64>(std::cout,
" "));
1381 std::cout <<
"=================END FACE CELLS================="
1384 return m_face_cell_uids;
1393 if (m_face_nb_cells.empty())
1395 return m_face_nb_cells;
1404 if (m_edge_nb_cells.empty())
1406 return m_edge_nb_cells;
1415 if (m_edge_cell_uids.empty())
1417 return m_edge_cell_uids;
1426 if (m_cell_nb_faces.empty())
1428 return m_cell_nb_faces;
1437 if (m_cell_face_uids.empty())
1439 return m_cell_face_uids;
1448 if (m_edge_nb_faces.empty())
1450 return m_edge_nb_faces;
1459 if (m_edge_face_uids.empty())
1461 return m_edge_face_uids;
1470 if (m_cell_nb_edges.empty())
1472 return m_cell_nb_edges;
1481 if (m_cell_edge_uids.empty())
1483 return m_cell_edge_uids;
1492 if (m_face_nb_edges.empty())
1494 return m_face_nb_edges;
1503 if (m_face_edge_uids.empty())
1505 return m_face_edge_uids;
1511template <
typename Connectivity2DArray>
1512void VtkPolyhedralMeshIOService::VtkReader::
1513_flattenConnectivity(Connectivity2DArray connected_item_2darray,
1514 Int32Span nb_connected_item_per_source_item,
1518 std::transform(connected_item_2darray.begin(), connected_item_2darray.end(), nb_connected_item_per_source_item.begin(), [](
auto const& connected_items) {
1519 return connected_items.size();
1522 connected_item_array.reserve(std::accumulate(nb_connected_item_per_source_item.begin(), nb_connected_item_per_source_item.end(), 0));
1523 std::for_each(connected_item_2darray.begin(), connected_item_2darray.end(), [&connected_item_array](
auto const& connected_items) {
1524 for (auto const& connected_item : connected_items) {
1525 connected_item_array.push_back(connected_item);
1536 if (m_node_nb_cells.empty())
1538 return m_node_nb_cells;
1547 if (m_node_cell_uids.empty())
1549 return m_node_cell_uids;
1558 if (m_node_nb_faces.empty())
1560 return m_node_nb_faces;
1569 if (m_node_face_uids.empty())
1571 return m_node_face_uids;
1580 if (m_node_nb_edges.empty())
1582 return m_node_nb_edges;
1591 if (m_node_edge_uids.empty())
1593 return m_node_edge_uids;
1602 if (!doRead())
return m_node_coordinates;
1603 if (m_node_coordinates.empty()) {
1605 auto point_coords = m_vtk_grid->GetPoints()->GetData();
1606 if (m_print_info_level.print_debug_info) {
1607 std::cout <<
"======= Point COORDS ====" << std::endl;
1608 std::ostringstream oss;
1609 point_coords->PrintSelf(oss, vtkIndent{ 2 });
1610 std::cout << oss.str() << std::endl;
1612 auto nb_nodes = m_vtk_grid->GetNumberOfPoints();
1613 for (
int i = 0; i < nb_nodes; ++i) {
1614 if (m_print_info_level.print_debug_info) {
1615 std::cout <<
"==========current point coordinates : ( ";
1616 std::cout << *(point_coords->GetTuple(i)) <<
" , ";
1617 std::cout << *(point_coords->GetTuple(i) + 1) <<
" , ";
1618 std::cout << *(point_coords->GetTuple(i) + 2) <<
" ) ===" << std::endl;
1620 m_node_coordinates.add({ *(point_coords->GetTuple(i)),
1621 *(point_coords->GetTuple(i) + 1),
1622 *(point_coords->GetTuple(i) + 2) });
1625 return m_node_coordinates;
1631vtkCellData* VtkPolyhedralMeshIOService::VtkReader::
1640vtkPointData* VtkPolyhedralMeshIOService::VtkReader::
1643 return m_point_data;
1649void VtkPolyhedralMeshIOService::VtkReader::
1650_printMeshInfos()
const
1653 std::cout <<
"-- VTK GRID READ "
1654 <<
" NB CELLS " << m_vtk_grid->GetNumberOfCells() << std::endl;
1656 auto* cell_iter = m_vtk_grid->vtkDataSet::NewCellIterator();
1657 cell_iter->InitTraversal();
1658 vtkIdType_generic* cell_faces{
nullptr };
1659 vtkIdType nb_faces = 0;
1660 while (!cell_iter->IsDoneWithTraversal()) {
1661 std::cout <<
"---- visiting cell id " << cell_iter->GetCellId() << std::endl;
1662 std::cout <<
"---- cell number of faces " << cell_iter->GetNumberOfFaces() << std::endl;
1663 std::cout <<
"---- cell number of points " << cell_iter->GetNumberOfPoints() << std::endl;
1664 m_vtk_grid->GetFaceStream(cell_iter->GetCellId(), nb_faces, cell_faces);
1665 for (
auto iface = 0; iface < nb_faces; ++iface) {
1666 auto face_nb_nodes = *cell_faces++;
1667 std::cout <<
"---- has face with " << face_nb_nodes <<
" nodes. Node ids : ";
1668 for (
int inode = 0; inode < face_nb_nodes; ++inode) {
1669 std::cout << *cell_faces++ <<
" ";
1671 std::cout << std::endl;
1673 cell_iter->GoToNextCell();
1680vtkCellData* VtkPolyhedralMeshIOService::VtkReader::faceData()
1690void VtkPolyhedralMeshIOService::VtkReader::
1691_readPlainTextVtkGrid(
const String& filename)
1693 m_vtk_grid_reader->SetFileName(filename.localstr());
1694 m_vtk_grid_reader->ReadAllScalarsOn();
1695 m_vtk_grid_reader->Update();
1696 m_vtk_grid = m_vtk_grid_reader->GetOutput();
1702void VtkPolyhedralMeshIOService::VtkReader::
1703_readXlmVtkGrid(
const String& filename)
1705 m_vtk_xml_grid_reader->SetFileName(filename.localstr());
1706 m_vtk_xml_grid_reader->Update();
1707 m_vtk_grid = m_vtk_xml_grid_reader->GetOutput();
1713void VtkPolyhedralMeshIOService::VtkReader::
1714_readPlainTextVtkFaceGrid(
const String& faces_filename)
1716 m_vtk_face_grid_reader->SetFileName(faces_filename.localstr());
1717 m_vtk_face_grid_reader->ReadAllScalarsOn();
1718 m_vtk_face_grid_reader->Update();
1719 m_vtk_face_grid = m_vtk_face_grid_reader->GetOutput();
1725void VtkPolyhedralMeshIOService::VtkReader::
1726_readXmlVtkFaceGrid(
const String& faces_filename)
1728 m_vtk_xml_face_grid_reader->SetFileName(faces_filename.localstr());
1729 m_vtk_xml_face_grid_reader->Update();
1730 m_vtk_face_grid = m_vtk_xml_face_grid_reader->GetOutput();
1736void VtkPolyhedralMeshIOService::VtkReader::
1737_readfaceNodesInFaceMesh()
1739 m_face_nb_nodes_in_face_mesh.resize(m_poly_data->GetNumberOfCells());
1740 m_face_node_uids_in_face_mesh.reserve(m_poly_data->GetNumberOfCells() * m_poly_data->GetMaxCellSize());
1741 m_poly_data->InitTraversal();
1742 vtkIdType face_nb_nodes;
1743 vtkIdType_generic* face_nodes;
1745 auto face_nb_node_index = 0;
1748 current_face_node_uids.
reserve(m_poly_data->GetMaxCellSize());
1749 reordered_current_face_node_uids.reserve(m_poly_data->GetMaxCellSize());
1751 while (m_poly_data->GetNextCell(face_nb_nodes, face_nodes)) {
1752 m_face_nb_nodes_in_face_mesh[face_nb_node_index] = face_nb_nodes;
1753 ConstArrayView<vtkIdType> face_nodes_view(face_nb_nodes, face_nodes);
1754 current_face_node_uids.resize(face_nb_nodes);
1755 reordered_current_face_node_uids.resize(face_nb_nodes);
1756 std::copy(face_nodes_view.begin(), face_nodes_view.end(), current_face_node_uids.begin());
1757 MeshUtils::reorderNodesOfFace(current_face_node_uids, reordered_current_face_node_uids);
1758 std::copy(reordered_current_face_node_uids.begin(), reordered_current_face_node_uids.end(), std::back_inserter(m_face_node_uids_in_face_mesh));
1759 ++face_nb_node_index;
1765void VtkPolyhedralMeshIOService::VtkReader::
1766_checkVtkGrid()
const
1769 ARCANE_FATAL(
"Polyhedral vtk grid not loaded. Cannot continue.");
Fichier de configuration d'Arcane.
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Déclarations des types généraux de Arcane.
Fonctions utilitaires sur le maillage.
Ce fichier contient les différentes fabriques de services et macro pour enregistrer les services.
#define ARCANE_SERVICE_INTERFACE(ainterface)
Macro pour déclarer une interface lors de l'enregistrement d'un service.
Gestion des références à une classe C++.
Generation de la classe de base du Service.
CaseOptionsVtkPolyhedralMeshIO * options() const
Options du jeu de données du service.
ArcaneVtkPolyhedralMeshIOObject(const Arcane::ServiceBuildInfo &sbi)
Constructeur.
void reserve(Int64 new_capacity)
Réserve le mémoire pour new_capacity éléments.
Informations nécessaires pour la lecture d'un fichier de maillage.
Interface d'une famille d'entités.
virtual String name() const =0
Nom de la famille.
virtual Integer nbItem() const =0
Nombre d'entités.
virtual String name() const =0
Nom du maillage.
Interface d'un service de création/lecture du maillage.
virtual IVariableMng * variableMng() const =0
Gestionnaire de variable associé
Interface du gestionnaire de traces.
virtual void addAutoDestroyVariable(VariableRef *var)=0
Ajoute la variable à la liste des variables qui sont conservées jusqu'à la fin de l'exécution.
virtual IVariableMngInternal * _internalApi()=0
API interne à Arcane.
static IXmlDocumentHolder * loadFromBuffer(Span< const Byte > buffer, const String &name, ITraceMng *tm)
Charge un document XML.
Paramètres nécessaires à la construction d'un maillage.
MeshBuildInfo & addNeedPartitioning(bool v)
Indique si le générateur nécessite d'appeler un partitionneur.
MeshBuildInfo & addMeshKind(const MeshKind &v)
Positionne les caractéristiques du maillage.
MeshBuildInfo & addFactoryName(const String &factory_name)
Positionne le nom de la fabrique pour créer ce maillage.
Caractéristiques d'un maillage.
Référence à une instance.
Structure contenant les informations pour créer un service.
Chaîne de caractères unicode.
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium) const
Flot pour un message de debug.
TraceMessage fatal() const
Flot pour un message d'erreur fatale.
TraceMessage info() const
Flot pour un message d'information.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
Paramètres nécessaires à la construction d'une variable.
Infos caractérisant une variable.
Référence à une variable.
void fillMeshBuildInfo(MeshBuildInfo &build_info) override
Remplit build_info avec les informations nécessaires pour créer le maillage.
void allocateMeshItems(IPrimaryMesh *pm) override
Alloue les entités du maillage géré par ce service.
Ref< IMeshBuilder > createBuilder(const CaseMeshReaderReadInfo &read_info) const override
Retourne un builder pour créer et lire le maillage dont les informations sont spécifiées dans read_in...
Liste de noeuds d'un arbre DOM.
const value_type & const_reference
Type référence constante d'un élément du tableau.
#define ARCANE_REGISTER_SERVICE(aclass, a_service_property,...)
Macro pour enregistrer un service.
Integer len(const char *s)
Retourne la longueur de la chaîne s.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Span< Int64 > Int64Span
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
UniqueArray< Int64 > Int64UniqueArray
Tableau dynamique à une dimension d'entiers 64 bits.
std::int64_t Int64
Type entier signé sur 64 bits.
ArrayView< Real3 > Real3ArrayView
Equivalent C d'un tableau à une dimension de Real3.
Int32 Integer
Type représentant un entier.
UniqueArray< Real3 > Real3UniqueArray
Tableau dynamique à une dimension de vecteurs de rang 3.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
@ Polyhedral
Maillage polyedrique.
@ ST_CaseOption
Le service s'utilise au niveau du jeu de données.
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
UniqueArray< Byte > ByteUniqueArray
Tableau dynamique à une dimension de caractères.
SharedArray< Int32 > Int32SharedArray
Tableau dynamique à une dimension d'entiers 32 bits.
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
eItemKind
Genre d'entité de maillage.
@ IK_Node
Entité de maillage de genre noeud.
@ IK_Cell
Entité de maillage de genre maille.
@ IK_Face
Entité de maillage de genre face.
@ IK_Edge
Entité de maillage de genre arête.
double Real
Type représentant un réel.
ConstArrayView< Byte > ByteConstArrayView
Equivalent C d'un tableau à une dimension de caractères.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
UniqueArray< String > StringUniqueArray
Tableau dynamique à une dimension de chaînes de caractères.
Span< Int32 > Int32Span
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
eDataType
Type d'une donnée.
@ DT_Int32
Donnée de type entier 32 bits.
@ DT_Int64
Donnée de type entier 64 bits.
@ DT_Unknown
Donnée de type inconnue ou non initialisée.
@ DT_Real
Donnée de type réel.
Span< const Int32 > Int32ConstSpan
Vue en lecture seule d'un tableau à une dimension d'entiers 32 bits.
ARCANE_DATATYPE_EXPORT eDataType dataTypeFromName(const char *name, bool &has_error)
Trouve le type associé à name.
const char * dataTypeName(eDataType type)
Nom du type de donnée.
std::int32_t Int32
Type entier signé sur 32 bits.