inline
int field_length(NgpFieldVector<Scalar> & xField, const stk::mesh::Bucket & b)
{
const stk::mesh::Bucket::size_type length = b.size();
const unsigned int fieldSize = field_scalars_per_entity(xField.get_field(), b);
return length * fieldSize;
}
unsigned get_max_field_bucket_length(const stk::mesh::Field<Scalar> & fieldBase,
const stk::mesh::Selector& selector)
{
stk::mesh::BucketVector const& buckets = fieldBase.get_mesh().get_buckets(fieldBase.entity_rank(),
selector & fieldBase.mesh_meta_data().locally_owned_part());
unsigned max_field_bucket_length = 0;
for(size_t i=0; i < buckets.size(); i++) {
stk::mesh::Bucket & b = *buckets[i];
const stk::mesh::Bucket::size_type length = b.size();
const unsigned int fieldSize = field_scalars_per_entity(fieldBase, b);
const unsigned kmax = length * fieldSize;
max_field_bucket_length = std::max(max_field_bucket_length, kmax);
}
return max_field_bucket_length;
}
inline void parallel_sum_including_ghosts(
const BulkData & mesh ,
const std::vector< const FieldBase *> & fields )
{
if ( fields.empty() ) { return; }
const int parallel_size = mesh.parallel_size();
const int parallel_rank = mesh.parallel_rank();
const std::vector<const FieldBase *>::const_iterator fe = fields.end();
const std::vector<const FieldBase *>::const_iterator fb = fields.begin();
std::vector<const FieldBase *>::const_iterator fi ;
// Sizing for send and receive
const unsigned zero = 0 ;
std::vector<unsigned> send_size( parallel_size , zero );
std::vector<unsigned> recv_size( parallel_size , zero );
const EntityCommListInfoVector& comm_info_vec = mesh.internal_comm_list();
size_t comm_info_vec_size = comm_info_vec.size();
for ( fi = fb ; fi != fe ; ++fi ) {
const FieldBase & f = **fi ;
for (size_t i=0; i<comm_info_vec_size; ++i) {
if (!mesh.is_valid(comm_info_vec[i].entity))
{
ThrowAssertMsg(mesh.is_valid(comm_info_vec[i].entity),"parallel_sum_including_ghosts found invalid entity");
}
const Bucket* bucket = comm_info_vec[i].bucket;
unsigned e_size = 0 ;
if(is_matching_rank(f, *bucket)) {
const unsigned bucketId = bucket->bucket_id();
e_size += field_bytes_per_entity( f , bucketId );
}
if (e_size == 0) {
continue;
}
const bool owned = comm_info_vec[i].owner == parallel_rank ;
if ( !owned ) {
send_size[ comm_info_vec[i].owner ] += e_size ;
}
else {
const EntityCommInfoVector& infovec = comm_info_vec[i].entity_comm->comm_map;
size_t info_vec_size = infovec.size();
for (size_t j=0; j<info_vec_size; ++j ) {
recv_size[ infovec[j].proc ] += e_size ;
}
}
}
}
// Allocate send and receive buffers:
CommAll sparse ;
{
const unsigned * const snd_size = & send_size[0] ;
const unsigned * const rcv_size = & recv_size[0] ;
sparse.allocate_buffers( mesh.parallel(), snd_size, rcv_size);
}
// Send packing:
for (int phase = 0; phase < 2; ++phase) {
for ( fi = fb ; fi != fe ; ++fi ) {
const FieldBase & f = **fi ;
for (size_t i=0; i<comm_info_vec_size; ++i) {
const bool owned = comm_info_vec[i].owner == parallel_rank;
if ( (!owned && phase == 0) || (owned && phase == 1) )
{
const Bucket* bucket = comm_info_vec[i].bucket;
if(!is_matching_rank(f, *bucket)) continue;
const unsigned bucketId = bucket->bucket_id();
const size_t bucket_ordinal = comm_info_vec[i].bucket_ordinal;
const unsigned scalars_per_entity = field_scalars_per_entity(f, bucketId);
if ( scalars_per_entity > 0 ) {
int owner = comm_info_vec[i].owner;
if (f.data_traits().is_floating_point && f.data_traits().size_of == 8)
{
send_or_recv_field_data_for_assembly<double>(sparse, phase, f, owner, comm_info_vec[i].entity_comm->comm_map, scalars_per_entity, bucketId, bucket_ordinal);
}
else if (f.data_traits().is_floating_point && f.data_traits().size_of == 4)
{
send_or_recv_field_data_for_assembly<float>(sparse, phase, f, owner, comm_info_vec[i].entity_comm->comm_map, scalars_per_entity, bucketId, bucket_ordinal);
}
else if (f.data_traits().is_integral && f.data_traits().size_of == 4 && f.data_traits().is_unsigned)
{
send_or_recv_field_data_for_assembly<unsigned>(sparse, phase, f, owner, comm_info_vec[i].entity_comm->comm_map, scalars_per_entity, bucketId, bucket_ordinal);
}
else if (f.data_traits().is_integral && f.data_traits().size_of == 4 && f.data_traits().is_signed)
{
send_or_recv_field_data_for_assembly<int>(sparse, phase, f, owner, comm_info_vec[i].entity_comm->comm_map, scalars_per_entity, bucketId, bucket_ordinal);
}
else
{
ThrowRequireMsg(false,"Unsupported field type in parallel_sum_including_ghosts");
}
}
}
}
}
if (phase == 0) { sparse.communicate(); }
}
copy_from_owned(mesh, fields);
}
