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

STK: Snapshot 10-07-24 12:22 from Sierra 5.21.5-699-g38edc8e6 #13506

Merged
merged 1 commit into from
Oct 7, 2024
Merged

STK: Snapshot 10-07-24 12:22 from Sierra 5.21.5-699-g38edc8e6 #13506

Show file tree
Hide file tree
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
3 changes: 3 additions & 0 deletions packages/stk/CHANGELOG.md
View file
Open in desktop
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
Open in desktop
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
Open in desktop
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
Open in desktop
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
Open in desktop
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
Open in desktop
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
Open in desktop
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
Loading