// ------------------------------------------------------------
// SFCPartitioner implementation
void SFCPartitioner::_do_partition (MeshBase & mesh,
const unsigned int n)
{
libmesh_assert_greater (n, 0);
// Check for an easy return
if (n == 1)
{
this->single_partition (mesh);
return;
}
// What to do if the sfcurves library IS NOT present
#ifndef LIBMESH_HAVE_SFCURVES
libmesh_here();
libMesh::err << "ERROR: The library has been built without" << std::endl
<< "Space Filling Curve support. Using a linear" << std::endl
<< "partitioner instead!" << std::endl;
LinearPartitioner lp;
lp.partition (mesh, n);
// What to do if the sfcurves library IS present
#else
LOG_SCOPE("sfc_partition()", "SFCPartitioner");
const dof_id_type n_active_elem = mesh.n_active_elem();
const dof_id_type n_elem = mesh.n_elem();
// the forward_map maps the active element id
// into a contiguous block of indices
std::vector<dof_id_type>
forward_map (n_elem, DofObject::invalid_id);
// the reverse_map maps the contiguous ids back
// to active elements
std::vector<Elem *> reverse_map (n_active_elem, libmesh_nullptr);
int size = static_cast<int>(n_active_elem);
std::vector<double> x (size);
std::vector<double> y (size);
std::vector<double> z (size);
std::vector<int> table (size);
// We need to map the active element ids into a
// contiguous range.
{
MeshBase::element_iterator elem_it = mesh.active_elements_begin();
const MeshBase::element_iterator elem_end = mesh.active_elements_end();
dof_id_type el_num = 0;
for (; elem_it != elem_end; ++elem_it)
{
libmesh_assert_less ((*elem_it)->id(), forward_map.size());
libmesh_assert_less (el_num, reverse_map.size());
forward_map[(*elem_it)->id()] = el_num;
reverse_map[el_num] = *elem_it;
el_num++;
}
libmesh_assert_equal_to (el_num, n_active_elem);
}
// Get the centroid for each active element
{
// const_active_elem_iterator elem_it (mesh.const_elements_begin());
// const const_active_elem_iterator elem_end(mesh.const_elements_end());
MeshBase::element_iterator elem_it = mesh.active_elements_begin();
const MeshBase::element_iterator elem_end = mesh.active_elements_end();
for (; elem_it != elem_end; ++elem_it)
{
const Elem * elem = *elem_it;
libmesh_assert_less (elem->id(), forward_map.size());
const Point p = elem->centroid();
x[forward_map[elem->id()]] = p(0);
y[forward_map[elem->id()]] = p(1);
z[forward_map[elem->id()]] = p(2);
}
}
// build the space-filling curve
if (_sfc_type == "Hilbert")
Sfc::hilbert (&x[0], &y[0], &z[0], &size, &table[0]);
else if (_sfc_type == "Morton")
Sfc::morton (&x[0], &y[0], &z[0], &size, &table[0]);
else
{
libmesh_here();
libMesh::err << "ERROR: Unknown type: " << _sfc_type << std::endl
<< " Valid types are" << std::endl
<< " \"Hilbert\"" << std::endl
<< " \"Morton\"" << std::endl
<< " " << std::endl
<< "Proceeding with a Hilbert curve." << std::endl;
Sfc::hilbert (&x[0], &y[0], &z[0], &size, &table[0]);
}
// Assign the partitioning to the active elements
{
// {
// std::ofstream out ("sfc.dat");
// out << "variables=x,y,z" << std::endl;
// out << "zone f=point" << std::endl;
// for (unsigned int i=0; i<n_active_elem; i++)
// out << x[i] << " "
// << y[i] << " "
// << z[i] << std::endl;
// }
const dof_id_type blksize = (n_active_elem+n-1)/n;
for (dof_id_type i=0; i<n_active_elem; i++)
{
libmesh_assert_less (static_cast<unsigned int>(table[i]-1), reverse_map.size());
Elem * elem = reverse_map[table[i]-1];
elem->processor_id() = cast_int<processor_id_type>
(i/blksize);
}
}
#endif
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc = sdi->priv;
struct parport *port;
int ret, i, ch = -1;
if (cg) /* sr_config_get will validate cg using config_list */
ch = ((struct sr_channel *)cg->channels->data)->index;
ret = SR_OK;
switch (key) {
case SR_CONF_CONN:
port = sdi->conn;
*data = g_variant_new_string(port->name);
break;
case SR_CONF_LIMIT_FRAMES:
*data = g_variant_new_uint64(devc->frame_limit);
break;
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(samplerates[devc->rate]);
break;
case SR_CONF_TRIGGER_SOURCE:
i = reverse_map(devc->cctl[0] & 0xC0, trigger_sources_map,
ARRAY_SIZE(trigger_sources_map));
if (i == -1)
ret = SR_ERR;
else
*data = g_variant_new_string(trigger_sources[i]);
break;
case SR_CONF_TRIGGER_SLOPE:
if (devc->edge >= ARRAY_SIZE(trigger_slopes))
ret = SR_ERR;
else
*data = g_variant_new_string(trigger_slopes[devc->edge]);
break;
case SR_CONF_BUFFERSIZE:
*data = g_variant_new_uint64(buffersizes[devc->last_step]);
break;
case SR_CONF_VDIV:
if (ch == -1) {
ret = SR_ERR_CHANNEL_GROUP;
} else {
i = reverse_map(devc->cctl[ch] & 0x33, vdivs_map,
ARRAY_SIZE(vdivs_map));
if (i == -1)
ret = SR_ERR;
else
*data = g_variant_new("(tt)", vdivs[i][0],
vdivs[i][1]);
}
break;
case SR_CONF_COUPLING:
if (ch == -1) {
ret = SR_ERR_CHANNEL_GROUP;
} else {
i = reverse_map(devc->cctl[ch] & 0x0C, coupling_map,
ARRAY_SIZE(coupling_map));
if (i == -1)
ret = SR_ERR;
else
*data = g_variant_new_string(coupling[i]);
}
break;
case SR_CONF_PROBE_FACTOR:
if (ch == -1)
ret = SR_ERR_CHANNEL_GROUP;
else
*data = g_variant_new_uint64(devc->probe[ch]);
break;
default:
ret = SR_ERR_NA;
}
return ret;
}