void buildLocalIds(const STK_Interface & mesh,
std::map<std::string,Teuchos::RCP<std::vector<std::size_t> > > & localIds)
{
// defines ordering of blocks
std::vector<std::string> blockIds;
mesh.getElementBlockNames(blockIds);
std::vector<std::string>::const_iterator idItr;
for(idItr=blockIds.begin();idItr!=blockIds.end();++idItr) {
std::string blockId = *idItr;
localIds[blockId] = Teuchos::rcp(new std::vector<std::size_t>);
std::vector<std::size_t> & localBlockIds = *localIds[blockId];
// grab elements on this block
std::vector<stk::mesh::Entity*> blockElmts;
mesh.getMyElements(blockId,blockElmts);
std::vector<stk::mesh::Entity*>::const_iterator itr;
for(itr=blockElmts.begin();itr!=blockElmts.end();++itr)
localBlockIds.push_back(mesh.elementLocalId(*itr));
std::sort(localBlockIds.begin(),localBlockIds.end());
}
}
void
CustomMeshFactory::fillSolutionFieldData(STK_Interface &mesh) const
{
for (int blk=0;blk<NumBlocks_;++blk) {
std::stringstream block_id;
block_id << "eblock-" << blk;
// elements in this processor for this block
std::vector<stk_classic::mesh::Entity*> elements;
mesh.getMyElements(block_id.str(), elements);
// size of elements in the current block
std::size_t n_elements = elements.size();
// build local element index
std::vector<std::size_t> local_ids;
for (std::vector<stk_classic::mesh::Entity*>::const_iterator
itr=elements.begin();itr!=elements.end();++itr)
local_ids.push_back(mesh.elementLocalId(*itr));
// re-index solution fields in the same order of local_ids
std::vector<double> charge_density_by_local_ids, electric_potential_by_local_ids;
for (std::vector<stk_classic::mesh::Entity*>::const_iterator
itr=elements.begin();itr!=elements.end();++itr) {
int q = (*itr)->identifier() - OffsetToGlobalElementIDs_;
for (int k=0;k<8;++k) {
int loc = q*8 + k;
charge_density_by_local_ids.push_back(ChargeDensity_[loc]);
electric_potential_by_local_ids.push_back(ElectricPotential_[loc]);
}
}
// wrap the buffer with a proper container
FieldContainer charge_density(n_elements, 8, &charge_density_by_local_ids[0]),
electric_potential(n_elements, 8, &electric_potential_by_local_ids[0]);
// write out to stk mesh
mesh.setSolutionFieldData("CHARGE_DENSITY",
block_id.str(),
local_ids,
charge_density, 1.0);
mesh.setSolutionFieldData("ELECTRIC_POTENTIAL",
block_id.str(),
local_ids,
electric_potential, 1.0);
}
}
void
CustomMeshFactory::addSideSets(STK_Interface &mesh) const
{
mesh.beginModification();
// get all part vectors
stk_classic::mesh::Part *box[6];
box[0] = mesh.getSideset("front");
box[1] = mesh.getSideset("right");
box[2] = mesh.getSideset("back");
box[3] = mesh.getSideset("left");
box[4] = mesh.getSideset("bottom");
box[5] = mesh.getSideset("top");
stk_classic::mesh::Part *wall = mesh.getSideset("wall");
std::vector<stk_classic::mesh::Entity*> elements;
mesh.getMyElements(elements);
// loop over elements adding sides to sidesets
for (std::vector<stk_classic::mesh::Entity*>::const_iterator
itr=elements.begin();itr!=elements.end();++itr) {
stk_classic::mesh::Entity *element = (*itr);
stk_classic::mesh::PairIterRelation relations = element->relations(mesh.getSideRank());
// loop over side id checking element neighbors
for (std::size_t i=0;i<relations.size();++i) {
stk_classic::mesh::Entity *side = relations[i].entity();
stk_classic::mesh::PairIterRelation neighbors = side->relations(mesh.getElementRank());
const std::size_t numNeighbors = neighbors.size();
if (numNeighbors == 1) {
if (side->owner_rank() == machRank_)
mesh.addEntityToSideset(*side, box[i]);
}
else if (numNeighbors == 2) {
std::string neig_block_id_0 = mesh.containingBlockId(neighbors[0].entity());
std::string neig_block_id_1 = mesh.containingBlockId(neighbors[1].entity());
if ((neig_block_id_0 != neig_block_id_1) && (side->owner_rank() == machRank_))
mesh.addEntityToSideset(*side, wall);
}
else {
// runtime exception
}
}
}
mesh.endModification();
}
void LineMeshFactory::addSideSets(STK_Interface & mesh) const
{
mesh.beginModification();
std::size_t totalXElems = nXElems_*xBlocks_;
// get all part vectors
stk::mesh::Part * left = mesh.getSideset("left");
stk::mesh::Part * right = mesh.getSideset("right");
std::vector<stk::mesh::Entity*> localElmts;
mesh.getMyElements(localElmts);
// loop over elements adding edges to sidesets
std::vector<stk::mesh::Entity*>::const_iterator itr;
for(itr=localElmts.begin();itr!=localElmts.end();++itr) {
stk::mesh::Entity * element = (*itr);
stk::mesh::EntityId gid = element->identifier();
stk::mesh::PairIterRelation relations = element->relations(mesh.getSideRank());
std::size_t nx = gid-1;
// vertical boundaries
///////////////////////////////////////////
if(nx+1==totalXElems) {
stk::mesh::Entity * edge = getRelationByID(1,relations)->entity();
// on the right
if(edge->owner_rank()==machRank_)
mesh.addEntityToSideset(*edge,right);
}
if(nx==0) {
stk::mesh::Entity * edge = getRelationByID(0,relations)->entity();
// on the left
if(edge->owner_rank()==machRank_)
mesh.addEntityToSideset(*edge,left);
}
}
mesh.endModification();
}
void CubeTetMeshFactory::addSideSets(STK_Interface & mesh) const
{
mesh.beginModification();
std::size_t totalXElems = nXElems_*xBlocks_;
std::size_t totalYElems = nYElems_*yBlocks_;
std::size_t totalZElems = nZElems_*zBlocks_;
// get all part vectors
stk_classic::mesh::Part * left = mesh.getSideset("left");
stk_classic::mesh::Part * right = mesh.getSideset("right");
stk_classic::mesh::Part * top = mesh.getSideset("top");
stk_classic::mesh::Part * bottom = mesh.getSideset("bottom");
stk_classic::mesh::Part * front = mesh.getSideset("front");
stk_classic::mesh::Part * back = mesh.getSideset("back");
std::vector<stk_classic::mesh::Entity*> localElmts;
mesh.getMyElements(localElmts);
// gid = totalXElems*totalYElems*nz+totalXElems*ny+nx+1
// loop over elements adding sides to sidesets
std::vector<stk_classic::mesh::Entity*>::const_iterator itr;
for(itr=localElmts.begin();itr!=localElmts.end();++itr) {
stk_classic::mesh::Entity * element = (*itr);
stk_classic::mesh::EntityId gid = element->identifier();
stk_classic::mesh::PairIterRelation relations = element->relations(mesh.getSideRank());
// get hex global id
stk_classic::mesh::EntityId h_gid = (gid-1)/12+1;
stk_classic::mesh::EntityId t_offset = gid - (12*(h_gid-1)+1);
std::size_t nx,ny,nz;
nz = (h_gid-1) / (totalXElems*totalYElems);
h_gid = (h_gid-1)-nz*(totalXElems*totalYElems);
ny = h_gid / totalXElems;
nx = h_gid-ny*totalXElems;
if(nz==0 && (t_offset==0 || t_offset==1)) {
stk_classic::mesh::Entity * side = getRelationByID(3,relations)->entity();
// on the back
if(side->owner_rank()==machRank_)
mesh.addEntityToSideset(*side,back);
}
if(nz+1==totalZElems && (t_offset==10 || t_offset==11)) {
stk_classic::mesh::Entity * side = getRelationByID(3,relations)->entity();
// on the front
if(side->owner_rank()==machRank_)
mesh.addEntityToSideset(*side,front);
}
if(ny==0 && (t_offset==2 || t_offset==3)) {
stk_classic::mesh::Entity * side = getRelationByID(3,relations)->entity();
// on the bottom
if(side->owner_rank()==machRank_)
mesh.addEntityToSideset(*side,bottom);
}
if(ny+1==totalYElems && (t_offset==8 || t_offset==9)) {
stk_classic::mesh::Entity * side = getRelationByID(3,relations)->entity();
// on the top
if(side->owner_rank()==machRank_)
mesh.addEntityToSideset(*side,top);
}
if(nx==0 && (t_offset==4 || t_offset==5)) {
stk_classic::mesh::Entity * side = getRelationByID(3,relations)->entity();
// on the left
if(side->owner_rank()==machRank_)
mesh.addEntityToSideset(*side,left);
}
if(nx+1==totalXElems && (t_offset==6 || t_offset==7)) {
stk_classic::mesh::Entity * side = getRelationByID(3,relations)->entity();
// on the right
if(side->owner_rank()==machRank_)
mesh.addEntityToSideset(*side,right);
}
}
mesh.endModification();
}
void SculptMeshFactory::addSideSets(STK_Interface & mesh) const
{
mesh.beginModification();
struct MeshStorageStruct *mss = get_sculpt_mesh();
int num_side_sets = mss->num_side_sets;
int *side_set_id = new int[num_side_sets];
int *num_elements_in_side_set = new int[num_side_sets];
int *num_nodes_in_side_set = new int[num_side_sets];
int *num_df_in_side_set = new int[num_side_sets];
int **side_set_elements = new int*[num_side_sets];
int **side_set_faces = new int*[num_side_sets];
//Element_Type **side_set_element_type = new Element_Type*[num_side_sets];
int **side_set_node_counter = new int*[num_side_sets];
int **side_set_nodes = new int*[num_side_sets];
double **side_set_df = new double*[num_side_sets];
for(int ict = 0;ict < num_side_sets;ict ++){
side_set_id[ict] = mss->side_set_id[ict];
}
for(int i = 0; i < num_side_sets; i++) {
std::stringstream sidesetName;
sidesetName << "Sideset-" << mss->side_set_id[i];
stk_classic::mesh::Part * sideset = mesh.getSideset(sidesetName.str());
num_elements_in_side_set[i] = mss->num_elements_in_side_set[i];
num_df_in_side_set[i] = mss->num_df_in_side_set[i];
int ne = num_elements_in_side_set[i];
side_set_elements[i] = new int[ne];
side_set_faces[i] = new int[ne];
//side_set_element_type[i] = new Element_Type[ne];
side_set_node_counter[i] = new int[ne];
side_set_df[i] = new double[num_df_in_side_set[i]];
if(ne) {
for(int nct = 0; nct < ne; nct ++){
std::vector<stk_classic::mesh::EntityId> nodes(4);
int sculpt_elem_id = mss->global_element_numbers[ mss->side_set_elements[i][nct]-1 ];
int sculpt_face_id = -1 ;
std::vector<stk_classic::mesh::Entity*> localElmts;
mesh.getMyElements(localElmts);
std::vector<stk_classic::mesh::Entity*>::const_iterator itr;
for(itr=localElmts.begin();itr!=localElmts.end();++itr) {
stk_classic::mesh::Entity * element = (*itr);
if( element->identifier() == sculpt_elem_id )
{
sculpt_face_id = mss->side_set_faces[i][nct];
stk_classic::mesh::EntityId gid = element->identifier();
stk_classic::mesh::PairIterRelation relations = element->relations(mesh.getSideRank());
stk_classic::mesh::Entity * side = getRelationByID(sculpt_face_id-1,relations)->entity();
if( side != NULL )
{
if(side->owner_rank()==machRank_)
mesh.addEntityToSideset(*side,sideset );
}
}
}
if( sculpt_face_id == -1 )
printf(" ERROR: Could not find the element id for a sideset face \n");
}
}
}
mesh.endModification();
}
void MultiBlockMeshFactory::addSideSets(STK_Interface & mesh) const
{
mesh.beginModification();
std::size_t totalXElems = nXElems_*2;
std::size_t totalYElems = nYElems_*1;
// get all part vectors
stk::mesh::Part * left = mesh.getSideset("left");
stk::mesh::Part * right = mesh.getSideset("right");
stk::mesh::Part * top = mesh.getSideset("top");
stk::mesh::Part * bottom = mesh.getSideset("bottom");
std::vector<stk::mesh::Entity*> localElmts;
mesh.getMyElements(localElmts);
// loop over elements adding edges to sidesets
std::vector<stk::mesh::Entity*>::const_iterator itr;
for(itr=localElmts.begin();itr!=localElmts.end();++itr) {
stk::mesh::Entity * element = (*itr);
stk::mesh::EntityId gid = element->identifier();
stk::mesh::PairIterRelation relations = element->relations(mesh.getEdgeRank());
std::size_t nx,ny;
ny = (gid-1) / totalXElems;
nx = gid-ny*totalXElems-1;
// vertical boundaries
///////////////////////////////////////////
if(nx+1==totalXElems) {
stk::mesh::Entity * edge = getRelationByID(1,relations)->entity();
// on the right
if(edge->owner_rank()==machRank_)
mesh.addEntityToSideset(*edge,right);
}
if(nx==0) {
stk::mesh::Entity * edge = getRelationByID(3,relations)->entity();
// on the left
if(edge->owner_rank()==machRank_)
mesh.addEntityToSideset(*edge,left);
}
// horizontal boundaries
///////////////////////////////////////////
if(ny==0) {
stk::mesh::Entity * edge = getRelationByID(0,relations)->entity();
// on the bottom
if(edge->owner_rank()==machRank_)
mesh.addEntityToSideset(*edge,bottom);
}
if(ny+1==totalYElems) {
stk::mesh::Entity * edge = getRelationByID(2,relations)->entity();
// on the top
if(edge->owner_rank()==machRank_)
mesh.addEntityToSideset(*edge,top);
}
}
mesh.endModification();
}
