void SculptMeshFactory::addNodeSets(STK_Interface & mesh) const
{
mesh.beginModification();
struct MeshStorageStruct *mss = get_sculpt_mesh();
int num_node_sets = mss->num_node_sets;
if (num_node_sets) {
int *node_set_id = new int[num_node_sets];
int *num_nodes_in_node_set = new int[num_node_sets];
int *num_df_in_node_set = new int[num_node_sets];
int **node_set_nodes = new int*[num_node_sets];
double **node_set_df = new double*[num_node_sets];
for(int ict = 0; ict < num_node_sets; ict ++){
node_set_id[ict] = mss->node_set_id[ict];
num_nodes_in_node_set[ict] = mss->num_nodes_in_node_set[ict];
num_df_in_node_set[ict] = mss->num_df_in_node_set[ict];
}
for(int i = 0; i < num_node_sets; i++) {
node_set_nodes[i] = new int[num_nodes_in_node_set[i]];
node_set_df[i] = NULL;
if(num_nodes_in_node_set[i]) {
for(int nct = 0; nct < num_nodes_in_node_set[i];nct ++){
node_set_nodes[i][nct] = mss->node_set_nodes[i][nct];
}
}
}
for(int i = 0; i < num_node_sets; i++) {
std::stringstream nodesetName;
nodesetName << "Nodeset-" << mss->node_set_id[i];
stk_classic::mesh::Part * nodeset = mesh.getNodeset(nodesetName.str());
for( int j = 0; j < num_nodes_in_node_set[i]; j++ )
{
int node_id = node_set_nodes[i][j];
Teuchos::RCP<stk_classic::mesh::BulkData> bulkData = mesh.getBulkData();
if(machRank_==0)
{
stk_classic::mesh::Entity * node = bulkData->get_entity(mesh.getNodeRank(),node_id);
mesh.addEntityToNodeset(*node, nodeset);
}
}
}
}
mesh.endModification();
}
void STK_ExodusReaderFactory::registerNodesets(STK_Interface & mesh,stk::io::MeshData & meshData) const
{
using Teuchos::RCP;
RCP<stk::mesh::fem::FEMMetaData> metaData = mesh.getMetaData();
const stk::mesh::PartVector & parts = metaData->get_parts();
stk::mesh::PartVector::const_iterator partItr;
for(partItr=parts.begin();partItr!=parts.end();++partItr) {
const stk::mesh::Part * part = *partItr;
const CellTopologyData * ct = metaData->get_cell_topology(*part).getCellTopologyData();
// if a side part ==> this is a sideset: now storage is recursive
// on part contains all sub parts with consistent topology
if(part->primary_entity_rank()==mesh.getNodeRank() && ct==0) {
// only add subset parts that have no topology
if(part->name()!=STK_Interface::nodesString)
mesh.addNodeset(part->name());
}
}
}
void SquareQuadMeshFactory::addNodeSets(STK_Interface & mesh) const
{
mesh.beginModification();
// get all part vectors
stk::mesh::Part * lower_left = mesh.getNodeset("lower_left");
stk::mesh::Part * origin = mesh.getNodeset("origin");
// std::vector<stk::mesh::Entity*> localElmts;
// mesh.getMyElements(localElmts);
Teuchos::RCP<stk::mesh::BulkData> bulkData = mesh.getBulkData();
if(machRank_==0)
{
// add zero node to lower_left node set
stk::mesh::Entity * node = bulkData->get_entity(mesh.getNodeRank(),1);
mesh.addEntityToNodeset(*node,lower_left);
// add zero node to origin node set
mesh.addEntityToNodeset(*node,origin);
}
mesh.endModification();
}
std::pair<Teuchos::RCP<std::vector<std::size_t> >,
Teuchos::RCP<std::vector<Teuchos::Tuple<double,3> > > >
getLocalSideIdsAndCoords(const STK_Interface & mesh,
const std::string & sideName, const std::string type_)
{
unsigned physicalDim = mesh.getDimension();
Teuchos::RCP<stk::mesh::MetaData> metaData = mesh.getMetaData();
Teuchos::RCP<stk::mesh::BulkData> bulkData = mesh.getBulkData();
// grab nodes owned by requested side
/////////////////////////////////////////////
std::stringstream ss;
ss << "Can't find part=\"" << sideName << "\"" << std::endl;
stk::mesh::Part * side = metaData->get_part(sideName,ss.str().c_str());
stk::mesh::Selector mySides = (*side) & metaData->locally_owned_part();
stk::mesh::EntityRank rank;
const STK_Interface::VectorFieldType * field = 0;
unsigned int offset = 0;
if(type_ == "coord"){
rank = mesh.getNodeRank();
field = & mesh.getCoordinatesField();
} else if(type_ == "edge"){
rank = mesh.getEdgeRank();
field = & mesh.getEdgesField();
offset = mesh.getMaxEntityId(mesh.getNodeRank());
} else if(type_ == "face"){
rank = mesh.getFaceRank();
field = & mesh.getFacesField();
offset = mesh.getMaxEntityId(mesh.getNodeRank())+mesh.getMaxEntityId(mesh.getEdgeRank());
} else {
ss << "Can't do BCs of type " << type_ << std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(true,std::runtime_error, ss.str())
}
std::vector<stk::mesh::Bucket*> const& nodeBuckets =
bulkData->get_buckets(rank, mySides);
// build id vector
////////////////////////////////////////////
std::size_t nodeCount = 0;
for(std::size_t b=0;b<nodeBuckets.size();b++)
nodeCount += nodeBuckets[b]->size();
Teuchos::RCP<std::vector<std::size_t> > sideIds
= Teuchos::rcp(new std::vector<std::size_t>(nodeCount));
Teuchos::RCP<std::vector<Teuchos::Tuple<double,3> > > sideCoords
= Teuchos::rcp(new std::vector<Teuchos::Tuple<double,3> >(nodeCount));
// loop over node buckets
for(std::size_t b=0,index=0;b<nodeBuckets.size();b++) {
stk::mesh::Bucket & bucket = *nodeBuckets[b];
double const* array = stk::mesh::field_data(*field, bucket);
for(std::size_t n=0;n<bucket.size();n++,index++) {
(*sideIds)[index] = bulkData->identifier(bucket[n]) + offset;
Teuchos::Tuple<double,3> & coord = (*sideCoords)[index];
// copy coordinates into multi vector
for(std::size_t d=0;d<physicalDim;d++)
coord[d] = array[physicalDim*n + d];
}
}
return std::make_pair(sideIds,sideCoords);
}
