ErrorCode SpectralMeshTool::create_spectral_elems(const T *conn, int num_fine_elems, int dim,
Range &output_range, int start_idx, Range *local_gids)
{
assert(spectralOrder && num_fine_elems);
// now create num_coarse_elems
// compute the number of local elems, accounting for coarse or fine representation
// spectral_unit is the # fine elems per coarse elem, or spectralOrder^2
int spectral_unit = spectralOrder*spectralOrder;
int num_coarse_elems = num_fine_elems / spectral_unit;
EntityHandle *new_conn;
EntityHandle start_elem;
ReadUtilIface *rmi;
ErrorCode rval = mbImpl->query_interface(rmi);
if (MB_SUCCESS != rval) return rval;
int verts_per_felem = spectralOrderp1*spectralOrderp1,
verts_per_celem = std::pow((double)2.0, dim);
rval = rmi->get_element_connect(num_coarse_elems, verts_per_celem,
(2 == dim ? MBQUAD : MBHEX), 0,
start_elem, new_conn);MB_CHK_SET_ERR(rval, "Failed to create elems");
output_range.insert(start_elem, start_elem + num_coarse_elems - 1);
// read connectivity into that space
// permute_array takes a 4*order^2-long vector of integers, representing the connectivity of order^2
// elems (fine elems in a coarse elem), and picks out the ids of the vertices necessary
// to get a lexicographically-ordered array of vertices in a spectral element of that order
//assert(verts_per_felem == (sizeof(permute_array)/sizeof(unsigned int)));
// we're assuming here that elems was empty on input
int count;
EntityHandle *sv_ptr = NULL;
rval = mbImpl->tag_iterate(spectral_vertices_tag(true), output_range.begin(), output_range.end(), count,
(void*&)sv_ptr);MB_CHK_SET_ERR(rval, "Failed to get SPECTRAL_VERTICES ptr");
assert(count == num_coarse_elems);
int f = start_idx, fs = 0, fl = 0;
for (int c = 0; c < num_coarse_elems; c++) {
for (int i = 0; i < verts_per_celem; i++)
new_conn[fl+i] = conn[f+lin_permute_array[i]];
fl += verts_per_celem;
for (int i = 0; i < verts_per_felem; i++)
sv_ptr[fs+i] = conn[f+permute_array[i]];
f += verts_per_celem*spectral_unit;
fs += verts_per_felem;
}
if (local_gids)
std::copy(sv_ptr, sv_ptr+verts_per_felem*num_coarse_elems, range_inserter(*local_gids));
return MB_SUCCESS;
}
void test_write_invalid_elem()
{
Core mbcore;
Interface& moab = mbcore;
ReadUtilIface* readtool = 0;
ErrorCode rval;
rval = moab.query_interface( readtool );
CHECK_ERR(rval);
CHECK( readtool != 0 );
// create two nodes
EntityHandle first_node;
std::vector<double*> coords;
rval = readtool->get_node_coords( 3, 2, 1, first_node, coords );
CHECK_ERR(rval);
coords[0][0] = coords[0][1] = 0.0;
coords[1][0] = coords[1][1] = 0.0;
coords[2][0] = coords[2][1] = 0.0;
// create a triangle with an invalid node handle for its
// third vertex
EntityHandle tri;
EntityHandle* conn = 0;
rval = readtool->get_element_connect( 1, 3, MBTRI, 1, tri, conn );
CHECK_ERR(rval);
conn[0] = first_node; // valid
conn[1] = first_node+1; // valid
conn[2] = first_node+2; // invalid
// try to write the file (should fail)
WriteHDF5 writer( &moab );
FileOptions opts(0);
rval = writer.write_file( filename, true, opts, 0, 0, std::vector<std::string>() );
CHECK(MB_SUCCESS != rval);
}
void test_gather_onevar()
{
Core moab;
Interface& mb = moab;
EntityHandle file_set;
ErrorCode rval = mb.create_meshset(MESHSET_SET, file_set);
CHECK_ERR(rval);
std::string opts;
get_options(opts);
// Read cell variable vorticity and create gather set on processor 0
opts += ";VARIABLE=vorticity;GATHER_SET=0";
rval = mb.load_file(example, &file_set, opts.c_str());
CHECK_ERR(rval);
#ifdef MOAB_HAVE_MPI
ParallelComm* pcomm = ParallelComm::get_pcomm(&mb, 0);
int rank = pcomm->proc_config().proc_rank();
Range cells, cells_owned;
rval = mb.get_entities_by_type(file_set, MBPOLYGON, cells);
CHECK_ERR(rval);
// Get local owned cells
rval = pcomm->filter_pstatus(cells, PSTATUS_NOT_OWNED, PSTATUS_NOT, -1, &cells_owned);
CHECK_ERR(rval);
EntityHandle gather_set = 0;
if (0 == rank) {
// Get gather set
ReadUtilIface* readUtilIface;
mb.query_interface(readUtilIface);
rval = readUtilIface->get_gather_set(gather_set);
CHECK_ERR(rval);
assert(gather_set != 0);
}
Tag vorticity_tag0, gid_tag;
rval = mb.tag_get_handle("vorticity0", layers, MB_TYPE_DOUBLE, vorticity_tag0, MB_TAG_DENSE);
CHECK_ERR(rval);
rval = mb.tag_get_handle(GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag, MB_TAG_DENSE);
CHECK_ERR(rval);
pcomm->gather_data(cells_owned, vorticity_tag0, gid_tag, gather_set, 0);
if (0 == rank) {
// Get gather set cells
Range gather_set_cells;
rval = mb.get_entities_by_type(gather_set, MBPOLYGON, gather_set_cells);
CHECK_ERR(rval);
CHECK_EQUAL((size_t)642, gather_set_cells.size());
CHECK_EQUAL((size_t)1, gather_set_cells.psize());
// Check vorticity0 tag values on 4 gather set cells: first cell, two median cells, and last cell
EntityHandle cell_ents[] = {gather_set_cells[0], gather_set_cells[320],
gather_set_cells[321], gather_set_cells[641]};
double vorticity0_val[4 * layers];
rval = mb.tag_get_data(vorticity_tag0, cell_ents, 4, vorticity0_val);
CHECK_ERR(rval);
// Only check first two layers
// Layer 0
CHECK_REAL_EQUAL(3.629994, vorticity0_val[0 * layers], eps);
CHECK_REAL_EQUAL(0.131688, vorticity0_val[1 * layers], eps);
CHECK_REAL_EQUAL(-0.554888, vorticity0_val[2 * layers], eps);
CHECK_REAL_EQUAL(-0.554888, vorticity0_val[3 * layers], eps);
// Layer 1
CHECK_REAL_EQUAL(3.629944, vorticity0_val[0 * layers + 1], eps);
CHECK_REAL_EQUAL(0.131686, vorticity0_val[1 * layers + 1], eps);
CHECK_REAL_EQUAL(-0.554881, vorticity0_val[2 * layers + 1], eps);
CHECK_REAL_EQUAL(-0.554881, vorticity0_val[3 * layers + 1], eps);
}
#endif
}
void gather_one_cell_var(int gather_set_rank)
{
Core moab;
Interface& mb = moab;
EntityHandle file_set;
ErrorCode rval = mb.create_meshset(MESHSET_SET, file_set);
CHECK_ERR(rval);
read_options = "PARALLEL=READ_PART;PARTITION_METHOD=TRIVIAL;PARALLEL_RESOLVE_SHARED_ENTS";
std::ostringstream gather_set_option;
gather_set_option << ";GATHER_SET=" << gather_set_rank;
read_options += gather_set_option.str();
rval = mb.load_file(example, &file_set, read_options.c_str());
CHECK_ERR(rval);
ParallelComm* pcomm = ParallelComm::get_pcomm(&mb, 0);
int procs = pcomm->proc_config().proc_size();
int rank = pcomm->proc_config().proc_rank();
// Make sure gather_set_rank is valid
if (gather_set_rank < 0 || gather_set_rank >= procs)
return;
Range cells, cells_owned;
rval = mb.get_entities_by_type(file_set, MBPOLYGON, cells);
CHECK_ERR(rval);
// Get local owned cells
rval = pcomm->filter_pstatus(cells, PSTATUS_NOT_OWNED, PSTATUS_NOT, -1, &cells_owned);
CHECK_ERR(rval);
EntityHandle gather_set = 0;
if (gather_set_rank == rank) {
// Get gather set
ReadUtilIface* readUtilIface;
mb.query_interface(readUtilIface);
rval = readUtilIface->get_gather_set(gather_set);
CHECK_ERR(rval);
assert(gather_set != 0);
}
Tag vorticity_tag0, gid_tag;
rval = mb.tag_get_handle("vorticity0", layers, MB_TYPE_DOUBLE, vorticity_tag0, MB_TAG_DENSE);
CHECK_ERR(rval);
rval = mb.tag_get_handle(GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag, MB_TAG_DENSE);
CHECK_ERR(rval);
pcomm->gather_data(cells_owned, vorticity_tag0, gid_tag, gather_set, gather_set_rank);
if (gather_set_rank == rank) {
// Get gather set cells
Range gather_set_cells;
rval = mb.get_entities_by_type(gather_set, MBPOLYGON, gather_set_cells);
CHECK_ERR(rval);
CHECK_EQUAL((size_t)642, gather_set_cells.size());
CHECK_EQUAL((size_t)1, gather_set_cells.psize());
// Check vorticity0 tag values on 4 gather set cells: first cell, two median cells, and last cell
EntityHandle cell_ents[] = {gather_set_cells[0], gather_set_cells[320],
gather_set_cells[321], gather_set_cells[641]};
double vorticity0_val[4 * layers];
rval = mb.tag_get_data(vorticity_tag0, &cell_ents[0], 4, vorticity0_val);
CHECK_ERR(rval);
// Only check first two layers
// Layer 0
CHECK_REAL_EQUAL(3.629994, vorticity0_val[0 * layers], eps);
CHECK_REAL_EQUAL(0.131688, vorticity0_val[1 * layers], eps);
CHECK_REAL_EQUAL(-0.554888, vorticity0_val[2 * layers], eps);
CHECK_REAL_EQUAL(-0.554888, vorticity0_val[3 * layers], eps);
// Layer 1
CHECK_REAL_EQUAL(3.629944, vorticity0_val[0 * layers + 1], eps);
CHECK_REAL_EQUAL(0.131686, vorticity0_val[1 * layers + 1], eps);
CHECK_REAL_EQUAL(-0.554881, vorticity0_val[2 * layers + 1], eps);
CHECK_REAL_EQUAL(-0.554881, vorticity0_val[3 * layers + 1], eps);
}
}
void test_gather_onevar()
{
Core moab;
Interface& mb = moab;
EntityHandle file_set;
ErrorCode rval = mb.create_meshset(MESHSET_SET, file_set);
CHECK_ERR(rval);
std::string opts;
get_options(opts);
// Read vertex variable T and create gather set on processor 0
opts += ";VARIABLE=T;GATHER_SET=0";
#ifdef MOAB_HAVE_MPI
opts += ";PARALLEL_RESOLVE_SHARED_ENTS";
#endif
rval = mb.load_file(example, &file_set, opts.c_str());
CHECK_ERR(rval);
#ifdef MOAB_HAVE_MPI
ParallelComm* pcomm = ParallelComm::get_pcomm(&mb, 0);
int rank = pcomm->proc_config().proc_rank();
Range verts, verts_owned;
rval = mb.get_entities_by_type(file_set, MBVERTEX, verts);
CHECK_ERR(rval);
// Get local owned vertices
rval = pcomm->filter_pstatus(verts, PSTATUS_NOT_OWNED, PSTATUS_NOT, -1, &verts_owned);
CHECK_ERR(rval);
EntityHandle gather_set = 0;
if (0 == rank) {
// Get gather set
ReadUtilIface* readUtilIface;
mb.query_interface(readUtilIface);
rval = readUtilIface->get_gather_set(gather_set);
CHECK_ERR(rval);
assert(gather_set != 0);
}
Tag Ttag0, gid_tag;
rval = mb.tag_get_handle("T0", levels, MB_TYPE_DOUBLE, Ttag0, MB_TAG_DENSE);
CHECK_ERR(rval);
rval = mb.tag_get_handle(GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag, MB_TAG_DENSE);
CHECK_ERR(rval);
pcomm->gather_data(verts_owned, Ttag0, gid_tag, gather_set, 0);
if (0 == rank) {
// Get gather set vertices
Range gather_set_verts;
rval = mb.get_entities_by_type(gather_set, MBVERTEX, gather_set_verts);
CHECK_ERR(rval);
CHECK_EQUAL((size_t)3458, gather_set_verts.size());
// Get T0 tag values on 4 strategically selected gather set vertices
double T0_val[4 * levels];
EntityHandle vert_ents[] = {gather_set_verts[0], gather_set_verts[1728],
gather_set_verts[1729], gather_set_verts[3457]};
rval = mb.tag_get_data(Ttag0, vert_ents, 4, T0_val);
CHECK_ERR(rval);
const double eps = 0.001;
// Check first level values
CHECK_REAL_EQUAL(233.1136, T0_val[0 * levels], eps); // First vert
CHECK_REAL_EQUAL(236.1505, T0_val[1 * levels], eps); // Median vert
CHECK_REAL_EQUAL(235.7722, T0_val[2 * levels], eps); // Median vert
CHECK_REAL_EQUAL(234.0416, T0_val[3 * levels], eps); // Last vert
}
#endif
}
