Function main

tests/spread/spread_02.cpp:76–416

}

int
main(int argc, char** argv)
{
    // Initialize IBAMR and libraries. Deinitialization is handled by this object as well.
    IBTKInit ibtk_init(argc, argv, MPI_COMM_WORLD);
    const LibMeshInit& init = ibtk_init.getLibMeshInit();

    // suppress warnings caused by using a refinement ratio of 4 and not
    // setting up coarsening correctly
    SAMRAI::tbox::Logger::getInstance()->setWarning(false);

    PetscOptionsSetValue(nullptr, "-ksp_rtol", "1e-16");
    PetscOptionsSetValue(nullptr, "-ksp_atol", "1e-16");

    // prevent a warning about timer initializations
    TimerManager::createManager(nullptr);
    {
        // Parse command line options, set some standard options from the input
        // file, initialize the restart database (if this is a restarted run),
        // and enable file logging.
        Pointer<AppInitializer> app_initializer = new AppInitializer(argc, argv, "IB.log");

        Pointer<Database> input_db = app_initializer->getInputDatabase();

        // Create a simple FE mesh.
        std::vector<std::unique_ptr<ReplicatedMesh>> meshes;
        meshes.emplace_back(std::make_unique<ReplicatedMesh>(init.comm(), NDIM));
        const double dx = input_db->getDouble("DX");
        const double ds = input_db->getDouble("MFAC") * dx;
        const std::string elem_str = input_db->getString("ELEM_TYPE");
        const auto elem_type = Utility::string_to_enum<ElemType>(elem_str);

        // This test only supports one type of mesh.
        {
            ReplicatedMesh& mesh = *meshes[0];
            const double L = input_db->getDouble("L");
            if (NDIM == 2)
                MeshTools::Generation::build_square(
                    mesh, int(L / ds), int(L / (4.0 * ds)), 0.0, L, 0.0, L / 4.0, elem_type);
            else
                MeshTools::Generation::build_cube(mesh,
                                                  int(L / ds),
                                                  int(L / (4.0 * ds)),
                                                  int(L / (4.0 * ds)),
                                                  0.0,
                                                  L,
                                                  0.0,
                                                  L / 4.0,
                                                  0.0,
                                                  L / 4.0,
                                                  elem_type);

            // Assign boundary elements to a finer patch level
            MeshBase::element_iterator el_end = mesh.active_elements_end();
            for (MeshBase::element_iterator el = mesh.active_elements_begin(); el != el_end; ++el)
            {
                const libMesh::Point centroid = (*el)->vertex_average();
                if (centroid(0) < 0.5)