Method CIBSaddlePointSolver

src/IB/CIBSaddlePointSolver.cpp:119–315

/////////////////////////////// PUBLIC ///////////////////////////////////////

CIBSaddlePointSolver::CIBSaddlePointSolver(std::string object_name,
                                           Pointer<Database> input_db,
                                           Pointer<INSStaggeredHierarchyIntegrator> navier_stokes_integrator,
                                           Pointer<CIBStrategy> cib_strategy,
                                           std::string default_options_prefix,
                                           MPI_Comm petsc_comm)
    : d_object_name(std::move(object_name)),
      d_options_prefix(std::move(default_options_prefix)),
      d_petsc_comm(petsc_comm),
      d_ins_integrator(navier_stokes_integrator),
      d_cib_strategy(cib_strategy),
      d_num_rigid_parts(cib_strategy->getNumberOfRigidStructures())
{
    // Get values from the input database.
    if (input_db) getFromInput(input_db);

    // Create the linear operator for the extended Stokes (Krylov) solver.
    d_A = new CIBStaggeredStokesOperator(d_object_name + "CIBStaggeredStokesOperator",
                                         d_cib_strategy,
                                         /*homogeneous_bc*/ false);
    d_A->setInterpScaleFactor(d_scale_interp);
    d_A->setSpreadScaleFactor(d_scale_spread);
    d_A->setRegularizeMobilityFactor(d_reg_mob_factor);
    d_A->setNormalizeSpreadForce(d_normalize_spread_force);

    // Create the mobility solver and pass-in some parameters.
    d_mob_solver =
        new CIBMobilitySolver(d_object_name + "CIBMobilitySolver", input_db, d_ins_integrator, d_cib_strategy);
    d_mob_solver->setInterpScale(d_scale_interp);
    d_mob_solver->setSpreadScale(d_scale_spread);
    d_mob_solver->setRegularizeMobilityScale(d_reg_mob_factor);
    d_mob_solver->setNormalizeSpreadForce(d_normalize_spread_force);

    // Create the Stokes solver (LInv) for the preconditioner.
    // Create databases for setting up LInv solver.
    Pointer<Database> LInv_db = input_db->getDatabase("PCStokesSolver");
    if (LInv_db->keyExists("normalize_pressure")) d_normalize_pressure = LInv_db->getBool("normalize_pressure");
    if (LInv_db->keyExists("normalize_velocity")) d_normalize_velocity = LInv_db->getBool("normalize_velocity");

    std::string stokes_solver_type = StaggeredStokesSolverManager::PETSC_KRYLOV_SOLVER;
    Pointer<Database> stokes_solver_db = nullptr;
    if (LInv_db->keyExists("stokes_solver_type"))
    {
        stokes_solver_type = LInv_db->getString("stokes_solver_type");
        if (LInv_db->keyExists("stokes_solver_db")) stokes_solver_db = LInv_db->getDatabase("stokes_solver_db");
    }
    if (!stokes_solver_db)
    {
        stokes_solver_db = new MemoryDatabase("stokes_solver_db");
        stokes_solver_db->putString("ksp_type", "fgmres");
    }

    std::string stokes_precond_type = StaggeredStokesSolverManager::DEFAULT_BLOCK_PRECONDITIONER;
    Pointer<Database> stokes_precond_db = nullptr;
    if (LInv_db->keyExists("stokes_precond_type"))
    {
        stokes_precond_type = LInv_db->getString("stokes_precond_type");
        if (LInv_db->keyExists("stokes_precond_db")) stokes_precond_db = LInv_db->getDatabase("stokes_precond_db");