void
TransferOperatorRegistry::addRefineOperator(
const char* var_type_name,
const boost::shared_ptr<RefineOperator>& refine_op)
{
if (d_max_op_stencil_width_req) {
for (short unsigned int d(1); d <= SAMRAI::MAX_DIM_VAL; ++d) {
if (refine_op->getStencilWidth(tbox::Dimension(d)) >
getMaxTransferOpStencilWidth(tbox::Dimension(d))) {
TBOX_WARNING(
"Adding refine operator " << refine_op->getOperatorName()
<< "\nwith stencil width greater than current maximum\n"
<< "after call to getMaxTransferOpStencilWidth.\n");
}
}
}
boost::unordered_map<std::string, boost::unordered_map<std::string,
boost::shared_ptr<RefineOperator> > >::
iterator refine_ops =
d_refine_operators.find(refine_op->getOperatorName());
if (refine_ops == d_refine_operators.end()) {
refine_ops = d_refine_operators.insert(
std::make_pair(refine_op->getOperatorName(),
boost::unordered_map<std::string,
boost::shared_ptr<RefineOperator> >(0))).first;
}
refine_ops->second.insert(std::make_pair(var_type_name, refine_op));
}
void
LinearOperator::modifyRhsForInhomogeneousBc(
SAMRAIVectorReal<NDIM,double>& /*y*/)
{
TBOX_WARNING("LinearOperator::modifyRhsForInhomogeneousBc() not implemented for this operator" << std::endl);
return;
}// modifyRhsForInhomogeneousBc
void CartCellDoubleCubicCoarsen::coarsen(Patch<NDIM>& coarse,
const Patch<NDIM>& fine,
const int dst_component,
const int src_component,
const Box<NDIM>& coarse_box,
const IntVector<NDIM>& ratio) const
{
if (ratio.min() < 4)
{
IBTK_DO_ONCE(TBOX_WARNING("CartCellDoubleCubicCoarsen::coarsen():\n"
<< " cubic coarsening requires a refinement ratio of 4 or larger.\n"
<< " reverting to weighted averaging." << std::endl););
/*
*************************************************************************
*
* Get data from input database.
*
*************************************************************************
*/
void
CVODEModel::getFromInput(
std::shared_ptr<Database> input_db,
bool is_from_restart)
{
NULL_USE(is_from_restart);
d_initial_value = input_db->getDoubleWithDefault("initial_value", 0.0);
IntVector periodic(d_grid_geometry->getPeriodicShift(IntVector(d_dim,
1)));
int num_per_dirs = 0;
for (int id = 0; id < d_dim.getValue(); ++id) {
if (periodic(id)) ++num_per_dirs;
}
if (input_db->keyExists("Boundary_data")) {
std::shared_ptr<Database> boundary_db(
input_db->getDatabase("Boundary_data"));
if (d_dim == Dimension(2)) {
CartesianBoundaryUtilities2::getFromInput(this,
boundary_db,
d_scalar_bdry_edge_conds,
d_scalar_bdry_node_conds,
periodic);
} else if (d_dim == Dimension(3)) {
CartesianBoundaryUtilities3::getFromInput(this,
boundary_db,
d_scalar_bdry_face_conds,
d_scalar_bdry_edge_conds,
d_scalar_bdry_node_conds,
periodic);
}
} else {
TBOX_WARNING(
d_object_name << ": "
<< "Key data `Boundary_data' not found in input. " << endl);
}
#ifdef USE_FAC_PRECONDITIONER
d_use_neumann_bcs =
input_db->getBoolWithDefault("use_neumann_bcs", d_use_neumann_bcs);
d_print_solver_info =
input_db->getBoolWithDefault("print_solver_info", d_print_solver_info);
#endif
}
void
PenaltyIBMethod::getFromInput(Pointer<Database> db, bool is_from_restart)
{
if (!is_from_restart)
{
if (db->keyExists("gravitational_acceleration"))
{
db->getDoubleArray("gravitational_acceleration", &d_gravitational_acceleration[0], NDIM);
}
else
{
TBOX_WARNING(d_object_name << ": "
<< "Using penalty-IB method but key data "
"`gravitational_acceleration' not found in input.");
}
}
return;
} // getFromInput
RigidBodyKinematics::RigidBodyKinematics(const std::string& object_name,
Pointer<Database> input_db,
LDataManager* l_data_manager,
Pointer<PatchHierarchy<NDIM> > /*patch_hierarchy*/,
bool register_for_restart)
: ConstraintIBKinematics(object_name, input_db, l_data_manager, register_for_restart),
d_parser_time(0.0),
d_center_of_mass(3, 0.0),
d_incremented_angle_from_reference_axis(3, 0.0),
d_tagged_pt_position(3, 0.0)
{
// NOTE: Parent class constructor registers class with the restart manager, sets object name.
// Read-in kinematics velocity functions
for (int d = 0; d < NDIM; ++d)
{
const std::string postfix = "_function_" + std::to_string(d);
std::string key_name = "kinematics_velocity" + postfix;
if (input_db->isString(key_name))
{
d_kinematicsvel_function_strings.push_back(input_db->getString(key_name));
}
else
{
d_kinematicsvel_function_strings.push_back("0.0");
TBOX_WARNING("RigidBodyKinematics::RigidBodyKinematics() :\n"
<< " no function corresponding to key " << key_name << "found for dimension = " << d
<< "; using kinematics_vel = 0.0. " << std::endl);
}
d_kinematicsvel_parsers.push_back(new mu::Parser());
d_kinematicsvel_parsers.back()->SetExpr(d_kinematicsvel_function_strings.back());
d_all_parsers.push_back(d_kinematicsvel_parsers.back());
}
// Define constants and variables for the parsers.
for (std::vector<mu::Parser*>::const_iterator cit = d_all_parsers.begin(); cit != d_all_parsers.end(); ++cit)
{
// Various names for pi.
(*cit)->DefineConst("pi", PII);
(*cit)->DefineConst("Pi", PII);
(*cit)->DefineConst("PI", PII);
// Variables
(*cit)->DefineVar("T", &d_parser_time);
(*cit)->DefineVar("t", &d_parser_time);
for (int d = 0; d < NDIM; ++d)
{
const std::string postfix = std::to_string(d);
(*cit)->DefineVar("X" + postfix, d_parser_posn.data() + d);
(*cit)->DefineVar("x" + postfix, d_parser_posn.data() + d);
(*cit)->DefineVar("X_" + postfix, d_parser_posn.data() + d);
(*cit)->DefineVar("x_" + postfix, d_parser_posn.data() + d);
}
}
// Set the size of vectors.
const StructureParameters& struct_param = getStructureParameters();
const int coarsest_ln = struct_param.getCoarsestLevelNumber();
const int finest_ln = struct_param.getFinestLevelNumber();
const int total_levels = finest_ln - coarsest_ln + 1;
d_kinematics_vel.resize(total_levels);
const std::vector<std::pair<int, int> >& idx_range = struct_param.getLagIdxRange();
for (int ln = 0; ln < total_levels; ++ln)
{
const int nodes_this_ln = idx_range[ln].second - idx_range[ln].first;
d_kinematics_vel[ln].resize(NDIM);
for (int d = 0; d < NDIM; ++d)
{
d_kinematics_vel[ln][d].resize(nodes_this_ln);
}
}
bool from_restart = RestartManager::getManager()->isFromRestart();
if (from_restart)
{
getFromRestart();
setRigidBodySpecificVelocity(
d_current_time, d_incremented_angle_from_reference_axis, d_center_of_mass, d_tagged_pt_position);
setShape(d_current_time, d_incremented_angle_from_reference_axis);
}
return;
} // RigidBodyKinematics
muParserRobinBcCoefs::muParserRobinBcCoefs(const std::string& object_name,
Pointer<Database> input_db,
Pointer<CartesianGridGeometry<NDIM> > grid_geom)
: d_grid_geom(grid_geom), d_constants(), d_acoef_function_strings(), d_bcoef_function_strings(),
d_gcoef_function_strings(), d_acoef_parsers(2 * NDIM), d_bcoef_parsers(2 * NDIM), d_gcoef_parsers(2 * NDIM),
d_parser_time(new double), d_parser_posn(new Point)
{
#if !defined(NDEBUG)
TBOX_ASSERT(!object_name.empty());
TBOX_ASSERT(input_db);
#else
NULL_USE(object_name);
#endif
// Read in user-provided constants.
Array<std::string> db_key_names = input_db->getAllKeys();
for (int k = 0; k < db_key_names.size(); ++k)
{
const std::string& name = db_key_names[k];
if (input_db->isDouble(name))
{
d_constants[name] = input_db->getDouble(name);
}
else if (input_db->isFloat(name))
{
d_constants[name] = input_db->getFloat(name);
}
else if (input_db->isInteger(name))
{
d_constants[name] = input_db->getInteger(name);
}
}
// Initialize the parsers with data read in from the input database.
for (int d = 0; d < 2 * NDIM; ++d)
{
std::string key_name;
std::ostringstream stream;
stream << "_function_" << d;
const std::string postfix = stream.str();
key_name = "acoef" + postfix;
if (input_db->isString(key_name))
{
d_acoef_function_strings.push_back(input_db->getString(key_name));
}
else
{
d_acoef_function_strings.push_back("0.0");
TBOX_WARNING("muParserRobinBcCoefs::muParserRobinBcCoefs():\n"
<< " no function corresponding to key ``" << key_name << "'' found for side = " << d
<< "; using acoef = 0.0." << std::endl);
}
try
{
d_acoef_parsers[d].SetExpr(d_acoef_function_strings.back());
}
catch (mu::ParserError& e)
{
TBOX_ERROR("muParserRobinBcCoefs::setDataOnPatch():\n"
<< " error: " << e.GetMsg() << "\n"
<< " in: " << e.GetExpr() << "\n");
}
catch (...)
{
TBOX_ERROR("muParserRobinBcCoefs::setDataOnPatch():\n"
<< " unrecognized exception generated by muParser library.\n");
}
key_name = "bcoef" + postfix;
if (input_db->isString(key_name))
{
d_bcoef_function_strings.push_back(input_db->getString(key_name));
}
else
{
d_bcoef_function_strings.push_back("0.0");
TBOX_WARNING("muParserRobinBcCoefs::muParserRobinBcCoefs():\n"
<< " no function corresponding to key ``" << key_name << "'' found for side = " << d
<< "; using bcoef = 0.0." << std::endl);
}
try
{
d_bcoef_parsers[d].SetExpr(d_bcoef_function_strings.back());
}
catch (mu::ParserError& e)
{
TBOX_ERROR("muParserRobinBcCoefs::setDataOnPatch():\n"
<< " error: " << e.GetMsg() << "\n"
<< " in: " << e.GetExpr() << "\n");
}
catch (...)
{
TBOX_ERROR("muParserRobinBcCoefs::setDataOnPatch():\n"
<< " unrecognized exception generated by muParser library.\n");
}
key_name = "gcoef" + postfix;
if (input_db->isString(key_name))
{
d_gcoef_function_strings.push_back(input_db->getString(key_name));
}
else
{
d_gcoef_function_strings.push_back("0.0");
TBOX_WARNING("muParserRobinBcCoefs::muParserRobinBcCoefs():\n"
<< " no function corresponding to key ``" << key_name << "'' found for side = " << d
<< "; using gcoef = 0.0." << std::endl);
}
try
{
d_gcoef_parsers[d].SetExpr(d_gcoef_function_strings.back());
}
catch (mu::ParserError& e)
{
TBOX_ERROR("muParserRobinBcCoefs::setDataOnPatch():\n"
<< " error: " << e.GetMsg() << "\n"
<< " in: " << e.GetExpr() << "\n");
}
catch (...)
{
TBOX_ERROR("muParserRobinBcCoefs::setDataOnPatch():\n"
<< " unrecognized exception generated by muParser library.\n");
}
}
// Define the default and user-provided constants.
std::vector<mu::Parser*> all_parsers(3 * 2 * NDIM);
for (int d = 0; d < 2 * NDIM; ++d)
{
all_parsers[3 * d] = &d_acoef_parsers[d];
all_parsers[3 * d + 1] = &d_bcoef_parsers[d];
all_parsers[3 * d + 2] = &d_gcoef_parsers[d];
}
const double pi = 3.1415926535897932384626433832795;
const double* const xLower = grid_geom->getXLower();
const double* const xUpper = grid_geom->getXUpper();
for (std::vector<mu::Parser*>::const_iterator cit = all_parsers.begin(); cit != all_parsers.end(); ++cit)
{
// Various names for pi.
(*cit)->DefineConst("pi", pi);
(*cit)->DefineConst("Pi", pi);
(*cit)->DefineConst("PI", pi);
// The extents of the domain.
for (unsigned int d = 0; d < NDIM; ++d)
{
std::ostringstream stream;
stream << d;
const std::string postfix = stream.str();
(*cit)->DefineConst("X_LOWER" + postfix, xLower[d]);
(*cit)->DefineConst("X_lower" + postfix, xLower[d]);
(*cit)->DefineConst("x_lower" + postfix, xLower[d]);
(*cit)->DefineConst("x_LOWER" + postfix, xLower[d]);
(*cit)->DefineConst("X_Lower" + postfix, xLower[d]);
(*cit)->DefineConst("X_lower" + postfix, xLower[d]);
(*cit)->DefineConst("XLower" + postfix, xLower[d]);
(*cit)->DefineConst("Xlower" + postfix, xLower[d]);
(*cit)->DefineConst("x_Lower" + postfix, xLower[d]);
(*cit)->DefineConst("x_lower" + postfix, xLower[d]);
(*cit)->DefineConst("xLower" + postfix, xLower[d]);
(*cit)->DefineConst("xlower" + postfix, xLower[d]);
(*cit)->DefineConst("X_LOWER_" + postfix, xLower[d]);
(*cit)->DefineConst("X_lower_" + postfix, xLower[d]);
(*cit)->DefineConst("x_lower_" + postfix, xLower[d]);
(*cit)->DefineConst("x_LOWER_" + postfix, xLower[d]);
(*cit)->DefineConst("X_Lower_" + postfix, xLower[d]);
(*cit)->DefineConst("X_lower_" + postfix, xLower[d]);
(*cit)->DefineConst("XLower_" + postfix, xLower[d]);
(*cit)->DefineConst("Xlower_" + postfix, xLower[d]);
(*cit)->DefineConst("x_Lower_" + postfix, xLower[d]);
(*cit)->DefineConst("x_lower_" + postfix, xLower[d]);
(*cit)->DefineConst("xLower_" + postfix, xLower[d]);
(*cit)->DefineConst("xlower_" + postfix, xLower[d]);
(*cit)->DefineConst("X_UPPER" + postfix, xUpper[d]);
(*cit)->DefineConst("X_upper" + postfix, xUpper[d]);
(*cit)->DefineConst("x_upper" + postfix, xUpper[d]);
(*cit)->DefineConst("x_UPPER" + postfix, xUpper[d]);
(*cit)->DefineConst("X_Upper" + postfix, xUpper[d]);
(*cit)->DefineConst("X_upper" + postfix, xUpper[d]);
(*cit)->DefineConst("XUpper" + postfix, xUpper[d]);
(*cit)->DefineConst("Xupper" + postfix, xUpper[d]);
(*cit)->DefineConst("x_Upper" + postfix, xUpper[d]);
(*cit)->DefineConst("x_upper" + postfix, xUpper[d]);
(*cit)->DefineConst("xUpper" + postfix, xUpper[d]);
(*cit)->DefineConst("xupper" + postfix, xUpper[d]);
(*cit)->DefineConst("X_UPPER_" + postfix, xUpper[d]);
(*cit)->DefineConst("X_upper_" + postfix, xUpper[d]);
(*cit)->DefineConst("x_upper_" + postfix, xUpper[d]);
(*cit)->DefineConst("x_UPPER_" + postfix, xUpper[d]);
(*cit)->DefineConst("X_Upper_" + postfix, xUpper[d]);
(*cit)->DefineConst("X_upper_" + postfix, xUpper[d]);
(*cit)->DefineConst("XUpper_" + postfix, xUpper[d]);
(*cit)->DefineConst("Xupper_" + postfix, xUpper[d]);
(*cit)->DefineConst("x_Upper_" + postfix, xUpper[d]);
(*cit)->DefineConst("x_upper_" + postfix, xUpper[d]);
(*cit)->DefineConst("xUpper_" + postfix, xUpper[d]);
(*cit)->DefineConst("xupper_" + postfix, xUpper[d]);
}
// User-provided constants.
for (std::map<std::string, double>::const_iterator map_cit = d_constants.begin(); map_cit != d_constants.end();
++map_cit)
{
(*cit)->DefineConst(map_cit->first, map_cit->second);
}
// Variables.
(*cit)->DefineVar("T", d_parser_time);
(*cit)->DefineVar("t", d_parser_time);
for (unsigned int d = 0; d < NDIM; ++d)
{
std::ostringstream stream;
stream << d;
const std::string postfix = stream.str();
(*cit)->DefineVar("X" + postfix, &d_parser_posn->data()[d]);
(*cit)->DefineVar("x" + postfix, &d_parser_posn->data()[d]);
(*cit)->DefineVar("X_" + postfix, &d_parser_posn->data()[d]);
(*cit)->DefineVar("x_" + postfix, &d_parser_posn->data()[d]);
}
}
return;
} // muParserRobinBcCoefs
/*
****************************************************************
* Advance one communication Member by using MPI_Waitany
* to complete one requests.
*
* Get one completed request and check its communication Member to see
* if the Member finished its communication operation. If it finished
* its operation, return the member. If not, repeat until one Member
* has completed its communication operation.
****************************************************************
*/
bool
AsyncCommStage::advanceAny()
{
if (!SAMRAI_MPI::usingMPI()) {
return false;
}
#ifdef DEBUG_CHECK_ASSERTIONS
for (unsigned int i = static_cast<unsigned int>(d_member_to_req[d_members.size()]);
i < d_req.size();
++i) {
if (d_req[i] != MPI_REQUEST_NULL)
TBOX_WARNING("non-null request above d_n_reg." << std::endl);
}
#endif
int ireq = MPI_UNDEFINED;
int member_index_on_stage = -1;
bool member_done;
do {
SAMRAI_MPI::Status mpi_stat;
int errf;
if (d_communication_timer) d_communication_timer->start();
errf = SAMRAI_MPI::Waitany(
static_cast<int>(d_member_to_req[d_members.size()]),
&d_req[0],
&ireq,
&mpi_stat);
if (d_communication_timer) d_communication_timer->stop();
if (errf != MPI_SUCCESS) {
TBOX_ERROR("Error in MPI_Waitany call.\n"
<< "Error-in-status is "
<< (errf == MPI_ERR_IN_STATUS) << '\n'
<< "MPI_ERROR value is " << mpi_stat.MPI_ERROR
<< '\n');
}
if (ireq == MPI_UNDEFINED) {
// All input requests are completed even before waiting.
break;
}
TBOX_ASSERT(ireq >= 0 &&
ireq < static_cast<int>(d_member_to_req[d_members.size()]));
d_stat[ireq] = mpi_stat;
member_index_on_stage = static_cast<int>(d_req_to_member[ireq]);
TBOX_ASSERT(member_index_on_stage >= 0 &&
member_index_on_stage < static_cast<int>(d_members.size()));
TBOX_ASSERT(d_members[member_index_on_stage] != 0);
Member* member = d_members[member_index_on_stage];
/*
* Member member_index_on_stage had a request completed.
* See if all of its requests are now completed.
* If so, run proceedToNextWait() to see if the member is done.
* (The member may not be done because it may initiate
* follow-up communication tasks.)
* Exit the do loop when a Member is actually done
* with all of its communication tasks.
*/
const size_t init_req = d_member_to_req[member->d_index_on_stage];
const size_t term_req = d_member_to_req[member->d_index_on_stage + 1];
size_t i;
for (i = init_req; i < term_req; ++i) {
if (d_req[i] != MPI_REQUEST_NULL) {
break;
}
}
if (i == term_req) {
/*
* Member is done with at least its current communication
* requests. Follow-up communication may be launched,
* so check the return value of proceedToNextWait().
*/
member_done = d_members[member_index_on_stage]->proceedToNextWait();
} else {
member_done = false;
TBOX_ASSERT(d_members[member_index_on_stage]->hasPendingRequests());
}
} while (member_done == false);
if (member_index_on_stage >= 0) {
privatePushToCompletionQueue(*d_members[member_index_on_stage]);
}
return !d_completed_members.empty();
}
/*
******************************************************************
* Advance one or more communication Members by using
* MPI_Waitsome to complete one or more communication requests.
*
* Get one or more completed requests and check their communication
* Members to see if any Member finished its communication operation.
* If at least one Member finished its communication, return those that
* finished. If no Member has finished, repeat until at least one has.
******************************************************************
*/
bool
AsyncCommStage::advanceSome()
{
if (!SAMRAI_MPI::usingMPI()) {
return false;
}
if (d_members.empty()) {
// Short cut for an empty stage.
return false;
}
#ifdef DEBUG_CHECK_ASSERTIONS
for (unsigned int i = static_cast<unsigned int>(d_member_to_req[d_members.size()]);
i < d_req.size();
++i) {
if (d_req[i] != MPI_REQUEST_NULL)
TBOX_WARNING("non-null request above d_n_req." << std::endl);
}
#endif
std::vector<int> index(static_cast<int>(d_member_to_req[d_members.size()]));
std::vector<SAMRAI_MPI::Status> stat(
static_cast<int>(d_member_to_req[d_members.size()]));
size_t n_member_completed = 0;
int n_req_completed = 0;
do {
int errf;
if (d_communication_timer) d_communication_timer->start();
errf = SAMRAI_MPI::Waitsome(
static_cast<int>(d_member_to_req[d_members.size()]),
&d_req[0],
&n_req_completed,
&index[0],
&stat[0]);
if (d_communication_timer) d_communication_timer->stop();
#ifdef DEBUG_CHECK_ASSERTIONS
if (n_req_completed <= 0) {
/*
* Undocumented feature of some MPI_Waitsome implementations:
* MPI_Waitsome sets n_req_completed to a negative number
* if all the input requests are MPI_REQUEST_NULL.
*/
for (size_t i = 0; i < d_member_to_req[d_members.size()]; ++i) {
if (d_req[i] != MPI_REQUEST_NULL) {
TBOX_ERROR("Library error in AsyncCommStage::advanceSome:\n"
<< "errf = " << errf << '\n'
<< "MPI_SUCCESS = " << MPI_SUCCESS << '\n'
<< "MPI_ERR_IN_STATUS = " << MPI_ERR_IN_STATUS << '\n'
<< "MPI_REQUEST_NULL = " << MPI_REQUEST_NULL << '\n'
<< "number of requests = "
<< d_member_to_req[d_members.size()] << '\n'
<< "d_req.size() = " << d_req.size() << '\n'
<< "n_req_completed = " << n_req_completed << '\n'
<< "i = " << i << '\n'
);
}
}
for (unsigned int i = static_cast<unsigned int>(d_member_to_req[d_members.size()]);
i < d_req.size();
++i) {
if (d_req[i] != MPI_REQUEST_NULL)
TBOX_WARNING("non-null request above d_n_reg." << std::endl);
}
}
if (n_req_completed == 0) {
TBOX_ASSERT(!hasPendingRequests());
}
#endif
if (errf != MPI_SUCCESS) {
TBOX_ERROR("Error in MPI_Waitsome call.\n"
<< "Error-in-status is "
<< (errf == MPI_ERR_IN_STATUS)
<< '\n');
}
/*
* Construct array of Members with at least one completed
* request.
*/
// Number of Members to check with at least one completed request.
unsigned int n_check_member = 0;
for (int iout = 0; iout < n_req_completed; ++iout) {
// Save status of completed request.
d_stat[index[iout]] = stat[iout];
/*
* Change index from request index to Member index.
* If the Member index is not a duplicate, add it to
* the list of Members to check (which is actually
* the same list) and increase n_check_member.
*/
index[iout] = static_cast<int>(d_req_to_member[index[iout]]);
#ifdef AsyncCommStage_ExtraDebug
plog << "AsyncCommStage::advanceSome completed:"
<< " tag-" << stat[iout].MPI_TAG
<< " source-" << stat[iout].MPI_SOURCE
<< " for member index " << index[iout]
<< std::endl;
#endif
unsigned int i;
for (i = 0; i < n_check_member; ++i) {
if (index[i] == index[iout]) break;
}
if (i == n_check_member) {
index[n_check_member++] = index[iout];
}
}
/*
* Check the Members whose requests completed and count up the
* Members that completed all their communication tasks.
*/
for (unsigned int imember = 0; imember < n_check_member; ++imember) {
Member& memberi = *d_members[index[imember]];
TBOX_ASSERT(!memberi.isDone());
bool memberi_done = memberi.proceedToNextWait();
#ifdef AsyncCommStage_ExtraDebug
plog
<< "AsyncCommStage::advanceSome proceedToNextWait for member:"
<< memberi.d_index_on_stage
<< " completion=" << memberi_done
<< std::endl;
#endif
if (memberi_done) {
++n_member_completed;
TBOX_ASSERT(!memberi.hasPendingRequests());
privatePushToCompletionQueue(memberi);
}
}
} while (n_req_completed > 0 && n_member_completed == 0);
return !d_completed_members.empty();
}
