Date: 2026-05-01T10:02:15+00:00

Actual source code: bvmat.c

      1: /*
      2:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      3:    SLEPc - Scalable Library for Eigenvalue Problem Computations
      4:    Copyright (c) 2002-, Universitat Politecnica de Valencia, Spain

      6:    This file is part of SLEPc.
      7:    SLEPc is distributed under a 2-clause BSD license (see LICENSE).
      8:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      9: */
     10: /*
     11:    BV implemented with a dense Mat
     12: */

     14: #include <slepc/private/bvimpl.h>
     15: #include "bvmat.h"

     17: static PetscErrorCode BVMult_Mat(BV Y,PetscScalar alpha,PetscScalar beta,BV X,Mat Q)
     18: {
     19:   BV_MAT            *y = (BV_MAT*)Y->data,*x = (BV_MAT*)X->data;
     20:   PetscScalar       *py;
     21:   const PetscScalar *px,*q;
     22:   PetscInt          ldq;

     24:   PetscFunctionBegin;
     25:   PetscCall(MatDenseGetArrayRead(x->A,&px));
     26:   PetscCall(MatDenseGetArray(y->A,&py));
     27:   if (Q) {
     28:     PetscCall(MatDenseGetLDA(Q,&ldq));
     29:     PetscCall(MatDenseGetArrayRead(Q,&q));
     30:     PetscCall(BVMult_BLAS_Private(Y,Y->n,Y->k-Y->l,X->k-X->l,alpha,px+(X->nc+X->l)*X->ld,X->ld,q+Y->l*ldq+X->l,ldq,beta,py+(Y->nc+Y->l)*Y->ld,Y->ld));
     31:     PetscCall(MatDenseRestoreArrayRead(Q,&q));
     32:   } else PetscCall(BVAXPY_BLAS_Private(Y,Y->n,Y->k-Y->l,alpha,px+(X->nc+X->l)*X->ld,X->ld,beta,py+(Y->nc+Y->l)*Y->ld,Y->ld));
     33:   PetscCall(MatDenseRestoreArrayRead(x->A,&px));
     34:   PetscCall(MatDenseRestoreArray(y->A,&py));
     35:   PetscFunctionReturn(PETSC_SUCCESS);
     36: }

     38: static PetscErrorCode BVMultVec_Mat(BV X,PetscScalar alpha,PetscScalar beta,Vec y,PetscScalar *q)
     39: {
     40:   BV_MAT            *x = (BV_MAT*)X->data;
     41:   PetscScalar       *py,*qq=q;
     42:   const PetscScalar *px;

     44:   PetscFunctionBegin;
     45:   PetscCall(MatDenseGetArrayRead(x->A,&px));
     46:   PetscCall(VecGetArray(y,&py));
     47:   if (!q) PetscCall(VecGetArray(X->buffer,&qq));
     48:   PetscCall(BVMultVec_BLAS_Private(X,X->n,X->k-X->l,alpha,px+(X->nc+X->l)*X->ld,X->ld,qq,beta,py));
     49:   if (!q) PetscCall(VecRestoreArray(X->buffer,&qq));
     50:   PetscCall(MatDenseRestoreArrayRead(x->A,&px));
     51:   PetscCall(VecRestoreArray(y,&py));
     52:   PetscFunctionReturn(PETSC_SUCCESS);
     53: }

     55: static PetscErrorCode BVMultInPlace_Mat(BV V,Mat Q,PetscInt s,PetscInt e)
     56: {
     57:   BV_MAT            *ctx = (BV_MAT*)V->data;
     58:   PetscScalar       *pv;
     59:   const PetscScalar *q;
     60:   PetscInt          ldq;

     62:   PetscFunctionBegin;
     63:   if (s>=e || !V->n) PetscFunctionReturn(PETSC_SUCCESS);
     64:   PetscCall(MatDenseGetLDA(Q,&ldq));
     65:   PetscCall(MatDenseGetArray(ctx->A,&pv));
     66:   PetscCall(MatDenseGetArrayRead(Q,&q));
     67:   PetscCall(BVMultInPlace_BLAS_Private(V,V->n,V->k-V->l,s-V->l,e-V->l,pv+(V->nc+V->l)*V->ld,V->ld,q+V->l*ldq+V->l,ldq,PETSC_FALSE));
     68:   PetscCall(MatDenseRestoreArrayRead(Q,&q));
     69:   PetscCall(MatDenseRestoreArray(ctx->A,&pv));
     70:   PetscFunctionReturn(PETSC_SUCCESS);
     71: }

     73: static PetscErrorCode BVMultInPlaceHermitianTranspose_Mat(BV V,Mat Q,PetscInt s,PetscInt e)
     74: {
     75:   BV_MAT            *ctx = (BV_MAT*)V->data;
     76:   PetscScalar       *pv;
     77:   const PetscScalar *q;
     78:   PetscInt          ldq;

     80:   PetscFunctionBegin;
     81:   if (s>=e || !V->n) PetscFunctionReturn(PETSC_SUCCESS);
     82:   PetscCall(MatDenseGetLDA(Q,&ldq));
     83:   PetscCall(MatDenseGetArray(ctx->A,&pv));
     84:   PetscCall(MatDenseGetArrayRead(Q,&q));
     85:   PetscCall(BVMultInPlace_BLAS_Private(V,V->n,V->k-V->l,s-V->l,e-V->l,pv+(V->nc+V->l)*V->ld,V->ld,q+V->l*ldq+V->l,ldq,PETSC_TRUE));
     86:   PetscCall(MatDenseRestoreArrayRead(Q,&q));
     87:   PetscCall(MatDenseRestoreArray(ctx->A,&pv));
     88:   PetscFunctionReturn(PETSC_SUCCESS);
     89: }

     91: static PetscErrorCode BVDot_Mat(BV X,BV Y,Mat M)
     92: {
     93:   BV_MAT            *x = (BV_MAT*)X->data,*y = (BV_MAT*)Y->data;
     94:   PetscScalar       *m;
     95:   const PetscScalar *px,*py;
     96:   PetscInt          ldm;

     98:   PetscFunctionBegin;
     99:   PetscCall(MatDenseGetLDA(M,&ldm));
    100:   PetscCall(MatDenseGetArrayRead(x->A,&px));
    101:   PetscCall(MatDenseGetArrayRead(y->A,&py));
    102:   PetscCall(MatDenseGetArray(M,&m));
    103:   PetscCall(BVDot_BLAS_Private(X,Y->k-Y->l,X->k-X->l,X->n,py+(Y->nc+Y->l)*Y->ld,Y->ld,px+(X->nc+X->l)*X->ld,X->ld,m+X->l*ldm+Y->l,ldm,x->mpi));
    104:   PetscCall(MatDenseRestoreArray(M,&m));
    105:   PetscCall(MatDenseRestoreArrayRead(x->A,&px));
    106:   PetscCall(MatDenseRestoreArrayRead(y->A,&py));
    107:   PetscFunctionReturn(PETSC_SUCCESS);
    108: }

    110: static PetscErrorCode BVDotVec_Mat(BV X,Vec y,PetscScalar *q)
    111: {
    112:   BV_MAT            *x = (BV_MAT*)X->data;
    113:   PetscScalar       *qq=q;
    114:   const PetscScalar *px,*py;
    115:   Vec               z = y;

    117:   PetscFunctionBegin;
    118:   if (PetscUnlikely(X->matrix)) {
    119:     PetscCall(BV_IPMatMult(X,y));
    120:     z = X->Bx;
    121:   }
    122:   PetscCall(MatDenseGetArrayRead(x->A,&px));
    123:   PetscCall(VecGetArrayRead(z,&py));
    124:   if (!q) PetscCall(VecGetArray(X->buffer,&qq));
    125:   PetscCall(BVDotVec_BLAS_Private(X,X->n,X->k-X->l,px+(X->nc+X->l)*X->ld,X->ld,py,qq,x->mpi));
    126:   if (!q) PetscCall(VecRestoreArray(X->buffer,&qq));
    127:   PetscCall(VecRestoreArrayRead(z,&py));
    128:   PetscCall(MatDenseRestoreArrayRead(x->A,&px));
    129:   PetscFunctionReturn(PETSC_SUCCESS);
    130: }

    132: static PetscErrorCode BVDotVec_Local_Mat(BV X,Vec y,PetscScalar *m)
    133: {
    134:   BV_MAT            *x = (BV_MAT*)X->data;
    135:   const PetscScalar *px,*py;
    136:   Vec               z = y;

    138:   PetscFunctionBegin;
    139:   if (PetscUnlikely(X->matrix)) {
    140:     PetscCall(BV_IPMatMult(X,y));
    141:     z = X->Bx;
    142:   }
    143:   PetscCall(MatDenseGetArrayRead(x->A,&px));
    144:   PetscCall(VecGetArrayRead(z,&py));
    145:   PetscCall(BVDotVec_BLAS_Private(X,X->n,X->k-X->l,px+(X->nc+X->l)*X->ld,X->ld,py,m,PETSC_FALSE));
    146:   PetscCall(VecRestoreArrayRead(z,&py));
    147:   PetscCall(MatDenseRestoreArrayRead(x->A,&px));
    148:   PetscFunctionReturn(PETSC_SUCCESS);
    149: }

    151: static PetscErrorCode BVScale_Mat(BV bv,PetscInt j,PetscScalar alpha)
    152: {
    153:   BV_MAT         *ctx = (BV_MAT*)bv->data;
    154:   PetscScalar    *array;

    156:   PetscFunctionBegin;
    157:   if (!bv->n) PetscFunctionReturn(PETSC_SUCCESS);
    158:   PetscCall(MatDenseGetArray(ctx->A,&array));
    159:   if (PetscUnlikely(j<0)) PetscCall(BVScale_BLAS_Private(bv,(bv->k-bv->l)*bv->ld,array+(bv->nc+bv->l)*bv->ld,alpha));
    160:   else PetscCall(BVScale_BLAS_Private(bv,bv->n,array+(bv->nc+j)*bv->ld,alpha));
    161:   PetscCall(MatDenseRestoreArray(ctx->A,&array));
    162:   PetscFunctionReturn(PETSC_SUCCESS);
    163: }

    165: static PetscErrorCode BVNorm_Mat(BV bv,PetscInt j,NormType type,PetscReal *val)
    166: {
    167:   BV_MAT            *ctx = (BV_MAT*)bv->data;
    168:   const PetscScalar *array;

    170:   PetscFunctionBegin;
    171:   PetscCall(MatDenseGetArrayRead(ctx->A,&array));
    172:   if (PetscUnlikely(j<0)) PetscCall(BVNorm_LAPACK_Private(bv,bv->n,bv->k-bv->l,array+(bv->nc+bv->l)*bv->ld,bv->ld,type,val,ctx->mpi));
    173:   else PetscCall(BVNorm_LAPACK_Private(bv,bv->n,1,array+(bv->nc+j)*bv->ld,bv->ld,type,val,ctx->mpi));
    174:   PetscCall(MatDenseRestoreArrayRead(ctx->A,&array));
    175:   PetscFunctionReturn(PETSC_SUCCESS);
    176: }

    178: static PetscErrorCode BVNorm_Local_Mat(BV bv,PetscInt j,NormType type,PetscReal *val)
    179: {
    180:   BV_MAT            *ctx = (BV_MAT*)bv->data;
    181:   const PetscScalar *array;

    183:   PetscFunctionBegin;
    184:   PetscCall(MatDenseGetArrayRead(ctx->A,&array));
    185:   if (PetscUnlikely(j<0)) PetscCall(BVNorm_LAPACK_Private(bv,bv->n,bv->k-bv->l,array+(bv->nc+bv->l)*bv->ld,bv->ld,type,val,PETSC_FALSE));
    186:   else PetscCall(BVNorm_LAPACK_Private(bv,bv->n,1,array+(bv->nc+j)*bv->ld,bv->ld,type,val,PETSC_FALSE));
    187:   PetscCall(MatDenseRestoreArrayRead(ctx->A,&array));
    188:   PetscFunctionReturn(PETSC_SUCCESS);
    189: }

    191: static PetscErrorCode BVNormalize_Mat(BV bv,PetscScalar *eigi)
    192: {
    193:   BV_MAT         *ctx = (BV_MAT*)bv->data;
    194:   PetscScalar    *array,*wi=NULL;

    196:   PetscFunctionBegin;
    197:   PetscCall(MatDenseGetArray(ctx->A,&array));
    198:   if (eigi) wi = eigi+bv->l;
    199:   PetscCall(BVNormalize_LAPACK_Private(bv,bv->n,bv->k-bv->l,array+(bv->nc+bv->l)*bv->ld,bv->ld,wi,ctx->mpi));
    200:   PetscCall(MatDenseRestoreArray(ctx->A,&array));
    201:   PetscFunctionReturn(PETSC_SUCCESS);
    202: }

    204: static PetscErrorCode BVMatMult_Mat(BV V,Mat A,BV W)
    205: {
    206:   PetscInt       j;
    207:   Mat            Vmat,Wmat;
    208:   Vec            vv,ww;

    210:   PetscFunctionBegin;
    211:   if (V->vmm) {
    212:     PetscCall(BVGetMat(V,&Vmat));
    213:     PetscCall(BVGetMat(W,&Wmat));
    214:     PetscCall(MatProductCreateWithMat(A,Vmat,NULL,Wmat));
    215:     PetscCall(MatProductSetType(Wmat,MATPRODUCT_AB));
    216:     PetscCall(MatProductSetFromOptions(Wmat));
    217:     PetscCall(MatProductSymbolic(Wmat));
    218:     PetscCall(MatProductNumeric(Wmat));
    219:     PetscCall(MatProductClear(Wmat));
    220:     PetscCall(BVRestoreMat(V,&Vmat));
    221:     PetscCall(BVRestoreMat(W,&Wmat));
    222:   } else {
    223:     for (j=0;j<V->k-V->l;j++) {
    224:       PetscCall(BVGetColumn(V,V->l+j,&vv));
    225:       PetscCall(BVGetColumn(W,W->l+j,&ww));
    226:       PetscCall(MatMult(A,vv,ww));
    227:       PetscCall(BVRestoreColumn(V,V->l+j,&vv));
    228:       PetscCall(BVRestoreColumn(W,W->l+j,&ww));
    229:     }
    230:   }
    231:   PetscFunctionReturn(PETSC_SUCCESS);
    232: }

    234: static PetscErrorCode BVCopy_Mat(BV V,BV W)
    235: {
    236:   BV_MAT            *v = (BV_MAT*)V->data,*w = (BV_MAT*)W->data;
    237:   const PetscScalar *pv;
    238:   PetscScalar       *pw;
    239:   PetscInt          j;

    241:   PetscFunctionBegin;
    242:   PetscCall(MatDenseGetArrayRead(v->A,&pv));
    243:   PetscCall(MatDenseGetArray(w->A,&pw));
    244:   for (j=0;j<V->k-V->l;j++) PetscCall(PetscArraycpy(pw+(W->nc+W->l+j)*W->ld,pv+(V->nc+V->l+j)*V->ld,V->n));
    245:   PetscCall(MatDenseRestoreArrayRead(v->A,&pv));
    246:   PetscCall(MatDenseRestoreArray(w->A,&pw));
    247:   PetscFunctionReturn(PETSC_SUCCESS);
    248: }

    250: static PetscErrorCode BVCopyColumn_Mat(BV V,PetscInt j,PetscInt i)
    251: {
    252:   BV_MAT         *v = (BV_MAT*)V->data;
    253:   PetscScalar    *pv;

    255:   PetscFunctionBegin;
    256:   PetscCall(MatDenseGetArray(v->A,&pv));
    257:   PetscCall(PetscArraycpy(pv+(V->nc+i)*V->ld,pv+(V->nc+j)*V->ld,V->n));
    258:   PetscCall(MatDenseRestoreArray(v->A,&pv));
    259:   PetscFunctionReturn(PETSC_SUCCESS);
    260: }

    262: static PetscErrorCode BVResize_Mat(BV bv,PetscInt m,PetscBool copy)
    263: {
    264:   BV_MAT            *ctx = (BV_MAT*)bv->data;
    265:   Mat               A,Msrc,Mdst;
    266:   char              str[50];

    268:   PetscFunctionBegin;
    269:   PetscCall(MatCreateDenseFromVecType(PetscObjectComm((PetscObject)bv),bv->vtype,bv->n,PETSC_DECIDE,bv->N,m,bv->ld,NULL,&A));
    270:   if (((PetscObject)bv)->name) {
    271:     PetscCall(PetscSNPrintf(str,sizeof(str),"%s_0",((PetscObject)bv)->name));
    272:     PetscCall(PetscObjectSetName((PetscObject)A,str));
    273:   }
    274:   if (copy) {
    275:     PetscCall(MatDenseGetSubMatrix(ctx->A,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,PetscMin(m,bv->m),&Msrc));
    276:     PetscCall(MatDenseGetSubMatrix(A,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,PetscMin(m,bv->m),&Mdst));
    277:     PetscCall(MatCopy(Msrc,Mdst,SAME_NONZERO_PATTERN));
    278:     PetscCall(MatDenseRestoreSubMatrix(ctx->A,&Msrc));
    279:     PetscCall(MatDenseRestoreSubMatrix(A,&Mdst));
    280:   }
    281:   PetscCall(MatDestroy(&ctx->A));
    282:   ctx->A = A;
    283:   PetscFunctionReturn(PETSC_SUCCESS);
    284: }

    286: static PetscErrorCode BVGetColumn_Mat(BV bv,PetscInt j,Vec *v)
    287: {
    288:   BV_MAT         *ctx = (BV_MAT*)bv->data;
    289:   PetscScalar    *pA;
    290:   PetscInt       l;

    292:   PetscFunctionBegin;
    293:   l = BVAvailableVec;
    294:   PetscCall(MatDenseGetArray(ctx->A,&pA));
    295:   PetscCall(VecPlaceArray(bv->cv[l],pA+(bv->nc+j)*bv->ld));
    296:   PetscFunctionReturn(PETSC_SUCCESS);
    297: }

    299: static PetscErrorCode BVRestoreColumn_Mat(BV bv,PetscInt j,Vec *v)
    300: {
    301:   BV_MAT         *ctx = (BV_MAT*)bv->data;
    302:   PetscScalar    *pA;
    303:   PetscInt       l;

    305:   PetscFunctionBegin;
    306:   l = (j==bv->ci[0])? 0: 1;
    307:   PetscCall(VecResetArray(bv->cv[l]));
    308:   PetscCall(MatDenseRestoreArray(ctx->A,&pA));
    309:   PetscFunctionReturn(PETSC_SUCCESS);
    310: }

    312: static PetscErrorCode BVGetArray_Mat(BV bv,PetscScalar **a)
    313: {
    314:   BV_MAT         *ctx = (BV_MAT*)bv->data;

    316:   PetscFunctionBegin;
    317:   PetscCall(MatDenseGetArray(ctx->A,a));
    318:   PetscFunctionReturn(PETSC_SUCCESS);
    319: }

    321: static PetscErrorCode BVRestoreArray_Mat(BV bv,PetscScalar **a)
    322: {
    323:   BV_MAT         *ctx = (BV_MAT*)bv->data;

    325:   PetscFunctionBegin;
    326:   if (a) PetscCall(MatDenseRestoreArray(ctx->A,a));
    327:   PetscFunctionReturn(PETSC_SUCCESS);
    328: }

    330: static PetscErrorCode BVGetArrayRead_Mat(BV bv,const PetscScalar **a)
    331: {
    332:   BV_MAT         *ctx = (BV_MAT*)bv->data;

    334:   PetscFunctionBegin;
    335:   PetscCall(MatDenseGetArrayRead(ctx->A,a));
    336:   PetscFunctionReturn(PETSC_SUCCESS);
    337: }

    339: static PetscErrorCode BVRestoreArrayRead_Mat(BV bv,const PetscScalar **a)
    340: {
    341:   BV_MAT         *ctx = (BV_MAT*)bv->data;

    343:   PetscFunctionBegin;
    344:   if (a) PetscCall(MatDenseRestoreArrayRead(ctx->A,a));
    345:   PetscFunctionReturn(PETSC_SUCCESS);
    346: }

    348: static PetscErrorCode BVView_Mat(BV bv,PetscViewer viewer)
    349: {
    350:   Mat               A;
    351:   PetscViewerFormat format;
    352:   PetscBool         isascii;
    353:   const char        *bvname,*name;

    355:   PetscFunctionBegin;
    356:   PetscCall(PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii));
    357:   if (isascii) {
    358:     PetscCall(PetscViewerGetFormat(viewer,&format));
    359:     if (format == PETSC_VIEWER_ASCII_INFO || format == PETSC_VIEWER_ASCII_INFO_DETAIL) PetscFunctionReturn(PETSC_SUCCESS);
    360:   }
    361:   PetscCall(BVGetMat(bv,&A));
    362:   PetscCall(MatView(A,viewer));
    363:   if (format == PETSC_VIEWER_ASCII_MATLAB) {
    364:     PetscCall(PetscObjectGetName((PetscObject)A,&name));
    365:     PetscCall(PetscObjectGetName((PetscObject)bv,&bvname));
    366:     PetscCall(PetscViewerASCIIPrintf(viewer,"%s=%s;clear %s\n",bvname,name,name));
    367:     if (bv->nc) PetscCall(PetscViewerASCIIPrintf(viewer,"%s=%s(:,%" PetscInt_FMT ":end);\n",bvname,bvname,bv->nc+1));
    368:   }
    369:   PetscCall(BVRestoreMat(bv,&A));
    370:   PetscFunctionReturn(PETSC_SUCCESS);
    371: }

    373: static PetscErrorCode BVDestroy_Mat(BV bv)
    374: {
    375:   BV_MAT         *ctx = (BV_MAT*)bv->data;

    377:   PetscFunctionBegin;
    378:   PetscCall(MatDestroy(&ctx->A));
    379:   PetscCall(VecDestroy(&bv->cv[0]));
    380:   PetscCall(VecDestroy(&bv->cv[1]));
    381:   PetscCall(PetscFree(bv->data));
    382:   PetscFunctionReturn(PETSC_SUCCESS);
    383: }

    385: /*MC
    386:    BVMAT - BVMAT = "mat" - A basis vectors object represented by a dense `Mat`.

    388:    Level: beginner

    390: .seealso: [](sec:bv), `BV`, `BVType`, `BVSetType()`
    391: M*/

    393: SLEPC_EXTERN PetscErrorCode BVCreate_Mat(BV bv)
    394: {
    395:   BV_MAT         *ctx;
    396:   PetscInt       nloc,lsplit;
    397:   PetscBool      seq;
    398:   char           str[50];
    399:   PetscScalar    *array,*ptr=NULL;
    400:   BV             parent;
    401:   Mat            Apar;

    403:   PetscFunctionBegin;
    404:   PetscCall(PetscNew(&ctx));
    405:   bv->data = (void*)ctx;

    407:   PetscCall(PetscStrcmpAny(bv->vtype,&bv->cuda,VECSEQCUDA,VECMPICUDA,""));
    408:   PetscCall(PetscStrcmpAny(bv->vtype,&bv->hip,VECSEQHIP,VECMPIHIP,""));
    409:   PetscCall(PetscStrcmpAny(bv->vtype,&ctx->mpi,VECMPI,VECMPICUDA,VECMPIHIP,""));

    411:   PetscCall(PetscStrcmp(bv->vtype,VECSEQ,&seq));
    412:   PetscCheck(seq || ctx->mpi || bv->cuda || bv->hip,PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"BVMAT does not support the requested vector type: %s",bv->vtype);

    414:   PetscCall(PetscLayoutGetLocalSize(bv->map,&nloc));
    415:   PetscCall(BV_SetDefaultLD(bv,nloc));

    417:   if (PetscUnlikely(bv->issplit)) {
    418:     /* split BV: share the memory of the parent BV */
    419:     parent = bv->splitparent;
    420:     lsplit = parent->lsplit;
    421:     Apar = ((BV_MAT*)parent->data)->A;
    422:     if (bv->cuda) {
    423: #if defined(PETSC_HAVE_CUDA)
    424:       PetscCall(MatDenseCUDAGetArray(Apar,&array));
    425:       if (bv->issplit>0) ptr = (bv->issplit==1)? array: array+lsplit*bv->ld;
    426:       else ptr = (bv->issplit==1)? array: array-lsplit;
    427:       PetscCall(MatDenseCUDARestoreArray(Apar,&array));
    428: #endif
    429:     } else if (bv->hip) {
    430: #if defined(PETSC_HAVE_HIP)
    431:       PetscCall(MatDenseHIPGetArray(Apar,&array));
    432:       if (bv->issplit>0) ptr = (bv->issplit==1)? array: array+lsplit*bv->ld;
    433:       else ptr = (bv->issplit==1)? array: array-lsplit;
    434:       PetscCall(MatDenseHIPRestoreArray(Apar,&array));
    435: #endif
    436:     } else {
    437:       PetscCall(MatDenseGetArray(Apar,&array));
    438:       if (bv->issplit>0) ptr = (bv->issplit==1)? array: array+lsplit*bv->ld;
    439:       else ptr = (bv->issplit==-1)? array: array-lsplit;
    440:       PetscCall(MatDenseRestoreArray(Apar,&array));
    441:     }
    442:   }

    444:   PetscCall(MatCreateDenseFromVecType(PetscObjectComm((PetscObject)bv),bv->vtype,nloc,PETSC_DECIDE,bv->N,bv->m,bv->ld,ptr,&ctx->A));
    445:   if (((PetscObject)bv)->name) {
    446:     PetscCall(PetscSNPrintf(str,sizeof(str),"%s_0",((PetscObject)bv)->name));
    447:     PetscCall(PetscObjectSetName((PetscObject)ctx->A,str));
    448:   }

    450:   if (PetscUnlikely(bv->Acreate)) {
    451:     PetscCall(MatConvert(bv->Acreate,bv->cuda?MATDENSECUDA:bv->hip?MATDENSEHIP:MATDENSE,MAT_REUSE_MATRIX,&ctx->A));
    452:     PetscCall(MatDestroy(&bv->Acreate));
    453:   }

    455:   PetscCall(BVCreateVecEmpty(bv,&bv->cv[0]));
    456:   PetscCall(BVCreateVecEmpty(bv,&bv->cv[1]));

    458:   if (bv->cuda) {
    459: #if defined(PETSC_HAVE_CUDA)
    460:     bv->ops->mult             = BVMult_Mat_CUDA;
    461:     bv->ops->multvec          = BVMultVec_Mat_CUDA;
    462:     bv->ops->multinplace      = BVMultInPlace_Mat_CUDA;
    463:     bv->ops->multinplacetrans = BVMultInPlaceHermitianTranspose_Mat_CUDA;
    464:     bv->ops->dot              = BVDot_Mat_CUDA;
    465:     bv->ops->dotvec           = BVDotVec_Mat_CUDA;
    466:     bv->ops->dotvec_local     = BVDotVec_Local_Mat_CUDA;
    467:     bv->ops->scale            = BVScale_Mat_CUDA;
    468:     bv->ops->norm             = BVNorm_Mat_CUDA;
    469:     bv->ops->norm_local       = BVNorm_Local_Mat_CUDA;
    470:     bv->ops->normalize        = BVNormalize_Mat_CUDA;
    471:     bv->ops->matmult          = BVMatMult_Mat_CUDA;
    472:     bv->ops->copy             = BVCopy_Mat_CUDA;
    473:     bv->ops->copycolumn       = BVCopyColumn_Mat_CUDA;
    474:     bv->ops->getcolumn        = BVGetColumn_Mat_CUDA;
    475:     bv->ops->restorecolumn    = BVRestoreColumn_Mat_CUDA;
    476:     bv->ops->restoresplit     = BVRestoreSplit_Mat_CUDA;
    477:     bv->ops->restoresplitrows = BVRestoreSplitRows_Mat_CUDA;
    478:     bv->ops->getmat           = BVGetMat_Mat_CUDA;
    479:     bv->ops->restoremat       = BVRestoreMat_Mat_CUDA;
    480: #endif
    481:   } else if (bv->hip) {
    482: #if defined(PETSC_HAVE_HIP)
    483:     bv->ops->mult             = BVMult_Mat_HIP;
    484:     bv->ops->multvec          = BVMultVec_Mat_HIP;
    485:     bv->ops->multinplace      = BVMultInPlace_Mat_HIP;
    486:     bv->ops->multinplacetrans = BVMultInPlaceHermitianTranspose_Mat_HIP;
    487:     bv->ops->dot              = BVDot_Mat_HIP;
    488:     bv->ops->dotvec           = BVDotVec_Mat_HIP;
    489:     bv->ops->dotvec_local     = BVDotVec_Local_Mat_HIP;
    490:     bv->ops->scale            = BVScale_Mat_HIP;
    491:     bv->ops->norm             = BVNorm_Mat_HIP;
    492:     bv->ops->norm_local       = BVNorm_Local_Mat_HIP;
    493:     bv->ops->normalize        = BVNormalize_Mat_HIP;
    494:     bv->ops->matmult          = BVMatMult_Mat_HIP;
    495:     bv->ops->copy             = BVCopy_Mat_HIP;
    496:     bv->ops->copycolumn       = BVCopyColumn_Mat_HIP;
    497:     bv->ops->getcolumn        = BVGetColumn_Mat_HIP;
    498:     bv->ops->restorecolumn    = BVRestoreColumn_Mat_HIP;
    499:     bv->ops->restoresplit     = BVRestoreSplit_Mat_HIP;
    500:     bv->ops->restoresplitrows = BVRestoreSplitRows_Mat_HIP;
    501:     bv->ops->getmat           = BVGetMat_Mat_HIP;
    502:     bv->ops->restoremat       = BVRestoreMat_Mat_HIP;
    503: #endif
    504:   } else {
    505:     bv->ops->mult             = BVMult_Mat;
    506:     bv->ops->multvec          = BVMultVec_Mat;
    507:     bv->ops->multinplace      = BVMultInPlace_Mat;
    508:     bv->ops->multinplacetrans = BVMultInPlaceHermitianTranspose_Mat;
    509:     bv->ops->dot              = BVDot_Mat;
    510:     bv->ops->dotvec           = BVDotVec_Mat;
    511:     bv->ops->dotvec_local     = BVDotVec_Local_Mat;
    512:     bv->ops->scale            = BVScale_Mat;
    513:     bv->ops->norm             = BVNorm_Mat;
    514:     bv->ops->norm_local       = BVNorm_Local_Mat;
    515:     bv->ops->normalize        = BVNormalize_Mat;
    516:     bv->ops->matmult          = BVMatMult_Mat;
    517:     bv->ops->copy             = BVCopy_Mat;
    518:     bv->ops->copycolumn       = BVCopyColumn_Mat;
    519:     bv->ops->getcolumn        = BVGetColumn_Mat;
    520:     bv->ops->restorecolumn    = BVRestoreColumn_Mat;
    521:     bv->ops->getmat           = BVGetMat_Default;
    522:     bv->ops->restoremat       = BVRestoreMat_Default;
    523:   }
    524:   bv->ops->resize           = BVResize_Mat;
    525:   bv->ops->getarray         = BVGetArray_Mat;
    526:   bv->ops->restorearray     = BVRestoreArray_Mat;
    527:   bv->ops->getarrayread     = BVGetArrayRead_Mat;
    528:   bv->ops->restorearrayread = BVRestoreArrayRead_Mat;
    529:   bv->ops->destroy          = BVDestroy_Mat;
    530:   bv->ops->view             = BVView_Mat;
    531:   PetscFunctionReturn(PETSC_SUCCESS);
    532: }