Ejemplo n.º 1
0
PetscErrorCode
VecMAXPY_SAMRAI(
    Vec y,
    PetscInt nv,
    const PetscScalar* alpha,
    Vec* x)
{
    IBTK_TIMER_START(t_vec_maxpy);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(y != PETSC_NULL);
    for (PetscInt i = 0; i < nv; ++i)
    {
        TBOX_ASSERT(x[i] != PETSC_NULL);
    }
#endif
    static const bool interior_only = false;
    for (PetscInt i = 0; i < nv; ++i)
    {
        if (MathUtilities<double>::equalEps(alpha[i],1.0))
        {
            PSVR_CAST2(y)->add(PSVR_CAST2(x[i]), PSVR_CAST2(y), interior_only);
        }
        else if (MathUtilities<double>::equalEps(alpha[i],-1.0))
        {
            PSVR_CAST2(y)->subtract(PSVR_CAST2(y), PSVR_CAST2(x[i]), interior_only);
        }
        else
        {
            PSVR_CAST2(y)->axpy(alpha[i], PSVR_CAST2(x[i]), PSVR_CAST2(y), interior_only);
        }
    }
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y)); IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_maxpy);
    PetscFunctionReturn(0);
}// VecMAXPY
Ejemplo n.º 2
0
PetscErrorCode VecNorm_local_SAMRAI(Vec x, NormType type, PetscScalar* val)
{
    IBTK_TIMER_START(t_vec_norm_local);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
#endif
    static const bool local_only = true;
    if (type == NORM_1)
    {
        *val = NormOps::L1Norm(PSVR_CAST2(x), local_only);
    }
    else if (type == NORM_2)
    {
        *val = NormOps::L2Norm(PSVR_CAST2(x), local_only);
    }
    else if (type == NORM_INFINITY)
    {
        *val = NormOps::maxNorm(PSVR_CAST2(x), local_only);
    }
    else if (type == NORM_1_AND_2)
    {
        val[0] = NormOps::L1Norm(PSVR_CAST2(x), local_only);
        val[1] = NormOps::L2Norm(PSVR_CAST2(x), local_only);
    }
    else
    {
        TBOX_ERROR("PETScSAMRAIVectorReal::norm()\n"
                   << "  vector norm type " << static_cast<int>(type) << " unsupported"
                   << std::endl);
    }
    IBTK_TIMER_STOP(t_vec_norm_local);
    PetscFunctionReturn(0);
} // VecNorm_local
Ejemplo n.º 3
0
PetscErrorCode
VecWAXPY_SAMRAI(
    Vec w,
    PetscScalar alpha,
    Vec x,
    Vec y)
{
    IBTK_TIMER_START(t_vec_waxpy);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(x != PETSC_NULL);
    TBOX_ASSERT(y != PETSC_NULL);
    TBOX_ASSERT(w != PETSC_NULL);
#endif
    static const bool interior_only = false;
    if (MathUtilities<double>::equalEps(alpha,1.0))
    {
        PSVR_CAST2(w)->add(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);
    }
    else if (MathUtilities<double>::equalEps(alpha,-1.0))
    {
        PSVR_CAST2(w)->subtract(PSVR_CAST2(y), PSVR_CAST2(x), interior_only);
    }
    else
    {
        PSVR_CAST2(w)->axpy(alpha, PSVR_CAST2(x), PSVR_CAST2(y), interior_only);
    }
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(w)); IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_waxpy);
    PetscFunctionReturn(0);
}// VecWAXPY
Ejemplo n.º 4
0
PetscErrorCode VecAYPX_SAMRAI(Vec y, const PetscScalar alpha, Vec x)
{
    IBTK_TIMER_START(t_vec_aypx);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    TBOX_ASSERT(y);
#endif
    static const bool interior_only = false;
    if (MathUtilities<double>::equalEps(alpha, 1.0))
    {
        PSVR_CAST2(y)->add(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);
    }
    else if (MathUtilities<double>::equalEps(alpha, -1.0))
    {
        PSVR_CAST2(y)->subtract(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);
    }
    else
    {
        PSVR_CAST2(y)->axpy(alpha, PSVR_CAST2(y), PSVR_CAST2(x), interior_only);
    }
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y));
    IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_aypx);
    PetscFunctionReturn(0);
} // VecAYPX
Ejemplo n.º 5
0
bool
PETScKrylovLinearSolver::solveSystem(SAMRAIVectorReal<NDIM, double>& x, SAMRAIVectorReal<NDIM, double>& b)
{
    IBTK_TIMER_START(t_solve_system);

#if !defined(NDEBUG)
    TBOX_ASSERT(d_A);
#endif
    int ierr;

    // Initialize the solver, when necessary.
    const bool deallocate_after_solve = !d_is_initialized;
    if (deallocate_after_solve) initializeSolverState(x, b);
#if !defined(NDEBUG)
    TBOX_ASSERT(d_petsc_ksp);
#endif
    resetKSPOptions();

    // Allocate scratch data.
    d_b->allocateVectorData();

    // Solve the system using a PETSc KSP object.
    d_b->copyVector(Pointer<SAMRAIVectorReal<NDIM, double> >(&b, false));
    d_A->setHomogeneousBc(d_homogeneous_bc);
    d_A->modifyRhsForBcs(*d_b);
    d_A->setHomogeneousBc(true);
    PETScSAMRAIVectorReal::replaceSAMRAIVector(d_petsc_x, Pointer<SAMRAIVectorReal<NDIM, double> >(&x, false));
    PETScSAMRAIVectorReal::replaceSAMRAIVector(d_petsc_b, d_b);
    ierr = KSPSolve(d_petsc_ksp, d_petsc_b, d_petsc_x);
    IBTK_CHKERRQ(ierr);
    d_A->setHomogeneousBc(d_homogeneous_bc);
    d_A->imposeSolBcs(x);

    // Get iterations count and residual norm.
    ierr = KSPGetIterationNumber(d_petsc_ksp, &d_current_iterations);
    IBTK_CHKERRQ(ierr);
    ierr = KSPGetResidualNorm(d_petsc_ksp, &d_current_residual_norm);
    IBTK_CHKERRQ(ierr);
    d_A->setHomogeneousBc(d_homogeneous_bc);

    // Determine the convergence reason.
    KSPConvergedReason reason;
    ierr = KSPGetConvergedReason(d_petsc_ksp, &reason);
    IBTK_CHKERRQ(ierr);
    const bool converged = (static_cast<int>(reason) > 0);
    if (d_enable_logging) reportKSPConvergedReason(reason, plog);

    // Dealocate scratch data.
    d_b->deallocateVectorData();

    // Deallocate the solver, when necessary.
    if (deallocate_after_solve) deallocateSolverState();

    IBTK_TIMER_STOP(t_solve_system);
    return converged;
} // solveSystem
Ejemplo n.º 6
0
PetscErrorCode VecGetLocalSize_SAMRAI(Vec v, PetscInt* size)
{
    IBTK_TIMER_START(t_vec_get_local_size);
#if !defined(NDEBUG)
    TBOX_ASSERT(v);
#endif
    *size = v->map->n;
    IBTK_TIMER_STOP(t_vec_get_local_size);
    PetscFunctionReturn(0);
} // VecGetLocalSize
Ejemplo n.º 7
0
PetscErrorCode VecMin_SAMRAI(Vec x, PetscInt* p, PetscScalar* val)
{
    IBTK_TIMER_START(t_vec_min);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
#endif
    *p = -1;
    *val = PSVR_CAST2(x)->min();
    IBTK_TIMER_STOP(t_vec_min);
    PetscFunctionReturn(0);
} // VecMin
Ejemplo n.º 8
0
PetscErrorCode VecTDot_SAMRAI(Vec x, Vec y, PetscScalar* val)
{
    IBTK_TIMER_START(t_vec_t_dot);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    TBOX_ASSERT(y);
#endif
    *val = PSVR_CAST2(x)->dot(PSVR_CAST2(y));
    IBTK_TIMER_STOP(t_vec_t_dot);
    PetscFunctionReturn(0);
} // VecTDot
Ejemplo n.º 9
0
PetscErrorCode VecMaxPointwiseDivide_SAMRAI(Vec x, Vec y, PetscScalar* max)
{
    IBTK_TIMER_START(t_vec_max_pointwise_divide);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    TBOX_ASSERT(y);
#endif
    *max = PSVR_CAST2(x)->maxPointwiseDivide(PSVR_CAST2(y));
    IBTK_TIMER_STOP(t_vec_max_pointwise_divide);
    PetscFunctionReturn(0);
} // VecMaxPointwiseDivide
Ejemplo n.º 10
0
PetscErrorCode VecTDot_local_SAMRAI(Vec x, Vec y, PetscScalar* val)
{
    IBTK_TIMER_START(t_vec_t_dot_local);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    TBOX_ASSERT(y);
#endif
    static const bool local_only = true;
    *val = PSVR_CAST2(x)->dot(PSVR_CAST2(y), local_only);
    IBTK_TIMER_STOP(t_vec_t_dot_local);
    PetscFunctionReturn(0);
} // VecTDot_local
Ejemplo n.º 11
0
PetscErrorCode VecDotNorm2_SAMRAI(Vec s, Vec t, PetscScalar* dp, PetscScalar* nm)
{
    IBTK_TIMER_START(t_vec_dot_norm2);
#if !defined(NDEBUG)
    TBOX_ASSERT(s);
    TBOX_ASSERT(t);
#endif
    *dp = PSVR_CAST2(s)->dot(PSVR_CAST2(t));
    *nm = PSVR_CAST2(t)->dot(PSVR_CAST2(t));
    IBTK_TIMER_STOP(t_vec_dot_norm2);
    PetscFunctionReturn(0);
} // VecDotNorm2_SAMRAI
Ejemplo n.º 12
0
PetscErrorCode VecSet_SAMRAI(Vec x, PetscScalar alpha)
{
    IBTK_TIMER_START(t_vec_set);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
#endif
    static const bool interior_only = false;
    PSVR_CAST2(x)->setToScalar(alpha, interior_only);
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(x));
    IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_set);
    PetscFunctionReturn(0);
} // VecSet
Ejemplo n.º 13
0
PetscErrorCode VecCopy_SAMRAI(Vec x, Vec y)
{
    IBTK_TIMER_START(t_vec_copy);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    TBOX_ASSERT(y);
#endif
    static const bool interior_only = false;
    PSVR_CAST2(y)->copyVector(PSVR_CAST2(x), interior_only);
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y));
    IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_copy);
    PetscFunctionReturn(0);
} // VecCopy
Ejemplo n.º 14
0
bool
CCDivGradHypreLevelSolver::solveSystem(
    SAMRAIVectorReal<NDIM,double>& x,
    SAMRAIVectorReal<NDIM,double>& b)
{
    IBTK_TIMER_START(t_solve_system);

    if (d_enable_logging) plog << d_object_name << "::solveSystem():" << std::endl;

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

    // Solve the system using the hypre solver.
    static const int comp = 0;
    const int x_idx = x.getComponentDescriptorIndex(comp);
    const int b_idx = b.getComponentDescriptorIndex(comp);

    bool converged = true;
    IntVector<NDIM> chkbrd_mode_id;
#if (NDIM > 2)
    for (chkbrd_mode_id(2) = 0; chkbrd_mode_id(2) < 2; ++chkbrd_mode_id(2))
    {
#endif
        for (chkbrd_mode_id(1) = 0; chkbrd_mode_id(1) < 2; ++chkbrd_mode_id(1))
        {
            for (chkbrd_mode_id(0) = 0; chkbrd_mode_id(0) < 2; ++chkbrd_mode_id(0))
            {
                bool converged_mode = solveSystem(x_idx, b_idx, chkbrd_mode_id);
                if (d_enable_logging)
                {
                    plog << d_object_name << "::solveSystem(): solver " << (converged_mode ? "converged" : "diverged") << "\n"
                         << "chkbrd_mode_id = " << chkbrd_mode_id << "\n"
                         << "iterations = " << d_current_its << "\n"
                         << "residual norm = " << d_current_residual_norm << std::endl;
                }
                converged = converged && converged_mode;
            }
        }
#if (NDIM > 2)
    }
#endif

    // Deallocate the solver, when necessary.
    if (deallocate_after_solve) deallocateSolverState();

    IBTK_TIMER_STOP(t_solve_system);
    return converged;
}// solveSystem
Ejemplo n.º 15
0
PetscErrorCode
VecGetLocalSize_SAMRAI(
    Vec v,
    PetscInt* n)
{
    IBTK_TIMER_START(t_vec_get_local_size);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(v != PETSC_NULL);
#else
    NULL_USE(v);
#endif
    *n = 0;
    IBTK_TIMER_STOP(t_vec_get_local_size);
    PetscFunctionReturn(0);
}// VecGetLocalSize
Ejemplo n.º 16
0
PetscErrorCode
VecScale_SAMRAI(
    Vec x,
    PetscScalar alpha)
{
    IBTK_TIMER_START(t_vec_scale);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(x != PETSC_NULL);
#endif
    static const bool interior_only = false;
    PSVR_CAST2(x)->scale(alpha,PSVR_CAST2(x), interior_only);
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(x)); IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_scale);
    PetscFunctionReturn(0);
}// VecScale
Ejemplo n.º 17
0
PetscErrorCode VecPointwiseDivide_SAMRAI(Vec w, Vec x, Vec y)
{
    IBTK_TIMER_START(t_vec_pointwise_divide);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    TBOX_ASSERT(y);
    TBOX_ASSERT(w);
#endif
    static const bool interior_only = false;
    PSVR_CAST2(w)->divide(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(w));
    IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_pointwise_divide);
    PetscFunctionReturn(0);
} // VecPointwiseDivide
Ejemplo n.º 18
0
PetscErrorCode
VecMaxPointwiseDivide_SAMRAI(
    Vec x,
    Vec y,
    PetscScalar* max)
{
    IBTK_TIMER_START(t_vec_max_pointwise_divide);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(x != PETSC_NULL);
    TBOX_ASSERT(y != PETSC_NULL);
#endif
    *max = PSVR_CAST2(x)->maxPointwiseDivide(PSVR_CAST2(y));
    IBTK_TIMER_STOP(t_vec_max_pointwise_divide);
    PetscFunctionReturn(0);
}// VecMaxPointwiseDivide
Ejemplo n.º 19
0
PetscErrorCode
VecMin_SAMRAI(
    Vec x,
    PetscInt* p,
    PetscScalar* val)
{
    IBTK_TIMER_START(t_vec_min);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(x != PETSC_NULL);
#endif
    *p = -1;
    *val = PSVR_CAST2(x)->min();
    IBTK_TIMER_STOP(t_vec_min);
    PetscFunctionReturn(0);
}// VecMin
Ejemplo n.º 20
0
PetscErrorCode
VecTDot_SAMRAI(
    Vec x,
    Vec y,
    PetscScalar* val)
{
    IBTK_TIMER_START(t_vec_t_dot);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(x != PETSC_NULL);
    TBOX_ASSERT(y != PETSC_NULL);
#endif
    *val = PSVR_CAST2(x)->dot(PSVR_CAST2(y));
    IBTK_TIMER_STOP(t_vec_t_dot);
    PetscFunctionReturn(0);
}// VecTDot
Ejemplo n.º 21
0
PetscErrorCode
VecDot_local_SAMRAI(
    Vec x,
    Vec y,
    PetscScalar* val)
{
    IBTK_TIMER_START(t_vec_dot_local);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(x != PETSC_NULL);
    TBOX_ASSERT(y != PETSC_NULL);
#endif
    static const bool local_only = true;
    *val = PSVR_CAST2(x)->dot(PSVR_CAST2(y), local_only);
    IBTK_TIMER_STOP(t_vec_dot_local);
    PetscFunctionReturn(0);
}// VecDot_local
Ejemplo n.º 22
0
PetscErrorCode VecSetRandom_SAMRAI(Vec x, PetscRandom rctx)
{
    IBTK_TIMER_START(t_vec_set_random);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
#endif
    PetscScalar lo, hi;
    int ierr;
    ierr = PetscRandomGetInterval(rctx, &lo, &hi);
    IBTK_CHKERRQ(ierr);
    PSVR_CAST2(x)->setRandomValues(hi - lo, lo);
    ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(x));
    IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_set_random);
    PetscFunctionReturn(0);
} // VecSetRandom
Ejemplo n.º 23
0
PetscErrorCode VecSwap_SAMRAI(Vec x, Vec y)
{
    IBTK_TIMER_START(t_vec_swap);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    TBOX_ASSERT(y);
#endif
    PSVR_CAST2(x)->swapVectors(PSVR_CAST2(y));
    int ierr;
    ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(x));
    IBTK_CHKERRQ(ierr);
    ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y));
    IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_swap);
    PetscFunctionReturn(0);
} // VecSwap
Ejemplo n.º 24
0
void PETScNewtonKrylovSolver::deallocateSolverState()
{
    if (!d_is_initialized) return;

    IBTK_TIMER_START(t_deallocate_solver_state);

    int ierr;

    // Deallocate the linear solver and operator states only if we are not
    // re-initializing the Newton solver.
    if (!d_reinitializing_solver)
    {
        if (d_krylov_solver) d_krylov_solver->deallocateSolverState();
        if (d_J) d_J->deallocateOperatorState();
        if (d_F) d_F->deallocateOperatorState();
    }

    // Delete the solution and rhs vectors.
    PETScSAMRAIVectorReal::destroyPETScVector(d_petsc_x);
    d_petsc_x = NULL;
    d_x->freeVectorComponents();
    d_x.setNull();

    PETScSAMRAIVectorReal::destroyPETScVector(d_petsc_b);
    d_petsc_b = NULL;
    d_b->freeVectorComponents();
    d_b.setNull();

    PETScSAMRAIVectorReal::destroyPETScVector(d_petsc_r);
    d_petsc_r = NULL;
    d_r->freeVectorComponents();
    d_r.setNull();

    // Destroy the SNES solver.
    if (d_managing_petsc_snes)
    {
        ierr = SNESDestroy(&d_petsc_snes);
        IBTK_CHKERRQ(ierr);
        d_petsc_snes = NULL;
    }

    // Indicate that the solver is NOT initialized.
    d_is_initialized = false;

    IBTK_TIMER_STOP(t_deallocate_solver_state);
    return;
} // deallocateSolverState
Ejemplo n.º 25
0
void
CCDivGradHypreLevelSolver::deallocateSolverState()
{
    if (!d_is_initialized) return;

    IBTK_TIMER_START(t_deallocate_solver_state);

    // Deallocate the hypre data structures.
    destroyHypreSolver();
    deallocateHypreData();

    // Indicate that the solver is NOT initialized.
    d_is_initialized = false;

    IBTK_TIMER_STOP(t_deallocate_solver_state);
    return;
}// deallocateSolverState
Ejemplo n.º 26
0
void
PETScKrylovLinearSolver::deallocateSolverState()
{
    if (!d_is_initialized) return;

    IBTK_TIMER_START(t_deallocate_solver_state);

    int ierr;

    // Deallocate the operator and preconditioner states only if we are not
    // re-initializing the solver.
    if (!d_reinitializing_solver)
    {
        if (d_pc_solver) d_pc_solver->deallocateSolverState();
        if (d_A) d_A->deallocateOperatorState();
    }

    // Delete the solution and rhs vectors.
    PETScSAMRAIVectorReal::destroyPETScVector(d_petsc_x);
    d_petsc_x = NULL;
    d_x->freeVectorComponents();
    d_x.setNull();

    PETScSAMRAIVectorReal::destroyPETScVector(d_petsc_b);
    d_petsc_b = NULL;
    d_b->freeVectorComponents();
    d_b.setNull();

    // Deallocate the nullspace object.
    deallocateNullspaceData();

    // Destroy the KSP solver.
    if (d_managing_petsc_ksp)
    {
        ierr = KSPDestroy(&d_petsc_ksp);
        IBTK_CHKERRQ(ierr);
        d_petsc_ksp = NULL;
        d_solver_has_attached_nullspace = false;
    }

    // Indicate that the solver is NOT initialized.
    d_is_initialized = false;

    IBTK_TIMER_STOP(t_deallocate_solver_state);
    return;
} // deallocateSolverState
Ejemplo n.º 27
0
PetscErrorCode
VecDotNorm2_SAMRAI(
    Vec s,
    Vec t,
    PetscScalar* dp,
    PetscScalar* nm)
{
    IBTK_TIMER_START(t_vec_dot_norm2);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(s != PETSC_NULL);
    TBOX_ASSERT(t != PETSC_NULL);
#endif
    *dp = PSVR_CAST2(s)->dot(PSVR_CAST2(t));
    *nm = PSVR_CAST2(t)->dot(PSVR_CAST2(t));
    IBTK_TIMER_STOP(t_vec_dot_norm2);
    PetscFunctionReturn(0);
}// VecDotNorm2_SAMRAI
Ejemplo n.º 28
0
PetscErrorCode
VecAXPBYPCZ_SAMRAI(Vec z, PetscScalar alpha, PetscScalar beta, PetscScalar gamma, Vec x, Vec y)
{
    IBTK_TIMER_START(t_vec_axpbypcz);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    TBOX_ASSERT(y);
    TBOX_ASSERT(z);
#endif
    static const bool interior_only = false;
    PSVR_CAST2(z)->linearSum(alpha, PSVR_CAST2(x), gamma, PSVR_CAST2(z), interior_only);
    PSVR_CAST2(z)->axpy(beta, PSVR_CAST2(y), PSVR_CAST2(z), interior_only);
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(z));
    IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_axpbypcz);
    PetscFunctionReturn(0);
} // VecAXPBYPCZ
Ejemplo n.º 29
0
PetscErrorCode VecMTDot_local_SAMRAI(Vec x, PetscInt nv, const Vec* y, PetscScalar* val)
{
    IBTK_TIMER_START(t_vec_m_t_dot_local);
#if !defined(NDEBUG)
    TBOX_ASSERT(x);
    for (PetscInt i = 0; i < nv; ++i)
    {
        TBOX_ASSERT(y[i]);
    }
#endif
    static const bool local_only = true;
    for (PetscInt i = 0; i < nv; ++i)
    {
        val[i] = PSVR_CAST2(x)->dot(PSVR_CAST2(y[i]), local_only);
    }
    IBTK_TIMER_STOP(t_vec_m_t_dot_local);
    PetscFunctionReturn(0);
} // VecMTDot_local
Ejemplo n.º 30
0
PetscErrorCode
VecPointwiseMult_SAMRAI(
    Vec w,
    Vec x,
    Vec y)
{
    IBTK_TIMER_START(t_vec_pointwise_mult);
#ifdef DEBUG_CHECK_ASSERTIONS
    TBOX_ASSERT(x != PETSC_NULL);
    TBOX_ASSERT(y != PETSC_NULL);
    TBOX_ASSERT(w != PETSC_NULL);
#endif
    static const bool interior_only = false;
    PSVR_CAST2(w)->multiply(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);
    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(w)); IBTK_CHKERRQ(ierr);
    IBTK_TIMER_STOP(t_vec_pointwise_mult);
    PetscFunctionReturn(0);
}// VecPointwiseMult