Skip to content

Commit

Permalink
STK: Snapshot 10-07-24 12:22 from Sierra 5.21.5-699-g38edc8e6
Browse files Browse the repository at this point in the history
  • Loading branch information
@hpacella
hpacella committed Oct 7, 2024
1 parent 4734595 commit f6f55b7
Show file tree
Hide file tree
Showing 21 changed files with 326 additions and 298 deletions.
3 changes: 3 additions & 0 deletions packages/stk/CHANGELOG.md
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,8 @@
# CHANGELOG

5.21.5-2 (STK_VERSION 5210502) 10/07/2024
stk_search: Fixed HIP sort error.
stk_mesh: add multi-field NGP-FieldBLAS field_fill
5.21.5-1 (STK_VERSION 5210501) 9/27/2024
stk_mesh: deprecate BulkData::relation_exist

Expand Down
4 changes: 4 additions & 0 deletions packages/stk/stk_coupling/stk_coupling/Constants.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,10 @@ static const std::string TimeStep = "Time Step";
static const std::string FinalTime = "Final Time";
static const std::string IsFinished = "Is Finished";
static const std::string SuccessFlag = "Is Successful";
static const std::string GlobalVars = "Global Vars";
static const std::string CouplingVersion = "CouplingVersion";
static const std::string ConvergenceStatus = "iteration_convergence_status";
static const std::string StepContinuationStatus = "solve_step_continuation_status";
//ENDCouplingReservedNames

}
Expand Down
1 change: 0 additions & 1 deletion packages/stk/stk_io/stk_io/OutputFile.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -213,7 +213,6 @@ class OutputFile
void has_adaptivity(bool hasAdaptivity);

bool is_skin_mesh() const;
void is_skin_mesh(bool skinMesh);

void set_enable_edge_io(bool enableEdgeIO);

Expand Down
6 changes: 0 additions & 6 deletions packages/stk/stk_io/stk_io/StkMeshIoBroker.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -159,7 +159,6 @@ namespace stk {

void set_ghosting_filter(size_t output_file_index, bool hasGhosting);
void set_adaptivity_filter(size_t output_file_index, bool hasAdaptivity);
void set_skin_mesh_flag(size_t output_file_index, bool skinMesh);

void set_filter_empty_output_entity_blocks(size_t output_file_index, const bool filterEmptyEntityBlocks);
void set_filter_empty_output_assembly_entity_blocks(size_t output_file_index, const bool filterEmptyAssemblyEntityBlocks);
Expand Down Expand Up @@ -853,11 +852,6 @@ namespace stk {
m_outputFiles[output_file_index]->has_adaptivity(hasAdaptivity);
}

inline void StkMeshIoBroker::set_skin_mesh_flag(size_t output_file_index, bool skinMesh) {
validate_output_file_index(output_file_index);
m_outputFiles[output_file_index]->is_skin_mesh(skinMesh);
}

inline void StkMeshIoBroker::set_filter_empty_output_entity_blocks(size_t output_file_index, const bool filterEmptyEntityBlocks) {
validate_output_file_index(output_file_index);
m_outputFiles[output_file_index]->set_filter_empty_entity_blocks(filterEmptyEntityBlocks);
Expand Down
23 changes: 3 additions & 20 deletions packages/stk/stk_mesh/stk_mesh/baseImpl/NgpFieldBLASImpl.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -288,21 +288,8 @@ void field_fill_impl(const Scalar alpha,
}
}
else {
stk::mesh::HostMesh hostMesh(fields[0]->get_mesh());
if (nfields == 1)
{
stk::mesh::HostField<Scalar> ngpField(fields[0]->get_mesh(), *fields[0]);
field_fill_for_each_entity(hostMesh, &ngpField, nfields, alpha, component, fieldSelector, execSpace);
} else
{
std::vector<stk::mesh::HostField<Scalar>> ngpFields;
for (int i=0; i < nfields; ++i)
{
ngpFields.emplace_back(fields[i]->get_mesh(), *fields[i]);

}
field_fill_for_each_entity(hostMesh, ngpFields.data(), nfields, alpha, component, fieldSelector, execSpace);
}
std::vector<const stk::mesh::FieldBase*> fieldsVec(fields, fields+nfields);
stk::mesh::field_fill(alpha, fieldsVec, fieldSelector);
}

for (int i=0; i < nfields; ++i)
Expand Down Expand Up @@ -348,11 +335,7 @@ void field_copy_no_mark_t(const stk::mesh::FieldBase& xField,
}
else {
xField.sync_to_host();
stk::mesh::HostField<Scalar> hostX(xField.get_mesh(), xField);
stk::mesh::HostField<Scalar> hostY(yField.get_mesh(), yField);
stk::mesh::HostMesh hostMesh(xField.get_mesh());
FieldCopy<stk::mesh::HostField<Scalar>> fieldCopy(hostX, hostY);
stk::mesh::for_each_entity_run(hostMesh, xField.entity_rank(), selector, fieldCopy);
stk::mesh::field_copy(xField, yField, selector);
}
}

Expand Down
241 changes: 0 additions & 241 deletions packages/stk/stk_mesh/stk_mesh/baseImpl/elementGraph/ElemElemGraph.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -680,247 +680,6 @@ stk::topology ElemElemGraph::get_topology_of_connected_element(const GraphEdge &
return m_element_topologies[graphEdge.elem2()];
}

void report_error_with_invalid_ordinal(std::pair<stk::mesh::ConnectivityOrdinal, stk::mesh::Permutation> ord_and_perm, const stk::mesh::BulkData& bulkData, const stk::mesh::EntityVector& side_nodes_vec,
stk::mesh::Entity element_with_perm_0, stk::mesh::Entity element_with_perm_4)
{
if(ord_and_perm.first == stk::mesh::INVALID_CONNECTIVITY_ORDINAL)
{
std::ostringstream os;
os << "Proc: " << bulkData.parallel_rank() << std::endl;
os << "this element: " << bulkData.identifier(element_with_perm_0) << std::endl;
os << "other element: " << bulkData.identifier(element_with_perm_4) << std::endl;
os << "Nodes: ";

for(stk::mesh::Entity side_node : side_nodes_vec)
{
os << bulkData.identifier(side_node) << " ";
}

os << std::endl;
std::cerr << os.str();
}

STK_ThrowRequireMsg(ord_and_perm.first != stk::mesh::INVALID_CONNECTIVITY_ORDINAL, "yikes!");
STK_ThrowRequireMsg(ord_and_perm.second != stk::mesh::INVALID_PERMUTATION, "yikes!");
}

void ensure_fresh_modifiable_state(stk::mesh::BulkData& bulkData)
{
if(bulkData.in_modifiable_state()) {
bulkData.modification_end();
}
bulkData.modification_begin();
}

class RemoteDeathBoundary
{
public:
RemoteDeathBoundary(stk::mesh::BulkData& bulkData, ElemElemGraph& elementGraph,
const stk::mesh::EntityVector& killedElements, const stk::mesh::PartVector& parts_for_creating_side, stk::mesh::Part& active, const stk::mesh::PartVector* boundary_mesh_parts) :
m_bulkData(bulkData), m_elementGraph(elementGraph), m_killedElements(killedElements), m_parts_for_creating_side(parts_for_creating_side), m_active(active),
m_boundary_mesh_parts(boundary_mesh_parts), m_topology_modified(false)
{}
~RemoteDeathBoundary(){}

void update_death_boundary_for_remotely_killed_elements(std::vector<stk::mesh::sharing_info> &shared_modified,
stk::mesh::EntityVector& deletedEntities,
stk::mesh::impl::ParallelSelectedInfo &remoteActiveSelector)
{
std::vector<impl::GraphEdgeProc> remote_edges = get_remote_edges();

for(impl::GraphEdgeProc& re : remote_edges)
{
stk::mesh::EntityId local_id = re.get_local_element_global_id();
int local_side = re.get_local_element_side_index();
stk::mesh::EntityId remote_id = re.get_remote_element_global_id();
int remote_side = re.get_remote_element_side_index();

stk::mesh::Entity element = m_bulkData.get_entity(stk::topology::ELEM_RANK, local_id);

impl::ParallelInfo &parallel_edge_info = m_elementGraph.get_parallel_edge_info(element, local_side, remote_id, remote_side);
remoteActiveSelector[-remote_id] = false;

m_topology_modified = true;

bool create_side = m_bulkData.bucket(element).member(m_active);
if(create_side==true)
{
impl::add_side_into_exposed_boundary(m_bulkData,
parallel_edge_info,
element,
local_side,
remote_id,
m_parts_for_creating_side,
shared_modified,
remoteActiveSelector,
m_boundary_mesh_parts);
}
else
{
impl::remove_side_from_death_boundary(m_bulkData, element, m_active, deletedEntities, local_side);
}
}
}

void set_topology_is_modified()
{
m_topology_modified = true;
}

bool get_topology_modification_status() const
{
return m_topology_modified;
}

private:

std::vector<impl::GraphEdgeProc> get_remote_edges() const
{
std::vector<impl::GraphEdgeProc> elements_to_comm = get_elements_to_communicate();
return impl::communicate_killed_entities(m_bulkData.parallel(), elements_to_comm);
}

std::vector<impl::GraphEdgeProc> get_elements_to_communicate() const
{
std::vector<impl::GraphEdgeProc> elements_to_comm;

for(stk::mesh::Entity this_element :m_killedElements)
{
for(size_t j=0;j<m_elementGraph.get_num_connected_elems(this_element);++j)
{
if(impl::does_element_have_side(m_bulkData, this_element) && !m_elementGraph.is_connected_elem_locally_owned(this_element, j))
{
impl::IdViaSidePair idViaSidePair = m_elementGraph.get_connected_remote_id_and_via_side(this_element,j);
stk::mesh::EntityId other_element_id = idViaSidePair.id;
int side1 = idViaSidePair.side;
int side2 = m_elementGraph.get_connected_elements_side(this_element,j);
int other_proc = m_elementGraph.get_owning_proc_id_of_remote_element(this_element, j);
elements_to_comm.push_back(impl::GraphEdgeProc(m_bulkData.identifier(this_element), side1, other_element_id, side2, other_proc));
}
}
}

return elements_to_comm;
}

stk::mesh::BulkData& m_bulkData;
ElemElemGraph& m_elementGraph;
const stk::mesh::EntityVector& m_killedElements;
const stk::mesh::PartVector& m_parts_for_creating_side;
stk::mesh::Part& m_active;
const stk::mesh::PartVector* m_boundary_mesh_parts;
bool m_topology_modified;
};


bool process_killed_elements(stk::mesh::BulkData& bulkData,
const stk::mesh::EntityVector& killedElements,
stk::mesh::Part& active,
stk::mesh::impl::ParallelSelectedInfo &remoteActiveSelector,
const stk::mesh::PartVector& parts_for_creating_side,
const stk::mesh::PartVector* boundary_mesh_parts,
stk::mesh::ModEndOptimizationFlag modEndOpt)
{
ensure_fresh_modifiable_state(bulkData);
bulkData.m_bucket_repository.set_remove_mode_tracking();
impl::create_sides_created_during_death_part(bulkData.mesh_meta_data());

std::vector<stk::mesh::sharing_info> shared_modified;
stk::mesh::EntityVector deletedEntities;

bulkData.initialize_face_adjacent_element_graph();
ElemElemGraph& elementGraph = bulkData.get_face_adjacent_element_graph();

RemoteDeathBoundary remote_death_boundary(bulkData, elementGraph, killedElements, parts_for_creating_side, active, boundary_mesh_parts);
remote_death_boundary.update_death_boundary_for_remotely_killed_elements(shared_modified, deletedEntities, remoteActiveSelector);

std::vector<impl::ElementSidePair> element_side_pairs;
element_side_pairs.reserve(impl::get_element_side_multiplier() * killedElements.size());

for(size_t k = 0; k < killedElements.size(); ++k)
{
stk::mesh::Entity this_element = killedElements[k];

for(size_t j = 0; j < elementGraph.get_num_connected_elems(this_element); ++j)
{
if(impl::does_element_have_side(bulkData, this_element))
{
remote_death_boundary.set_topology_is_modified();
if(elementGraph.is_connected_elem_locally_owned(this_element, j))
{
impl::ElementViaSidePair other_element_via_side = elementGraph.get_connected_element_and_via_side(this_element, j);
stk::mesh::Entity other_element = other_element_via_side.element;
if(impl::does_element_have_side(bulkData, other_element_via_side.element))
{
int side_id = other_element_via_side.side;
STK_ThrowRequireWithSierraHelpMsg(side_id != -1);

bool is_other_element_alive = bulkData.bucket(other_element).member(active);
if(is_other_element_alive)
{
stk::mesh::Entity side = stk::mesh::get_side_entity_for_elem_side_pair(bulkData, this_element, side_id);

if(bulkData.is_valid(side))
{
if(bulkData.bucket(side).owned())
{
stk::mesh::ConstPartVector parts = impl::get_stk_parts_for_moving_parts_into_death_boundary(boundary_mesh_parts);
bulkData.change_entity_parts(side, parts);
}
}
else
{
stk::mesh::PartVector parts = impl::get_parts_for_creating_side(bulkData, parts_for_creating_side, other_element, side_id);

// switch elements
stk::mesh::Entity element_with_perm_0 = other_element;
stk::mesh::Entity element_with_perm_4 = this_element;

int side_id_needed = elementGraph.get_connected_elements_side(this_element, j);

STK_ThrowRequireMsg(side_id_needed >= 0, "ERROR: proc " << bulkData.parallel_rank() << " found side_id_needed=" << side_id_needed
<< " between elem " << bulkData.identifier(element_with_perm_0)<< " and " << bulkData.identifier(element_with_perm_4)
<< " in elem-elem-graph");

side = bulkData.declare_element_side(element_with_perm_0, side_id_needed, parts);
}
}
else
{
impl::remove_side_from_death_boundary(bulkData, this_element, active, deletedEntities, side_id);
}
}
}
else
{
impl::IdViaSidePair remote_id_side_pair = elementGraph.get_connected_remote_id_and_via_side(this_element, j);
stk::mesh::EntityId remote_id = remote_id_side_pair.id;
int remote_side = elementGraph.get_connected_elements_side(this_element, j);
impl::ParallelInfo &parallel_edge_info = elementGraph.get_parallel_edge_info(this_element, remote_id_side_pair.side, remote_id, remote_side);
bool other_element_active = remoteActiveSelector[-remote_id];
bool create_side = other_element_active;

if(create_side)
{
impl::add_side_into_exposed_boundary(bulkData, parallel_edge_info, this_element, remote_id_side_pair.side, remote_id, parts_for_creating_side,
shared_modified, remoteActiveSelector, boundary_mesh_parts);
}
else
{
int side_id = remote_id_side_pair.side;
STK_ThrowRequireWithSierraHelpMsg(side_id != -1);
impl::remove_side_from_death_boundary(bulkData, this_element, active, deletedEntities, side_id);
}
}
}
}
}
stk::mesh::impl::delete_entities_and_upward_relations(bulkData, deletedEntities);
bulkData.make_mesh_parallel_consistent_after_element_death(shared_modified, deletedEntities, elementGraph, killedElements, active, modEndOpt);
bulkData.m_bucket_repository.set_remove_mode_fill_and_sort();
return remote_death_boundary.get_topology_modification_status();
}

stk::mesh::SideIdChooser ElemElemGraph::get_side_id_chooser()
{
return stk::mesh::SideIdChooser(m_bulk_data, m_idMapper, m_graph, m_coincidentGraph);
Expand Down
8 changes: 0 additions & 8 deletions packages/stk/stk_mesh/stk_mesh/baseImpl/elementGraph/ElemElemGraph.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -350,14 +350,6 @@ class ElemElemGraph
std::string print_edge(const GraphEdge& graphEdge);
};

bool process_killed_elements(stk::mesh::BulkData& bulkData,
const stk::mesh::EntityVector& killedElements,
stk::mesh::Part& active,
stk::mesh::impl::ParallelSelectedInfo &remoteActiveSelector,
const stk::mesh::PartVector& side_parts,
const stk::mesh::PartVector* boundary_mesh_parts = nullptr,
stk::mesh::ModEndOptimizationFlag modEndOpt = stk::mesh::ModEndOptimizationFlag::MOD_END_SORT);

namespace impl
{

Expand Down
Loading

0 comments on commit f6f55b7

Please sign in to comment.