STKUNIT_UNIT_TEST( PerformanceTestSelector, start)
{
size_t N = 5;
VariableSelectorFixture fix(N);
stk::mesh::Selector selectUnion;
for (size_t part_i = 0 ; part_i<N ; ++part_i) {
selectUnion |= *fix.m_declared_part_vector[part_i];
}
std::vector<stk::mesh::Bucket*> buckets_out;
unsigned entity_rank = 0;
get_buckets(selectUnion, fix.m_BulkData.buckets(entity_rank), buckets_out);
STKUNIT_ASSERT_EQUAL( buckets_out.size(), N );
// Construct once for large N
// Graph time for get_buckets against 1..N
}
STKUNIT_UNIT_TEST(UnitTestTeeStreambuf, UnitTest)
{
stk::tee_streambuf out_tee_streambuf;
std::ostream my_out(&out_tee_streambuf);
std::ostringstream dest1;
std::ostringstream dest2;
out_tee_streambuf.add(&dest1);
out_tee_streambuf.add(&dest2);
std::string message1("This is a test");
std::string message2("This is a test");
std::string message3 = message1 + message2;
my_out << message1;
STKUNIT_ASSERT_EQUAL((dest1.str() == message1), true);
STKUNIT_ASSERT_EQUAL((dest2.str() == message1), true);
out_tee_streambuf.remove(&dest2);
my_out << message2;
STKUNIT_ASSERT_EQUAL((dest1.str() == message3), true);
STKUNIT_ASSERT_EQUAL((dest2.str() == message1), true);
out_tee_streambuf.remove(&dest1);
my_out << message2;
STKUNIT_ASSERT_EQUAL((dest1.str() == message3), true);
STKUNIT_ASSERT_EQUAL((dest2.str() == message1), true);
}
void tests() {
stk_classic::search::ident::IdentProc<uint64_t,unsigned> a(1,0), b;
b = a;
stk_classic::search::ident::IdentProc<uint64_t,unsigned> c(a), d(1,1), e(0,0);
STKUNIT_ASSERT_EQUAL(a == b,true);
STKUNIT_ASSERT_EQUAL(a == d,false);
STKUNIT_ASSERT_EQUAL(a != d,true);
STKUNIT_ASSERT_EQUAL(a != b,false);
STKUNIT_ASSERT_EQUAL(a < d,true);
STKUNIT_ASSERT_EQUAL(a < b,false);
STKUNIT_ASSERT_EQUAL(a > e,true);
STKUNIT_ASSERT_EQUAL(a > b,false);
STKUNIT_ASSERT_EQUAL(a <= b,true);
STKUNIT_ASSERT_EQUAL(a <= d,true);
STKUNIT_ASSERT_EQUAL(a <= e,false);
STKUNIT_ASSERT_EQUAL(a >= b,true);
STKUNIT_ASSERT_EQUAL(a >= d,false);
STKUNIT_ASSERT_EQUAL(a >= e,true);
//use_case::dw() << "Test diag writer for IdentProc: " << a << std::endl;
}
BOOST_FOREACH(stk_classic::mesh::Bucket* b, f0_buckets) {
unsigned f0_size = b->field_data_size(f0);
STKUNIT_ASSERT_EQUAL(32u, f0_size);
}
STKUNIT_UNIT_TEST(UnitTestLinsysFunctions, test1)
{
static const size_t spatial_dimension = 3;
MPI_Barrier( MPI_COMM_WORLD );
MPI_Comm comm = MPI_COMM_WORLD;
//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::fem::FEMMetaData fem_meta;
stk::mesh::fem::FEMMetaData fem_meta2;
fem_meta.FEM_initialize(spatial_dimension);
fem_meta2.FEM_initialize(spatial_dimension);
stk::mesh::MetaData & meta_data = stk::mesh::fem::FEMMetaData::get_meta_data(fem_meta);
stk::mesh::MetaData & meta_data2 = stk::mesh::fem::FEMMetaData::get_meta_data(fem_meta2);
const stk::mesh::EntityRank element_rank = fem_meta.element_rank();
stk::mesh::BulkData bulk_data( meta_data, comm, bucket_size );
stk::mesh::BulkData bulk_data2( meta_data2, comm, bucket_size );
//create a boundary-condition part for testing later:
stk::mesh::Part& bcpart = fem_meta.declare_part("bcpart");
fill_utest_mesh_meta_data( fem_meta );
bool use_temperature=false;
fill_utest_mesh_meta_data( fem_meta2, use_temperature );
fill_utest_mesh_bulk_data( bulk_data );
fill_utest_mesh_bulk_data( bulk_data2 );
//set owner-processors to lowest-sharing (stk::mesh defaults to
//highest-sharing) If highest-sharing owns, then it isn't correct for the
//way the fei library sets ownership of shared nodes for vectors etc.
stk::mesh::set_owners<stk::mesh::LowestRankSharingProcOwns>( bulk_data );
//put a node in our boundary-condition part. arbitrarily choose the
//first locally-owned node:
bulk_data.modification_begin();
std::vector<stk::mesh::Entity*> local_nodes;
stk::mesh::Selector select_owned(meta_data.locally_owned_part());
stk::mesh::get_selected_entities(select_owned,
bulk_data.buckets(NODE_RANK),
local_nodes);
stk::mesh::EntityId bc_node_id = 0;
if (local_nodes.size() > 0) {
stk::mesh::PartVector partvector;
partvector.push_back(&bcpart);
bulk_data.change_entity_parts(*local_nodes[0], partvector);
bc_node_id = stk::linsys::impl::entityid_to_int(local_nodes[0]->identifier());
}
bulk_data.modification_end();
stk::mesh::Selector selector = ( meta_data.locally_owned_part() | meta_data.globally_shared_part() ) & *meta_data.get_part("block_1");
std::vector<unsigned> count;
stk::mesh::count_entities(selector, bulk_data, count);
STKUNIT_ASSERT_EQUAL( count[element_rank], (unsigned)4 );
STKUNIT_ASSERT_EQUAL( count[NODE_RANK], (unsigned)20 );
ScalarField* temperature_field = meta_data.get_field<ScalarField>("temperature");
//Create a fei Factory and stk::linsys::LinearSystem object:
fei::SharedPtr<fei::Factory> factory(new Factory_Trilinos(comm));
stk::linsys::LinearSystem ls(comm, factory);
stk::linsys::add_connectivities(ls, element_rank, NODE_RANK,
*temperature_field, selector, bulk_data);
fei::SharedPtr<fei::MatrixGraph> matgraph = ls.get_fei_MatrixGraph();
int num_blocks = matgraph->getNumConnectivityBlocks();
STKUNIT_ASSERT_EQUAL( num_blocks, (int)1 );
ls.synchronize_mappings_and_structure();
ls.create_fei_LinearSystem();
//put 0 throughout the matrix and 3 throughout the rhs:
fei::SharedPtr<fei::Matrix> mat = ls.get_fei_LinearSystem()->getMatrix();
ls.get_fei_LinearSystem()->getMatrix()->putScalar(0);
ls.get_fei_LinearSystem()->getRHS()->putScalar(3.0);
//put 10 on the matrix diagonal to ensure it will be easy to solve later.
fei::SharedPtr<fei::VectorSpace> vspace = ls.get_fei_LinearSystem()->getRHS()->getVectorSpace();
int numLocalRows = vspace->getNumIndices_Owned();
std::vector<int> local_rows(numLocalRows);
vspace->getIndices_Owned(numLocalRows, &local_rows[0], numLocalRows);
for(size_t i=0; i<local_rows.size(); ++i) {
int col = local_rows[i];
double coef = 10;
double* coefPtr = &coef;
mat->sumIn(1, &local_rows[i], 1, &col, &coefPtr);
}
//now we'll impose a dirichlet bc on our one-node bcpart:
stk::linsys::dirichlet_bc(ls, bulk_data, bcpart, NODE_RANK,
*temperature_field, 0, 9.0);
ls.finalize_assembly();
//now confirm that the rhs value for the equation corresponding to our
//bc node is 9.0:
fei::SharedPtr<fei::Vector> rhsvec = ls.get_fei_LinearSystem()->getRHS();
double rhs_bc_val = 0;
int bc_eqn_index = ls.get_DofMapper().get_global_index(NODE_RANK,
bc_node_id, *temperature_field);
rhsvec->copyOut(1, &bc_eqn_index, &rhs_bc_val);
bool bc_val_is_correct = std::abs(rhs_bc_val - 9.0) < 1.e-13;
STKUNIT_ASSERT( bc_val_is_correct );
stk::linsys::copy_vector_to_mesh( *rhsvec, ls.get_DofMapper(), bulk_data);
stk::mesh::Entity* bc_node = bulk_data.get_entity(NODE_RANK, local_nodes[0]->identifier());
stk::mesh::FieldTraits<ScalarField>::data_type* bc_node_data = stk::mesh::field_data(*temperature_field, *bc_node);
bool bc_node_data_is_correct = std::abs(bc_node_data[0] - 9.0) < 1.e-13;
STKUNIT_ASSERT( bc_node_data_is_correct );
//now make sure we get a throw if we use the wrong bulk-data (that doesn't have the
//temperature field defined)
STKUNIT_ASSERT_THROW(stk::linsys::copy_vector_to_mesh( *rhsvec, ls.get_DofMapper(), bulk_data2), std::runtime_error);
//obtain and zero the solution vector
fei::SharedPtr<fei::Vector> solnvec = ls.get_fei_LinearSystem()->getSolutionVector();
solnvec->putScalar(0);
//copy the vector of zeros into the mesh:
stk::linsys::copy_vector_to_mesh( *solnvec, ls.get_DofMapper(), bulk_data);
//assert that our bc node's data is now zero.
bc_node_data_is_correct = std::abs(bc_node_data[0] - 0) < 1.e-13;
STKUNIT_ASSERT( bc_node_data_is_correct );
//call the linear-system solve function.
//(note that when we add options to the solve method, we'll need to enhance this
//testing to exercise various specific solves.)
Teuchos::ParameterList params;
int status = 0;
ls.solve(status, params);
//copy the solution-vector into the mesh:
stk::linsys::copy_vector_to_mesh( *solnvec, ls.get_DofMapper(), bulk_data);
//now assert that the value 9 (bc value) produced by the solve is in this
//node's data.
//note that we use a loose tolerance, because the default solver tolerance
//is (I think) only 1.e-6.
bc_node_data_is_correct = std::abs(bc_node_data[0] - 9.0) < 1.e-6;
STKUNIT_ASSERT( bc_node_data_is_correct );
STKUNIT_ASSERT(bc_node_data_is_correct);
}
STKUNIT_UNIT_TEST(UnitTestLinsysFunctions, test3)
{
static const size_t spatial_dimension = 3;
MPI_Barrier( MPI_COMM_WORLD );
MPI_Comm comm = MPI_COMM_WORLD;
//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::fem::FEMMetaData fem_meta;
fem_meta.FEM_initialize(spatial_dimension);
stk::mesh::MetaData & meta_data = stk::mesh::fem::FEMMetaData::get_meta_data(fem_meta);
stk::mesh::BulkData bulk_data( meta_data, comm, bucket_size );
fill_utest_mesh_meta_data( fem_meta );
fill_utest_mesh_bulk_data( bulk_data );
//set owner-processors to lowest-sharing (stk::mesh defaults to
//highest-sharing) If highest-sharing owns, then it isn't correct for the
//way the fei library sets ownership of shared nodes for vectors etc.
stk::mesh::set_owners<stk::mesh::LowestRankSharingProcOwns>( bulk_data );
stk::mesh::Selector selector = ( meta_data.locally_owned_part() | meta_data.globally_shared_part() ) & *meta_data.get_part("block_1");
std::vector<unsigned> count;
stk::mesh::count_entities(selector, bulk_data, count);
const stk::mesh::EntityRank element_rank = fem_meta.element_rank();
STKUNIT_ASSERT_EQUAL( count[element_rank], (unsigned)4 );
STKUNIT_ASSERT_EQUAL( count[NODE_RANK], (unsigned)20 );
ScalarField* temperature_field = meta_data.get_field<ScalarField>("temperature");
//Create a fei Factory and stk::linsys::LinearSystem object:
fei::SharedPtr<fei::Factory> factory(new Factory_Trilinos(comm));
stk::linsys::LinearSystem ls(comm, factory);
stk::linsys::add_connectivities(ls, element_rank, NODE_RANK,
*temperature_field, selector, bulk_data);
fei::SharedPtr<fei::MatrixGraph> matgraph = ls.get_fei_MatrixGraph();
int num_blocks = matgraph->getNumConnectivityBlocks();
STKUNIT_ASSERT_EQUAL( num_blocks, (int)1 );
ls.synchronize_mappings_and_structure();
ls.create_fei_LinearSystem();
//put 3 throughout the matrix and 3 throughout the rhs:
fei::SharedPtr<fei::Matrix> mat = ls.get_fei_LinearSystem()->getMatrix();
mat->putScalar(3.0);
ls.get_fei_LinearSystem()->getRHS()->putScalar(3.0);
fei::SharedPtr<fei::Vector> rhsvec = ls.get_fei_LinearSystem()->getRHS();
stk::linsys::scale_vector(2, *rhsvec);
stk::linsys::scale_matrix(2, *mat);
//now the rhs and matrix contain 6.
//create another matrix and vector:
fei::SharedPtr<fei::Matrix> mat2 = factory->createMatrix(matgraph);
fei::SharedPtr<fei::Vector> vec2 = factory->createVector(matgraph);
mat2->putScalar(3.0);
vec2->putScalar(3.0);
//add 3*mat to mat2
stk::linsys::add_matrix_to_matrix(3.0, *mat, *mat2);
//confirm that mat2 contains 21:
bool result = confirm_matrix_values(*mat2, 21);
STKUNIT_ASSERT(result);
//add 3*rhsvec to vec2:
stk::linsys::add_vector_to_vector(3.0, *rhsvec, *vec2);
//confirm that vec2 contains 21:
result = confirm_vector_values(*vec2, 21);
STKUNIT_ASSERT(result);
}
STKUNIT_UNIT_TEST(UnitTestTimer, UnitTest)
{
stk_classic::diag::TimeBlock root_time_block(unitTestTimer());
std::ostringstream strout;
// Create subtimer and test lap time
{
static stk_classic::diag::Timer lap_timer("One second Wall time twice", unitTestTimer());
stk_classic::diag::TimeBlock _time(lap_timer);
double x = quick_work();
x = x;
std::ostringstream oss;
oss << x << std::endl;
::sleep(1);
lap_timer.lap();
stk_classic::diag::MetricTraits<stk_classic::diag::WallTime>::Type lap_time = lap_timer.getMetric<stk_classic::diag::WallTime>().getLap();
STKUNIT_ASSERT(lap_time >= 1.0);
::sleep(1);
lap_timer.stop();
lap_time = lap_timer.getMetric<stk_classic::diag::WallTime>().getLap();
STKUNIT_ASSERT(lap_time >= 2.0);
}
//
{
static stk_classic::diag::Timer run_timer("Run 100 times twice", unitTestTimer());
for (int i = 0; i < 100; ++i) {
stk_classic::diag::TimeBlock _time(run_timer);
work();
}
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = run_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT(lap_count == 100);
}
// Create second timer set
{
static stk_classic::diag::Timer second_timer("Second timer set", unitTestTimer(), unitTestSecondTimerSet());
static stk_classic::diag::Timer second_timer_on_default("On default", second_timer);
static stk_classic::diag::Timer second_timer_on("On", TIMER_APP_3, second_timer);
static stk_classic::diag::Timer second_timer_off("Off", TIMER_APP_1, second_timer);
stk_classic::diag::TimeBlock _time(second_timer);
stk_classic::diag::TimeBlock _time1(second_timer_on_default);
stk_classic::diag::TimeBlock _time2(second_timer_on);
stk_classic::diag::TimeBlock _time3(second_timer_off);
::sleep(1);
}
// Grab previous subtimer and run 100 laps
{
static stk_classic::diag::Timer run_timer("Run 100 times twice", unitTestTimer());
for (int i = 0; i < 100; ++i) {
stk_classic::diag::TimeBlock _time(run_timer);
work();
}
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = run_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT(lap_count == 200);
}
// Create root object
RootObject root_object;
{
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = root_object.m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT(lap_count == 0);
}
// Create object
{
Object time_object("One object", root_object);
for (int i = 0; i < 100; ++i) {
time_object.run();
}
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = time_object.m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT(lap_count == 100);
}
// Create object tree
{
std::vector<Object> object_vector;
object_vector.push_back(Object("Object Tree", root_object));
int id = 0;
for (size_t i = 0; i < 2; ++i) {
size_t ix = object_vector.size();
object_vector.push_back(Object(id++, object_vector[0]));
for (size_t j = 0; j < 2; ++j) {
size_t jx = object_vector.size();
object_vector.push_back(Object(id++, object_vector[ix]));
for (int k = 0; k < 2; ++k) {
object_vector.push_back(Object(id++, object_vector[jx]));
}
}
}
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, false);
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = 0;
for (size_t j = 0; j < object_vector.size(); ++j)
lap_count += object_vector[j].m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT_EQUAL(lap_count, stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type(0));
for (size_t j = 0; j < object_vector.size(); ++j)
object_vector[j].run();
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, false);
lap_count = 0;
for (size_t j = 0; j < object_vector.size(); ++j)
lap_count += object_vector[j].m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT_EQUAL(lap_count, stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type(object_vector.size()));
for (size_t i = 1; i < 100; ++i)
for (size_t j = 0; j < object_vector.size(); ++j)
object_vector[j].run();
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, false);
lap_count = 0;
for (size_t j = 0; j < object_vector.size(); ++j)
lap_count += object_vector[j].m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT_EQUAL(lap_count, stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type(100*object_vector.size()));
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, true);
for (size_t i = 1; i < 100; ++i)
for (size_t j = 0; j < object_vector.size(); ++j)
object_vector[j].run();
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, true);
std::cout << strout.str() << std::endl;
// dw().m(LOG_TIMER) << strout.str() << stk_classic::diag::dendl;
}
}
void UnitTestBulkData::testChangeParts( ParallelMachine pm )
{
static const char method[] =
"stk::mesh::UnitTestBulkData::testChangeParts" ;
std::cout << std::endl << method << std::endl ;
const unsigned p_size = parallel_machine_size( pm );
const unsigned p_rank = parallel_machine_rank( pm );
if ( 1 < p_size ) return ;
// Single process, no sharing
// Meta data with entity ranks [0..9]
std::vector<std::string> entity_names(10);
for ( size_t i = 0 ; i < 10 ; ++i ) {
std::ostringstream name ;
name << "EntityRank_" << i ;
entity_names[i] = name.str();
}
MetaData meta( entity_names );
BulkData bulk( meta , pm , 100 );
Part & part_univ = meta.universal_part();
Part & part_owns = meta.locally_owned_part();
Part & part_A_0 = meta.declare_part( std::string("A_0") , 0 );
Part & part_A_1 = meta.declare_part( std::string("A_1") , 1 );
Part & part_A_2 = meta.declare_part( std::string("A_2") , 2 );
Part & part_A_3 = meta.declare_part( std::string("A_3") , 3 );
Part & part_B_0 = meta.declare_part( std::string("B_0") , 0 );
// Part & part_B_1 = meta.declare_part( std::string("B_1") , 1 );
Part & part_B_2 = meta.declare_part( std::string("B_2") , 2 );
// Part & part_B_3 = meta.declare_part( std::string("B_3") , 3 );
meta.commit();
bulk.modification_begin();
PartVector tmp(1);
tmp[0] = & part_A_0 ;
Entity & entity_0_1 = bulk.declare_entity( 0 , 1 , tmp );
tmp[0] = & part_A_1 ;
Entity & entity_1_1 = bulk.declare_entity( 1 , 1 , tmp );
tmp[0] = & part_A_2 ;
Entity & entity_2_1 = bulk.declare_entity( 2 , 1 , tmp );
tmp[0] = & part_A_3 ;
Entity & entity_3_1 = bulk.declare_entity( 3 , 1 , tmp );
entity_0_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
entity_1_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_1 );
entity_2_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_2 );
entity_3_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_3 );
{
tmp.resize(1);
tmp[0] = & part_A_0 ;
bulk.change_entity_parts( entity_0_1 , tmp );
entity_0_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
}
{ // Add a new part:
tmp.resize(1);
tmp[0] = & part_B_0 ;
bulk.change_entity_parts( entity_0_1 , tmp );
entity_0_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(4) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
STKUNIT_ASSERT( tmp[3] == & part_B_0 );
}
{ // Remove the part just added:
tmp.resize(1);
tmp[0] = & part_B_0 ;
bulk.change_entity_parts( entity_0_1 , PartVector() , tmp );
entity_0_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
}
{ // Relationship induced membership:
bulk.declare_relation( entity_1_1 , entity_0_1 , 0 );
entity_0_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(4) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
STKUNIT_ASSERT( tmp[3] == & part_A_1 );
}
{ // Remove relationship induced membership:
bulk.destroy_relation( entity_1_1 , entity_0_1 );
entity_0_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
}
{ // Add a new part:
tmp.resize(1);
tmp[0] = & part_B_2 ;
bulk.change_entity_parts( entity_2_1 , tmp );
entity_2_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(4) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_2 );
STKUNIT_ASSERT( tmp[3] == & part_B_2 );
}
{ // Relationship induced membership:
bulk.declare_relation( entity_2_1 , entity_0_1 , 0 );
entity_0_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(5) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
STKUNIT_ASSERT( tmp[3] == & part_A_2 );
STKUNIT_ASSERT( tmp[4] == & part_B_2 );
}
{ // Remove relationship induced membership:
bulk.destroy_relation( entity_2_1 , entity_0_1 );
entity_0_1.bucket().supersets( tmp );
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
}
bulk.modification_end();
//------------------------------
// Now the parallel fun. Existing entities should be shared
// by all processes since they have the same identifiers.
// They should also have the same parts.
entity_0_1.bucket().supersets( tmp );
if ( entity_0_1.owner_rank() == p_rank ) {
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
}
else {
STKUNIT_ASSERT_EQUAL( size_t(2) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_A_0 );
}
entity_2_1.bucket().supersets( tmp );
if ( entity_2_1.owner_rank() == p_rank ) {
STKUNIT_ASSERT_EQUAL( size_t(4) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_2 );
STKUNIT_ASSERT( tmp[3] == & part_B_2 );
}
else {
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_A_2 );
STKUNIT_ASSERT( tmp[2] == & part_B_2 );
}
if (bulk.parallel_size() > 1) {
STKUNIT_ASSERT_EQUAL( size_t(p_size - 1) , entity_0_1.sharing().size() );
STKUNIT_ASSERT_EQUAL( size_t(p_size - 1) , entity_1_1.sharing().size() );
STKUNIT_ASSERT_EQUAL( size_t(p_size - 1) , entity_2_1.sharing().size() );
STKUNIT_ASSERT_EQUAL( size_t(p_size - 1) , entity_3_1.sharing().size() );
}
bulk.modification_begin();
// Add a new part on the owning process:
int ok_to_modify = entity_0_1.owner_rank() == p_rank ;
try {
tmp.resize(1);
tmp[0] = & part_B_0 ;
bulk.change_entity_parts( entity_0_1 , tmp );
STKUNIT_ASSERT( ok_to_modify );
}
catch( const std::exception & x ) {
STKUNIT_ASSERT( ! ok_to_modify );
}
entity_0_1.bucket().supersets( tmp );
if ( entity_0_1.owner_rank() == p_rank ) {
STKUNIT_ASSERT_EQUAL( size_t(4) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
STKUNIT_ASSERT( tmp[3] == & part_B_0 );
}
else {
STKUNIT_ASSERT_EQUAL( size_t(2) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_A_0 );
}
bulk.modification_end();
entity_0_1.bucket().supersets( tmp );
if ( entity_0_1.owner_rank() == p_rank ) {
STKUNIT_ASSERT_EQUAL( size_t(4) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_owns );
STKUNIT_ASSERT( tmp[2] == & part_A_0 );
STKUNIT_ASSERT( tmp[3] == & part_B_0 );
}
else {
STKUNIT_ASSERT_EQUAL( size_t(3) , tmp.size() );
STKUNIT_ASSERT( tmp[0] == & part_univ );
STKUNIT_ASSERT( tmp[1] == & part_A_0 );
STKUNIT_ASSERT( tmp[2] == & part_B_0 );
}
}
STKUNIT_UNIT_TEST(UnitTestFormatTime, UnitTest)
{
double time = 41.399684906;
STKUNIT_ASSERT_EQUAL((std::string("41") == stk::formatTime(time, stk::TIMEFORMAT_HMS)), true);
STKUNIT_ASSERT_EQUAL((std::string("41.400") == stk::formatTime(time, stk::TIMEFORMAT_HMS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("41") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS)), true);
STKUNIT_ASSERT_EQUAL((std::string("41.400") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("41.3997") == stk::formatTime(time, stk::TIMEFORMAT_NONE)), true);
time = 441.399684906;
STKUNIT_ASSERT_EQUAL((std::string("7:21") == stk::formatTime(time, stk::TIMEFORMAT_HMS)), true);
STKUNIT_ASSERT_EQUAL((std::string("7:21.400") == stk::formatTime(time, stk::TIMEFORMAT_HMS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("441") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS)), true);
STKUNIT_ASSERT_EQUAL((std::string("441.400") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("441.4") == stk::formatTime(time, stk::TIMEFORMAT_NONE)), true);
time = 5441.399684906;
STKUNIT_ASSERT_EQUAL((std::string("1:30:41") == stk::formatTime(time, stk::TIMEFORMAT_HMS)), true);
STKUNIT_ASSERT_EQUAL((std::string("1:30:41.400") == stk::formatTime(time, stk::TIMEFORMAT_HMS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("5441") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS)), true);
STKUNIT_ASSERT_EQUAL((std::string("5441.400") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("5441.4") == stk::formatTime(time, stk::TIMEFORMAT_NONE)), true);
time = 1251305441.399684906;
STKUNIT_ASSERT_EQUAL((std::string("347584:50:41") == stk::formatTime(time, stk::TIMEFORMAT_HMS)), true);
STKUNIT_ASSERT_EQUAL((std::string("347584:50:41.400") == stk::formatTime(time, stk::TIMEFORMAT_HMS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("1251305441") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS)), true);
STKUNIT_ASSERT_EQUAL((std::string("1251305441.400") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("1.25131e+09") == stk::formatTime(time, stk::TIMEFORMAT_NONE)), true);
time = -41.399684906;
STKUNIT_ASSERT_EQUAL((std::string("-41") == stk::formatTime(time, stk::TIMEFORMAT_HMS)), true);
STKUNIT_ASSERT_EQUAL((std::string("-41.400") == stk::formatTime(time, stk::TIMEFORMAT_HMS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("-41") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS)), true);
STKUNIT_ASSERT_EQUAL((std::string("-41.400") == stk::formatTime(time, stk::TIMEFORMAT_SECONDS | stk::TIMEFORMAT_MILLIS)), true);
STKUNIT_ASSERT_EQUAL((std::string("-41.3997") == stk::formatTime(time, stk::TIMEFORMAT_NONE)), true);
}
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 );
}
