MeshLib::NodePartitionedMesh* NodePartitionedMeshReader::readBinary(
const std::string &file_name_base)
{
//----------------------------------------------------------------------------------
// Read headers
const std::string fname_header = file_name_base + "_partitioned_msh_";
const std::string fname_num_p_ext = std::to_string(_mpi_comm_size) + ".bin";
if (!readBinaryDataFromFile(fname_header + "cfg" + fname_num_p_ext,
static_cast<MPI_Offset>(
static_cast<unsigned>(_mpi_rank) * sizeof(_mesh_info)),
MPI_LONG, _mesh_info))
return nullptr;
//----------------------------------------------------------------------------------
// Read Nodes
std::vector<NodeData> nodes(_mesh_info.nodes);
if (!readBinaryDataFromFile(fname_header + "nod" + fname_num_p_ext,
static_cast<MPI_Offset>(_mesh_info.offset[2]), _mpi_node_type, nodes))
return nullptr;
std::vector<MeshLib::Node*> mesh_nodes;
std::vector<unsigned long> glb_node_ids;
setNodes(nodes, mesh_nodes, glb_node_ids);
//----------------------------------------------------------------------------------
// Read non-ghost elements
std::vector<unsigned long> elem_data(
_mesh_info.regular_elements + _mesh_info.offset[0]);
if (!readBinaryDataFromFile(fname_header + "ele" + fname_num_p_ext,
static_cast<MPI_Offset>(_mesh_info.offset[3]), MPI_LONG, elem_data))
return nullptr;
std::vector<MeshLib::Element*> mesh_elems(
_mesh_info.regular_elements + _mesh_info.ghost_elements);
setElements(mesh_nodes, elem_data, mesh_elems);
//----------------------------------------------------------------------------------
//Read ghost element
std::vector<unsigned long> ghost_elem_data(
_mesh_info.ghost_elements + _mesh_info.offset[1]);
if (!readBinaryDataFromFile(fname_header + "ele_g" + fname_num_p_ext,
static_cast<MPI_Offset>(_mesh_info.offset[4]), MPI_LONG, ghost_elem_data))
return nullptr;
const bool process_ghost = true;
setElements(mesh_nodes, ghost_elem_data, mesh_elems, process_ghost);
//----------------------------------------------------------------------------------
return newMesh(BaseLib::extractBaseName(file_name_base),
mesh_nodes, glb_node_ids, mesh_elems);
}
data heap_extract_min(heap** H){
assert(H && *H);
node* z = *H;
data d = elem_data(z);
node* first = z->kid;
heap_remove_from(H, z);
node_free(z);
if (first){
node* current = first->right;
while (current != first){
current->parent = NULL;
current = current->right;
}
first->parent = NULL;
*H = heap_union(*H, first);
}
heap_consolidate(H);
return d;
}
void CheckpointIO::read_connectivity (Xdr & io)
{
// convenient reference to our mesh
MeshBase & mesh = MeshInput<MeshBase>::mesh();
unsigned int n_active_levels;
io.data(n_active_levels, "# n_active_levels");
// Keep track of the highest dimensional element we've added to the mesh
unsigned int highest_elem_dim = 1;
for(unsigned int level=0; level < n_active_levels; level++)
{
xdr_id_type n_elem_at_level = 0;
io.data (n_elem_at_level, "");
for (unsigned int i=0; i<n_elem_at_level; i++)
{
// id type pid subdomain_id parent_id
std::vector<largest_id_type> elem_data(5);
io.data_stream
(&elem_data[0], cast_int<unsigned int>(elem_data.size()),
cast_int<unsigned int>(elem_data.size()));
#ifdef LIBMESH_ENABLE_UNIQUE_ID
largest_id_type unique_id = 0;
io.data(unique_id, "# unique id");
#endif
#ifdef LIBMESH_ENABLE_AMR
unsigned int p_level = 0;
io.data(p_level, "# p_level");
#endif
unsigned int n_nodes = Elem::type_to_n_nodes_map[elem_data[1]];
// Snag the node ids this element was connected to
std::vector<largest_id_type> conn_data(n_nodes);
io.data_stream
(&conn_data[0], cast_int<unsigned int>(conn_data.size()),
cast_int<unsigned int>(conn_data.size()));
const dof_id_type id =
cast_int<dof_id_type> (elem_data[0]);
const ElemType elem_type =
static_cast<ElemType> (elem_data[1]);
const processor_id_type proc_id =
cast_int<processor_id_type>(elem_data[2]);
const subdomain_id_type subdomain_id =
cast_int<subdomain_id_type>(elem_data[3]);
const dof_id_type parent_id =
cast_int<dof_id_type> (elem_data[4]);
Elem * parent =
(parent_id == DofObject::invalid_processor_id) ?
libmesh_nullptr : mesh.elem_ptr(parent_id);
// Create the element
Elem * elem = Elem::build(elem_type, parent).release();
#ifdef LIBMESH_ENABLE_UNIQUE_ID
elem->set_unique_id() = unique_id;
#endif
if(elem->dim() > highest_elem_dim)
highest_elem_dim = elem->dim();
elem->set_id() = id;
elem->processor_id() = proc_id;
elem->subdomain_id() = subdomain_id;
#ifdef LIBMESH_ENABLE_AMR
elem->hack_p_level(p_level);
// Set parent connections
if(parent)
{
parent->add_child(elem);
parent->set_refinement_flag (Elem::INACTIVE);
elem->set_refinement_flag (Elem::JUST_REFINED);
}
#endif
libmesh_assert(elem->n_nodes() == conn_data.size());
// Connect all the nodes to this element
for (unsigned int n=0; n<conn_data.size(); n++)
elem->set_node(n) =
mesh.node_ptr(cast_int<dof_id_type>(conn_data[n]));
mesh.add_elem(elem);
}
}
mesh.set_mesh_dimension(cast_int<unsigned char>(highest_elem_dim));
}
void CheckpointIO::write_connectivity (Xdr & io) const
{
libmesh_assert (io.writing());
// convenient reference to our mesh
const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
// We will only write active elements and their parents.
unsigned int n_active_levels = n_active_levels_on_processor(mesh);
std::vector<xdr_id_type> n_elem_at_level(n_active_levels);
// Find the number of elements at each level
for (unsigned int level=0; level<n_active_levels; level++)
{
MeshBase::const_element_iterator it = mesh.level_elements_begin(level);
MeshBase::const_element_iterator end = mesh.level_elements_end(level);
n_elem_at_level[level] = MeshTools::n_elem(it, end);
}
io.data(n_active_levels, "# n_active_levels");
for(unsigned int level=0; level < n_active_levels; level++)
{
std::ostringstream comment;
comment << "# n_elem at level ";
comment << level ;
io.data (n_elem_at_level[level], comment.str().c_str());
MeshBase::const_element_iterator it = mesh.level_elements_begin(level);
MeshBase::const_element_iterator end = mesh.level_elements_end(level);
for (; it != end; ++it)
{
Elem & elem = *(*it);
unsigned int n_nodes = elem.n_nodes();
// id type pid subdomain_id parent_id
std::vector<largest_id_type> elem_data(5);
elem_data[0] = elem.id();
elem_data[1] = elem.type();
elem_data[2] = elem.processor_id();
elem_data[3] = elem.subdomain_id();
if(elem.parent() != libmesh_nullptr)
elem_data[4] = elem.parent()->id();
else
elem_data[4] = DofObject::invalid_processor_id;
std::vector<largest_id_type> conn_data(n_nodes);
for(unsigned int i=0; i<n_nodes; i++)
conn_data[i] = elem.node_id(i);
io.data_stream(&elem_data[0],
cast_int<unsigned int>(elem_data.size()),
cast_int<unsigned int>(elem_data.size()));
#ifdef LIBMESH_ENABLE_UNIQUE_ID
largest_id_type unique_id = elem.unique_id();
io.data(unique_id, "# unique id");
#endif
#ifdef LIBMESH_ENABLE_AMR
unsigned int p_level = elem.p_level();
io.data(p_level, "# p_level");
#endif
io.data_stream(&conn_data[0],
cast_int<unsigned int>(conn_data.size()),
cast_int<unsigned int>(conn_data.size()));
}
}
}
