43#include <PanzerAdaptersSTK_config.hpp>
46#include <Teuchos_as.hpp>
50#include <stk_mesh/base/FieldBase.hpp>
51#include <stk_mesh/base/Comm.hpp>
52#include <stk_mesh/base/Selector.hpp>
53#include <stk_mesh/base/GetEntities.hpp>
54#include <stk_mesh/base/GetBuckets.hpp>
55#include <stk_mesh/base/MeshBuilder.hpp>
56#include <stk_mesh/base/CreateAdjacentEntities.hpp>
63#include <stk_util/parallel/ParallelReduce.hpp>
64#include <stk_util/parallel/CommSparse.hpp>
66#ifdef PANZER_HAVE_IOSS
67#include <Ionit_Initializer.h>
68#include <stk_io/IossBridge.hpp>
69#include <stk_io/WriteMesh.hpp>
72#ifdef PANZER_HAVE_PERCEPT
73#include <percept/PerceptMesh.hpp>
74#include <adapt/UniformRefinerPattern.hpp>
75#include <adapt/UniformRefiner.hpp>
89 : gid_(gid), nodes_(nodes) {}
94Teuchos::RCP<ElementDescriptor>
108 : dimension_(0), initialized_(false), currentLocalId_(0), initialStateTime_(0.0), currentStateTime_(0.0), useFieldCoordinates_(false)
110 metaData_ = rcp(
new stk::mesh::MetaData());
114 : dimension_(0), initialized_(false), currentLocalId_(0), initialStateTime_(0.0), currentStateTime_(0.0), useFieldCoordinates_(false)
120 : dimension_(dim), initialized_(false), currentLocalId_(0), useFieldCoordinates_(false)
122 std::vector<std::string> entity_rank_names = stk::mesh::entity_rank_names();
123 entity_rank_names.push_back(
"FAMILY_TREE");
135 stk::mesh::Part * sideset =
metaData_->get_part(name);
137 sideset = &
metaData_->declare_part_with_topology(name,
138 stk::mesh::get_topology(shards::CellTopology(ctData),
dimension_));
139 sidesets_.insert(std::make_pair(name,sideset));
147 stk::mesh::Part * nodeset =
metaData_->get_part(name);
148 if(nodeset==
nullptr) {
149 const CellTopologyData * ctData = shards::getCellTopologyData<shards::Node>();
150 nodeset = &
metaData_->declare_part_with_topology(name,
151 stk::mesh::get_topology(shards::CellTopology(ctData),
dimension_));
153 nodesets_.insert(std::make_pair(name,nodeset));
159 "Unknown element block \"" << blockId <<
"\"");
160 std::pair<std::string,std::string> key = std::make_pair(fieldName,blockId);
169 stk::mesh::FieldTraits<SolutionFieldType>::data_type* init_sol =
nullptr;
170 stk::mesh::put_field_on_mesh(*
field,
metaData_->universal_part(),init_sol );
179 "Unknown element block \"" << blockId <<
"\"");
180 std::pair<std::string,std::string> key = std::make_pair(fieldName,blockId);
190 stk::mesh::FieldTraits<SolutionFieldType>::data_type* init_sol =
nullptr;
191 stk::mesh::put_field_on_mesh(*
field,
metaData_->universal_part(),init_sol );
200 "Unknown element block \"" << blockId <<
"\"");
201 std::pair<std::string,std::string> key = std::make_pair(fieldName,blockId);
212 stk::mesh::FieldTraits<SolutionFieldType>::data_type* init_sol =
nullptr;
213 stk::mesh::put_field_on_mesh(*
field,
metaData_->universal_part(),init_sol );
222 "Unknown element block \"" << blockId <<
"\"");
223 std::pair<std::string,std::string> key = std::make_pair(fieldName,blockId);
234 stk::mesh::FieldTraits<SolutionFieldType>::data_type* init_sol =
nullptr;
235 stk::mesh::put_field_on_mesh(*
field,
metaData_->universal_part(),init_sol );
242 const std::vector<std::string> & coordNames,
243 const std::string & dispPrefix)
246 TEUCHOS_ASSERT(
dimension_==coordNames.size());
249 "Unknown element block \"" << blockId <<
"\"");
253 "STK_Interface::addMeshCoordFields: Can't set more than one set of coordinate "
254 "fields for element block \""+blockId+
"\".");
267 std::pair<std::string,std::string> key = std::make_pair(coordNames[i],blockId);
268 std::string dispName = dispPrefix+coordNames[i];
270 dispFields[i] = dispName;
291 const bool buildRefinementSupport)
302 stk::mesh::FieldTraits<VectorFieldType>::data_type* init_vf =
nullptr;
303 stk::mesh::FieldTraits<ProcIdFieldType>::data_type* init_pid =
nullptr;
304 stk::mesh::FieldTraits<SolutionFieldType>::data_type* init_sol =
nullptr;
317#ifdef PANZER_HAVE_IOSS
324 std::map<std::string, stk::mesh::Part*>::iterator itr;
326 if(!stk::io::is_part_io_part(*itr->second))
327 stk::io::put_io_part_attribute(*itr->second);
332 std::map<std::string, stk::mesh::Part*>::iterator itr;
334 if(!stk::io::is_part_edge_block_io_part(*itr->second))
335 stk::io::put_edge_block_io_part_attribute(*itr->second);
340 std::map<std::string, stk::mesh::Part*>::iterator itr;
342 if(!stk::io::is_part_face_block_io_part(*itr->second))
343 stk::io::put_face_block_io_part_attribute(*itr->second);
348 std::map<std::string, stk::mesh::Part*>::iterator itr;
350 if(!stk::io::is_part_io_part(*itr->second))
351 stk::io::put_io_part_attribute(*itr->second);
356 std::map<std::string, stk::mesh::Part*>::iterator itr;
358 if(!stk::io::is_part_io_part(*itr->second))
359 stk::io::put_io_part_attribute(*itr->second);
367 stk::io::set_field_role(*
edgesField_, Ioss::Field::MESH);
369 stk::io::set_field_role(*
facesField_, Ioss::Field::MESH);
375 if (buildRefinementSupport) {
376#ifdef PANZER_HAVE_PERCEPT
377 refinedMesh_ = Teuchos::rcp(
new percept::PerceptMesh(this->
getMetaData().get(),
381 breakPattern_ = Teuchos::rcp(
new percept::URP_Heterogeneous_3D(*refinedMesh_));
383 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
384 "ERROR: Uniform refinement requested. This requires the Percept package to be enabled in Trilinos!");
399 std::set<SolutionFieldType*> uniqueFields;
400 std::map<std::pair<std::string,std::string>,
SolutionFieldType*>::const_iterator fieldIter;
401 for(fieldIter=nameToField.begin();fieldIter!=nameToField.end();++fieldIter)
402 uniqueFields.insert(fieldIter->second);
405 std::set<SolutionFieldType*>::const_iterator uniqueFieldIter;
406 stk::mesh::FieldTraits<SolutionFieldType>::data_type* init_sol =
nullptr;
407 for(uniqueFieldIter=uniqueFields.begin();uniqueFieldIter!=uniqueFields.end();++uniqueFieldIter)
408 stk::mesh::put_field_on_mesh(*(*uniqueFieldIter),
metaData_->universal_part(),init_sol);
411#ifdef PANZER_HAVE_IOSS
414 std::set<SolutionFieldType*>::const_iterator uniqueFieldIter;
415 for(uniqueFieldIter=uniqueFields.begin();uniqueFieldIter!=uniqueFields.end();++uniqueFieldIter)
416 stk::io::set_field_role(*(*uniqueFieldIter), Ioss::Field::TRANSIENT);
423 TEUCHOS_ASSERT(
bulkData_==Teuchos::null);
427 std::unique_ptr<stk::mesh::BulkData> bulkUPtr = stk::mesh::MeshBuilder(*
mpiComm_->getRawMpiComm()).create(Teuchos::get_shared_ptr(
metaData_));
433 TEUCHOS_TEST_FOR_EXCEPTION(
bulkData_==Teuchos::null,std::logic_error,
434 "STK_Interface: Must call \"initialized\" or \"instantiateBulkData\" before \"beginModification\"");
441 TEUCHOS_TEST_FOR_EXCEPTION(
bulkData_==Teuchos::null,std::logic_error,
442 "STK_Interface: Must call \"initialized\" or \"instantiateBulkData\" before \"endModification\"");
449 stk::CommSparse comm(
bulkData_->parallel());
451 for (
int phase=0;phase<2;++phase) {
452 for (
int i=0;i<
bulkData_->parallel_size();++i) {
454 const stk::mesh::BucketVector& buckets =
bulkData_->buckets(stk::topology::NODE_RANK);
455 for (
size_t j=0;j<buckets.size();++j) {
456 const stk::mesh::Bucket& bucket = *buckets[j];
457 if ( bucket.owned() ) {
458 for (
size_t k=0;k<bucket.size();++k) {
459 stk::mesh::EntityKey key =
bulkData_->entity_key(bucket[k]);
460 comm.send_buffer(i).pack<stk::mesh::EntityKey>(key);
468 comm.allocate_buffers();
475 for (
int i=0;i<
bulkData_->parallel_size();++i) {
477 while(comm.recv_buffer(i).remaining()) {
478 stk::mesh::EntityKey key;
479 comm.recv_buffer(i).unpack<stk::mesh::EntityKey>(key);
480 stk::mesh::Entity node =
bulkData_->get_entity(key);
497 TEUCHOS_TEST_FOR_EXCEPTION(not
isModifiable(),std::logic_error,
498 "STK_Interface::addNode: STK_Interface must be modifiable to add a node");
499 TEUCHOS_TEST_FOR_EXCEPTION(coord.size()!=
getDimension(),std::logic_error,
500 "STK_Interface::addNode: number of coordinates in vector must mation dimension");
501 TEUCHOS_TEST_FOR_EXCEPTION(gid==0,std::logic_error,
502 "STK_Interface::addNode: STK has STUPID restriction of no zero GIDs, pick something else");
509 for(std::size_t i=0;i<coord.size();++i)
510 fieldCoords[i] = coord[i];
515 std::vector<stk::mesh::Part*> sidesetV;
516 sidesetV.push_back(sideset);
518 bulkData_->change_entity_parts(entity,sidesetV);
523 std::vector<stk::mesh::Part*> nodesetV;
524 nodesetV.push_back(nodeset);
526 bulkData_->change_entity_parts(entity,nodesetV);
531 std::vector<stk::mesh::Part*> edgeblockV;
532 edgeblockV.push_back(edgeblock);
534 bulkData_->change_entity_parts(entity,edgeblockV);
538 if (entities.size() > 0) {
539 std::vector<stk::mesh::Part*> edgeblockV;
540 edgeblockV.push_back(edgeblock);
542 bulkData_->change_entity_parts(entities,edgeblockV);
548 std::vector<stk::mesh::Part*> faceblockV;
549 faceblockV.push_back(faceblock);
551 bulkData_->change_entity_parts(entity,faceblockV);
555 if (entities.size() > 0) {
556 std::vector<stk::mesh::Part*> faceblockV;
557 faceblockV.push_back(faceblock);
559 bulkData_->change_entity_parts(entities,faceblockV);
565 std::vector<stk::mesh::Part*> blockVec;
566 blockVec.push_back(block);
570 stk::mesh::Entity element =
bulkData_->declare_entity(elementRank,ed->getGID(),blockVec);
573 const std::vector<stk::mesh::EntityId> & nodes = ed->getNodes();
574 for(std::size_t i=0;i<nodes.size();++i) {
576 stk::mesh::Entity node =
bulkData_->get_entity(nodeRank,nodes[i]);
577 TEUCHOS_ASSERT(
bulkData_->is_valid(node));
578 bulkData_->declare_relation(element,node,i);
582 procId[0] = Teuchos::as<ProcIdData>(
procRank_);
590 std::vector<stk::mesh::Entity> localElmts;
592 std::vector<stk::mesh::Entity>::const_iterator itr;
593 for(itr=localElmts.begin();itr!=localElmts.end();++itr) {
594 stk::mesh::Entity element = (*itr);
595 stk::mesh::EntityId gid =
bulkData_->identifier(element);
596 std::vector<stk::mesh::EntityId> subcellIds;
599 for(std::size_t i=0;i<subcellIds.size();++i) {
600 stk::mesh::Entity edge =
bulkData_->get_entity(edgeRank,subcellIds[i]);
601 stk::mesh::Entity
const* relations =
bulkData_->begin_nodes(edge);
607 double * edgeCoords = stk::mesh::field_data(*
edgesField_,edge);
609 edgeCoords[j] = (node_coord_1[j]+node_coord_2[j])/2.0;
618 std::vector<stk::mesh::Entity> localElmts;
620 std::vector<stk::mesh::Entity>::const_iterator itr;
621 for(itr=localElmts.begin();itr!=localElmts.end();++itr) {
622 stk::mesh::Entity element = (*itr);
624 std::vector<stk::mesh::EntityId> subcellIds;
627 for(std::size_t i=0;i<subcellIds.size();++i) {
628 stk::mesh::Entity face =
bulkData_->get_entity(faceRank,subcellIds[i]);
629 stk::mesh::Entity
const* relations =
bulkData_->begin_nodes(face);
630 const size_t num_relations =
bulkData_->num_nodes(face);
633 double * faceCoords = stk::mesh::field_data(*
facesField_,face);
636 for(std::size_t k=0;k<num_relations;++k)
638 faceCoords[j] /= double(num_relations);
646 const size_t num_rels =
bulkData_->num_connectivity(src, tgt_rank);
647 stk::mesh::Entity
const* relations =
bulkData_->begin(src, tgt_rank);
648 stk::mesh::ConnectivityOrdinal
const* ordinals =
bulkData_->begin_ordinals(src, tgt_rank);
649 for (
size_t i = 0; i < num_rels; ++i) {
650 if (ordinals[i] ==
static_cast<stk::mesh::ConnectivityOrdinal
>(rel_id)) {
655 return stk::mesh::Entity();
681 const bool append_after_restart_time,
682 const double restart_time)
684 using std::runtime_error;
685 using stk::io::StkMeshIoBroker;
686 using stk::mesh::FieldVector;
687 using stk::ParallelMachine;
689 PANZER_FUNC_TIME_MONITOR(
"STK_Interface::setupExodusFile(filename)");
690#ifdef PANZER_HAVE_IOSS
691 TEUCHOS_ASSERT(not
mpiComm_.is_null())
693 ParallelMachine comm = *
mpiComm_->getRawMpiComm();
694 meshData_ = rcp(
new StkMeshIoBroker(comm));
695 meshData_->set_bulk_data(Teuchos::get_shared_ptr(
bulkData_));
696 Ioss::PropertyManager props;
697 props.add(Ioss::Property(
"LOWER_CASE_VARIABLE_NAMES",
"FALSE"));
699 if (append_after_restart_time) {
700 meshIndex_ = meshData_->create_output_mesh(filename, stk::io::APPEND_RESULTS,
701 props, restart_time);
704 meshIndex_ = meshData_->create_output_mesh(filename, stk::io::APPEND_RESULTS, props);
707 meshIndex_ = meshData_->create_output_mesh(filename, stk::io::WRITE_RESULTS, props);
708 const FieldVector& fields =
metaData_->get_fields();
709 for (
size_t i(0); i < fields.size(); ++i) {
715 auto role = stk::io::get_field_role(*fields[i]);
716 if (role !=
nullptr) {
717 if (*role != Ioss::Field::MESH)
718 meshData_->add_field(meshIndex_, *fields[i]);
720 meshData_->add_field(meshIndex_, *fields[i]);
726 meshData_->add_info_records(meshIndex_, deduped_info_records);
728 TEUCHOS_ASSERT(
false)
744 using Teuchos::FancyOStream;
745 using Teuchos::rcpFromRef;
746 PANZER_FUNC_TIME_MONITOR(
"STK_Interface::writeToExodus(timestep)");
747#ifdef PANZER_HAVE_IOSS
748 if (not meshData_.is_null())
751 globalToExodus(GlobalVariable::ADD);
753 meshData_->write_defined_output_fields(meshIndex_);
754 globalToExodus(GlobalVariable::WRITE);
755 meshData_->end_output_step(meshIndex_);
759 FancyOStream out(rcpFromRef(cout));
760 out.setOutputToRootOnly(0);
761 out <<
"WARNING: Exodus I/O has been disabled or not setup properly; "
762 <<
"not writing to Exodus." << endl;
765 TEUCHOS_ASSERT(
false);
777 const GlobalVariable& flag)
779 using std::invalid_argument;
781 using Teuchos::Array;
786 for (
auto i = globalData_.begin(); i != globalData_.end(); ++i)
788 const string& name = globalData_.name(i);
791 if (globalData_.isType<
int>(name))
793 const auto& value = globalData_.get<
int>(name);
794 if (flag == GlobalVariable::ADD)
798 meshData_->add_global(meshIndex_, name, value,
799 stk::util::ParameterType::INTEGER);
807 meshData_->write_global(meshIndex_, name, value,
808 stk::util::ParameterType::INTEGER);
812 else if (globalData_.isType<
double>(name))
814 const auto& value = globalData_.get<
double>(name);
815 if (flag == GlobalVariable::ADD)
819 meshData_->add_global(meshIndex_, name, value,
820 stk::util::ParameterType::DOUBLE);
828 meshData_->write_global(meshIndex_, name, value,
829 stk::util::ParameterType::DOUBLE);
833 else if (globalData_.isType<Array<int>>(name))
835 const auto& value = globalData_.get<Array<int>>(name).toVector();
836 if (flag == GlobalVariable::ADD)
840 meshData_->add_global(meshIndex_, name, value,
841 stk::util::ParameterType::INTEGERVECTOR);
849 meshData_->write_global(meshIndex_, name, value,
850 stk::util::ParameterType::INTEGERVECTOR);
854 else if (globalData_.isType<Array<double>>(name))
856 const auto& value = globalData_.get<Array<double>>(name).toVector();
857 if (flag == GlobalVariable::ADD)
861 meshData_->add_global(meshIndex_, name, value,
862 stk::util::ParameterType::DOUBLEVECTOR);
870 meshData_->write_global(meshIndex_, name, value,
871 stk::util::ParameterType::DOUBLEVECTOR);
876 TEUCHOS_TEST_FOR_EXCEPTION(
true, invalid_argument,
877 "STK_Interface::globalToExodus(): The global variable to be added " \
878 "to the Exodus output file is of an invalid type. Valid types are " \
879 "int and double, along with std::vectors of those types.")
891 const std::string& key,
894 globalData_.set(key, value);
905 const std::string& key,
908 globalData_.set(key, value);
919 const std::string& key,
920 const std::vector<int>& value)
922 using Teuchos::Array;
923 globalData_.set(key, Array<int>(value));
934 const std::string& key,
935 const std::vector<double>& value)
937 using Teuchos::Array;
938 globalData_.set(key, Array<double>(value));
943 #ifdef PANZER_HAVE_IOSS
955 stk::mesh::Entity node =
bulkData_->get_entity(nodeRank,nodeId);
956 const size_t numElements =
bulkData_->num_elements(node);
957 stk::mesh::Entity
const* relations =
bulkData_->begin_elements(node);
960 elements.insert(elements.end(), relations, relations + numElements);
964 std::vector<int> & relIds)
const
967 const size_t numElements =
bulkData_->num_elements(node);
968 stk::mesh::Entity
const* relations =
bulkData_->begin_elements(node);
969 stk::mesh::ConnectivityOrdinal
const* rel_ids =
bulkData_->begin_element_ordinals(node);
972 for (
size_t i = 0; i < numElements; ++i) {
973 stk::mesh::Entity element = relations[i];
977 elements.push_back(element);
978 relIds.push_back(rel_ids[i]);
984 std::vector<int> & relIds,
unsigned int matchType)
const
986 stk::mesh::EntityRank rank;
989 else if(matchType == 1)
991 else if(matchType == 2)
994 TEUCHOS_ASSERT(
false);
996 stk::mesh::Entity node =
bulkData_->get_entity(rank,nodeId);
1003 std::vector<stk::mesh::Entity> current;
1006 std::sort(current.begin(),current.end());
1009 for(std::size_t n=1;n<nodeIds.size();++n) {
1011 std::vector<stk::mesh::Entity> nextNode;
1013 std::sort(nextNode.begin(),nextNode.end());
1016 std::vector<stk::mesh::Entity> intersection(std::min(nextNode.size(),current.size()));
1017 std::vector<stk::mesh::Entity>::const_iterator endItr
1018 = std::set_intersection(current.begin(),current.end(),
1019 nextNode.begin(),nextNode.end(),
1020 intersection.begin());
1021 std::size_t newLength = endItr-intersection.begin();
1022 intersection.resize(newLength);
1026 current = intersection;
1035 stk::mesh::Entity
const* nodeRel =
getBulkData()->begin_nodes(element);
1036 const size_t numNodes =
getBulkData()->num_nodes(element);
1038 nodeIds.reserve(numNodes);
1039 for(
size_t i = 0; i < numNodes; ++i) {
1054 const auto entityRankCount =
metaData_->entity_rank_count();
1055 const size_t commCount = 10;
1057 TEUCHOS_ASSERT(entityRankCount<10);
1060 stk::ParallelMachine mach = *
mpiComm_->getRawMpiComm();
1062 std::vector<stk::mesh::EntityId> local(commCount,0);
1065 stk::mesh::Selector ownedPart =
metaData_->locally_owned_part();
1066 for(stk::mesh::EntityRank i=stk::topology::NODE_RANK;
1067 i < static_cast<stk::mesh::EntityRank>(entityRankCount); ++i) {
1068 std::vector<stk::mesh::Entity> entities;
1070 stk::mesh::get_selected_entities(ownedPart,
bulkData_->buckets(i),entities);
1073 std::vector<stk::mesh::Entity>::const_iterator itr;
1074 for(itr=entities.begin();itr!=entities.end();++itr) {
1075 stk::mesh::EntityId
id =
bulkData_->identifier(*itr);
1082 stk::all_reduce(mach,stk::ReduceMax<10>(&local[0]));
1083 maxEntityId_.assign(local.begin(),local.begin()+entityRankCount+1);
1088 TEUCHOS_TEST_FOR_EXCEPTION(entityRank>=
entityCounts_.size(),std::logic_error,
1089 "STK_Interface::getEntityCounts: Entity counts do not include rank: " << entityRank);
1096 TEUCHOS_TEST_FOR_EXCEPTION(entityRank>=
maxEntityId_.size(),std::logic_error,
1097 "STK_Interface::getMaxEntityId: Max entity ids do not include rank: " << entityRank);
1104 stk::mesh::PartVector emptyPartVector;
1105 stk::mesh::create_adjacent_entities(*
bulkData_,emptyPartVector);
1127 std::vector<stk::mesh::EntityId> & subcellIds)
const
1130 stk::mesh::Entity cell =
bulkData_->get_entity(elementRank,elementId);
1132 TEUCHOS_TEST_FOR_EXCEPTION(!
bulkData_->is_valid(cell),std::logic_error,
1133 "STK_Interface::getSubcellIndices: could not find element requested (GID = " << elementId <<
")");
1135 const size_t numSubcells =
bulkData_->num_connectivity(cell,
static_cast<stk::mesh::EntityRank
>(entityRank));
1136 stk::mesh::Entity
const* subcells =
bulkData_->begin(cell,
static_cast<stk::mesh::EntityRank
>(entityRank));
1138 subcellIds.resize(numSubcells,0);
1141 for(
size_t i = 0; i < numSubcells; ++i) {
1142 stk::mesh::Entity subcell = subcells[i];
1143 subcellIds[i] =
bulkData_->identifier(subcell);
1150 stk::mesh::Selector ownedPart =
metaData_->locally_owned_part();
1154 stk::mesh::get_selected_entities(ownedPart,
bulkData_->buckets(elementRank),elements);
1161 TEUCHOS_TEST_FOR_EXCEPTION(elementBlock==0,std::logic_error,
"Could not find element block \"" << blockID <<
"\"");
1165 stk::mesh::Selector ownedBlock =
metaData_->locally_owned_part() & (*elementBlock);
1169 stk::mesh::get_selected_entities(ownedBlock,
bulkData_->buckets(elementRank),elements);
1175 stk::mesh::Selector neighborBlock = (!
metaData_->locally_owned_part());
1179 stk::mesh::get_selected_entities(neighborBlock,
bulkData_->buckets(elementRank),elements);
1186 TEUCHOS_TEST_FOR_EXCEPTION(elementBlock==0,std::logic_error,
"Could not find element block \"" << blockID <<
"\"");
1189 stk::mesh::Selector neighborBlock = (!
metaData_->locally_owned_part()) & (*elementBlock);
1193 stk::mesh::get_selected_entities(neighborBlock,
bulkData_->buckets(elementRank),elements);
1199 stk::mesh::Selector ownedPart =
metaData_->locally_owned_part();
1207 stk::mesh::Part * edgeBlockPart =
getEdgeBlock(edgeBlockName);
1208 TEUCHOS_TEST_FOR_EXCEPTION(edgeBlockPart==0,std::logic_error,
1209 "Unknown edge block \"" << edgeBlockName <<
"\"");
1211 stk::mesh::Selector edge_block = *edgeBlockPart;
1212 stk::mesh::Selector owned_block =
metaData_->locally_owned_part() & edge_block;
1220 stk::mesh::Part * edgeBlockPart =
getEdgeBlock(edgeBlockName);
1223 "Unknown edge block \"" << edgeBlockName <<
"\"");
1225 "Unknown element block \"" << blockName <<
"\"");
1227 stk::mesh::Selector edge_block = *edgeBlockPart;
1228 stk::mesh::Selector element_block = *elmtPart;
1229 stk::mesh::Selector owned_block =
metaData_->locally_owned_part() & element_block & edge_block;
1237 stk::mesh::Part * edgeBlockPart =
getEdgeBlock(edgeBlockName);
1238 TEUCHOS_TEST_FOR_EXCEPTION(edgeBlockPart==0,std::logic_error,
1239 "Unknown edge block \"" << edgeBlockName <<
"\"");
1241 stk::mesh::Selector edge_block = *edgeBlockPart;
1249 stk::mesh::Part * edgeBlockPart =
getEdgeBlock(edgeBlockName);
1252 "Unknown edge block \"" << edgeBlockName <<
"\"");
1254 "Unknown element block \"" << blockName <<
"\"");
1256 stk::mesh::Selector edge_block = *edgeBlockPart;
1257 stk::mesh::Selector element_block = *elmtPart;
1258 stk::mesh::Selector element_edge_block = element_block & edge_block;
1267 stk::mesh::Selector ownedPart =
metaData_->locally_owned_part();
1271 stk::mesh::get_selected_entities(ownedPart,
bulkData_->buckets(faceRank),faces);
1276 stk::mesh::Part * faceBlockPart =
getFaceBlock(faceBlockName);
1277 TEUCHOS_TEST_FOR_EXCEPTION(faceBlockPart==0,std::logic_error,
1278 "Unknown face block \"" << faceBlockName <<
"\"");
1280 stk::mesh::Selector face_block = *faceBlockPart;
1281 stk::mesh::Selector owned_block =
metaData_->locally_owned_part() & face_block;
1289 stk::mesh::Part * faceBlockPart =
getFaceBlock(faceBlockName);
1292 "Unknown face block \"" << faceBlockName <<
"\"");
1294 "Unknown element block \"" << blockName <<
"\"");
1296 stk::mesh::Selector face_block = *faceBlockPart;
1297 stk::mesh::Selector element_block = *elmtPart;
1298 stk::mesh::Selector owned_block =
metaData_->locally_owned_part() & element_block & face_block;
1306 stk::mesh::Part * faceBlockPart =
getFaceBlock(faceBlockName);
1307 TEUCHOS_TEST_FOR_EXCEPTION(faceBlockPart==0,std::logic_error,
1308 "Unknown face block \"" << faceBlockName <<
"\"");
1310 stk::mesh::Selector face_block = *faceBlockPart;
1318 stk::mesh::Part * faceBlockPart =
getFaceBlock(faceBlockName);
1321 "Unknown face block \"" << faceBlockName <<
"\"");
1323 "Unknown element block \"" << blockName <<
"\"");
1325 stk::mesh::Selector face_block = *faceBlockPart;
1326 stk::mesh::Selector element_block = *elmtPart;
1327 stk::mesh::Selector element_face_block = element_block & face_block;
1335 stk::mesh::Part * sidePart =
getSideset(sideName);
1336 TEUCHOS_TEST_FOR_EXCEPTION(sidePart==0,std::logic_error,
1337 "Unknown side set \"" << sideName <<
"\"");
1339 stk::mesh::Selector side = *sidePart;
1340 stk::mesh::Selector ownedBlock =
metaData_->locally_owned_part() & side;
1348 stk::mesh::Part * sidePart =
getSideset(sideName);
1351 "Unknown side set \"" << sideName <<
"\"");
1353 "Unknown element block \"" << blockName <<
"\"");
1355 stk::mesh::Selector side = *sidePart;
1356 stk::mesh::Selector block = *elmtPart;
1357 stk::mesh::Selector ownedBlock =
metaData_->locally_owned_part() & block & side;
1365 stk::mesh::Part * sidePart =
getSideset(sideName);
1366 TEUCHOS_TEST_FOR_EXCEPTION(sidePart==0,std::logic_error,
1367 "Unknown side set \"" << sideName <<
"\"");
1369 stk::mesh::Selector side = *sidePart;
1377 stk::mesh::Part * sidePart =
getSideset(sideName);
1380 "Unknown side set \"" << sideName <<
"\"");
1382 "Unknown element block \"" << blockName <<
"\"");
1384 stk::mesh::Selector side = *sidePart;
1385 stk::mesh::Selector block = *elmtPart;
1386 stk::mesh::Selector sideBlock = block & side;
1394 stk::mesh::Part * nodePart =
getNodeset(nodesetName);
1397 "Unknown node set \"" << nodesetName <<
"\"");
1399 "Unknown element block \"" << blockName <<
"\"");
1401 stk::mesh::Selector nodeset = *nodePart;
1402 stk::mesh::Selector block = *elmtPart;
1403 stk::mesh::Selector ownedBlock =
metaData_->locally_owned_part() & block & nodeset;
1416 std::map<std::string, stk::mesh::Part*>::const_iterator blkItr;
1418 names.push_back(blkItr->first);
1428 std::map<std::string, stk::mesh::Part*>::const_iterator sideItr;
1430 names.push_back(sideItr->first);
1438 std::map<std::string, stk::mesh::Part*>::const_iterator nodeItr;
1440 names.push_back(nodeItr->first);
1448 std::map<std::string, stk::mesh::Part*>::const_iterator edgeBlockItr;
1450 names.push_back(edgeBlockItr->first);
1458 std::map<std::string, stk::mesh::Part*>::const_iterator faceBlockItr;
1460 names.push_back(faceBlockItr->first);
1476 std::unordered_map<stk::mesh::EntityId,std::size_t>::const_iterator itr =
localIDHash_.find(gid);
1488 std::unordered_map<stk::mesh::EntityId,std::size_t>::const_iterator itr =
localEdgeIDHash_.find(gid);
1502 std::unordered_map<stk::mesh::EntityId,std::size_t>::const_iterator itr =
localEdgeIDHash_.find(gid);
1514 std::unordered_map<stk::mesh::EntityId,std::size_t>::const_iterator itr =
localFaceIDHash_.find(gid);
1528 std::unordered_map<stk::mesh::EntityId,std::size_t>::const_iterator itr =
localFaceIDHash_.find(gid);
1537 if(
bulkData_->bucket(elmt).member(*(eb_pair.second)))
1538 return eb_pair.first;
1543 const std::string & blockId)
const
1546 std::map<std::pair<std::string,std::string>,
SolutionFieldType*>::const_iterator
1551 "Solution field name \"" << fieldName <<
"\" in block ID \"" << blockId <<
"\" was not found");
1553 return iter->second;
1557 const std::string & blockId)
const
1560 std::map<std::pair<std::string,std::string>,
SolutionFieldType*>::const_iterator
1565 "Cell field named \"" << fieldName <<
"\" in block ID \"" << blockId <<
"\" was not found");
1567 return iter->second;
1571 const std::string & blockId)
const
1574 std::map<std::pair<std::string,std::string>,
SolutionFieldType*>::const_iterator
1579 "Edge field named \"" << fieldName <<
"\" in block ID \"" << blockId <<
"\" was not found");
1581 return iter->second;
1585 const std::string & blockId)
const
1588 std::map<std::pair<std::string,std::string>,
SolutionFieldType*>::const_iterator
1593 "Face field named \"" << fieldName <<
"\" in block ID \"" << blockId <<
"\" was not found");
1595 return iter->second;
1615 stk::mesh::Part * block =
metaData_->get_part(name);
1617 block = &
metaData_->declare_part_with_topology(name, stk::mesh::get_topology(shards::CellTopology(ctData),
dimension_));
1621 Teuchos::RCP<shards::CellTopology> ct
1622 = Teuchos::rcp(
new shards::CellTopology(ctData));
1643 const std::string & edgeBlockName,
1644 const stk::topology & topology)
1648 stk::mesh::Part * edge_block =
metaData_->get_part(edgeBlockName);
1650 edge_block = &
metaData_->declare_part_with_topology(edgeBlockName, topology);
1656 stk::mesh::Part * elem_block =
metaData_->get_part(elemBlockName);
1657 metaData_->declare_part_subset(*elem_block, *edge_block);
1660 edgeBlocks_.insert(std::make_pair(edgeBlockName,edge_block));
1664 const std::string & edgeBlockName,
1665 const CellTopologyData * ctData)
1671 stk::mesh::get_topology(shards::CellTopology(ctData),
dimension_));
1688 const std::string & faceBlockName,
1689 const stk::topology & topology)
1693 stk::mesh::Part * face_block =
metaData_->get_part(faceBlockName);
1695 face_block = &
metaData_->declare_part_with_topology(faceBlockName, topology);
1701 stk::mesh::Part * elem_block =
metaData_->get_part(elemBlockName);
1702 metaData_->declare_part_subset(*elem_block, *face_block);
1705 faceBlocks_.insert(std::make_pair(faceBlockName,face_block));
1709 const std::string & faceBlockName,
1710 const CellTopologyData * ctData)
1716 stk::mesh::get_topology(shards::CellTopology(ctData),
dimension_));
1750 std::vector<stk::mesh::Entity> elements;
1753 for(std::size_t index=0;index<elements.size();++index) {
1754 stk::mesh::Entity element = elements[index];
1758 procId[0] = Teuchos::as<ProcIdData>(
procRank_);
1771 for(std::size_t index=0;index<elements.size();++index) {
1772 stk::mesh::Entity element = elements[index];
1776 procId[0] = Teuchos::as<ProcIdData>(
procRank_);
1788 std::vector<std::string> names;
1791 for(std::size_t b=0;b<names.size();b++) {
1793 std::map<std::string,double>::const_iterator bw_itr =
blockWeights_.find(names[b]);
1794 double blockWeight = (bw_itr!=
blockWeights_.end()) ? bw_itr->second : 1.0;
1796 std::vector<stk::mesh::Entity> elements;
1799 for(std::size_t index=0;index<elements.size();++index) {
1801 double * loadBal = stk::mesh::field_data(*
loadBalField_,elements[index]);
1802 loadBal[0] = blockWeight;
1814 std::vector<stk::mesh::Entity> edges;
1817 for(std::size_t index=0;index<edges.size();++index) {
1818 stk::mesh::Entity edge = edges[index];
1834 std::vector<stk::mesh::Entity> faces;
1837 for(std::size_t index=0;index<faces.size();++index) {
1838 stk::mesh::Entity face = faces[index];
1849 const std::string & fieldName,
1852 std::map<std::string,std::vector<std::string> >::const_iterator blkItr =
meshCoordFields_.find(eBlock);
1858 for(axis=0;axis<Teuchos::as<int>(blkItr->second.size());axis++) {
1859 if(blkItr->second[axis]==fieldName)
1863 if(axis>=Teuchos::as<int>(blkItr->second.size()))
1869std::pair<Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >, Teuchos::RCP<std::vector<unsigned int> > >
1872 Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > > vec;
1873 Teuchos::RCP<std::vector<unsigned int > > type_vec = rcp(
new std::vector<unsigned int>);
1874 const std::vector<Teuchos::RCP<const PeriodicBC_MatcherBase> > & matchers =
getPeriodicBCVector();
1876 std::vector<std::vector<std::string> > matchedSides(3);
1879 for(std::size_t m=0;m<matchers.size();m++){
1881 if(matchers[m]->getType() ==
"coord")
1883 else if(matchers[m]->getType() ==
"edge")
1885 else if(matchers[m]->getType() ==
"face")
1888 TEUCHOS_ASSERT(
false);
1889#ifdef PANZER_HAVE_STKSEARCH
1891 if (useBBoxSearch) {
1892 vec = matchers[m]->getMatchedPair(*
this,matchedSides[type],vec);
1894 vec = matchers[m]->getMatchedPair(*
this,vec);
1897 TEUCHOS_TEST_FOR_EXCEPTION(useBBoxSearch,std::logic_error,
1898 "panzer::STK_Interface::getPeriodicNodePairing(): Requested bounding box search, but "
1899 "did not compile with STK_SEARCH enabled.");
1900 vec = matchers[m]->getMatchedPair(*
this,vec);
1902 type_vec->insert(type_vec->begin(),vec->size()-type_vec->size(),type);
1903 matchedSides[type].push_back(matchers[m]->getLeftSidesetName());
1906 return std::make_pair(vec,type_vec);
1911 std::map<std::string, stk::mesh::Part*>::const_iterator blkItr =
elementBlocks_.find(blockId);
1918 std::vector<std::string> blockNames, sidesetNames, nodesetNames;
1924 os <<
"STK Mesh data:\n";
1927 os <<
" Entity counts (Nodes, Edges, Cells) = ( "
1932 os <<
" Entity counts (Nodes, Edges, Faces, Cells) = ( "
1938 os <<
" Entity counts (Nodes, Cells) = ( "
1942 os <<
" Element blocks = ";
1943 for(std::size_t i=0;i<blockNames.size();i++)
1944 os <<
"\"" << blockNames[i] <<
"\" ";
1946 os <<
" Sidesets = ";
1947 for(std::size_t i=0;i<sidesetNames.size();i++)
1948 os <<
"\"" << sidesetNames[i] <<
"\" ";
1950 os <<
" Nodesets = ";
1951 for(std::size_t i=0;i<nodesetNames.size();i++)
1952 os <<
"\"" << nodesetNames[i] <<
"\" ";
1956 const std::vector<Teuchos::RCP<const PeriodicBC_MatcherBase> > & bcVector
1958 if(bcVector.size()!=0) {
1959 os <<
" Periodic BCs:\n";
1960 for(std::size_t i=0;i<bcVector.size();i++)
1961 os <<
" " << bcVector[i]->getString() <<
"\n";
1968 std::vector<std::string> blockNames, sidesetNames, nodesetNames;
1974 os <<
"STK Meta data:\n";
1975 os <<
" Element blocks = ";
1976 for(std::size_t i=0;i<blockNames.size();i++)
1977 os <<
"\"" << blockNames[i] <<
"\" ";
1979 os <<
" Sidesets = ";
1980 for(std::size_t i=0;i<sidesetNames.size();i++)
1981 os <<
"\"" << sidesetNames[i] <<
"\" ";
1983 os <<
" Nodesets = ";
1984 for(std::size_t i=0;i<nodesetNames.size();i++)
1985 os <<
"\"" << nodesetNames[i] <<
"\" ";
1989 const std::vector<Teuchos::RCP<const PeriodicBC_MatcherBase> > & bcVector
1991 if(bcVector.size()!=0) {
1992 os <<
" Periodic BCs:\n";
1993 for(std::size_t i=0;i<bcVector.size();i++)
1994 os <<
" " << bcVector[i]->getString() <<
"\n";
2000 const stk::mesh::FieldVector & fv =
metaData_->get_fields();
2001 for(std::size_t i=0;i<fv.size();i++)
2002 os <<
"\"" << fv[i]->name() <<
"\" ";
2008 std::map<std::string, Teuchos::RCP<shards::CellTopology> >::const_iterator itr;
2012 std::stringstream ss;
2014 TEUCHOS_TEST_FOR_EXCEPTION(itr==
elementBlockCT_.end(),std::logic_error,
2015 "STK_Interface::getCellTopology: No such element block \"" +eBlock +
"\" available.\n\n"
2016 <<
"STK Meta Data follows: \n" << ss.str());
2025 const int err = MPI_Comm_dup (parallelMach, &newComm);
2026 TEUCHOS_TEST_FOR_EXCEPTION(err != MPI_SUCCESS, std::runtime_error,
2027 "panzer::STK_Interface: MPI_Comm_dup failed with error \""
2028 << Teuchos::mpiErrorCodeToString (err) <<
"\".");
2035 TEUCHOS_TEST_FOR_EXCEPTION(
true, std::runtime_error,
"Rebalance not currently supported");
2040 stk::mesh::Selector selector(
getMetaData()->universal_part());
2041 stk::mesh::Selector owned_selector(
getMetaData()->locally_owned_part());
2043 Teuchos::FancyOStream out(Teuchos::rcpFromRef(std::cout));
2044 out.setOutputToRootOnly(0);
2048 Teuchos::ParameterList graph;
2049 if(params.begin()!=params.end())
2050 graph.sublist(stk::rebalance::Zoltan::default_parameters_name()) = params;
2061Teuchos::RCP<const Teuchos::Comm<int> >
2069#ifdef PANZER_HAVE_PERCEPT
2070 TEUCHOS_TEST_FOR_EXCEPTION(numberOfLevels < 1,std::runtime_error,
2071 "ERROR: Number of levels for uniform refinement must be greater than 0");
2072 TEUCHOS_ASSERT(nonnull(refinedMesh_));
2073 TEUCHOS_ASSERT(nonnull(breakPattern_));
2075 refinedMesh_->setCoordinatesField();
2077 percept::UniformRefiner breaker(*refinedMesh_,*breakPattern_);
2078 breaker.setRemoveOldElements(deleteParentElements);
2080 for (
int i=0; i < numberOfLevels; ++i)
2084 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
2085 "ERROR: Uniform refinement requested. This requires the Percept package to be enabled in Trilinos!");
PHX::MDField< ScalarT, panzer::Cell, panzer::BASIS > field
A field to which we'll contribute, or in which we'll store, the result of computing this integral.
virtual ~ElementDescriptor()
void rebalance(const Teuchos::ParameterList ¶ms)
void buildLocalElementIDs()
stk::mesh::Entity findConnectivityById(stk::mesh::Entity src, stk::mesh::EntityRank tgt_rank, unsigned rel_id) const
void applyElementLoadBalanceWeights()
Teuchos::RCP< stk::mesh::MetaData > metaData_
VectorFieldType * facesField_
Teuchos::RCP< std::vector< stk::mesh::Entity > > orderedFaceVector_
std::pair< Teuchos::RCP< std::vector< std::pair< std::size_t, std::size_t > > >, Teuchos::RCP< std::vector< unsigned int > > > getPeriodicNodePairing() const
const std::vector< Teuchos::RCP< const PeriodicBC_MatcherBase > > & getPeriodicBCVector() const
void initialize(stk::ParallelMachine parallelMach, bool setupIO=true, const bool buildRefinementSupport=false)
stk::mesh::Field< double > SolutionFieldType
void getMyFaces(std::vector< stk::mesh::Entity > &faces) const
stk::mesh::Part * getElementBlockPart(const std::string &name) const
get the block part
static const std::string edgesString
void addGlobalToExodus(const std::string &key, const int &value)
Add an int global variable to the information to be written to the Exodus output file.
static const std::string edgeBlockString
Teuchos::RCP< std::vector< stk::mesh::Entity > > orderedElementVector_
std::map< std::string, stk::mesh::Part * > sidesets_
stk::mesh::EntityId elementGlobalId(std::size_t lid) const
stk::mesh::Part * getEdgeBlock(const std::string &name) const
get the block part
std::unordered_map< stk::mesh::EntityId, std::size_t > localFaceIDHash_
void getElementsSharingNodes(const std::vector< stk::mesh::EntityId > nodeId, std::vector< stk::mesh::Entity > &elements) const
get a set of elements sharing multiple nodes
std::size_t getEntityCounts(unsigned entityRank) const
get the global counts for the entity of specified rank
void getFaceBlockNames(std::vector< std::string > &names) const
stk::mesh::Field< double, stk::mesh::Cartesian > VectorFieldType
bool isFaceLocal(stk::mesh::Entity face) const
void initializeFromMetaData()
void addEntityToEdgeBlock(stk::mesh::Entity entity, stk::mesh::Part *edgeblock)
Teuchos::RCP< const std::vector< stk::mesh::Entity > > getElementsOrderedByLID() const
bool isInitialized() const
Has initialize been called on this mesh object?
std::map< std::string, stk::mesh::Part * > faceBlocks_
void addEntitiesToFaceBlock(std::vector< stk::mesh::Entity > entities, stk::mesh::Part *faceblock)
stk::mesh::EntityRank getNodeRank() const
void addInformationRecords(const std::vector< std::string > &info_records)
std::string containingBlockId(stk::mesh::Entity elmt) const
void getEdgeBlockNames(std::vector< std::string > &names) const
void addEdgeBlock(const std::string &elemBlockName, const std::string &edgeBlockName, const stk::topology &topology)
std::vector< std::size_t > entityCounts_
void getElementsSharingNode(stk::mesh::EntityId nodeId, std::vector< stk::mesh::Entity > &elements) const
get a set of elements sharing a single node
Teuchos::RCP< const std::vector< stk::mesh::Entity > > getEdgesOrderedByLID() const
void buildSubcells()
force the mesh to build subcells: edges and faces
stk::mesh::EntityId getMaxEntityId(unsigned entityRank) const
get max entity ID of type entityRank
stk::mesh::EntityRank getElementRank() const
std::size_t currentLocalId_
void getOwnedElementsSharingNode(stk::mesh::Entity node, std::vector< stk::mesh::Entity > &elements, std::vector< int > &relIds) const
const double * getNodeCoordinates(stk::mesh::EntityId nodeId) const
void getNodeIdsForElement(stk::mesh::Entity element, std::vector< stk::mesh::EntityId > &nodeIds) const
get a list of node ids for nodes connected to an element
void addEdgeField(const std::string &fieldName, const std::string &blockId)
std::unordered_map< stk::mesh::EntityId, std::size_t > localEdgeIDHash_
void addEntityToFaceBlock(stk::mesh::Entity entity, stk::mesh::Part *faceblock)
void getNeighborElements(std::vector< stk::mesh::Entity > &elements) const
void getMyNodes(const std::string &sideName, const std::string &blockName, std::vector< stk::mesh::Entity > &nodes) const
std::vector< stk::mesh::Part * > edgesPartVec_
bool isModifiable() const
const bool & useBoundingBoxSearch() const
void addEntityToNodeset(stk::mesh::Entity entity, stk::mesh::Part *nodeset)
void addElement(const Teuchos::RCP< ElementDescriptor > &ed, stk::mesh::Part *block)
bool isEdgeLocal(stk::mesh::Entity edge) const
void refineMesh(const int numberOfLevels, const bool deleteParentElements)
stk::mesh::Part * nodesPart_
stk::mesh::Part * facesPart_
std::map< std::string, double > blockWeights_
std::map< std::pair< std::string, std::string >, SolutionFieldType * > fieldNameToEdgeField_
void addNode(stk::mesh::EntityId gid, const std::vector< double > &coord)
Teuchos::RCP< const Teuchos::Comm< int > > getComm() const
get the comm associated with this mesh
std::map< std::pair< std::string, std::string >, SolutionFieldType * > fieldNameToFaceField_
std::size_t elementLocalId(stk::mesh::Entity elmt) const
void addCellField(const std::string &fieldName, const std::string &blockId)
stk::mesh::Field< double > * getSolutionField(const std::string &fieldName, const std::string &blockId) const
std::map< std::pair< std::string, std::string >, SolutionFieldType * > fieldNameToSolution_
void getAllSides(const std::string &sideName, std::vector< stk::mesh::Entity > &sides) const
VectorFieldType * coordinatesField_
stk::mesh::Part * edgesPart_
void getMySides(const std::string &sideName, std::vector< stk::mesh::Entity > &sides) const
void addMeshCoordFields(const std::string &blockId, const std::vector< std::string > &coordField, const std::string &dispPrefix)
stk::mesh::Field< double > * getEdgeField(const std::string &fieldName, const std::string &blockId) const
std::vector< stk::mesh::EntityId > maxEntityId_
void getElementBlockNames(std::vector< std::string > &names) const
Teuchos::RCP< stk::mesh::BulkData > bulkData_
void addNodeset(const std::string &name)
void getSidesetNames(std::vector< std::string > &name) const
void addSideset(const std::string &name, const CellTopologyData *ctData)
stk::mesh::EntityRank getFaceRank() const
void getMyEdges(std::vector< stk::mesh::Entity > &edges) const
std::set< std::string > informationRecords_
void getAllEdges(const std::string &edgeBlockName, std::vector< stk::mesh::Entity > &edges) const
std::vector< stk::mesh::Part * > nodesPartVec_
void initializeFieldsInSTK(const std::map< std::pair< std::string, std::string >, SolutionFieldType * > &nameToField, bool setupIO)
static const std::string nodesString
const VectorFieldType & getCoordinatesField() const
Teuchos::RCP< stk::mesh::MetaData > getMetaData() const
stk::mesh::Field< double > * getFaceField(const std::string &fieldName, const std::string &blockId) const
static const std::string facesString
void writeToExodus(const std::string &filename, const bool append=false)
Write this mesh and associated fields to the given output file.
unsigned getDimension() const
get the dimension
bool isMeshCoordField(const std::string &eBlock, const std::string &fieldName, int &axis) const
std::map< std::string, stk::mesh::Part * > nodesets_
SolutionFieldType * loadBalField_
std::map< std::string, std::vector< std::string > > meshCoordFields_
stk::mesh::Field< double > * getCellField(const std::string &fieldName, const std::string &blockId) const
std::size_t faceLocalId(stk::mesh::Entity elmt) const
void getAllFaces(const std::string &faceBlockName, std::vector< stk::mesh::Entity > &faces) const
void setupExodusFile(const std::string &filename, const bool append=false, const bool append_after_restart_time=false, const double restart_time=0.0)
Set up an output Exodus file for writing results.
Teuchos::RCP< std::vector< stk::mesh::Entity > > orderedEdgeVector_
stk::mesh::Part * getNodeset(const std::string &name) const
Teuchos::RCP< const shards::CellTopology > getCellTopology(const std::string &eBlock) const
void getNodesetNames(std::vector< std::string > &name) const
void addEntitiesToEdgeBlock(std::vector< stk::mesh::Entity > entities, stk::mesh::Part *edgeblock)
stk::mesh::Field< ProcIdData > ProcIdFieldType
std::unordered_map< stk::mesh::EntityId, std::size_t > localIDHash_
void addSolutionField(const std::string &fieldName, const std::string &blockId)
VectorFieldType * edgesField_
void getSubcellIndices(unsigned entityRank, stk::mesh::EntityId elementId, std::vector< stk::mesh::EntityId > &subcellIds) const
void addEntityToSideset(stk::mesh::Entity entity, stk::mesh::Part *sideset)
Teuchos::RCP< const std::vector< stk::mesh::Entity > > getFacesOrderedByLID() const
std::map< std::string, Teuchos::RCP< shards::CellTopology > > elementBlockCT_
stk::mesh::EntityRank getSideRank() const
Teuchos::RCP< Teuchos::MpiComm< int > > mpiComm_
ProcIdFieldType * processorIdField_
bool validBlockId(const std::string &blockId) const
void addFaceField(const std::string &fieldName, const std::string &blockId)
std::map< std::string, stk::mesh::Part * > edgeBlocks_
void print(std::ostream &os) const
void getMyElements(std::vector< stk::mesh::Entity > &elements) const
void addElementBlock(const std::string &name, const CellTopologyData *ctData)
void addFaceBlock(const std::string &elemBlockName, const std::string &faceBlockName, const stk::topology &topology)
Teuchos::RCP< stk::mesh::BulkData > getBulkData() const
std::map< std::string, std::vector< std::string > > meshDispFields_
static const std::string faceBlockString
std::vector< stk::mesh::Part * > facesPartVec_
void printMetaData(std::ostream &os) const
void instantiateBulkData(stk::ParallelMachine parallelMach)
std::map< std::pair< std::string, std::string >, SolutionFieldType * > fieldNameToCellField_
std::size_t edgeLocalId(stk::mesh::Entity elmt) const
std::map< std::string, stk::mesh::Part * > elementBlocks_
static const std::string coordsString
Teuchos::RCP< Teuchos::MpiComm< int > > getSafeCommunicator(stk::ParallelMachine parallelMach) const
stk::mesh::Part * getFaceBlock(const std::string &name) const
get the block part
stk::mesh::EntityRank getEdgeRank() const
stk::mesh::Part * getSideset(const std::string &name) const
Teuchos::RCP< ElementDescriptor > buildElementDescriptor(stk::mesh::EntityId elmtId, std::vector< stk::mesh::EntityId > &nodes)