STKUNIT_UNIT_TEST(UnitTestField, testFieldWithSelectorAnd)
{
stk_classic::ParallelMachine pm = MPI_COMM_SELF ;
std::ostringstream oss; // to test printing of things w/out spamming cout
typedef stk_classic::mesh::Field<double,shards::ArrayDimension> rank_one_field ;
// specifications for test field
const std::string name0("test_field_0");
const int spatial_dimension = 3;
stk_classic::mesh::fem::FEMMetaData meta_data( spatial_dimension );
stk_classic::mesh::BulkData bulk_data( stk_classic::mesh::fem::FEMMetaData::get_meta_data(meta_data) , pm );
rank_one_field & f0 = meta_data.declare_field< rank_one_field >( name0 );
stk_classic::mesh::EntityRank elem_rank = meta_data.element_rank();
stk_classic::mesh::Part & elements = meta_data.declare_part("Elements", elem_rank);
stk_classic::mesh::Part & hex8s = meta_data.declare_part("Hex8", elem_rank );
stk_classic::mesh::Part & tet4s = meta_data.declare_part("Tet4", elem_rank );
stk_classic::mesh::Selector elem_hex_selector = elements & hex8s;
stk_classic::mesh::Selector elem_tet_selector = elements & tet4s;
std::cout <<"elem_hex_selector: "<< elem_hex_selector << std::endl;
std::cout <<"elem_tet_selector: "<< elem_tet_selector << std::endl;
stk_classic::mesh::put_field( f0 , elem_rank , elem_hex_selector, 8u );
stk_classic::mesh::put_field( f0 , elem_rank , elem_tet_selector, 4u );
stk_classic::mesh::print( oss , " " , f0 );
meta_data.commit();
bulk_data.modification_begin();
// Declare 10 elements on each part
stk_classic::mesh::PartVector parts;
parts.push_back(&elements);
parts.push_back(&hex8s);
for ( unsigned i = 1 ; i < 11 ; ++i ) {
bulk_data.declare_entity( elem_rank , i , parts );
}
parts.clear();
parts.push_back(&elements);
parts.push_back(&tet4s);
for ( unsigned i = 11 ; i < 21 ; ++i ) {
bulk_data.declare_entity( elem_rank , i , parts );
}
stk_classic::mesh::BucketVector f0_buckets;
stk_classic::mesh::get_buckets(elem_hex_selector, bulk_data.buckets(elem_rank), f0_buckets);
BOOST_FOREACH(stk_classic::mesh::Bucket* b, f0_buckets) {
unsigned f0_size = b->field_data_size(f0);
STKUNIT_ASSERT_EQUAL(64u, f0_size);
}
//*
//*
//*
//*
// Two Dimensional Game ofLife Mesh
TwoDimGameofLifeMesh::TwoDimGameofLifeMesh(stk::ParallelMachine comm,
stk::topology elemType,
unsigned width, unsigned height,
stk::mesh::BulkData::AutomaticAuraOption
auraOption)
:GameofLifeMesh(comm, elemType, 2, auraOption), m_width(width), m_height(height),
m_rowsPerProc(height/m_numProcs), m_nodesPerRow(m_width+1)
{
declare_coordinate_field();
meta_data()->commit();
}
//*
//*
//*
//*
//Three Dimensional Game of Life Mesh
ThreeDimGameofLifeMesh::ThreeDimGameofLifeMesh(stk::ParallelMachine comm,
stk::topology elemType, unsigned width,
unsigned height, unsigned depth,
stk::mesh::BulkData::AutomaticAuraOption
auraOption)
:GameofLifeMesh(comm, elemType, 3, auraOption), m_width(width), m_height(height), m_depth(depth),
m_slicesPerProc(depth/m_numProcs), m_nodeWidth(width+1), m_nodeHeight(height+1),
m_nodesPerSlice(m_nodeWidth*m_nodeHeight)
{
declare_coordinate_field();
meta_data()->commit();
}
Loader::ResultStatus CIAContainer::Load(const std::string& filepath) {
FileUtil::IOFile file(filepath, "rb");
if (!file.IsOpen())
return Loader::ResultStatus::Error;
// Load CIA Header
std::vector<u8> header_data(sizeof(Header));
if (file.ReadBytes(header_data.data(), sizeof(Header)) != sizeof(Header))
return Loader::ResultStatus::Error;
Loader::ResultStatus result = LoadHeader(header_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load Title Metadata
std::vector<u8> tmd_data(cia_header.tmd_size);
file.Seek(GetTitleMetadataOffset(), SEEK_SET);
if (file.ReadBytes(tmd_data.data(), cia_header.tmd_size) != cia_header.tmd_size)
return Loader::ResultStatus::Error;
result = LoadTitleMetadata(tmd_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load CIA Metadata
if (cia_header.meta_size) {
std::vector<u8> meta_data(sizeof(Metadata));
file.Seek(GetMetadataOffset(), SEEK_SET);
if (file.ReadBytes(meta_data.data(), sizeof(Metadata)) != sizeof(Metadata))
return Loader::ResultStatus::Error;
result = LoadMetadata(meta_data);
if (result != Loader::ResultStatus::Success)
return result;
}
return Loader::ResultStatus::Success;
}
Loader::ResultStatus CIAContainer::Load(const FileBackend& backend) {
std::vector<u8> header_data(sizeof(Header));
// Load the CIA Header
ResultVal<size_t> read_result = backend.Read(0, sizeof(Header), header_data.data());
if (read_result.Failed() || *read_result != sizeof(Header))
return Loader::ResultStatus::Error;
Loader::ResultStatus result = LoadHeader(header_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load Title Metadata
std::vector<u8> tmd_data(cia_header.tmd_size);
read_result = backend.Read(GetTitleMetadataOffset(), cia_header.tmd_size, tmd_data.data());
if (read_result.Failed() || *read_result != cia_header.tmd_size)
return Loader::ResultStatus::Error;
result = LoadTitleMetadata(tmd_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load CIA Metadata
if (cia_header.meta_size) {
std::vector<u8> meta_data(sizeof(Metadata));
read_result = backend.Read(GetMetadataOffset(), sizeof(Metadata), meta_data.data());
if (read_result.Failed() || *read_result != sizeof(Metadata))
return Loader::ResultStatus::Error;
result = LoadMetadata(meta_data);
if (result != Loader::ResultStatus::Success)
return result;
}
return Loader::ResultStatus::Success;
}
//private
void HexMeshBuilder::declare_coordinates()
{
m_coordinates = &meta_data().declare_field<stk::mesh::Field<double, stk::mesh::Cartesian3d>>(
stk::topology::NODE_RANK, "coordinates");
stk::mesh::put_field(*m_coordinates, meta_data().universal_part(), 3);
}
//---------------------------------------------------------------------------//
// Hex-8 test.
TEUCHOS_UNIT_TEST( STKMeshEntity, hex_8_test )
{
// Extract the raw mpi communicator.
Teuchos::RCP<const Teuchos::Comm<int> > comm = getDefaultComm<int>();
Teuchos::RCP<const Teuchos::MpiComm<int> > mpi_comm =
Teuchos::rcp_dynamic_cast< const Teuchos::MpiComm<int> >( comm );
Teuchos::RCP<const Teuchos::OpaqueWrapper<MPI_Comm> > opaque_comm =
mpi_comm->getRawMpiComm();
MPI_Comm raw_comm = (*opaque_comm)();
// Create meta data.
int space_dim = 3;
stk::mesh::MetaData meta_data( space_dim );
// Make two parts.
std::string p1_name = "part_1";
stk::mesh::Part& part_1 = meta_data.declare_part( p1_name );
stk::mesh::set_topology( part_1, stk::topology::HEX_8 );
int part_1_id = part_1.mesh_meta_data_ordinal();
std::string p2_name = "part_2";
stk::mesh::Part& part_2 = meta_data.declare_part( p2_name );
int part_2_id = part_2.mesh_meta_data_ordinal();
// Make a coordinate field.
stk::mesh::Field<double, stk::mesh::Cartesian3d>& coord_field =
meta_data.declare_field<
stk::mesh::Field<double, stk::mesh::Cartesian3d> >(
stk::topology::NODE_RANK, "coordinates");
meta_data.set_coordinate_field( &coord_field );
stk::mesh::put_field( coord_field, part_1 );
meta_data.commit();
// Create bulk data.
Teuchos::RCP<stk::mesh::BulkData> bulk_data =
Teuchos::rcp( new stk::mesh::BulkData(meta_data,raw_comm) );
bulk_data->modification_begin();
// Make a hex-8.
int comm_rank = comm->getRank();
stk::mesh::EntityId hex_id = 23 + comm_rank;
stk::mesh::Entity hex_entity =
bulk_data->declare_entity( stk::topology::ELEM_RANK, hex_id, part_1 );
int num_nodes = 8;
Teuchos::Array<stk::mesh::EntityId> node_ids( num_nodes );
Teuchos::Array<stk::mesh::Entity> nodes( num_nodes );
for ( int i = 0; i < num_nodes; ++i )
{
node_ids[i] = num_nodes*comm_rank + i + 5;
nodes[i] = bulk_data->declare_entity(
stk::topology::NODE_RANK, node_ids[i], part_1 );
bulk_data->declare_relation( hex_entity, nodes[i], i );
}
bulk_data->modification_end();
// Create the node coordinates.
double* node_coords = 0;
node_coords = stk::mesh::field_data( coord_field, nodes[0] );
node_coords[0] = 0.0;
node_coords[1] = 0.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[1] );
node_coords[0] = 1.0;
node_coords[1] = 0.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[2] );
node_coords[0] = 1.0;
node_coords[1] = 1.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[3] );
node_coords[0] = 0.0;
node_coords[1] = 1.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[4] );
node_coords[0] = 0.0;
node_coords[1] = 0.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[5] );
node_coords[0] = 1.0;
node_coords[1] = 0.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[6] );
node_coords[0] = 1.0;
node_coords[1] = 1.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[7] );
node_coords[0] = 0.0;
node_coords[1] = 1.0;
node_coords[2] = 1.0;
// Create a DTK entity for the hex.
DataTransferKit::Entity dtk_entity =
DataTransferKit::STKMeshEntity( hex_entity, bulk_data.ptr() );
// Print out the entity.
Teuchos::RCP<Teuchos::FancyOStream>
fancy_out = Teuchos::VerboseObjectBase::getDefaultOStream();
dtk_entity.describe( *fancy_out );
// Test the entity.
TEST_EQUALITY( hex_id, dtk_entity.id() );
TEST_EQUALITY( comm_rank, dtk_entity.ownerRank() );
TEST_EQUALITY( 3, dtk_entity.topologicalDimension() );
TEST_EQUALITY( space_dim, dtk_entity.physicalDimension() );
TEST_ASSERT( dtk_entity.inBlock(part_1_id) );
TEST_ASSERT( !dtk_entity.inBlock(part_2_id) );
TEST_ASSERT( dtk_entity.onBoundary(part_1_id) );
TEST_ASSERT( !dtk_entity.onBoundary(part_2_id) );
Teuchos::RCP<DataTransferKit::EntityExtraData> extra_data =
dtk_entity.extraData();
TEST_EQUALITY( hex_entity,
Teuchos::rcp_dynamic_cast<DataTransferKit::STKMeshEntityExtraData>(
extra_data)->d_stk_entity );
Teuchos::Tuple<double,6> hex_bounds;
dtk_entity.boundingBox( hex_bounds );
TEST_EQUALITY( 0.0, hex_bounds[0] );
TEST_EQUALITY( 0.0, hex_bounds[1] );
TEST_EQUALITY( 0.0, hex_bounds[2] );
TEST_EQUALITY( 1.0, hex_bounds[3] );
TEST_EQUALITY( 1.0, hex_bounds[4] );
TEST_EQUALITY( 1.0, hex_bounds[5] );
}
void grammar_parser::parseFile()
{
if (grammar.size() > 0)
{
std::regex meta_data ("Meta Information(.*)Alphabets", std::regex_constants::extended);
std::regex alphabets ("Alphabets(.*)Starting", std::regex_constants::extended);
std::regex starting_symb ("Starting Symbol(.*)Production Rules", std::regex_constants::extended);
std::regex rules_regex ("Production Rules(.*)", std::regex_constants::extended);
std::smatch match;
std::string substring;
printf("Read grammar content : %s", grammar.c_str());
//Parse Meta Information
if (std::regex_search(grammar, match, meta_data))
{
substring = match.str(1);
printf("\ngrammar : %s \nMatched substring : %s\n", grammar.c_str(), substring.c_str());
meta_data = std::regex("(\\w{1,})\\s(\\d+[\\.]?[\\d]*)");
while (std::regex_search(substring, match, meta_data))
{
printf("\nMatched string pattern for meta information : %s\n", match.str().c_str());
//_sleep(1000);
if (match.str(1) == "iterations")
iterations = atoi((match).str(2).c_str());
else if (match.str(1) == "angle")
{
printf("Enters angle recignition\n");
angle = atof(match.str(2).c_str());
}
else
model_data->insert(std::pair<string, float>(match.str(1), atof(match.str(2).c_str())));
substring = match.suffix().str();
}
this->model_data->insert(std::pair <string, float >("iterations", this->iterations));
this->model_data->insert(std::pair <string, float >("angle", this->angle));
}
//Alphabets
if (std::regex_search(grammar, match, alphabets))
{
printf("Matched string pattern for alphabets : %s\n", match.str().c_str());
substring = match.str(1);
alphabets = std::regex("\\w{1}");
while(std::regex_search(substring, match, alphabets))
{
printf("Matched alphabets : %s\n", match.str().c_str());
//_sleep(1000);
this->axioms.push_back(match.str());
substring = match.suffix().str();
}
}
//Starting Symbol
if (std::regex_search(grammar, match, starting_symb))
{
printf("Matched string pattern for starting symbol : %s\n", match.str(1).c_str());
if (match.size() > 0)
this->start_symb = match.str(1);
}
//Production rules
if (std::regex_search(grammar, match, rules_regex))
{
printf("Matched string pattern for rules : %s\n", match.str().c_str());
substring = match.str(0);
rules_regex = std::regex("(\\w+)\\s->\\s([\\w+&^\\\\+-\\[\\]]+)");
while(std::regex_search(substring, match, rules_regex))
{
this->rules->insert(std::pair<string, string>(match.str(1), match.str(2)));
printf("Rules : \n %s -> %s", match.str(1).c_str(), match.str(2).c_str());
//_sleep(100);
substring = match.suffix().str();
}
}
}
}
void testDofMapper( MPI_Comm comm )
{
//First create and fill MetaData and BulkData objects:
const unsigned bucket_size = 100; //for a real application mesh, bucket_size would be much bigger...
stk::mesh::MetaData meta_data( stk::mesh::fem_entity_rank_names() );
stk::mesh::BulkData bulk_data( meta_data, comm, bucket_size );
fill_utest_mesh_meta_data( meta_data );
fill_utest_mesh_bulk_data( bulk_data );
stk::mesh::Selector selector = meta_data.locally_owned_part() | meta_data.globally_shared_part() ;
std::vector<unsigned> count;
stk::mesh::count_entities(selector, bulk_data, count);
STKUNIT_ASSERT_EQUAL( count[stk::mesh::Element], (unsigned)4 );
STKUNIT_ASSERT_EQUAL( count[stk::mesh::Node], (unsigned)20 );
std::vector<stk::mesh::Entity*> nodes;
stk::mesh::get_entities(bulk_data, stk::mesh::Node, nodes);
stk::mesh::ScalarField* temperature_field =
meta_data.get_field<stk::mesh::ScalarField>("temperature");
//Now we're ready to test the DofMapper:
stk::linsys::DofMapper dof_mapper(comm);
const stk::mesh::Selector select_used = meta_data.locally_owned_part() | meta_data.globally_shared_part();
dof_mapper.add_dof_mappings(bulk_data, select_used,
stk::mesh::Node, *temperature_field);
stk::mesh::EntityRank ent_type;
stk::mesh::EntityId ent_id;
const stk::mesh::FieldBase* field = NULL;
int offset_into_field;
int index = 0;
//DofMapper::get_dof can't be called until after DofMapper::finalize() has
//been called.
//We'll call it now to verify that an exception is thrown:
std::cout << "Testing error condition: " << std::endl;
STKUNIT_ASSERT_THROW(dof_mapper.get_dof(index, ent_type, ent_id, field, offset_into_field), std::runtime_error );
std::cout << "...Completed testing error condition." << std::endl;
dof_mapper.finalize();
//find a node that is in the locally-used part:
size_t i_node = 0;
while(! select_used( nodes[i_node]->bucket() ) && i_node<nodes.size()) {
++i_node;
}
//test the get_global_index function:
stk::mesh::EntityId node_id = nodes[i_node]->identifier();
index = dof_mapper.get_global_index(stk::mesh::Node, node_id, *temperature_field);
STKUNIT_ASSERT_EQUAL( index, (int)(node_id-1) );
std::cout << "Testing error condition: " << std::endl;
//call DofMapper::get_global_index with a non-existent ID and verify that an
//exception is thrown:
STKUNIT_ASSERT_THROW(dof_mapper.get_global_index(stk::mesh::Node, (stk::mesh::EntityId)999999, *temperature_field), std::runtime_error);
std::cout << "...Completed testing error condition." << std::endl;
int numProcs = 1;
numProcs = stk::parallel_machine_size( MPI_COMM_WORLD );
fei::SharedPtr<fei::VectorSpace> fei_vspace = dof_mapper.get_fei_VectorSpace();
int numIndices = fei_vspace->getGlobalNumIndices();
STKUNIT_ASSERT_EQUAL( numIndices, (int)(numProcs*20 - (numProcs-1)*4) );
dof_mapper.get_dof(index, ent_type, ent_id, field, offset_into_field);
STKUNIT_ASSERT_EQUAL( ent_type, nodes[i_node]->entity_rank() );
STKUNIT_ASSERT_EQUAL( ent_id, nodes[i_node]->identifier() );
STKUNIT_ASSERT_EQUAL( field->name() == temperature_field->name(), true );
STKUNIT_ASSERT_EQUAL( offset_into_field, (int)0 );
}
bool test_change_owner_3( stk::ParallelMachine pm )
{
const int p_rank = stk::parallel_machine_rank( pm );
const unsigned p_size = stk::parallel_machine_size( pm );
const int spatial_dimension = 2;
stk::mesh::MetaData meta_data( stk::mesh::TopologicalMetaData::entity_rank_names(spatial_dimension) );
stk::mesh::TopologicalMetaData top_data( meta_data, spatial_dimension );
VectorField * coordinates_field =
& put_field(
meta_data.declare_field<VectorField>("coordinates"),
top_data.node_rank,
meta_data.universal_part() ,
3
);
stk::mesh::Part & quad_part = top_data.declare_part<shards::Quadrilateral<4> >( "quad" );
meta_data.commit();
stk::mesh::BulkData bulk_data( meta_data, pm, 100 );
bulk_data.modification_begin();
unsigned nx = 3;
unsigned ny = 3;
if ( p_rank==0 )
{
const unsigned nnx = nx + 1 ;
for ( unsigned iy = 0 ; iy < ny ; ++iy ) {
for ( unsigned ix = 0 ; ix < nx ; ++ix ) {
stk::mesh::EntityId elem = 1 + ix + iy * nx ;
stk::mesh::EntityId nodes[4] ;
nodes[0] = 1 + ix + iy * nnx ;
nodes[1] = 2 + ix + iy * nnx ;
nodes[2] = 2 + ix + ( iy + 1 ) * nnx ;
nodes[3] = 1 + ix + ( iy + 1 ) * nnx ;
stk::mesh::declare_element( bulk_data , quad_part , elem , nodes );
}
}
for ( unsigned iy = 0 ; iy < ny+1 ; ++iy ) {
for ( unsigned ix = 0 ; ix < nx+1 ; ++ix ) {
stk::mesh::EntityId nid = 1 + ix + iy * nnx ;
stk::mesh::Entity * n = bulk_data.get_entity( top_data.node_rank, nid );
double * const coord = stk::mesh::field_data( *coordinates_field , *n );
coord[0] = .1*ix;
coord[1] = .1*iy;
coord[2] = 0;
}
}
}
bulk_data.modification_end();
if ( p_size>1 ) {
std::vector<stk::mesh::EntityProc> ep;
if ( p_rank==0 )
{
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 2 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 3 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 4 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 6 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 7 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 8 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 10 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 11 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 12 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 14 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 15 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 16 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 2 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 5 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 8 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 3 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 6 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 9 ), 1 ) );
}
bulk_data.modification_begin();
bulk_data.change_entity_owner( ep );
bulk_data.modification_end();
// output to debug
ep.clear();
if ( p_rank==0 )
{
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 1 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 5 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 1 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 4 ), 1 ) );
}
else if ( p_rank==1 )
{
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 10 ), 0 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 11 ), 0 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 12 ), 0 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 14 ), 0 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 15 ), 0 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 16 ), 0 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 8 ), 0 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 9 ), 0 ) );
}
bulk_data.modification_begin();
bulk_data.change_entity_owner( ep );
bulk_data.modification_end();
}
return true ;
}
bool test_change_owner_with_constraint( stk::ParallelMachine pm )
{
bool success = true ;
const unsigned p_rank = stk::parallel_machine_rank( pm );
const unsigned p_size = stk::parallel_machine_size( pm );
if ( p_size != 2 ) { return success ; }
unsigned spatial_dimension = 2;
std::vector<std::string> rank_names = stk::mesh::TopologicalMetaData::entity_rank_names(spatial_dimension);
const stk::mesh::EntityRank constraint_rank = rank_names.size();
rank_names.push_back("Constraint");
stk::mesh::MetaData meta_data( rank_names );
stk::mesh::TopologicalMetaData top_data( meta_data, spatial_dimension );
VectorField * coordinates_field =
& put_field(
meta_data.declare_field<VectorField>("coordinates"),
top_data.node_rank,
meta_data.universal_part() ,
3
);
stk::mesh::Part & owned_part = meta_data.locally_owned_part();
stk::mesh::Part & quad_part = top_data.declare_part<shards::Quadrilateral<4> >( "quad" );
meta_data.commit();
stk::mesh::BulkData bulk_data( meta_data, pm, 100 );
bulk_data.modification_begin();
unsigned nx = 3;
unsigned ny = 3;
if ( p_rank==0 )
{
const unsigned nnx = nx + 1 ;
for ( unsigned iy = 0 ; iy < ny ; ++iy ) {
for ( unsigned ix = 0 ; ix < nx ; ++ix ) {
stk::mesh::EntityId elem = 1 + ix + iy * nx ;
stk::mesh::EntityId nodes[4] ;
nodes[0] = 1 + ix + iy * nnx ;
nodes[1] = 2 + ix + iy * nnx ;
nodes[2] = 2 + ix + ( iy + 1 ) * nnx ;
nodes[3] = 1 + ix + ( iy + 1 ) * nnx ;
stk::mesh::declare_element( bulk_data , quad_part , elem , nodes );
}
}
for ( unsigned iy = 0 ; iy < ny+1 ; ++iy ) {
for ( unsigned ix = 0 ; ix < nx+1 ; ++ix ) {
stk::mesh::EntityId nid = 1 + ix + iy * nnx ;
stk::mesh::Entity * n = bulk_data.get_entity( top_data.node_rank, nid );
double * const coord = stk::mesh::field_data( *coordinates_field , *n );
coord[0] = .1*ix;
coord[1] = .1*iy;
coord[2] = 0;
}
}
}
bulk_data.modification_end();
if ( p_size>1 )
{
std::vector<stk::mesh::EntityProc> ep;
if ( p_rank==0 )
{
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 3 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 4 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 7 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 8 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 11 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 12 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 15 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.node_rank, 16 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 3 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 6 ), 1 ) );
ep.push_back( stk::mesh::EntityProc( bulk_data.get_entity( top_data.element_rank, 9 ), 1 ) );
}
bulk_data.modification_begin();
bulk_data.change_entity_owner( ep );
bulk_data.modification_end();
bulk_data.modification_begin();
if ( p_rank==1 )
{
// create constraint
stk::mesh::Entity * n10 = bulk_data.get_entity( top_data.node_rank, 10 );
stk::mesh::Entity * n11 = bulk_data.get_entity( top_data.node_rank, 11 );
stk::mesh::Entity * n12 = bulk_data.get_entity( top_data.node_rank, 12 );
stk::mesh::PartVector add;
add.push_back( &owned_part );
const stk::mesh::EntityId c_entity_id = 1;
stk::mesh::Entity & c = bulk_data.declare_entity( constraint_rank, c_entity_id, add );
bulk_data.declare_relation( c , *n10 , 0 );
bulk_data.declare_relation( c , *n11 , 1 );
bulk_data.declare_relation( c , *n12 , 2 );
}
bulk_data.modification_end();
stk::mesh::Entity * n10 = bulk_data.get_entity( top_data.node_rank, 10 );
if ( p_rank==0 or p_rank==1 )
{
if ( not stk::mesh::in_shared( *n10 ) )
throw std::runtime_error( "NODE[10] not shared" );
}
bulk_data.modification_begin();
if ( p_rank==1 )
{
// destroy constraint
stk::mesh::Entity * c1 = bulk_data.get_entity( constraint_rank, 1 );
if ( not bulk_data.destroy_entity( c1 ) )
{
throw std::runtime_error( "failed to destroy constraint" );
}
}
bulk_data.modification_end();
if ( p_rank==0 or p_rank==1 )
{
if ( stk::mesh::in_shared( *n10 ) )
throw std::runtime_error( "NODE[10] shared" );
}
}
return success ;
}
// private
void TwoDimGameofLifeMesh::declare_coordinate_field()
{
m_nodeCoords = &meta_data()->declare_field<stk::mesh::Field<double,stk::mesh::Cartesian2d>>(
stk::topology::NODE_RANK, "coordinates");
stk::mesh::put_field(*m_nodeCoords, meta_data()->universal_part(), 2);
}
bool use_case_blas_driver(MPI_Comm comm,
int num_threads,
int num_trials,
const std::string &working_directory,
const std::string &mesh_filename,
const std::string &mesh_type,
const std::string &thread_runner,
int bucket_size,
bool performance_test)
{
bool output = !performance_test; // If running for performance measurements, turn off output
if (stk::parallel_machine_rank(comm) == 0) {
std::cout << " stk_mesh Use Case Blas - fill, axpby, dot, norm , begin" << std::endl ;
std::cout << "Running '" << mesh_filename << "' case, num_trials = "
<< num_trials << std::endl;
}
const AlgorithmRunnerInterface* alg_runner = NULL ;
if ( thread_runner.empty() ||
thread_runner == std::string("NonThreaded") ) {
alg_runner = stk::algorithm_runner_non_thread();
}
else if ( thread_runner == std::string("TPI") ) {
alg_runner = stk::algorithm_runner_tpi(num_threads);
}
else if ( thread_runner == std::string("TBB") ) {
alg_runner = stk::algorithm_runner_tbb(num_threads);
}
if (alg_runner != NULL) {
if (stk::parallel_machine_rank(comm) == 0)
std::cout << "Using " << thread_runner
<< " algorithm runner, num_threads = " << num_threads
<< std::endl;
} else {
std::cout << "ERROR, failed to obtain requested AlgorithmRunner '"
<< thread_runner << "'." << std::endl;
return false;
}
//----------------------------------
// Timing:
// [0] = stk::mesh::MetaData creation
// [1] = stk::mesh::BulkData creation
// [2] = Initialization
// [3] = fill and axpby
// [4] = dot and norm2
double time_min[9] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
double time_max[9] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
double wtime = 0 ;
//--------------------------------------------------------------------
reset_malloc_stats();
if ( 0 == stk::parallel_machine_rank( comm ) ) {
std::cout << "stk_mesh performance use case BLAS" << std::endl
<< " Number Processes = " << stk::parallel_machine_size( comm )
<< std::endl ;
std::cout.flush();
}
//--------------------------------------------------------------------
// Initialize IO system. Registers all element types and storage
// types and the exodusII default database type.
Ioss::Init::Initializer init_db;
{
wtime = stk::wall_time();
//------------------------------------------------------------------
// Declare the mesh meta data: element blocks and associated fields
stk::mesh::fem::FEMMetaData meta_data( spatial_dimension );
stk::io::MeshData mesh_data;
std::string filename = working_directory + mesh_filename;
stk::io::create_input_mesh(mesh_type, filename, comm,
meta_data, mesh_data);
stk::io::define_input_fields(mesh_data, meta_data);
Fields fields;
use_case_14_declare_fields(fields, meta_data.get_meta_data(meta_data));
//--------------------------------
// Commit (finalize) the meta data. Is now ready to be used
// in the creation and management of mesh bulk data.
meta_data.commit();
//------------------------------------------------------------------
time_max[0] = stk::wall_dtime( wtime );
//------------------------------------------------------------------
// stk::mesh::BulkData bulk data conforming to the meta data.
stk::mesh::BulkData bulk_data(meta_data.get_meta_data(meta_data) , comm, bucket_size);
stk::io::populate_bulk_data(bulk_data, mesh_data);
//------------------------------------------------------------------
// Create output mesh... (input filename + ".out14")
if (output) {
filename = working_directory + mesh_filename + ".blas";
stk::io::create_output_mesh(filename, comm, bulk_data, mesh_data);
stk::io::define_output_fields(mesh_data, meta_data, true);
}
stk::app::use_case_14_initialize_nodal_data(bulk_data ,
*fields.model_coordinates ,
*fields.coordinates_field ,
*fields.velocity_field,
1.0 /*dt*/);
time_max[1] = stk::wall_dtime( wtime );
//------------------------------------------------------------------
// Ready to run the algorithms:
//------------------------------------------------------------------
//------------------------------------------------------------------
time_max[2] = stk::wall_dtime( wtime );
//------------------------------------------------------------------
wtime = stk::wall_time();
double dot1 = 0;
for(int n=0; n<num_trials; ++n) {
//
// Call BLAS algs.
//
wtime = stk::wall_time();
fill( *alg_runner, bulk_data , stk::mesh::fem::FEMMetaData::NODE_RANK , *fields.velocity_field, 0.2 );
fill( *alg_runner, bulk_data , stk::mesh::fem::FEMMetaData::NODE_RANK , *fields.fint_field, 1.0 );
axpby( *alg_runner, bulk_data , stk::mesh::fem::FEMMetaData::NODE_RANK ,
0.01, *fields.model_coordinates , 1.0 , *fields.coordinates_field );
axpby( *alg_runner, bulk_data , stk::mesh::fem::FEMMetaData::NODE_RANK ,
0.1, *fields.coordinates_field, 1.0 , *fields.velocity_field );
time_max[3] += stk::wall_dtime( wtime );
dot1 = dot( *alg_runner, bulk_data, stk::mesh::fem::FEMMetaData::NODE_RANK ,
*fields.velocity_field, *fields.coordinates_field );
double dot2 = dot( *alg_runner, bulk_data, stk::mesh::fem::FEMMetaData::NODE_RANK,
*fields.velocity_field, *fields.fint_field );
double norm_1 = norm2(*alg_runner, bulk_data, stk::mesh::fem::FEMMetaData::NODE_RANK, *fields.velocity_field );
double norm_2 = norm2(*alg_runner, bulk_data, stk::mesh::fem::FEMMetaData::NODE_RANK, *fields.coordinates_field );
if ( stk::parallel_machine_rank( comm ) == 0 ) {
std::cout << " " << dot1 << " " << dot2 << " " << norm_1 << " " << norm_2 << std::endl;
}
time_max[4] += stk::wall_dtime( wtime );
if (output) {
stk::io::process_output_request(mesh_data, bulk_data, n);
}
}//end for(..num_trials...
if ( stk::parallel_machine_rank( comm ) == 0 ) {
//Try to make sure the number gets printed out just the way we want it,
//so we can use it as a pass/fail check for a regression test...
std::cout.precision(6);
std::cout.setf(std::ios_base::scientific, std::ios_base::floatfield);
std::cout << "Final dot1: " << dot1 << std::endl;
}
//------------------------------------------------------------------
#ifdef USE_GNU_MALLOC_HOOKS
if (parallel_machine_rank(comm) == 0) {
double net_alloc = alloc_MB() - freed_MB();
std::cout << "Mesh creation:" << "\n Total allocated: "
<< alloc_MB()<<"MB in "<<alloc_blks() << " blocks."
<< "\n Total freed: " << freed_MB() << "MB in "
<< freed_blks() << " blocks."
<< "\n Net allocated: "<<net_alloc << "MB."<<std::endl;
}
#endif
//------------------------------------------------------------------
}
time_max[8] = stk::wall_dtime( wtime );
time_min[0] = time_max[0] ;
time_min[1] = time_max[1] ;
time_min[2] = time_max[2] ;
time_min[3] = time_max[3] ;
time_min[4] = time_max[4] ;
time_min[5] = time_max[5] ;
time_min[6] = time_max[6] ;
time_min[7] = time_max[7] ;
time_min[8] = time_max[8] ;
stk::all_reduce( comm , stk::ReduceMax<9>( time_max ) & stk::ReduceMin<9>( time_min ) );
time_max[3] /= num_trials ;
time_max[4] /= num_trials ;
time_max[5] /= num_trials ;
time_max[6] /= num_trials ;
time_min[3] /= num_trials ;
time_min[4] /= num_trials ;
time_min[5] /= num_trials ;
time_min[6] /= num_trials ;
// [0] = stk::mesh::MetaData creation
// [1] = stk::mesh::BulkData creation
// [2] = Initialization
// [3] = Internal force
if ( ! stk::parallel_machine_rank( comm ) ) {
std::cout
<< "stk_mesh performance use case results:" << std::endl
<< " Number of trials = " << num_trials << std::endl
<< " Meta-data setup = " << time_min[0] << " : "
<< time_max[0] << " sec, min : max"
<< std::endl
<< " Bulk-data generation = " << time_min[1] << " : "
<< time_max[1] << " sec, min : max"
<< std::endl
<< " Initialization = " << time_min[2] << " : "
<< time_max[2] << " sec, min : max"
<< std::endl
<< " fill & axpby (per-trial) = " << time_min[3] << " : "
<< time_max[3] << " sec, min : max"
<< std::endl
<< " dot & norm2 (per-trial) = " << time_min[4] << " : "
<< time_max[4] << " sec, min : max"
<< std::endl
<< " Mesh destruction = " << time_min[8] << " : "
<< time_max[8] << " sec, min : max"
<< std::endl
<< std::endl ;
}
return true;
}
//---------------------------------------------------------------------------//
// Hex-8 test.
TEUCHOS_UNIT_TEST( STKMeshEntitySet, hex_8_test )
{
// Extract the raw mpi communicator.
Teuchos::RCP<const Teuchos::Comm<int> > comm = getDefaultComm<int>();
Teuchos::RCP<const Teuchos::MpiComm<int> > mpi_comm =
Teuchos::rcp_dynamic_cast< const Teuchos::MpiComm<int> >( comm );
Teuchos::RCP<const Teuchos::OpaqueWrapper<MPI_Comm> > opaque_comm =
mpi_comm->getRawMpiComm();
MPI_Comm raw_comm = (*opaque_comm)();
// Create meta data.
int space_dim = 3;
stk::mesh::MetaData meta_data( space_dim );
// Make two parts.
std::string p1_name = "part_1";
stk::mesh::Part& part_1 = meta_data.declare_part( p1_name );
stk::mesh::set_topology( part_1, stk::topology::HEX_8 );
int part_1_id = part_1.mesh_meta_data_ordinal();
std::string p2_name = "part_2";
stk::mesh::Part& part_2 = meta_data.declare_part( p2_name );
int part_2_id = part_2.mesh_meta_data_ordinal();
// Make a coordinate field.
stk::mesh::Field<double, stk::mesh::Cartesian3d>& coord_field =
meta_data.declare_field<
stk::mesh::Field<double, stk::mesh::Cartesian3d> >(
stk::topology::NODE_RANK, "coordinates");
meta_data.set_coordinate_field( &coord_field );
stk::mesh::put_field( coord_field, part_1 );
meta_data.commit();
// Create bulk data.
Teuchos::RCP<stk::mesh::BulkData> bulk_data =
Teuchos::rcp( new stk::mesh::BulkData(meta_data,raw_comm) );
bulk_data->modification_begin();
// Make a hex-8.
int comm_rank = comm->getRank();
stk::mesh::EntityId hex_id = 23 + comm_rank;
stk::mesh::Entity hex_entity =
bulk_data->declare_entity( stk::topology::ELEM_RANK, hex_id, part_1 );
unsigned num_nodes = 8;
Teuchos::Array<stk::mesh::EntityId> node_ids( num_nodes );
Teuchos::Array<stk::mesh::Entity> nodes( num_nodes );
for ( unsigned i = 0; i < num_nodes; ++i )
{
node_ids[i] = num_nodes*comm_rank + i + 5;
nodes[i] = bulk_data->declare_entity(
stk::topology::NODE_RANK, node_ids[i], part_1 );
bulk_data->declare_relation( hex_entity, nodes[i], i );
}
bulk_data->modification_end();
// Create the node coordinates.
double* node_coords = 0;
node_coords = stk::mesh::field_data( coord_field, nodes[0] );
node_coords[0] = 0.0;
node_coords[1] = 0.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[1] );
node_coords[0] = 1.0;
node_coords[1] = 0.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[2] );
node_coords[0] = 1.0;
node_coords[1] = 1.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[3] );
node_coords[0] = 0.0;
node_coords[1] = 1.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[4] );
node_coords[0] = 0.0;
node_coords[1] = 0.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[5] );
node_coords[0] = 1.0;
node_coords[1] = 0.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[6] );
node_coords[0] = 1.0;
node_coords[1] = 1.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[7] );
node_coords[0] = 0.0;
node_coords[1] = 1.0;
node_coords[2] = 1.0;
// Create an entity set.
Teuchos::RCP<DataTransferKit::EntitySet> entity_set =
Teuchos::rcp( new DataTransferKit::STKMeshEntitySet(bulk_data) );
// Test the set.
Teuchos::RCP<const Teuchos::Comm<int> > set_comm =
entity_set->communicator();
TEST_EQUALITY( set_comm->getRank(), comm->getRank() );
TEST_EQUALITY( set_comm->getSize(), comm->getSize() );
TEST_EQUALITY( space_dim, entity_set->physicalDimension() );
// Make an iterator for the hex.
std::function<bool(DataTransferKit::Entity)> all_pred =
[=] (DataTransferKit::Entity e){return true;};
DataTransferKit::EntityIterator volume_iterator =
entity_set->entityIterator( space_dim, all_pred );
// Test the volume iterator.
TEST_EQUALITY( volume_iterator.size(), 1 );
TEST_ASSERT( volume_iterator == volume_iterator.begin() );
TEST_ASSERT( volume_iterator != volume_iterator.end() );
// Test the volume under the iterator.
TEST_EQUALITY( hex_id, volume_iterator->id() );
TEST_EQUALITY( comm_rank, volume_iterator->ownerRank() );
TEST_EQUALITY( space_dim, volume_iterator->topologicalDimension() );
TEST_EQUALITY( space_dim, volume_iterator->physicalDimension() );
TEST_ASSERT( volume_iterator->inBlock(part_1_id) );
TEST_ASSERT( !volume_iterator->inBlock(part_2_id) );
TEST_ASSERT( volume_iterator->onBoundary(part_1_id) );
TEST_ASSERT( !volume_iterator->onBoundary(part_2_id) );
Teuchos::RCP<DataTransferKit::EntityExtraData> extra_data_1 =
volume_iterator->extraData();
TEST_EQUALITY( hex_entity,
Teuchos::rcp_dynamic_cast<DataTransferKit::STKMeshEntityExtraData>(
extra_data_1)->d_stk_entity );
Teuchos::Tuple<double,6> hex_bounds_1;
volume_iterator->boundingBox( hex_bounds_1 );
TEST_EQUALITY( 0.0, hex_bounds_1[0] );
TEST_EQUALITY( 0.0, hex_bounds_1[1] );
TEST_EQUALITY( 0.0, hex_bounds_1[2] );
TEST_EQUALITY( 1.0, hex_bounds_1[3] );
TEST_EQUALITY( 1.0, hex_bounds_1[4] );
TEST_EQUALITY( 1.0, hex_bounds_1[5] );
// Test the end of the iterator.
volume_iterator++;
TEST_ASSERT( volume_iterator != volume_iterator.begin() );
TEST_ASSERT( volume_iterator == volume_iterator.end() );
// Make an iterator for the nodes.
DataTransferKit::EntityIterator node_iterator =
entity_set->entityIterator( 0, all_pred );
// Test the node iterator.
TEST_EQUALITY( node_iterator.size(), num_nodes );
TEST_ASSERT( node_iterator == node_iterator.begin() );
TEST_ASSERT( node_iterator != node_iterator.end() );
DataTransferKit::EntityIterator node_begin = node_iterator.begin();
DataTransferKit::EntityIterator node_end = node_iterator.end();
auto node_id_it = node_ids.begin();
for ( node_iterator = node_begin;
node_iterator != node_end;
++node_iterator, ++node_id_it )
{
TEST_EQUALITY( node_iterator->id(), *node_id_it );
}
// Get each entity and check.
DataTransferKit::Entity set_hex;
entity_set->getEntity( hex_id, space_dim, set_hex );
TEST_EQUALITY( set_hex.id(), hex_id );
for ( unsigned i = 0; i < num_nodes; ++i )
{
DataTransferKit::Entity set_node;
entity_set->getEntity( node_ids[i], 0, set_node );
TEST_EQUALITY( set_node.id(), node_ids[i] );
}
// Check the adjacency function.
Teuchos::Array<DataTransferKit::Entity> hex_adjacent_volumes;
entity_set->getAdjacentEntities( set_hex,
space_dim,
hex_adjacent_volumes );
TEST_EQUALITY( 0, hex_adjacent_volumes.size() );
Teuchos::Array<DataTransferKit::Entity> hex_adjacent_nodes;
entity_set->getAdjacentEntities( set_hex, 0, hex_adjacent_nodes );
TEST_EQUALITY( num_nodes, hex_adjacent_nodes.size() );
for ( unsigned i = 0; i < num_nodes; ++i )
{
TEST_EQUALITY( hex_adjacent_nodes[i].id(), node_ids[i] );
}
for ( unsigned i = 0; i < num_nodes; ++i )
{
Teuchos::Array<DataTransferKit::Entity> node_adjacent_volumes;
entity_set->getAdjacentEntities( hex_adjacent_nodes[i],
space_dim,
node_adjacent_volumes );
TEST_EQUALITY( 1, node_adjacent_volumes.size() );
TEST_EQUALITY( node_adjacent_volumes[0].id(), hex_id );
}
}
coord_field_type & get_coordinate_field()
{
coord_field_type * coord_field = meta_data().get_field<coord_field_type>("coordinates");
ThrowRequire( coord_field != NULL);
return * coord_field;
}
//---------------------------------------------------------------------------//
// Hex-8 test.
TEUCHOS_UNIT_TEST( STKMeshEntityIntegrationRule, hex_8_test )
{
// Extract the raw mpi communicator.
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
Teuchos::RCP<const Teuchos::MpiComm<int> > mpi_comm =
Teuchos::rcp_dynamic_cast< const Teuchos::MpiComm<int> >( comm );
Teuchos::RCP<const Teuchos::OpaqueWrapper<MPI_Comm> > opaque_comm =
mpi_comm->getRawMpiComm();
MPI_Comm raw_comm = (*opaque_comm)();
// Create meta data.
int space_dim = 3;
stk::mesh::MetaData meta_data( space_dim );
// Make two parts.
std::string p1_name = "part_1";
stk::mesh::Part& part_1 = meta_data.declare_part( p1_name );
stk::mesh::set_topology( part_1, stk::topology::HEX_8 );
// Make a data field.
stk::mesh::Field<double, stk::mesh::Cartesian3d>& data_field =
meta_data.declare_field<
stk::mesh::Field<double, stk::mesh::Cartesian3d> >(
stk::topology::NODE_RANK, "test field");
meta_data.set_coordinate_field( &data_field );
stk::mesh::put_field( data_field, part_1 );
meta_data.commit();
// Create bulk data.
Teuchos::RCP<stk::mesh::BulkData> bulk_data =
Teuchos::rcp( new stk::mesh::BulkData(meta_data,raw_comm) );
bulk_data->modification_begin();
// Make a hex-8.
int comm_rank = comm->getRank();
stk::mesh::EntityId hex_id = 23 + comm_rank;
stk::mesh::Entity hex_entity =
bulk_data->declare_entity( stk::topology::ELEM_RANK, hex_id, part_1 );
unsigned num_nodes = 8;
Teuchos::Array<stk::mesh::EntityId> node_ids( num_nodes );
Teuchos::Array<stk::mesh::Entity> nodes( num_nodes );
for ( unsigned i = 0; i < num_nodes; ++i )
{
node_ids[i] = num_nodes*comm_rank + i + 5;
nodes[i] = bulk_data->declare_entity(
stk::topology::NODE_RANK, node_ids[i], part_1 );
bulk_data->declare_relation( hex_entity, nodes[i], i );
}
bulk_data->modification_end();
// Create a DTK entity for the hex.
DataTransferKit::Entity dtk_entity =
DataTransferKit::STKMeshEntity( hex_entity, bulk_data.ptr() );
// Create an integration rule.
Teuchos::RCP<DataTransferKit::EntityIntegrationRule> integration_rule =
Teuchos::rcp( new DataTransferKit::STKMeshEntityIntegrationRule(bulk_data) );
// Test the integration rule.
Teuchos::Array<Teuchos::Array<double> > p_1;
Teuchos::Array<double> w_1;
integration_rule->getIntegrationRule( dtk_entity, 1, p_1, w_1 );
TEST_EQUALITY( 1, w_1.size() );
TEST_EQUALITY( 1, p_1.size() );
TEST_EQUALITY( 3, p_1[0].size() );
TEST_EQUALITY( 8.0, w_1[0] );
TEST_EQUALITY( 0.0, p_1[0][0] );
TEST_EQUALITY( 0.0, p_1[0][1] );
TEST_EQUALITY( 0.0, p_1[0][2] );
Teuchos::Array<Teuchos::Array<double> > p_2;
Teuchos::Array<double> w_2;
integration_rule->getIntegrationRule( dtk_entity, 2, p_2, w_2 );
TEST_EQUALITY( 8, w_2.size() );
TEST_EQUALITY( 8, p_2.size() );
for ( int i = 0; i < 8; ++i )
{
TEST_EQUALITY( w_2[i], 1.0 );
TEST_EQUALITY( p_2[i].size(), 3 );
for ( int d = 0; d < 3; ++d )
{
TEST_FLOATING_EQUALITY(
std::abs(p_2[i][d]), 1.0 / std::sqrt(3.0), 1.0e-15 );
}
}
}
//---------------------------------------------------------------------------//
// Hex-8 test.
TEUCHOS_UNIT_TEST( STKMeshEntityIterator, hex_8_test )
{
// Extract the raw mpi communicator.
Teuchos::RCP<const Teuchos::Comm<int> > comm = getDefaultComm<int>();
Teuchos::RCP<const Teuchos::MpiComm<int> > mpi_comm =
Teuchos::rcp_dynamic_cast< const Teuchos::MpiComm<int> >( comm );
Teuchos::RCP<const Teuchos::OpaqueWrapper<MPI_Comm> > opaque_comm =
mpi_comm->getRawMpiComm();
MPI_Comm raw_comm = (*opaque_comm)();
// Create meta data.
int space_dim = 3;
stk::mesh::MetaData meta_data( space_dim );
// Make two parts.
std::string p1_name = "part_1";
stk::mesh::Part& part_1 = meta_data.declare_part( p1_name );
stk::mesh::set_topology( part_1, stk::topology::HEX_8 );
std::string p2_name = "part_2";
stk::mesh::Part& part_2 = meta_data.declare_part( p2_name );
// Make a coordinate field.
stk::mesh::Field<double, stk::mesh::Cartesian3d>& coord_field =
meta_data.declare_field<
stk::mesh::Field<double, stk::mesh::Cartesian3d> >(
stk::topology::NODE_RANK, "coordinates");
meta_data.set_coordinate_field( &coord_field );
stk::mesh::put_field( coord_field, part_1 );
meta_data.commit();
// Create bulk data.
Teuchos::RCP<stk::mesh::BulkData> bulk_data =
Teuchos::rcp( new stk::mesh::BulkData(meta_data,raw_comm) );
bulk_data->modification_begin();
// Make a hex-8.
int comm_rank = comm->getRank();
stk::mesh::EntityId hex_id = 23 + comm_rank;
stk::mesh::Entity hex_entity =
bulk_data->declare_entity( stk::topology::ELEM_RANK, hex_id, part_1 );
int num_nodes = 8;
Teuchos::Array<stk::mesh::EntityId> node_ids( num_nodes );
Teuchos::Array<stk::mesh::Entity> nodes( num_nodes );
for ( int i = 0; i < num_nodes; ++i )
{
node_ids[i] = num_nodes*comm_rank + i + 5;
nodes[i] = bulk_data->declare_entity(
stk::topology::NODE_RANK, node_ids[i], part_1 );
bulk_data->declare_relation( hex_entity, nodes[i], i );
}
bulk_data->modification_end();
// Create the node coordinates.
double* node_coords = 0;
node_coords = stk::mesh::field_data( coord_field, nodes[0] );
node_coords[0] = 0.0;
node_coords[1] = 0.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[1] );
node_coords[0] = 1.0;
node_coords[1] = 0.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[2] );
node_coords[0] = 1.0;
node_coords[1] = 1.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[3] );
node_coords[0] = 0.0;
node_coords[1] = 1.0;
node_coords[2] = 0.0;
node_coords = stk::mesh::field_data( coord_field, nodes[4] );
node_coords[0] = 0.0;
node_coords[1] = 0.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[5] );
node_coords[0] = 1.0;
node_coords[1] = 0.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[6] );
node_coords[0] = 1.0;
node_coords[1] = 1.0;
node_coords[2] = 1.0;
node_coords = stk::mesh::field_data( coord_field, nodes[7] );
node_coords[0] = 0.0;
node_coords[1] = 1.0;
node_coords[2] = 1.0;
// Make a list of hexes.
unsigned num_hex = 2;
std::vector<stk::mesh::Entity> hex_entities( num_hex, hex_entity );
// Make a range for the iterators.
Teuchos::RCP<DataTransferKit::STKMeshEntityIteratorRange> iterator_range =
Teuchos::rcp( new DataTransferKit::STKMeshEntityIteratorRange() );
iterator_range->d_stk_entities = hex_entities;
// Test the name predicate for part 1.
DataTransferKit::STKPartNamePredicate part_1_name_pred(
Teuchos::Array<std::string>(1,p1_name), bulk_data );
DataTransferKit::EntityIterator part_1_name_iterator =
DataTransferKit::STKMeshEntityIterator(
iterator_range, bulk_data, part_1_name_pred.getFunction() );
TEST_EQUALITY( part_1_name_iterator.size(), num_hex );
// Test the name predicate for part 2.
DataTransferKit::STKPartNamePredicate part_2_name_pred(
Teuchos::Array<std::string>(2,p2_name), bulk_data );
DataTransferKit::EntityIterator part_2_name_iterator =
DataTransferKit::STKMeshEntityIterator(
iterator_range, bulk_data, part_2_name_pred.getFunction() );
TEST_EQUALITY( part_2_name_iterator.size(), 0 );
// Test the part vector predicate for part 1.
stk::mesh::PartVector p1_vec( 1, &part_1 );
DataTransferKit::STKPartVectorPredicate part_1_vec_pred( p1_vec );
DataTransferKit::EntityIterator part_1_vec_iterator =
DataTransferKit::STKMeshEntityIterator(
iterator_range, bulk_data, part_1_vec_pred.getFunction() );
TEST_EQUALITY( part_1_vec_iterator.size(), num_hex );
// Test the part vector predicate for part 2.
stk::mesh::PartVector p2_vec( 2, &part_2 );
DataTransferKit::STKPartVectorPredicate part_2_vec_pred( p2_vec );
DataTransferKit::EntityIterator part_2_vec_iterator =
DataTransferKit::STKMeshEntityIterator(
iterator_range, bulk_data, part_2_vec_pred.getFunction() );
TEST_EQUALITY( part_2_vec_iterator.size(), 0 );
// Test a part vector with 2 part 1's.
stk::mesh::PartVector p11_vec( 2, &part_1 );
DataTransferKit::STKPartVectorPredicate part_11_vec_pred( p11_vec );
DataTransferKit::EntityIterator part_11_vec_iterator =
DataTransferKit::STKMeshEntityIterator(
iterator_range, bulk_data, part_11_vec_pred.getFunction() );
TEST_EQUALITY( part_11_vec_iterator.size(), num_hex );
// Test a part vector with a part 1 and part 2
stk::mesh::PartVector p12_vec( 2 );
p12_vec[0] = &part_1;
p12_vec[1] = &part_2;
DataTransferKit::STKPartVectorPredicate part_12_vec_pred( p12_vec );
DataTransferKit::EntityIterator part_12_vec_iterator =
DataTransferKit::STKMeshEntityIterator(
iterator_range, bulk_data, part_12_vec_pred.getFunction() );
TEST_EQUALITY( part_12_vec_iterator.size(), 0 );
// Test the part selector predicate for part 1.
stk::mesh::Selector p1_sel( part_1 );
DataTransferKit::STKSelectorPredicate part_1_sel_pred( p1_sel );
DataTransferKit::EntityIterator part_1_sel_iterator =
DataTransferKit::STKMeshEntityIterator(
iterator_range, bulk_data, part_1_sel_pred.getFunction() );
TEST_EQUALITY( part_1_sel_iterator.size(), num_hex );
// Test the part selector predicate for part 2.
stk::mesh::Selector p2_sel( part_2 );
DataTransferKit::STKSelectorPredicate part_2_sel_pred( p2_sel );
DataTransferKit::EntityIterator part_2_sel_iterator =
DataTransferKit::STKMeshEntityIterator(
iterator_range, bulk_data, part_2_sel_pred.getFunction() );
TEST_EQUALITY( part_2_sel_iterator.size(), 0 );
}
