Method apply

ibtk/src/solvers/impls/VCSCViscousOperator.cpp:104–191

} // ~VCSCViscousOperator()

void
VCSCViscousOperator::apply(SAMRAIVectorReal<NDIM, double>& x, SAMRAIVectorReal<NDIM, double>& y)
{
    IBTK_TIMER_START(t_apply);

#if !defined(NDEBUG)
    TBOX_ASSERT(d_is_initialized);
    TBOX_ASSERT(d_bc_coefs.size() == NDIM);
    for (int comp = 0; comp < d_ncomp; ++comp)
    {
        Pointer<SideVariable<NDIM, double>> x_sc_var = x.getComponentVariable(comp);
        Pointer<SideVariable<NDIM, double>> y_sc_var = y.getComponentVariable(comp);
        if (!x_sc_var || !y_sc_var)
        {
            TBOX_ERROR(d_object_name << "::apply()\n"
                                     << "  encountered non-side centered vector components" << std::endl);
        }
        Pointer<SideDataFactory<NDIM, double>> x_factory = x_sc_var->getPatchDataFactory();
        Pointer<SideDataFactory<NDIM, double>> y_factory = y_sc_var->getPatchDataFactory();
        TBOX_ASSERT(x_factory);
        TBOX_ASSERT(y_factory);
        const unsigned int x_depth = x_factory->getDefaultDepth();
        const unsigned int y_depth = y_factory->getDefaultDepth();
        TBOX_ASSERT(x_depth == y_depth);
        if (x_depth != 1 || y_depth != 1)
        {
            TBOX_ERROR(d_object_name << "::apply()\n"
                                     << "  each vector component must have data depth == 1" << std::endl);
        }
    }
#endif

    // Simultaneously fill ghost cell values for all components.
    using InterpolationTransactionComponent = HierarchyGhostCellInterpolation::InterpolationTransactionComponent;
    std::vector<InterpolationTransactionComponent> transaction_comps;
    for (int comp = 0; comp < d_ncomp; ++comp)
    {
        InterpolationTransactionComponent x_component(x.getComponentDescriptorIndex(comp),
                                                      DATA_REFINE_TYPE,
                                                      USE_CF_INTERPOLATION,
                                                      DATA_COARSEN_TYPE,
                                                      BDRY_EXTRAP_TYPE,
                                                      CONSISTENT_TYPE_2_BDRY,
                                                      d_bc_coefs,
                                                      d_fill_pattern);
        transaction_comps.push_back(x_component);
    }
    d_hier_bdry_fill->resetTransactionComponents(transaction_comps);
    d_hier_bdry_fill->setHomogeneousBc(d_homogeneous_bc);
    d_hier_bdry_fill->fillData(d_solution_time);
    d_hier_bdry_fill->resetTransactionComponents(d_transaction_comps);

    double alpha = 1.0;
    double beta = 1.0;
    if (d_poisson_spec.cIsZero() || d_poisson_spec.cIsConstant())
    {
        beta = d_poisson_spec.cIsZero() ? 0.0 : d_poisson_spec.getCConstant();
    }