Method solveBodySystem

src/IB/DirectMobilitySolver.cpp:322–373

} // solveSystem

bool
DirectMobilitySolver::solveBodySystem(Vec x, Vec b)
{
    IBAMR_TIMER_START(t_solve_body_system);

    // Initialize the solver, when necessary.
    const bool deallocate_after_solve = !d_is_initialized;
    if (deallocate_after_solve) initializeSolverState(x, b);

    const int rank = IBTK_MPI::getRank();
    static const int data_depth = s_max_free_dofs;

    for (const auto& petsc_mat_pair : d_petsc_mat_map)
    {
        const std::string& mat_name = petsc_mat_pair.first;
        Mat& mat = d_petsc_mat_map[mat_name].second;
        const MobilityMatrixInverseType& inv_type = d_mat_inv_type_map[mat_name].second;
        const std::vector<std::vector<unsigned>>& struct_ids = d_mat_actual_id_map[mat_name];
        const int mat_size = d_mat_parts_map[mat_name] * data_depth;
        const int managing_proc = d_mat_proc_map[mat_name];
        const int num_structs = static_cast<int>(struct_ids.size());

        for (int k = 0; k < num_structs; ++k)
        {
            std::vector<double> rhs;
            if (rank == managing_proc) rhs.resize(mat_size);
            d_cib_strategy->copyFreeDOFsVecToArray(b, rhs.data(), struct_ids[k], managing_proc);
            if (!d_recompute_mob_mat)
            {
                d_cib_strategy->rotateArray(rhs.data(),
                                            struct_ids[k],
                                            /*use_transpose*/ true,
                                            managing_proc,
                                            data_depth);
            }
            if (rank == managing_proc) computeSolution(mat, inv_type, d_ipiv_map[mat_name].second.data(), rhs.data());
            if (!d_recompute_mob_mat)
            {
                d_cib_strategy->rotateArray(rhs.data(),
                                            struct_ids[k],
                                            /*use_transpose*/ false,
                                            managing_proc,
                                            data_depth);
            }
            d_cib_strategy->copyFreeDOFsArrayToVec(x, rhs.data(), struct_ids[k], managing_proc);
        }
    }

    IBAMR_TIMER_STOP(t_solve_body_system);

    return true;
} // solveBodySystem

void
DirectMobilitySolver::initializeSolverState(Vec x, Vec /*b*/)