LCOV - code coverage report
Current view: top level - src/sys/classes/bv/impls/mat - bvmat.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 280 289 96.9 %
Date: 2019-03-05 01:06:09 Functions: 23 23 100.0 %

          Line data    Source code
       1             : /*
       2             :    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
       3             :    SLEPc - Scalable Library for Eigenvalue Problem Computations
       4             :    Copyright (c) 2002-2018, Universitat Politecnica de Valencia, Spain
       5             : 
       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             : */
      13             : 
      14             : #include <slepc/private/bvimpl.h>
      15             : 
      16             : typedef struct {
      17             :   Mat       A;
      18             :   PetscBool mpi;
      19             : } BV_MAT;
      20             : 
      21          95 : PetscErrorCode BVMult_Mat(BV Y,PetscScalar alpha,PetscScalar beta,BV X,Mat Q)
      22             : {
      23             :   PetscErrorCode ierr;
      24          95 :   BV_MAT         *y = (BV_MAT*)Y->data,*x = (BV_MAT*)X->data;
      25             :   PetscScalar    *px,*py,*q;
      26             :   PetscInt       ldq;
      27             : 
      28          95 :   PetscFunctionBegin;
      29          95 :   ierr = MatDenseGetArray(x->A,&px);CHKERRQ(ierr);
      30          95 :   ierr = MatDenseGetArray(y->A,&py);CHKERRQ(ierr);
      31          95 :   if (Q) {
      32          79 :     ierr = MatGetSize(Q,&ldq,NULL);CHKERRQ(ierr);
      33          79 :     ierr = MatDenseGetArray(Q,&q);CHKERRQ(ierr);
      34          79 :     ierr = BVMult_BLAS_Private(Y,Y->n,Y->k-Y->l,X->k-X->l,ldq,alpha,px+(X->nc+X->l)*X->n,q+Y->l*ldq+X->l,beta,py+(Y->nc+Y->l)*Y->n);CHKERRQ(ierr);
      35          79 :     ierr = MatDenseRestoreArray(Q,&q);CHKERRQ(ierr);
      36             :   } else {
      37          16 :     ierr = BVAXPY_BLAS_Private(Y,Y->n,Y->k-Y->l,alpha,px+(X->nc+X->l)*X->n,beta,py+(Y->nc+Y->l)*Y->n);CHKERRQ(ierr);
      38             :   }
      39          95 :   ierr = MatDenseRestoreArray(x->A,&px);CHKERRQ(ierr);
      40          95 :   ierr = MatDenseRestoreArray(y->A,&py);CHKERRQ(ierr);
      41          95 :   PetscFunctionReturn(0);
      42             : }
      43             : 
      44         310 : PetscErrorCode BVMultVec_Mat(BV X,PetscScalar alpha,PetscScalar beta,Vec y,PetscScalar *q)
      45             : {
      46             :   PetscErrorCode ierr;
      47         310 :   BV_MAT         *x = (BV_MAT*)X->data;
      48         310 :   PetscScalar    *px,*py,*qq=q;
      49             : 
      50         310 :   PetscFunctionBegin;
      51         310 :   ierr = MatDenseGetArray(x->A,&px);CHKERRQ(ierr);
      52         310 :   ierr = VecGetArray(y,&py);CHKERRQ(ierr);
      53         310 :   if (!q) { ierr = VecGetArray(X->buffer,&qq);CHKERRQ(ierr); }
      54         310 :   ierr = BVMultVec_BLAS_Private(X,X->n,X->k-X->l,alpha,px+(X->nc+X->l)*X->n,qq,beta,py);CHKERRQ(ierr);
      55         310 :   if (!q) { ierr = VecRestoreArray(X->buffer,&qq);CHKERRQ(ierr); }
      56         310 :   ierr = MatDenseRestoreArray(x->A,&px);CHKERRQ(ierr);
      57         310 :   ierr = VecRestoreArray(y,&py);CHKERRQ(ierr);
      58         310 :   PetscFunctionReturn(0);
      59             : }
      60             : 
      61          45 : PetscErrorCode BVMultInPlace_Mat(BV V,Mat Q,PetscInt s,PetscInt e)
      62             : {
      63             :   PetscErrorCode ierr;
      64          45 :   BV_MAT         *ctx = (BV_MAT*)V->data;
      65             :   PetscScalar    *pv,*q;
      66             :   PetscInt       ldq;
      67             : 
      68          45 :   PetscFunctionBegin;
      69          45 :   ierr = MatGetSize(Q,&ldq,NULL);CHKERRQ(ierr);
      70          45 :   ierr = MatDenseGetArray(ctx->A,&pv);CHKERRQ(ierr);
      71          45 :   ierr = MatDenseGetArray(Q,&q);CHKERRQ(ierr);
      72          45 :   ierr = BVMultInPlace_BLAS_Private(V,V->n,V->k-V->l,ldq,s-V->l,e-V->l,pv+(V->nc+V->l)*V->n,q+V->l*ldq+V->l,PETSC_FALSE);CHKERRQ(ierr);
      73          45 :   ierr = MatDenseRestoreArray(Q,&q);CHKERRQ(ierr);
      74          45 :   ierr = MatDenseRestoreArray(ctx->A,&pv);CHKERRQ(ierr);
      75          45 :   PetscFunctionReturn(0);
      76             : }
      77             : 
      78           1 : PetscErrorCode BVMultInPlaceTranspose_Mat(BV V,Mat Q,PetscInt s,PetscInt e)
      79             : {
      80             :   PetscErrorCode ierr;
      81           1 :   BV_MAT         *ctx = (BV_MAT*)V->data;
      82             :   PetscScalar    *pv,*q;
      83             :   PetscInt       ldq;
      84             : 
      85           1 :   PetscFunctionBegin;
      86           1 :   ierr = MatGetSize(Q,&ldq,NULL);CHKERRQ(ierr);
      87           1 :   ierr = MatDenseGetArray(ctx->A,&pv);CHKERRQ(ierr);
      88           1 :   ierr = MatDenseGetArray(Q,&q);CHKERRQ(ierr);
      89           1 :   ierr = BVMultInPlace_BLAS_Private(V,V->n,V->k-V->l,ldq,s-V->l,e-V->l,pv+(V->nc+V->l)*V->n,q+V->l*ldq+V->l,PETSC_TRUE);CHKERRQ(ierr);
      90           1 :   ierr = MatDenseRestoreArray(Q,&q);CHKERRQ(ierr);
      91           1 :   ierr = MatDenseRestoreArray(ctx->A,&pv);CHKERRQ(ierr);
      92           1 :   PetscFunctionReturn(0);
      93             : }
      94             : 
      95         234 : PetscErrorCode BVDot_Mat(BV X,BV Y,Mat M)
      96             : {
      97             :   PetscErrorCode ierr;
      98         234 :   BV_MAT         *x = (BV_MAT*)X->data,*y = (BV_MAT*)Y->data;
      99             :   PetscScalar    *px,*py,*m;
     100             :   PetscInt       ldm;
     101             : 
     102         234 :   PetscFunctionBegin;
     103         234 :   ierr = MatGetSize(M,&ldm,NULL);CHKERRQ(ierr);
     104         234 :   ierr = MatDenseGetArray(x->A,&px);CHKERRQ(ierr);
     105         234 :   ierr = MatDenseGetArray(y->A,&py);CHKERRQ(ierr);
     106         234 :   ierr = MatDenseGetArray(M,&m);CHKERRQ(ierr);
     107         234 :   ierr = BVDot_BLAS_Private(X,Y->k-Y->l,X->k-X->l,X->n,ldm,py+(Y->nc+Y->l)*Y->n,px+(X->nc+X->l)*X->n,m+X->l*ldm+Y->l,x->mpi);CHKERRQ(ierr);
     108         234 :   ierr = MatDenseRestoreArray(M,&m);CHKERRQ(ierr);
     109         234 :   ierr = MatDenseRestoreArray(x->A,&px);CHKERRQ(ierr);
     110         234 :   ierr = MatDenseRestoreArray(y->A,&py);CHKERRQ(ierr);
     111         234 :   PetscFunctionReturn(0);
     112             : }
     113             : 
     114         318 : PetscErrorCode BVDotVec_Mat(BV X,Vec y,PetscScalar *q)
     115             : {
     116             :   PetscErrorCode    ierr;
     117         318 :   BV_MAT            *x = (BV_MAT*)X->data;
     118         318 :   PetscScalar       *px,*qq=q;
     119             :   const PetscScalar *py;
     120         318 :   Vec               z = y;
     121             : 
     122         318 :   PetscFunctionBegin;
     123         318 :   if (X->matrix) {
     124          57 :     ierr = BV_IPMatMult(X,y);CHKERRQ(ierr);
     125          57 :     z = X->Bx;
     126             :   }
     127         318 :   ierr = MatDenseGetArray(x->A,&px);CHKERRQ(ierr);
     128         318 :   ierr = VecGetArrayRead(z,&py);CHKERRQ(ierr);
     129         318 :   if (!q) { ierr = VecGetArray(X->buffer,&qq);CHKERRQ(ierr); }
     130         318 :   ierr = BVDotVec_BLAS_Private(X,X->n,X->k-X->l,px+(X->nc+X->l)*X->n,py,qq,x->mpi);CHKERRQ(ierr);
     131         318 :   if (!q) { ierr = VecRestoreArray(X->buffer,&qq);CHKERRQ(ierr); }
     132         318 :   ierr = VecRestoreArrayRead(z,&py);CHKERRQ(ierr);
     133         318 :   ierr = MatDenseRestoreArray(x->A,&px);CHKERRQ(ierr);
     134         318 :   PetscFunctionReturn(0);
     135             : }
     136             : 
     137           4 : PetscErrorCode BVDotVec_Local_Mat(BV X,Vec y,PetscScalar *m)
     138             : {
     139             :   PetscErrorCode ierr;
     140           4 :   BV_MAT         *x = (BV_MAT*)X->data;
     141             :   PetscScalar    *px,*py;
     142           4 :   Vec            z = y;
     143             : 
     144           4 :   PetscFunctionBegin;
     145           4 :   if (X->matrix) {
     146           0 :     ierr = BV_IPMatMult(X,y);CHKERRQ(ierr);
     147           0 :     z = X->Bx;
     148             :   }
     149           4 :   ierr = MatDenseGetArray(x->A,&px);CHKERRQ(ierr);
     150           4 :   ierr = VecGetArray(z,&py);CHKERRQ(ierr);
     151           4 :   ierr = BVDotVec_BLAS_Private(X,X->n,X->k-X->l,px+(X->nc+X->l)*X->n,py,m,PETSC_FALSE);CHKERRQ(ierr);
     152           4 :   ierr = VecRestoreArray(z,&py);CHKERRQ(ierr);
     153           4 :   ierr = MatDenseRestoreArray(x->A,&px);CHKERRQ(ierr);
     154           4 :   PetscFunctionReturn(0);
     155             : }
     156             : 
     157         267 : PetscErrorCode BVScale_Mat(BV bv,PetscInt j,PetscScalar alpha)
     158             : {
     159             :   PetscErrorCode ierr;
     160         267 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     161             :   PetscScalar    *array;
     162             : 
     163         267 :   PetscFunctionBegin;
     164         267 :   ierr = MatDenseGetArray(ctx->A,&array);CHKERRQ(ierr);
     165         267 :   if (j<0) {
     166           3 :     ierr = BVScale_BLAS_Private(bv,(bv->k-bv->l)*bv->n,array+(bv->nc+bv->l)*bv->n,alpha);CHKERRQ(ierr);
     167             :   } else {
     168         264 :     ierr = BVScale_BLAS_Private(bv,bv->n,array+(bv->nc+j)*bv->n,alpha);CHKERRQ(ierr);
     169             :   }
     170         267 :   ierr = MatDenseRestoreArray(ctx->A,&array);CHKERRQ(ierr);
     171         267 :   PetscFunctionReturn(0);
     172             : }
     173             : 
     174          77 : PetscErrorCode BVNorm_Mat(BV bv,PetscInt j,NormType type,PetscReal *val)
     175             : {
     176             :   PetscErrorCode ierr;
     177          77 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     178             :   PetscScalar    *array;
     179             : 
     180          77 :   PetscFunctionBegin;
     181          77 :   ierr = MatDenseGetArray(ctx->A,&array);CHKERRQ(ierr);
     182          77 :   if (j<0) {
     183          65 :     ierr = BVNorm_LAPACK_Private(bv,bv->n,bv->k-bv->l,array+(bv->nc+bv->l)*bv->n,type,val,ctx->mpi);CHKERRQ(ierr);
     184             :   } else {
     185          12 :     ierr = BVNorm_LAPACK_Private(bv,bv->n,1,array+(bv->nc+j)*bv->n,type,val,ctx->mpi);CHKERRQ(ierr);
     186             :   }
     187          77 :   ierr = MatDenseRestoreArray(ctx->A,&array);CHKERRQ(ierr);
     188          77 :   PetscFunctionReturn(0);
     189             : }
     190             : 
     191           2 : PetscErrorCode BVNorm_Local_Mat(BV bv,PetscInt j,NormType type,PetscReal *val)
     192             : {
     193             :   PetscErrorCode ierr;
     194           2 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     195             :   PetscScalar    *array;
     196             : 
     197           2 :   PetscFunctionBegin;
     198           2 :   ierr = MatDenseGetArray(ctx->A,&array);CHKERRQ(ierr);
     199           2 :   if (j<0) {
     200           0 :     ierr = BVNorm_LAPACK_Private(bv,bv->n,bv->k-bv->l,array+(bv->nc+bv->l)*bv->n,type,val,PETSC_FALSE);CHKERRQ(ierr);
     201             :   } else {
     202           2 :     ierr = BVNorm_LAPACK_Private(bv,bv->n,1,array+(bv->nc+j)*bv->n,type,val,PETSC_FALSE);CHKERRQ(ierr);
     203             :   }
     204           2 :   ierr = MatDenseRestoreArray(ctx->A,&array);CHKERRQ(ierr);
     205           2 :   PetscFunctionReturn(0);
     206             : }
     207             : 
     208          95 : PetscErrorCode BVMatMult_Mat(BV V,Mat A,BV W)
     209             : {
     210             :   PetscErrorCode ierr;
     211          95 :   BV_MAT         *v = (BV_MAT*)V->data,*w = (BV_MAT*)W->data;
     212             :   PetscScalar    *pv,*pw;
     213             :   PetscInt       j;
     214             :   PetscBool      flg;
     215             :   Mat            Vmat,Wmat;
     216             : 
     217          95 :   PetscFunctionBegin;
     218          95 :   ierr = MatHasOperation(A,MATOP_MAT_MULT,&flg);CHKERRQ(ierr);
     219          95 :   if (V->vmm && flg) {
     220          94 :     ierr = BVGetMat(V,&Vmat);CHKERRQ(ierr);
     221          94 :     ierr = BVGetMat(W,&Wmat);CHKERRQ(ierr);
     222          94 :     ierr = MatMatMult(A,Vmat,MAT_REUSE_MATRIX,PETSC_DEFAULT,&Wmat);CHKERRQ(ierr);
     223          94 :     ierr = BVRestoreMat(V,&Vmat);CHKERRQ(ierr);
     224          94 :     ierr = BVRestoreMat(W,&Wmat);CHKERRQ(ierr);
     225             :   } else {
     226           1 :     ierr = MatDenseGetArray(v->A,&pv);CHKERRQ(ierr);
     227           1 :     ierr = MatDenseGetArray(w->A,&pw);CHKERRQ(ierr);
     228           6 :     for (j=0;j<V->k-V->l;j++) {
     229           5 :       ierr = VecPlaceArray(V->cv[1],pv+(V->nc+V->l+j)*V->n);CHKERRQ(ierr);
     230           5 :       ierr = VecPlaceArray(W->cv[1],pw+(W->nc+W->l+j)*W->n);CHKERRQ(ierr);
     231           5 :       ierr = MatMult(A,V->cv[1],W->cv[1]);CHKERRQ(ierr);
     232           5 :       ierr = VecResetArray(V->cv[1]);CHKERRQ(ierr);
     233           5 :       ierr = VecResetArray(W->cv[1]);CHKERRQ(ierr);
     234             :     }
     235           1 :     ierr = MatDenseRestoreArray(v->A,&pv);CHKERRQ(ierr);
     236           1 :     ierr = MatDenseRestoreArray(w->A,&pw);CHKERRQ(ierr);
     237             :   }
     238          95 :   PetscFunctionReturn(0);
     239             : }
     240             : 
     241          89 : PetscErrorCode BVCopy_Mat(BV V,BV W)
     242             : {
     243             :   PetscErrorCode ierr;
     244          89 :   BV_MAT         *v = (BV_MAT*)V->data,*w = (BV_MAT*)W->data;
     245             :   PetscScalar    *pv,*pw,*pvc,*pwc;
     246             : 
     247          89 :   PetscFunctionBegin;
     248          89 :   ierr = MatDenseGetArray(v->A,&pv);CHKERRQ(ierr);
     249          89 :   ierr = MatDenseGetArray(w->A,&pw);CHKERRQ(ierr);
     250          89 :   pvc = pv+(V->nc+V->l)*V->n;
     251          89 :   pwc = pw+(W->nc+W->l)*W->n;
     252          89 :   ierr = PetscMemcpy(pwc,pvc,(V->k-V->l)*V->n*sizeof(PetscScalar));CHKERRQ(ierr);
     253          89 :   ierr = MatDenseRestoreArray(v->A,&pv);CHKERRQ(ierr);
     254          89 :   ierr = MatDenseRestoreArray(w->A,&pw);CHKERRQ(ierr);
     255          89 :   PetscFunctionReturn(0);
     256             : }
     257             : 
     258           2 : PetscErrorCode BVCopyColumn_Mat(BV V,PetscInt j,PetscInt i)
     259             : {
     260             :   PetscErrorCode ierr;
     261           2 :   BV_MAT         *v = (BV_MAT*)V->data;
     262             :   PetscScalar    *pv;
     263             : 
     264           2 :   PetscFunctionBegin;
     265           2 :   ierr = MatDenseGetArray(v->A,&pv);CHKERRQ(ierr);
     266           2 :   ierr = PetscMemcpy(pv+(V->nc+i)*V->n,pv+(V->nc+j)*V->n,V->n*sizeof(PetscScalar));CHKERRQ(ierr);
     267           2 :   ierr = MatDenseRestoreArray(v->A,&pv);CHKERRQ(ierr);
     268           2 :   PetscFunctionReturn(0);
     269             : }
     270             : 
     271          18 : PetscErrorCode BVResize_Mat(BV bv,PetscInt m,PetscBool copy)
     272             : {
     273             :   PetscErrorCode ierr;
     274          18 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     275             :   PetscScalar    *pA,*pnew;
     276             :   PetscInt       lsplit;
     277             :   Mat            A;
     278             :   char           str[50];
     279             :   PetscScalar    *array;
     280             :   BV             parent;
     281             : 
     282          18 :   PetscFunctionBegin;
     283          18 :   if (bv->issplit==2) {
     284           4 :     parent = bv->splitparent;
     285           4 :     lsplit = parent->lsplit;
     286           4 :     ierr = MatDenseGetArray(((BV_MAT*)parent->data)->A,&array);CHKERRQ(ierr);
     287           4 :     ierr = MatDensePlaceArray(ctx->A,array+lsplit*bv->n);CHKERRQ(ierr);
     288           4 :     ierr = MatDenseRestoreArray(((BV_MAT*)parent->data)->A,&array);CHKERRQ(ierr);
     289          14 :   } else if (!bv->issplit) {
     290           8 :     ierr = MatCreateDense(PetscObjectComm((PetscObject)bv->t),bv->n,PETSC_DECIDE,PETSC_DECIDE,m,NULL,&A);CHKERRQ(ierr);
     291           8 :     ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
     292           8 :     ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
     293           8 :     ierr = PetscLogObjectParent((PetscObject)bv,(PetscObject)A);CHKERRQ(ierr);
     294           8 :     if (((PetscObject)bv)->name) {
     295           8 :       ierr = PetscSNPrintf(str,50,"%s_0",((PetscObject)bv)->name);CHKERRQ(ierr);
     296           8 :       ierr = PetscObjectSetName((PetscObject)A,str);CHKERRQ(ierr);
     297             :     }
     298           8 :     if (copy) {
     299           2 :       ierr = MatDenseGetArray(ctx->A,&pA);CHKERRQ(ierr);
     300           2 :       ierr = MatDenseGetArray(A,&pnew);CHKERRQ(ierr);
     301           2 :       ierr = PetscMemcpy(pnew,pA,PetscMin(m,bv->m)*bv->n*sizeof(PetscScalar));CHKERRQ(ierr);
     302           2 :       ierr = MatDenseRestoreArray(ctx->A,&pA);CHKERRQ(ierr);
     303           2 :       ierr = MatDenseRestoreArray(A,&pnew);CHKERRQ(ierr);
     304             :     }
     305           8 :     ierr = MatDestroy(&ctx->A);CHKERRQ(ierr);
     306           8 :     ctx->A = A;
     307             :   }
     308          18 :   PetscFunctionReturn(0);
     309             : }
     310             : 
     311        1960 : PetscErrorCode BVGetColumn_Mat(BV bv,PetscInt j,Vec *v)
     312             : {
     313             :   PetscErrorCode ierr;
     314        1960 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     315             :   PetscScalar    *pA;
     316             :   PetscInt       l;
     317             : 
     318        1960 :   PetscFunctionBegin;
     319        1960 :   l = BVAvailableVec;
     320        1960 :   ierr = MatDenseGetArray(ctx->A,&pA);CHKERRQ(ierr);
     321        1960 :   ierr = VecPlaceArray(bv->cv[l],pA+(bv->nc+j)*bv->n);CHKERRQ(ierr);
     322        1960 :   PetscFunctionReturn(0);
     323             : }
     324             : 
     325        1960 : PetscErrorCode BVRestoreColumn_Mat(BV bv,PetscInt j,Vec *v)
     326             : {
     327             :   PetscErrorCode ierr;
     328        1960 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     329             :   PetscScalar    *pA;
     330             :   PetscInt       l;
     331             : 
     332        1960 :   PetscFunctionBegin;
     333        1960 :   l = (j==bv->ci[0])? 0: 1;
     334        1960 :   ierr = VecResetArray(bv->cv[l]);CHKERRQ(ierr);
     335        1960 :   ierr = MatDenseRestoreArray(ctx->A,&pA);CHKERRQ(ierr);
     336        1960 :   PetscFunctionReturn(0);
     337             : }
     338             : 
     339         231 : PetscErrorCode BVGetArray_Mat(BV bv,PetscScalar **a)
     340             : {
     341             :   PetscErrorCode ierr;
     342         231 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     343             : 
     344         231 :   PetscFunctionBegin;
     345         231 :   ierr = MatDenseGetArray(ctx->A,a);CHKERRQ(ierr);
     346         231 :   PetscFunctionReturn(0);
     347             : }
     348             : 
     349         231 : PetscErrorCode BVRestoreArray_Mat(BV bv,PetscScalar **a)
     350             : {
     351             :   PetscErrorCode ierr;
     352         231 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     353             : 
     354         231 :   PetscFunctionBegin;
     355         231 :   if (a) { ierr = MatDenseRestoreArray(ctx->A,a);CHKERRQ(ierr); }
     356         231 :   PetscFunctionReturn(0);
     357             : }
     358             : 
     359           9 : PetscErrorCode BVGetArrayRead_Mat(BV bv,const PetscScalar **a)
     360             : {
     361             :   PetscErrorCode ierr;
     362           9 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     363             : 
     364           9 :   PetscFunctionBegin;
     365           9 :   ierr = MatDenseGetArray(ctx->A,(PetscScalar**)a);CHKERRQ(ierr);
     366           9 :   PetscFunctionReturn(0);
     367             : }
     368             : 
     369           9 : PetscErrorCode BVRestoreArrayRead_Mat(BV bv,const PetscScalar **a)
     370             : {
     371             :   PetscErrorCode ierr;
     372           9 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     373             : 
     374           9 :   PetscFunctionBegin;
     375           9 :   if (a) { ierr = MatDenseRestoreArray(ctx->A,(PetscScalar**)a);CHKERRQ(ierr); }
     376           9 :   PetscFunctionReturn(0);
     377             : }
     378             : 
     379           6 : PetscErrorCode BVView_Mat(BV bv,PetscViewer viewer)
     380             : {
     381             :   PetscErrorCode    ierr;
     382           6 :   BV_MAT            *ctx = (BV_MAT*)bv->data;
     383             :   PetscViewerFormat format;
     384             :   PetscBool         isascii;
     385             :   const char        *bvname,*name;
     386             : 
     387           6 :   PetscFunctionBegin;
     388           6 :   ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);CHKERRQ(ierr);
     389           6 :   if (isascii) {
     390           6 :     ierr = PetscViewerGetFormat(viewer,&format);CHKERRQ(ierr);
     391           6 :     if (format == PETSC_VIEWER_ASCII_INFO || format == PETSC_VIEWER_ASCII_INFO_DETAIL) PetscFunctionReturn(0);
     392           5 :     ierr = MatView(ctx->A,viewer);CHKERRQ(ierr);
     393           5 :     if (format == PETSC_VIEWER_ASCII_MATLAB) {
     394           0 :       ierr = PetscObjectGetName((PetscObject)bv,&bvname);CHKERRQ(ierr);
     395           0 :       ierr = PetscObjectGetName((PetscObject)ctx->A,&name);CHKERRQ(ierr);
     396           0 :       ierr = PetscViewerASCIIPrintf(viewer,"%s=%s;clear %s\n",bvname,name,name);CHKERRQ(ierr);
     397           0 :       if (bv->nc) {
     398           0 :         ierr = PetscViewerASCIIPrintf(viewer,"%s=%s(:,%D:end);\n",bvname,bvname,bv->nc+1);CHKERRQ(ierr);
     399             :       }
     400             :     }
     401             :   } else {
     402           0 :     ierr = MatView(ctx->A,viewer);CHKERRQ(ierr);
     403             :   }
     404           5 :   PetscFunctionReturn(0);
     405             : }
     406             : 
     407         284 : PetscErrorCode BVDestroy_Mat(BV bv)
     408             : {
     409             :   PetscErrorCode ierr;
     410         284 :   BV_MAT         *ctx = (BV_MAT*)bv->data;
     411             : 
     412         284 :   PetscFunctionBegin;
     413         284 :   ierr = MatDestroy(&ctx->A);CHKERRQ(ierr);
     414         284 :   ierr = VecDestroy(&bv->cv[0]);CHKERRQ(ierr);
     415         284 :   ierr = VecDestroy(&bv->cv[1]);CHKERRQ(ierr);
     416         284 :   ierr = PetscFree(bv->data);CHKERRQ(ierr);
     417         284 :   PetscFunctionReturn(0);
     418             : }
     419             : 
     420         284 : SLEPC_EXTERN PetscErrorCode BVCreate_Mat(BV bv)
     421             : {
     422             :   PetscErrorCode ierr;
     423             :   BV_MAT         *ctx;
     424             :   PetscInt       nloc,bs,lsplit;
     425             :   PetscBool      seq;
     426             :   char           str[50];
     427             :   PetscScalar    *array,*ptr;
     428             :   BV             parent;
     429             : 
     430         284 :   PetscFunctionBegin;
     431         284 :   ierr = PetscNewLog(bv,&ctx);CHKERRQ(ierr);
     432         284 :   bv->data = (void*)ctx;
     433             : 
     434         284 :   ierr = PetscObjectTypeCompare((PetscObject)bv->t,VECMPI,&ctx->mpi);CHKERRQ(ierr);
     435         284 :   if (!ctx->mpi) {
     436          46 :     ierr = PetscObjectTypeCompare((PetscObject)bv->t,VECSEQ,&seq);CHKERRQ(ierr);
     437          46 :     if (!seq) SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"Cannot create a BVMAT from a non-standard template vector");
     438             :   }
     439             : 
     440         284 :   ierr = VecGetLocalSize(bv->t,&nloc);CHKERRQ(ierr);
     441         284 :   ierr = VecGetBlockSize(bv->t,&bs);CHKERRQ(ierr);
     442             : 
     443         284 :   if (bv->issplit) {
     444             :     /* split BV: share the memory of the parent BV */
     445          70 :     parent = bv->splitparent;
     446          70 :     lsplit = parent->lsplit;
     447          70 :     ierr = MatDenseGetArray(((BV_MAT*)parent->data)->A,&array);CHKERRQ(ierr);
     448          70 :     ptr = (bv->issplit==1)? array: array+lsplit*nloc;
     449          70 :     ierr = MatDenseRestoreArray(((BV_MAT*)parent->data)->A,&array);CHKERRQ(ierr);
     450             :   } else {
     451             :     /* regular BV: allocate memory for the BV entries */
     452         214 :     ptr = NULL;
     453             :   }
     454         284 :   ierr = MatCreateDense(PetscObjectComm((PetscObject)bv->t),nloc,PETSC_DECIDE,PETSC_DECIDE,bv->m,ptr,&ctx->A);CHKERRQ(ierr);
     455         284 :   ierr = MatAssemblyBegin(ctx->A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
     456         284 :   ierr = MatAssemblyEnd(ctx->A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
     457         284 :   ierr = PetscLogObjectParent((PetscObject)bv,(PetscObject)ctx->A);CHKERRQ(ierr);
     458         284 :   if (((PetscObject)bv)->name) {
     459          90 :     ierr = PetscSNPrintf(str,50,"%s_0",((PetscObject)bv)->name);CHKERRQ(ierr);
     460          90 :     ierr = PetscObjectSetName((PetscObject)ctx->A,str);CHKERRQ(ierr);
     461             :   }
     462             : 
     463         284 :   if (bv->Acreate) {
     464           2 :     ierr = MatCopy(bv->Acreate,ctx->A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
     465           2 :     ierr = MatDestroy(&bv->Acreate);CHKERRQ(ierr);
     466             :   }
     467             : 
     468         284 :   ierr = VecDuplicateEmpty(bv->t,&bv->cv[0]);CHKERRQ(ierr);
     469         284 :   ierr = VecDuplicateEmpty(bv->t,&bv->cv[1]);CHKERRQ(ierr);
     470             : 
     471         284 :   bv->ops->mult             = BVMult_Mat;
     472         284 :   bv->ops->multvec          = BVMultVec_Mat;
     473         284 :   bv->ops->multinplace      = BVMultInPlace_Mat;
     474         284 :   bv->ops->multinplacetrans = BVMultInPlaceTranspose_Mat;
     475         284 :   bv->ops->dot              = BVDot_Mat;
     476         284 :   bv->ops->dotvec           = BVDotVec_Mat;
     477         284 :   bv->ops->dotvec_local     = BVDotVec_Local_Mat;
     478         284 :   bv->ops->scale            = BVScale_Mat;
     479         284 :   bv->ops->norm             = BVNorm_Mat;
     480         284 :   bv->ops->norm_local       = BVNorm_Local_Mat;
     481         284 :   bv->ops->matmult          = BVMatMult_Mat;
     482         284 :   bv->ops->copy             = BVCopy_Mat;
     483         284 :   bv->ops->copycolumn       = BVCopyColumn_Mat;
     484         284 :   bv->ops->resize           = BVResize_Mat;
     485         284 :   bv->ops->getcolumn        = BVGetColumn_Mat;
     486         284 :   bv->ops->restorecolumn    = BVRestoreColumn_Mat;
     487         284 :   bv->ops->getarray         = BVGetArray_Mat;
     488         284 :   bv->ops->restorearray     = BVRestoreArray_Mat;
     489         284 :   bv->ops->getarrayread     = BVGetArrayRead_Mat;
     490         284 :   bv->ops->restorearrayread = BVRestoreArrayRead_Mat;
     491         284 :   bv->ops->destroy          = BVDestroy_Mat;
     492         284 :   if (!ctx->mpi) bv->ops->view = BVView_Mat;
     493         284 :   PetscFunctionReturn(0);
     494             : }
     495             : 

Generated by: LCOV version 1.13