/*@
BVMult - Computes Y = beta*Y + alpha*X*Q.
Logically Collective on BV
Input Parameters:
+ Y,X - basis vectors
. alpha,beta - scalars
- Q - a sequential dense matrix
Output Parameter:
. Y - the modified basis vectors
Notes:
X and Y must be different objects. The case X=Y can be addressed with
BVMultInPlace().
The matrix Q must be a sequential dense Mat, with all entries equal on
all processes (otherwise each process will compute a different update).
The dimensions of Q must be at least m,n where m is the number of active
columns of X and n is the number of active columns of Y.
The leading columns of Y are not modified. Also, if X has leading
columns specified, then these columns do not participate in the computation.
Hence, only rows (resp. columns) of Q starting from lx (resp. ly) are used,
where lx (resp. ly) is the number of leading columns of X (resp. Y).
Level: intermediate
.seealso: BVMultVec(), BVMultColumn(), BVMultInPlace(), BVSetActiveColumns()
@*/
PetscErrorCode BVMult(BV Y,PetscScalar alpha,PetscScalar beta,BV X,Mat Q)
{
PetscErrorCode ierr;
PetscBool match;
PetscInt m,n;
PetscFunctionBegin;
PetscValidHeaderSpecific(Y,BV_CLASSID,1);
PetscValidLogicalCollectiveScalar(Y,alpha,2);
PetscValidLogicalCollectiveScalar(Y,beta,3);
PetscValidHeaderSpecific(X,BV_CLASSID,4);
PetscValidHeaderSpecific(Q,MAT_CLASSID,5);
PetscValidType(Y,1);
BVCheckSizes(Y,1);
PetscValidType(X,4);
BVCheckSizes(X,4);
PetscValidType(Q,5);
PetscCheckSameTypeAndComm(Y,1,X,4);
if (X==Y) SETERRQ(PetscObjectComm((PetscObject)Y),PETSC_ERR_ARG_WRONG,"X and Y arguments must be different");
ierr = PetscObjectTypeCompare((PetscObject)Q,MATSEQDENSE,&match);CHKERRQ(ierr);
if (!match) SETERRQ(PetscObjectComm((PetscObject)Y),PETSC_ERR_SUP,"Mat argument must be of type seqdense");
ierr = MatGetSize(Q,&m,&n);CHKERRQ(ierr);
if (m<X->k) SETERRQ2(PetscObjectComm((PetscObject)Y),PETSC_ERR_ARG_SIZ,"Mat argument has %D rows, should have at least %D",m,X->k);
if (n<Y->k) SETERRQ2(PetscObjectComm((PetscObject)Y),PETSC_ERR_ARG_SIZ,"Mat argument has %D columns, should have at least %D",n,Y->k);
if (X->n!=Y->n) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Mismatching local dimension X %D, Y %D",X->n,Y->n);
if (!X->n) PetscFunctionReturn(0);
ierr = PetscLogEventBegin(BV_Mult,X,Y,0,0);CHKERRQ(ierr);
ierr = (*Y->ops->mult)(Y,alpha,beta,X,Q);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_Mult,X,Y,0,0);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)Y);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVMultColumn - Computes y = beta*y + alpha*X*q, where y is the j-th column
of X.
Logically Collective on BV
Input Parameters:
+ X - a basis vectors object
. alpha,beta - scalars
. j - the column index
- q - an array of scalars
Notes:
This operation is equivalent to BVMultVec() but it uses column j of X
rather than taking a Vec as an argument. The number of active columns of
X is set to j before the computation, and restored afterwards.
If X has leading columns specified, then these columns do not participate
in the computation. Therefore, the length of array q must be equal to j
minus the number of leading columns.
Level: advanced
.seealso: BVMult(), BVMultVec(), BVMultInPlace(), BVSetActiveColumns()
@*/
PetscErrorCode BVMultColumn(BV X,PetscScalar alpha,PetscScalar beta,PetscInt j,PetscScalar *q)
{
PetscErrorCode ierr;
PetscInt ksave;
Vec y;
PetscFunctionBegin;
PetscValidHeaderSpecific(X,BV_CLASSID,1);
PetscValidLogicalCollectiveScalar(X,alpha,2);
PetscValidLogicalCollectiveScalar(X,beta,3);
PetscValidLogicalCollectiveInt(X,j,4);
PetscValidPointer(q,5);
PetscValidType(X,1);
BVCheckSizes(X,1);
if (j<0) SETERRQ(PetscObjectComm((PetscObject)X),PETSC_ERR_ARG_OUTOFRANGE,"Index j must be non-negative");
if (j>=X->m) SETERRQ2(PetscObjectComm((PetscObject)X),PETSC_ERR_ARG_OUTOFRANGE,"Index j=%D but BV only has %D columns",j,X->m);
ierr = PetscLogEventBegin(BV_Mult,X,0,0,0);CHKERRQ(ierr);
ksave = X->k;
X->k = j;
ierr = BVGetColumn(X,j,&y);CHKERRQ(ierr);
ierr = (*X->ops->multvec)(X,alpha,beta,y,q);CHKERRQ(ierr);
ierr = BVRestoreColumn(X,j,&y);CHKERRQ(ierr);
X->k = ksave;
ierr = PetscLogEventEnd(BV_Mult,X,0,0,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVMultVec - Computes y = beta*y + alpha*X*q.
Logically Collective on BV and Vec
Input Parameters:
+ X - a basis vectors object
. alpha,beta - scalars
. y - a vector
- q - an array of scalars
Output Parameter:
. y - the modified vector
Notes:
This operation is the analogue of BVMult() but with a BV and a Vec,
instead of two BV. Note that arguments are listed in different order
with respect to BVMult().
If X has leading columns specified, then these columns do not participate
in the computation.
The length of array q must be equal to the number of active columns of X
minus the number of leading columns, i.e. the first entry of q multiplies
the first non-leading column.
Level: intermediate
.seealso: BVMult(), BVMultColumn(), BVMultInPlace(), BVSetActiveColumns()
@*/
PetscErrorCode BVMultVec(BV X,PetscScalar alpha,PetscScalar beta,Vec y,PetscScalar *q)
{
PetscErrorCode ierr;
PetscInt n,N;
PetscFunctionBegin;
PetscValidHeaderSpecific(X,BV_CLASSID,1);
PetscValidLogicalCollectiveScalar(X,alpha,2);
PetscValidLogicalCollectiveScalar(X,beta,3);
PetscValidHeaderSpecific(y,VEC_CLASSID,4);
PetscValidPointer(q,5);
PetscValidType(X,1);
BVCheckSizes(X,1);
PetscValidType(y,4);
PetscCheckSameComm(X,1,y,4);
ierr = VecGetSize(y,&N);CHKERRQ(ierr);
ierr = VecGetLocalSize(y,&n);CHKERRQ(ierr);
if (N!=X->N || n!=X->n) SETERRQ4(PetscObjectComm((PetscObject)X),PETSC_ERR_ARG_INCOMP,"Vec sizes (global %D, local %D) do not match BV sizes (global %D, local %D)",N,n,X->N,X->n);
if (!X->n) PetscFunctionReturn(0);
ierr = PetscLogEventBegin(BV_Mult,X,y,0,0);CHKERRQ(ierr);
ierr = (*X->ops->multvec)(X,alpha,beta,y,q);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_Mult,X,y,0,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVOrthogonalize - Orthogonalize all columns (except leading ones), that is,
compute the QR decomposition.
Collective on BV
Input Parameter:
. V - basis vectors
Output Parameters:
+ V - the modified basis vectors
- R - a sequential dense matrix (or NULL)
Notes:
On input, matrix R must be a sequential dense Mat, with at least as many rows
and columns as the number of active columns of V. The output satisfies
V0 = V*R (where V0 represent the input V) and V'*V = I.
If V has leading columns, then they are not modified (are assumed to be already
orthonormal) and the corresponding part of R is not referenced.
Can pass NULL if R is not required.
Level: intermediate
.seealso: BVOrthogonalizeColumn(), BVOrthogonalizeVec(), BVSetActiveColumns()
@*/
PetscErrorCode BVOrthogonalize(BV V,Mat R)
{
PetscErrorCode ierr;
PetscBool match;
PetscInt m,n;
PetscFunctionBegin;
PetscValidHeaderSpecific(V,BV_CLASSID,1);
PetscValidType(V,1);
BVCheckSizes(V,1);
if (R) {
PetscValidHeaderSpecific(R,MAT_CLASSID,2);
PetscValidType(R,2);
ierr = PetscObjectTypeCompare((PetscObject)R,MATSEQDENSE,&match);CHKERRQ(ierr);
if (!match) SETERRQ(PetscObjectComm((PetscObject)V),PETSC_ERR_SUP,"Mat argument must be of type seqdense");
ierr = MatGetSize(R,&m,&n);CHKERRQ(ierr);
if (m!=n) SETERRQ2(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_SIZ,"Mat argument is not square, it has %D rows and %D columns",m,n);
if (n<V->k) SETERRQ2(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_SIZ,"Mat size %D is smaller than the number of BV active columns %D",n,V->k);
}
if (V->matrix) SETERRQ(PetscObjectComm((PetscObject)V),PETSC_ERR_SUP,"Not implemented for non-standard inner product, use BVOrthogonalizeColumn() instead");
if (V->nc) SETERRQ(PetscObjectComm((PetscObject)V),PETSC_ERR_SUP,"Not implemented for BV with constraints, use BVOrthogonalizeColumn() instead");
ierr = PetscLogEventBegin(BV_Orthogonalize,V,R,0,0);CHKERRQ(ierr);
if (V->ops->orthogonalize) {
ierr = (*V->ops->orthogonalize)(V,R);CHKERRQ(ierr);
} else { /* no specific QR function available, so proceed column by column with Gram-Schmidt */
ierr = BVOrthogonalize_GS(V,R);CHKERRQ(ierr);
}
ierr = PetscLogEventEnd(BV_Orthogonalize,V,R,0,0);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVOrthogonalizeSomeColumn - Orthogonalize one of the column vectors with
respect to some of the previous ones.
Collective on BV
Input Parameters:
+ bv - the basis vectors context
. j - index of column to be orthogonalized
- which - logical array indicating selected columns
Output Parameters:
+ H - (optional) coefficients computed during orthogonalization
. norm - (optional) norm of the vector after being orthogonalized
- lindep - (optional) flag indicating that refinement did not improve the quality
of orthogonalization
Notes:
This function is similar to BVOrthogonalizeColumn(), but V[j] is
orthogonalized only against columns V[i] having which[i]=PETSC_TRUE.
The length of array which must be j at least.
The use of this operation is restricted to MGS orthogonalization type.
Level: advanced
.seealso: BVOrthogonalizeColumn(), BVSetOrthogonalization()
@*/
PetscErrorCode BVOrthogonalizeSomeColumn(BV bv,PetscInt j,PetscBool *which,PetscScalar *H,PetscReal *norm,PetscBool *lindep)
{
PetscErrorCode ierr;
PetscInt i,ksave,lsave;
PetscFunctionBegin;
PetscValidHeaderSpecific(bv,BV_CLASSID,1);
PetscValidLogicalCollectiveInt(bv,j,2);
PetscValidPointer(which,3);
PetscValidType(bv,1);
BVCheckSizes(bv,1);
if (j<0) SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Index j must be non-negative");
if (j>=bv->m) SETERRQ2(PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Index j=%D but BV only has %D columns",j,bv->m);
if (bv->orthog_type!=BV_ORTHOG_MGS) SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"Operation only available for MGS orthogonalization");
ierr = PetscLogEventBegin(BV_Orthogonalize,bv,0,0,0);CHKERRQ(ierr);
ksave = bv->k;
lsave = bv->l;
bv->l = -bv->nc; /* must also orthogonalize against constraints and leading columns */
ierr = BV_AllocateCoeffs(bv);CHKERRQ(ierr);
ierr = BV_AllocateSignature(bv);CHKERRQ(ierr);
ierr = BVOrthogonalizeMGS(bv,j,NULL,which,H,norm,lindep);CHKERRQ(ierr);
bv->k = ksave;
bv->l = lsave;
if (H) for (i=bv->l;i<j;i++) H[i-bv->l] = bv->h[bv->nc+i];
ierr = PetscLogEventEnd(BV_Orthogonalize,bv,0,0,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVOrthogonalizeVec - Orthogonalize a given vector with respect to all
active columns.
Collective on BV
Input Parameters:
+ bv - the basis vectors context
- v - the vector
Output Parameters:
+ H - (optional) coefficients computed during orthogonalization
. norm - (optional) norm of the vector after being orthogonalized
- lindep - (optional) flag indicating that refinement did not improve the quality
of orthogonalization
Notes:
This function is equivalent to BVOrthogonalizeColumn() but orthogonalizes
a vector as an argument rather than taking one of the BV columns. The
vector is orthogonalized against all active columns.
Level: advanced
.seealso: BVOrthogonalizeColumn(), BVSetOrthogonalization(), BVSetActiveColumns()
@*/
PetscErrorCode BVOrthogonalizeVec(BV bv,Vec v,PetscScalar *H,PetscReal *norm,PetscBool *lindep)
{
PetscErrorCode ierr;
PetscInt i,ksave,lsave;
PetscFunctionBegin;
PetscValidHeaderSpecific(bv,BV_CLASSID,1);
PetscValidHeaderSpecific(v,VEC_CLASSID,2);
PetscValidType(bv,1);
BVCheckSizes(bv,1);
PetscValidType(v,2);
PetscCheckSameComm(bv,1,v,2);
ierr = PetscLogEventBegin(BV_Orthogonalize,bv,0,0,0);CHKERRQ(ierr);
ksave = bv->k;
lsave = bv->l;
bv->l = -bv->nc; /* must also orthogonalize against constraints and leading columns */
ierr = BV_AllocateCoeffs(bv);CHKERRQ(ierr);
ierr = BV_AllocateSignature(bv);CHKERRQ(ierr);
switch (bv->orthog_type) {
case BV_ORTHOG_CGS:
ierr = BVOrthogonalizeCGS(bv,0,v,H,norm,lindep);CHKERRQ(ierr);
break;
case BV_ORTHOG_MGS:
ierr = BVOrthogonalizeMGS(bv,0,v,NULL,H,norm,lindep);CHKERRQ(ierr);
break;
}
bv->k = ksave;
bv->l = lsave;
if (H) for (i=bv->l;i<bv->k;i++) H[i-bv->l] = bv->h[bv->nc+i];
ierr = PetscLogEventEnd(BV_Orthogonalize,bv,0,0,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVInsertConstraints - Insert a set of vectors as constraints.
Collective on BV
Input Parameters:
+ V - basis vectors
- C - set of vectors to be inserted as constraints
Input/Output Parameter:
. nc - number of input vectors, on output the number of linearly independent
vectors
Notes:
The constraints are relevant only during orthogonalization. Constraint
vectors span a subspace that is deflated in every orthogonalization
operation, so they are intended for removing those directions from the
orthogonal basis computed in regular BV columns.
Constraints are not stored in regular BV colums, but in a special part of
the storage. They can be accessed with negative indices in BVGetColumn().
This operation is DESTRUCTIVE, meaning that all data contained in the
columns of V is lost. This is typically invoked just after creating the BV.
Once a set of constraints has been set, it is not allowed to call this
function again.
The vectors are copied one by one and then orthogonalized against the
previous ones. If any of them is linearly dependent then it is discarded
and the value of nc is decreased. The behaviour is similar to BVInsertVecs().
Level: advanced
.seealso: BVInsertVecs(), BVOrthogonalizeColumn(), BVGetColumn(), BVGetNumConstraints()
@*/
PetscErrorCode BVInsertConstraints(BV V,PetscInt *nc,Vec *C)
{
PetscErrorCode ierr;
PetscInt msave;
PetscFunctionBegin;
PetscValidHeaderSpecific(V,BV_CLASSID,1);
PetscValidPointer(nc,2);
PetscValidLogicalCollectiveInt(V,*nc,2);
if (!*nc) PetscFunctionReturn(0);
if (*nc<0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Number of constraints (given %D) cannot be negative",*nc);
PetscValidPointer(C,3);
PetscValidHeaderSpecific(*C,VEC_CLASSID,3);
PetscValidType(V,1);
BVCheckSizes(V,1);
PetscCheckSameComm(V,1,*C,3);
if (V->nc) SETERRQ(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_WRONGSTATE,"Constraints already present in this BV object");
if (V->ci[0]!=-1 || V->ci[1]!=-1) SETERRQ(PetscObjectComm((PetscObject)V),PETSC_ERR_SUP,"Cannot call BVInsertConstraints after BVGetColumn");
msave = V->m;
ierr = BVResize(V,*nc+V->m,PETSC_FALSE);CHKERRQ(ierr);
ierr = BVInsertVecs(V,0,nc,C,PETSC_TRUE);CHKERRQ(ierr);
V->nc = *nc;
V->m = msave;
V->ci[0] = -V->nc-1;
V->ci[1] = -V->nc-1;
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVMultInPlaceTranspose - Update a set of vectors as V(:,s:e-1) = V*Q'(:,s:e-1).
Logically Collective on BV
Input Parameters:
+ Q - a sequential dense matrix
. s - first column of V to be overwritten
- e - first column of V not to be overwritten
Input/Output Parameter:
+ V - basis vectors
Notes:
This is a variant of BVMultInPlace() where the conjugate transpose
of Q is used.
Level: intermediate
.seealso: BVMultInPlace()
@*/
PetscErrorCode BVMultInPlaceTranspose(BV V,Mat Q,PetscInt s,PetscInt e)
{
PetscErrorCode ierr;
PetscBool match;
PetscInt m,n;
PetscFunctionBegin;
PetscValidHeaderSpecific(V,BV_CLASSID,1);
PetscValidHeaderSpecific(Q,MAT_CLASSID,2);
PetscValidLogicalCollectiveInt(V,s,3);
PetscValidLogicalCollectiveInt(V,e,4);
PetscValidType(V,1);
BVCheckSizes(V,1);
PetscValidType(Q,2);
ierr = PetscObjectTypeCompare((PetscObject)Q,MATSEQDENSE,&match);CHKERRQ(ierr);
if (!match) SETERRQ(PetscObjectComm((PetscObject)V),PETSC_ERR_SUP,"Mat argument must be of type seqdense");
if (s<V->l || s>V->m) SETERRQ3(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Argument s has wrong value %D, should be between %D and %D",s,V->l,V->m);
if (e<V->l || e>V->m) SETERRQ3(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Argument e has wrong value %D, should be between %D and %D",e,V->l,V->m);
ierr = MatGetSize(Q,&m,&n);CHKERRQ(ierr);
if (n<V->k) SETERRQ2(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_SIZ,"Mat argument has %D columns, should have at least %D",n,V->k);
if (e>m) SETERRQ2(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_SIZ,"Mat argument only has %D rows, the requested value of e is larger: %D",m,e);
if (s>=e || !V->n) PetscFunctionReturn(0);
ierr = PetscLogEventBegin(BV_Mult,V,Q,0,0);CHKERRQ(ierr);
ierr = (*V->ops->multinplacetrans)(V,Q,s,e);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_Mult,V,Q,0,0);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVInsertVec - Insert a vector into the specified column.
Collective on BV
Input Parameters:
+ V - basis vectors
. j - the column of V to be overwritten
- w - the vector to be copied
Level: intermediate
.seealso: BVInsertVecs()
@*/
PetscErrorCode BVInsertVec(BV V,PetscInt j,Vec w)
{
PetscErrorCode ierr;
PetscInt n,N;
Vec v;
PetscFunctionBegin;
PetscValidHeaderSpecific(V,BV_CLASSID,1);
PetscValidLogicalCollectiveInt(V,j,2);
PetscValidHeaderSpecific(w,VEC_CLASSID,3);
PetscValidType(V,1);
BVCheckSizes(V,1);
PetscCheckSameComm(V,1,w,3);
ierr = VecGetSize(w,&N);CHKERRQ(ierr);
ierr = VecGetLocalSize(w,&n);CHKERRQ(ierr);
if (N!=V->N || n!=V->n) SETERRQ4(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_INCOMP,"Vec sizes (global %D, local %D) do not match BV sizes (global %D, local %D)",N,n,V->N,V->n);
if (j<-V->nc || j>=V->m) SETERRQ3(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Argument j has wrong value %D, should be between %D and %D",j,-V->nc,V->m-1);
ierr = BVGetColumn(V,j,&v);CHKERRQ(ierr);
ierr = VecCopy(w,v);CHKERRQ(ierr);
ierr = BVRestoreColumn(V,j,&v);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVMatMult - Computes the matrix-vector product for each column, Y=A*X.
Neighbor-wise Collective on Mat and BV
Input Parameters:
+ V - basis vectors context
- A - the matrix
Output Parameter:
. Y - the result
Note:
Both V and Y must be distributed in the same manner. Only active columns
(excluding the leading ones) are processed.
In the result Y, columns are overwritten starting from the leading ones.
Level: beginner
.seealso: BVCopy(), BVSetActiveColumns(), BVMatMultColumn()
@*/
PetscErrorCode BVMatMult(BV V,Mat A,BV Y)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(V,BV_CLASSID,1);
PetscValidType(V,1);
BVCheckSizes(V,1);
PetscValidHeaderSpecific(A,MAT_CLASSID,2);
PetscValidHeaderSpecific(Y,BV_CLASSID,3);
PetscValidType(Y,3);
BVCheckSizes(Y,3);
PetscCheckSameComm(V,1,A,2);
PetscCheckSameTypeAndComm(V,1,Y,3);
if (V->n!=Y->n) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Mismatching local dimension V %D, Y %D",V->n,Y->n);
if (V->k-V->l>Y->m-Y->l) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"Y has %D non-leading columns, not enough to store %D columns",Y->m-Y->l,V->k-V->l);
ierr = PetscLogEventBegin(BV_MatMult,V,A,Y,0);CHKERRQ(ierr);
ierr = (*V->ops->matmult)(V,A,Y);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_MatMult,V,A,Y,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
BVAXPY - Computes Y = Y + alpha*X.
Logically Collective on BV
Input Parameters:
+ Y,X - basis vectors
- alpha - scalar
Output Parameter:
. Y - the modified basis vectors
Notes:
X and Y must be different objects, with compatible dimensions.
The effect is the same as doing a VecAXPY for each of the active
columns (excluding the leading ones).
Level: intermediate
.seealso: BVMult(), BVSetActiveColumns()
@*/
PetscErrorCode BVAXPY(BV Y,PetscScalar alpha,BV X)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(Y,BV_CLASSID,1);
PetscValidLogicalCollectiveScalar(Y,alpha,2);
PetscValidHeaderSpecific(X,BV_CLASSID,3);
PetscValidType(Y,1);
BVCheckSizes(Y,1);
PetscValidType(X,3);
BVCheckSizes(X,3);
PetscCheckSameTypeAndComm(Y,1,X,3);
if (X==Y) SETERRQ(PetscObjectComm((PetscObject)Y),PETSC_ERR_ARG_WRONG,"X and Y arguments must be different");
if (X->n!=Y->n) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Mismatching local dimension X %D, Y %D",X->n,Y->n);
if (X->k-X->l!=Y->k-Y->l) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"Y has %D non-leading columns, while X has %D",Y->m-Y->l,X->k-X->l);
if (!X->n) PetscFunctionReturn(0);
ierr = PetscLogEventBegin(BV_AXPY,X,Y,0,0);CHKERRQ(ierr);
ierr = (*Y->ops->axpy)(Y,alpha,X);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_AXPY,X,Y,0,0);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)Y);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVInsertVecs - Insert a set of vectors into the specified columns.
Collective on BV
Input Parameters:
+ V - basis vectors
. s - first column of V to be overwritten
. W - set of vectors to be copied
- orth - flag indicating if the vectors must be orthogonalized
Input/Output Parameter:
. m - number of input vectors, on output the number of linearly independent
vectors
Notes:
Copies the contents of vectors W to V(:,s:s+n). If the orthogonalization
flag is set, then the vectors are copied one by one and then orthogonalized
against the previous ones. If any of them is linearly dependent then it
is discarded and the value of m is decreased.
Level: intermediate
.seealso: BVInsertVec(), BVOrthogonalizeColumn()
@*/
PetscErrorCode BVInsertVecs(BV V,PetscInt s,PetscInt *m,Vec *W,PetscBool orth)
{
PetscErrorCode ierr;
PetscInt n,N,i,ndep;
PetscBool lindep;
PetscReal norm;
Vec v;
PetscFunctionBegin;
PetscValidHeaderSpecific(V,BV_CLASSID,1);
PetscValidLogicalCollectiveInt(V,s,2);
PetscValidPointer(m,3);
PetscValidLogicalCollectiveInt(V,*m,3);
if (!*m) PetscFunctionReturn(0);
if (*m<0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Number of vectors (given %D) cannot be negative",*m);
PetscValidPointer(W,4);
PetscValidHeaderSpecific(*W,VEC_CLASSID,4);
PetscValidLogicalCollectiveBool(V,orth,5);
PetscValidType(V,1);
BVCheckSizes(V,1);
PetscCheckSameComm(V,1,*W,4);
ierr = VecGetSize(*W,&N);CHKERRQ(ierr);
ierr = VecGetLocalSize(*W,&n);CHKERRQ(ierr);
if (N!=V->N || n!=V->n) SETERRQ4(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_INCOMP,"Vec sizes (global %D, local %D) do not match BV sizes (global %D, local %D)",N,n,V->N,V->n);
if (s<0 || s>=V->m) SETERRQ2(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Argument s has wrong value %D, should be between 0 and %D",s,V->m-1);
if (s+(*m)>V->m) SETERRQ1(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Too many vectors provided, there is only room for %D",V->m);
ndep = 0;
for (i=0;i<*m;i++) {
ierr = BVGetColumn(V,s+i-ndep,&v);CHKERRQ(ierr);
ierr = VecCopy(W[i],v);CHKERRQ(ierr);
ierr = BVRestoreColumn(V,s+i-ndep,&v);CHKERRQ(ierr);
if (orth) {
ierr = BVOrthogonalizeColumn(V,s+i-ndep,NULL,&norm,&lindep);CHKERRQ(ierr);
if (norm==0.0 || lindep) {
ierr = PetscInfo1(V,"Removing linearly dependent vector %D\n",i);CHKERRQ(ierr);
ndep++;
} else {
ierr = BVScaleColumn(V,s+i-ndep,1.0/norm);CHKERRQ(ierr);
}
}
}
*m -= ndep;
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVScale - Multiply the BV entries by a scalar value.
Logically Collective on BV
Input Parameters:
+ bv - basis vectors
- alpha - scaling factor
Note:
All active columns (except the leading ones) are scaled.
Level: intermediate
.seealso: BVScaleColumn(), BVSetActiveColumns()
@*/
PetscErrorCode BVScale(BV bv,PetscScalar alpha)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(bv,BV_CLASSID,1);
PetscValidLogicalCollectiveScalar(bv,alpha,2);
PetscValidType(bv,1);
BVCheckSizes(bv,1);
if (!bv->n || alpha == (PetscScalar)1.0) PetscFunctionReturn(0);
ierr = PetscLogEventBegin(BV_Scale,bv,0,0,0);CHKERRQ(ierr);
ierr = (*bv->ops->scale)(bv,-1,alpha);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_Scale,bv,0,0,0);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)bv);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVScaleColumn - Scale one column of a BV.
Logically Collective on BV
Input Parameters:
+ bv - basis vectors
. j - column number to be scaled
- alpha - scaling factor
Level: intermediate
.seealso: BVScale(), BVSetActiveColumns()
@*/
PetscErrorCode BVScaleColumn(BV bv,PetscInt j,PetscScalar alpha)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(bv,BV_CLASSID,1);
PetscValidLogicalCollectiveInt(bv,j,2);
PetscValidLogicalCollectiveScalar(bv,alpha,3);
PetscValidType(bv,1);
BVCheckSizes(bv,1);
if (j<0 || j>=bv->m) SETERRQ2(PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Argument j has wrong value %D, the number of columns is %D",j,bv->m);
if (!bv->n || alpha == (PetscScalar)1.0) PetscFunctionReturn(0);
ierr = PetscLogEventBegin(BV_Scale,bv,0,0,0);CHKERRQ(ierr);
ierr = (*bv->ops->scale)(bv,j,alpha);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_Scale,bv,0,0,0);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)bv);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVMatMultColumn - Computes the matrix-vector product for a specified
column, storing the result in the next column: v_{j+1}=A*v_j.
Neighbor-wise Collective on Mat and BV
Input Parameters:
+ V - basis vectors context
. A - the matrix
- j - the column
Output Parameter:
. Y - the result
Level: beginner
.seealso: BVMatMult()
@*/
PetscErrorCode BVMatMultColumn(BV V,Mat A,PetscInt j)
{
PetscErrorCode ierr;
Vec vj,vj1;
PetscFunctionBegin;
PetscValidHeaderSpecific(V,BV_CLASSID,1);
PetscValidType(V,1);
BVCheckSizes(V,1);
PetscValidHeaderSpecific(A,MAT_CLASSID,2);
PetscCheckSameComm(V,1,A,2);
if (j<0) SETERRQ(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Index j must be non-negative");
if (j+1>=V->m) SETERRQ2(PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Result should go in index j+1=%D but BV only has %D columns",j+1,V->m);
ierr = PetscLogEventBegin(BV_MatMult,V,A,0,0);CHKERRQ(ierr);
ierr = BVGetColumn(V,j,&vj);CHKERRQ(ierr);
ierr = BVGetColumn(V,j+1,&vj1);CHKERRQ(ierr);
ierr = MatMult(A,vj,vj1);CHKERRQ(ierr);
ierr = BVRestoreColumn(V,j,&vj);CHKERRQ(ierr);
ierr = BVRestoreColumn(V,j+1,&vj1);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_MatMult,V,A,0,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVSetRandomColumn - Set one column of a BV to random numbers.
Logically Collective on BV
Input Parameters:
+ bv - basis vectors
. j - column number to be set
- rctx - the random number context, formed by PetscRandomCreate(), or NULL and
it will create one internally.
Note:
This operation is analogue to VecSetRandom - the difference is that the
generated random vector is the same irrespective of the size of the
communicator (if all processes pass a PetscRandom context initialized
with the same seed).
Level: advanced
.seealso: BVSetRandom(), BVSetActiveColumns()
@*/
PetscErrorCode BVSetRandomColumn(BV bv,PetscInt j,PetscRandom rctx)
{
PetscErrorCode ierr;
PetscRandom rand=NULL;
PetscInt i,low,high;
PetscScalar *px,t;
Vec x;
PetscFunctionBegin;
PetscValidHeaderSpecific(bv,BV_CLASSID,1);
PetscValidLogicalCollectiveInt(bv,j,2);
if (rctx) PetscValidHeaderSpecific(rctx,PETSC_RANDOM_CLASSID,3);
else {
ierr = PetscRandomCreate(PetscObjectComm((PetscObject)bv),&rand);CHKERRQ(ierr);
ierr = PetscRandomSetSeed(rand,0x12345678);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rand);CHKERRQ(ierr);
rctx = rand;
}
PetscValidType(bv,1);
BVCheckSizes(bv,1);
if (j<0 || j>=bv->m) SETERRQ2(PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Argument j has wrong value %D, the number of columns is %D",j,bv->m);
ierr = PetscLogEventBegin(BV_SetRandom,bv,rctx,0,0);CHKERRQ(ierr);
ierr = BVGetColumn(bv,j,&x);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(x,&low,&high);CHKERRQ(ierr);
ierr = VecGetArray(x,&px);CHKERRQ(ierr);
for (i=0;i<bv->N;i++) {
ierr = PetscRandomGetValue(rctx,&t);CHKERRQ(ierr);
if (i>=low && i<high) px[i-low] = t;
}
ierr = VecRestoreArray(x,&px);CHKERRQ(ierr);
ierr = BVRestoreColumn(bv,j,&x);CHKERRQ(ierr);
ierr = PetscLogEventEnd(BV_SetRandom,bv,rctx,0,0);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rand);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)bv);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
BVSetRandom - Set the columns of a BV to random numbers.
Logically Collective on BV
Input Parameters:
+ bv - basis vectors
- rctx - the random number context, formed by PetscRandomCreate(), or NULL and
it will create one internally.
Note:
All active columns (except the leading ones) are modified.
Level: advanced
.seealso: BVSetRandomColumn(), BVSetActiveColumns()
@*/
PetscErrorCode BVSetRandom(BV bv,PetscRandom rctx)
{
PetscErrorCode ierr;
PetscRandom rand=NULL;
PetscInt i,low,high,k;
PetscScalar *px,t;
Vec x;
PetscFunctionBegin;
PetscValidHeaderSpecific(bv,BV_CLASSID,1);
if (rctx) PetscValidHeaderSpecific(rctx,PETSC_RANDOM_CLASSID,2);
else {
ierr = PetscRandomCreate(PetscObjectComm((PetscObject)bv),&rand);CHKERRQ(ierr);
ierr = PetscRandomSetSeed(rand,0x12345678);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rand);CHKERRQ(ierr);
rctx = rand;
}
PetscValidType(bv,1);
BVCheckSizes(bv,1);
ierr = PetscLogEventBegin(BV_SetRandom,bv,rctx,0,0);CHKERRQ(ierr);
for (k=bv->l;k<bv->k;k++) {
ierr = BVGetColumn(bv,k,&x);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(x,&low,&high);CHKERRQ(ierr);
ierr = VecGetArray(x,&px);CHKERRQ(ierr);
for (i=0;i<bv->N;i++) {
ierr = PetscRandomGetValue(rctx,&t);CHKERRQ(ierr);
if (i>=low && i<high) px[i-low] = t;
}
ierr = VecRestoreArray(x,&px);CHKERRQ(ierr);
ierr = BVRestoreColumn(bv,k,&x);CHKERRQ(ierr);
}
ierr = PetscLogEventEnd(BV_SetRandom,bv,rctx,0,0);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rand);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)bv);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
