Actual source code: bvbasic.c
slepc-main 2024-11-09
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: Basic BV routines
12: */
14: #include <slepc/private/bvimpl.h>
16: PetscBool BVRegisterAllCalled = PETSC_FALSE;
17: PetscFunctionList BVList = NULL;
19: /*@
20: BVSetType - Selects the type for the BV object.
22: Logically Collective
24: Input Parameters:
25: + bv - the basis vectors context
26: - type - a known type
28: Options Database Key:
29: . -bv_type <type> - Sets BV type
31: Level: intermediate
33: .seealso: BVGetType()
34: @*/
35: PetscErrorCode BVSetType(BV bv,BVType type)
36: {
37: PetscErrorCode (*r)(BV);
38: PetscBool match;
40: PetscFunctionBegin;
42: PetscAssertPointer(type,2);
44: PetscCall(PetscObjectTypeCompare((PetscObject)bv,type,&match));
45: if (match) PetscFunctionReturn(PETSC_SUCCESS);
46: PetscCall(PetscStrcmp(type,BVTENSOR,&match));
47: PetscCheck(!match,PetscObjectComm((PetscObject)bv),PETSC_ERR_ORDER,"Use BVCreateTensor() to create a BV of type tensor");
49: PetscCall(PetscFunctionListFind(BVList,type,&r));
50: PetscCheck(r,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_UNKNOWN_TYPE,"Unable to find requested BV type %s",type);
52: PetscTryTypeMethod(bv,destroy);
53: PetscCall(PetscMemzero(bv->ops,sizeof(struct _BVOps)));
55: PetscCall(PetscObjectChangeTypeName((PetscObject)bv,type));
56: if (bv->n < 0 && bv->N < 0) {
57: bv->ops->create = r;
58: } else {
59: PetscCall(PetscLogEventBegin(BV_Create,bv,0,0,0));
60: PetscCall((*r)(bv));
61: PetscCall(PetscLogEventEnd(BV_Create,bv,0,0,0));
62: }
63: PetscFunctionReturn(PETSC_SUCCESS);
64: }
66: /*@
67: BVGetType - Gets the BV type name (as a string) from the BV context.
69: Not Collective
71: Input Parameter:
72: . bv - the basis vectors context
74: Output Parameter:
75: . type - name of the type of basis vectors
77: Level: intermediate
79: .seealso: BVSetType()
80: @*/
81: PetscErrorCode BVGetType(BV bv,BVType *type)
82: {
83: PetscFunctionBegin;
85: PetscAssertPointer(type,2);
86: *type = ((PetscObject)bv)->type_name;
87: PetscFunctionReturn(PETSC_SUCCESS);
88: }
90: /*@
91: BVSetSizes - Sets the local and global sizes, and the number of columns.
93: Collective
95: Input Parameters:
96: + bv - the basis vectors
97: . n - the local size (or PETSC_DECIDE to have it set)
98: . N - the global size (or PETSC_DECIDE)
99: - m - the number of columns
101: Notes:
102: n and N cannot be both PETSC_DECIDE.
103: If one processor calls this with N of PETSC_DECIDE then all processors must,
104: otherwise the program will hang.
106: Level: beginner
108: .seealso: BVSetSizesFromVec(), BVGetSizes(), BVResize()
109: @*/
110: PetscErrorCode BVSetSizes(BV bv,PetscInt n,PetscInt N,PetscInt m)
111: {
112: PetscInt ma;
113: PetscMPIInt size;
115: PetscFunctionBegin;
119: PetscCheck(N<0 || n<=N,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_INCOMP,"Local size %" PetscInt_FMT " cannot be larger than global size %" PetscInt_FMT,n,N);
120: PetscCheck(m>0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_INCOMP,"Number of columns %" PetscInt_FMT " must be positive",m);
121: PetscCheck((bv->n<0 && bv->N<0) || (bv->n==n && bv->N==N),PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"Cannot change/reset vector sizes to %" PetscInt_FMT " local %" PetscInt_FMT " global after previously setting them to %" PetscInt_FMT " local %" PetscInt_FMT " global",n,N,bv->n,bv->N);
122: PetscCheck(bv->m<=0 || bv->m==m,PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"Cannot change the number of columns to %" PetscInt_FMT " after previously setting it to %" PetscInt_FMT "; use BVResize()",m,bv->m);
123: PetscCheck(!bv->map,PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"Vector layout was already defined by a previous call to BVSetSizes/FromVec");
124: bv->n = n;
125: bv->N = N;
126: bv->m = m;
127: bv->k = m;
128: /* create layout and get actual dimensions */
129: PetscCall(PetscLayoutCreate(PetscObjectComm((PetscObject)bv),&bv->map));
130: PetscCall(PetscLayoutSetSize(bv->map,bv->N));
131: PetscCall(PetscLayoutSetLocalSize(bv->map,bv->n));
132: PetscCall(PetscLayoutSetUp(bv->map));
133: PetscCall(PetscLayoutGetSize(bv->map,&bv->N));
134: PetscCall(PetscLayoutGetLocalSize(bv->map,&bv->n));
135: PetscCallMPI(MPI_Comm_size(PetscObjectComm((PetscObject)bv),&size));
136: PetscCall(BVSetVecType(bv,(size==1)?VECSEQ:VECMPI));
137: if (bv->matrix) { /* check compatible dimensions of user-provided matrix */
138: PetscCall(MatGetLocalSize(bv->matrix,&ma,NULL));
139: PetscCheck(bv->n==ma,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_INCOMP,"Local dimension %" PetscInt_FMT " does not match that of matrix given at BVSetMatrix %" PetscInt_FMT,bv->n,ma);
140: }
141: if (bv->ops->create) {
142: PetscCall(PetscLogEventBegin(BV_Create,bv,0,0,0));
143: PetscUseTypeMethod(bv,create);
144: PetscCall(PetscLogEventEnd(BV_Create,bv,0,0,0));
145: bv->ops->create = NULL;
146: bv->defersfo = PETSC_FALSE;
147: }
148: PetscFunctionReturn(PETSC_SUCCESS);
149: }
151: /*@
152: BVSetSizesFromVec - Sets the local and global sizes, and the number of columns.
153: Local and global sizes are specified indirectly by passing a template vector.
155: Collective
157: Input Parameters:
158: + bv - the basis vectors
159: . t - the template vector
160: - m - the number of columns
162: Level: beginner
164: .seealso: BVSetSizes(), BVGetSizes(), BVResize()
165: @*/
166: PetscErrorCode BVSetSizesFromVec(BV bv,Vec t,PetscInt m)
167: {
168: PetscInt ma;
169: PetscLayout map;
170: VecType vtype;
172: PetscFunctionBegin;
175: PetscCheckSameComm(bv,1,t,2);
177: PetscCheck(m>0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_INCOMP,"Number of columns %" PetscInt_FMT " must be positive",m);
178: PetscCheck(!bv->map,PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"Vector layout was already defined by a previous call to BVSetSizes/FromVec");
179: PetscCall(VecGetType(t,&vtype));
180: PetscCall(BVSetVecType(bv,vtype));
181: PetscCall(VecGetLayout(t,&map));
182: PetscCall(PetscLayoutReference(map,&bv->map));
183: PetscCall(VecGetSize(t,&bv->N));
184: PetscCall(VecGetLocalSize(t,&bv->n));
185: if (bv->matrix) { /* check compatible dimensions of user-provided matrix */
186: PetscCall(MatGetLocalSize(bv->matrix,&ma,NULL));
187: PetscCheck(bv->n==ma,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_INCOMP,"Local dimension %" PetscInt_FMT " does not match that of matrix given at BVSetMatrix %" PetscInt_FMT,bv->n,ma);
188: }
189: bv->m = m;
190: bv->k = m;
191: if (bv->ops->create) {
192: PetscUseTypeMethod(bv,create);
193: bv->ops->create = NULL;
194: bv->defersfo = PETSC_FALSE;
195: }
196: PetscFunctionReturn(PETSC_SUCCESS);
197: }
199: /*@
200: BVGetSizes - Returns the local and global sizes, and the number of columns.
202: Not Collective
204: Input Parameter:
205: . bv - the basis vectors
207: Output Parameters:
208: + n - the local size
209: . N - the global size
210: - m - the number of columns
212: Note:
213: Normal usage requires that bv has already been given its sizes, otherwise
214: the call fails. However, this function can also be used to determine if
215: a BV object has been initialized completely (sizes and type). For this,
216: call with n=NULL and N=NULL, then a return value of m=0 indicates that
217: the BV object is not ready for use yet.
219: Level: beginner
221: .seealso: BVSetSizes(), BVSetSizesFromVec()
222: @*/
223: PetscErrorCode BVGetSizes(BV bv,PetscInt *n,PetscInt *N,PetscInt *m)
224: {
225: PetscFunctionBegin;
226: if (!bv) {
227: if (m && !n && !N) *m = 0;
228: PetscFunctionReturn(PETSC_SUCCESS);
229: }
231: if (n || N) BVCheckSizes(bv,1);
232: if (n) *n = bv->n;
233: if (N) *N = bv->N;
234: if (m) *m = bv->m;
235: if (m && !n && !N && !((PetscObject)bv)->type_name) *m = 0;
236: PetscFunctionReturn(PETSC_SUCCESS);
237: }
239: /*@
240: BVSetNumConstraints - Set the number of constraints.
242: Logically Collective
244: Input Parameters:
245: + V - basis vectors
246: - nc - number of constraints
248: Notes:
249: This function sets the number of constraints to nc and marks all remaining
250: columns as regular. Normal user would call BVInsertConstraints() instead.
252: If nc is smaller than the previously set value, then some of the constraints
253: are discarded. In particular, using nc=0 removes all constraints preserving
254: the content of regular columns.
256: Level: developer
258: .seealso: BVInsertConstraints()
259: @*/
260: PetscErrorCode BVSetNumConstraints(BV V,PetscInt nc)
261: {
262: PetscInt total,diff,i;
263: Vec x,y;
265: PetscFunctionBegin;
268: PetscCheck(nc>=0,PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Number of constraints (given %" PetscInt_FMT ") cannot be negative",nc);
270: BVCheckSizes(V,1);
271: PetscCheck(V->ci[0]==-V->nc-1 && V->ci[1]==-V->nc-1,PetscObjectComm((PetscObject)V),PETSC_ERR_SUP,"Cannot call BVSetNumConstraints after BVGetColumn");
273: diff = nc-V->nc;
274: if (!diff) PetscFunctionReturn(PETSC_SUCCESS);
275: total = V->nc+V->m;
276: PetscCheck(total-nc>0,PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_OUTOFRANGE,"Not enough columns for the given nc value");
277: if (diff<0) { /* lessen constraints, shift contents of BV */
278: for (i=0;i<V->m;i++) {
279: PetscCall(BVGetColumn(V,i,&x));
280: PetscCall(BVGetColumn(V,i+diff,&y));
281: PetscCall(VecCopy(x,y));
282: PetscCall(BVRestoreColumn(V,i,&x));
283: PetscCall(BVRestoreColumn(V,i+diff,&y));
284: }
285: }
286: V->nc = nc;
287: V->ci[0] = -V->nc-1;
288: V->ci[1] = -V->nc-1;
289: V->m = total-nc;
290: V->l = PetscMin(V->l,V->m);
291: V->k = PetscMin(V->k,V->m);
292: PetscCall(PetscObjectStateIncrease((PetscObject)V));
293: PetscFunctionReturn(PETSC_SUCCESS);
294: }
296: /*@
297: BVGetNumConstraints - Returns the number of constraints.
299: Not Collective
301: Input Parameter:
302: . bv - the basis vectors
304: Output Parameters:
305: . nc - the number of constraints
307: Level: advanced
309: .seealso: BVGetSizes(), BVInsertConstraints()
310: @*/
311: PetscErrorCode BVGetNumConstraints(BV bv,PetscInt *nc)
312: {
313: PetscFunctionBegin;
315: PetscAssertPointer(nc,2);
316: *nc = bv->nc;
317: PetscFunctionReturn(PETSC_SUCCESS);
318: }
320: /*@
321: BVResize - Change the number of columns.
323: Collective
325: Input Parameters:
326: + bv - the basis vectors
327: . m - the new number of columns
328: - copy - a flag indicating whether current values should be kept
330: Note:
331: Internal storage is reallocated. If the copy flag is set to true, then
332: the contents are copied to the leading part of the new space.
334: Level: advanced
336: .seealso: BVSetSizes(), BVSetSizesFromVec()
337: @*/
338: PetscErrorCode BVResize(BV bv,PetscInt m,PetscBool copy)
339: {
340: PetscScalar *array;
341: const PetscScalar *omega;
342: Vec v;
344: PetscFunctionBegin;
349: PetscCheck(m>0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_INCOMP,"Number of columns %" PetscInt_FMT " must be positive",m);
350: PetscCheck(!bv->nc || bv->issplit,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Cannot resize a BV with constraints");
351: if (bv->m == m) PetscFunctionReturn(PETSC_SUCCESS);
352: BVCheckOp(bv,1,resize);
354: PetscCall(PetscLogEventBegin(BV_Create,bv,0,0,0));
355: PetscUseTypeMethod(bv,resize,m,copy);
356: PetscCall(VecDestroy(&bv->buffer));
357: PetscCall(BVDestroy(&bv->cached));
358: PetscCall(PetscFree2(bv->h,bv->c));
359: if (bv->omega) {
360: if (bv->cuda) {
361: #if defined(PETSC_HAVE_CUDA)
362: PetscCall(VecCreateSeqCUDA(PETSC_COMM_SELF,m,&v));
363: #else
364: SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_PLIB,"Something wrong happened");
365: #endif
366: } else if (bv->hip) {
367: #if defined(PETSC_HAVE_HIP)
368: PetscCall(VecCreateSeqHIP(PETSC_COMM_SELF,m,&v));
369: #else
370: SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_PLIB,"Something wrong happened");
371: #endif
372: } else PetscCall(VecCreateSeq(PETSC_COMM_SELF,m,&v));
373: if (copy) {
374: PetscCall(VecGetArray(v,&array));
375: PetscCall(VecGetArrayRead(bv->omega,&omega));
376: PetscCall(PetscArraycpy(array,omega,PetscMin(m,bv->m)));
377: PetscCall(VecRestoreArrayRead(bv->omega,&omega));
378: PetscCall(VecRestoreArray(v,&array));
379: } else PetscCall(VecSet(v,1.0));
380: PetscCall(VecDestroy(&bv->omega));
381: bv->omega = v;
382: }
383: bv->m = m;
384: bv->k = PetscMin(bv->k,m);
385: bv->l = PetscMin(bv->l,m);
386: PetscCall(PetscLogEventEnd(BV_Create,bv,0,0,0));
387: PetscCall(PetscObjectStateIncrease((PetscObject)bv));
388: PetscFunctionReturn(PETSC_SUCCESS);
389: }
391: /*@
392: BVSetActiveColumns - Specify the columns that will be involved in operations.
394: Logically Collective
396: Input Parameters:
397: + bv - the basis vectors context
398: . l - number of leading columns
399: - k - number of active columns
401: Notes:
402: In operations such as BVMult() or BVDot(), only the first k columns are
403: considered. This is useful when the BV is filled from left to right, so
404: the last m-k columns do not have relevant information.
406: Also in operations such as BVMult() or BVDot(), the first l columns are
407: normally not included in the computation. See the manpage of each
408: operation.
410: In orthogonalization operations, the first l columns are treated
411: differently, they participate in the orthogonalization but the computed
412: coefficients are not stored.
414: Use PETSC_CURRENT to leave any of the values unchanged. Use PETSC_DETERMINE
415: to set l to the minimum value (0) and k to the maximum (m).
417: Level: intermediate
419: .seealso: BVGetActiveColumns(), BVSetSizes()
420: @*/
421: PetscErrorCode BVSetActiveColumns(BV bv,PetscInt l,PetscInt k)
422: {
423: PetscFunctionBegin;
427: BVCheckSizes(bv,1);
428: if (PetscUnlikely(k == PETSC_DETERMINE)) {
429: bv->k = bv->m;
430: } else if (k != PETSC_CURRENT) {
431: PetscCheck(k>=0 && k<=bv->m,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of k (%" PetscInt_FMT "). Must be between 0 and m (%" PetscInt_FMT ")",k,bv->m);
432: bv->k = k;
433: }
434: if (PetscUnlikely(l == PETSC_DETERMINE)) {
435: bv->l = 0;
436: } else if (l != PETSC_CURRENT) {
437: PetscCheck(l>=0 && l<=bv->k,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of l (%" PetscInt_FMT "). Must be between 0 and k (%" PetscInt_FMT ")",l,bv->k);
438: bv->l = l;
439: }
440: PetscFunctionReturn(PETSC_SUCCESS);
441: }
443: /*@
444: BVGetActiveColumns - Returns the current active dimensions.
446: Not Collective
448: Input Parameter:
449: . bv - the basis vectors context
451: Output Parameters:
452: + l - number of leading columns
453: - k - number of active columns
455: Level: intermediate
457: .seealso: BVSetActiveColumns()
458: @*/
459: PetscErrorCode BVGetActiveColumns(BV bv,PetscInt *l,PetscInt *k)
460: {
461: PetscFunctionBegin;
463: if (l) *l = bv->l;
464: if (k) *k = bv->k;
465: PetscFunctionReturn(PETSC_SUCCESS);
466: }
468: /*@
469: BVSetMatrix - Specifies the inner product to be used in orthogonalization.
471: Collective
473: Input Parameters:
474: + bv - the basis vectors context
475: . B - a symmetric matrix (may be NULL)
476: - indef - a flag indicating if the matrix is indefinite
478: Notes:
479: This is used to specify a non-standard inner product, whose matrix
480: representation is given by B. Then, all inner products required during
481: orthogonalization are computed as (x,y)_B=y^H*B*x rather than the
482: standard form (x,y)=y^H*x.
484: Matrix B must be real symmetric (or complex Hermitian). A genuine inner
485: product requires that B is also positive (semi-)definite. However, we
486: also allow for an indefinite B (setting indef=PETSC_TRUE), in which
487: case the orthogonalization uses an indefinite inner product.
489: This affects operations BVDot(), BVNorm(), BVOrthogonalize(), and variants.
491: Setting B=NULL has the same effect as if the identity matrix was passed.
493: Level: advanced
495: .seealso: BVGetMatrix(), BVDot(), BVNorm(), BVOrthogonalize(), BVSetDefiniteTolerance()
496: @*/
497: PetscErrorCode BVSetMatrix(BV bv,Mat B,PetscBool indef)
498: {
499: PetscInt m,n;
501: PetscFunctionBegin;
504: if (B!=bv->matrix || (B && ((PetscObject)B)->id!=((PetscObject)bv->matrix)->id) || indef!=bv->indef) {
505: if (B) {
507: PetscCall(MatGetLocalSize(B,&m,&n));
508: PetscCheck(m==n,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_SIZ,"Matrix must be square");
509: PetscCheck(!bv->m || bv->n==n,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_INCOMP,"Mismatching local dimension BV %" PetscInt_FMT ", Mat %" PetscInt_FMT,bv->n,n);
510: }
511: if (B) PetscCall(PetscObjectReference((PetscObject)B));
512: PetscCall(MatDestroy(&bv->matrix));
513: bv->matrix = B;
514: bv->indef = indef;
515: PetscCall(PetscObjectStateIncrease((PetscObject)bv));
516: if (bv->Bx) PetscCall(PetscObjectStateIncrease((PetscObject)bv->Bx));
517: if (bv->cached) PetscCall(PetscObjectStateIncrease((PetscObject)bv->cached));
518: }
519: PetscFunctionReturn(PETSC_SUCCESS);
520: }
522: /*@
523: BVGetMatrix - Retrieves the matrix representation of the inner product.
525: Not Collective
527: Input Parameter:
528: . bv - the basis vectors context
530: Output Parameters:
531: + B - the matrix of the inner product (may be NULL)
532: - indef - the flag indicating if the matrix is indefinite
534: Level: advanced
536: .seealso: BVSetMatrix()
537: @*/
538: PetscErrorCode BVGetMatrix(BV bv,Mat *B,PetscBool *indef)
539: {
540: PetscFunctionBegin;
542: if (B) *B = bv->matrix;
543: if (indef) *indef = bv->indef;
544: PetscFunctionReturn(PETSC_SUCCESS);
545: }
547: /*@
548: BVApplyMatrix - Multiplies a vector by the matrix representation of the
549: inner product.
551: Neighbor-wise Collective
553: Input Parameters:
554: + bv - the basis vectors context
555: - x - the vector
557: Output Parameter:
558: . y - the result
560: Note:
561: If no matrix was specified this function copies the vector.
563: Level: advanced
565: .seealso: BVSetMatrix(), BVApplyMatrixBV()
566: @*/
567: PetscErrorCode BVApplyMatrix(BV bv,Vec x,Vec y)
568: {
569: PetscFunctionBegin;
573: if (bv->matrix) {
574: PetscCall(BV_IPMatMult(bv,x));
575: PetscCall(VecCopy(bv->Bx,y));
576: } else PetscCall(VecCopy(x,y));
577: PetscFunctionReturn(PETSC_SUCCESS);
578: }
580: /*@
581: BVApplyMatrixBV - Multiplies the BV vectors by the matrix representation
582: of the inner product.
584: Neighbor-wise Collective
586: Input Parameter:
587: . X - the basis vectors context
589: Output Parameter:
590: . Y - the basis vectors to store the result (optional)
592: Note:
593: This function computes Y = B*X, where B is the matrix given with
594: BVSetMatrix(). This operation is computed as in BVMatMult().
595: If no matrix was specified, then it just copies Y = X.
597: If no Y is given, the result is stored internally in the cached BV.
599: Level: developer
601: .seealso: BVSetMatrix(), BVApplyMatrix(), BVMatMult(), BVGetCachedBV()
602: @*/
603: PetscErrorCode BVApplyMatrixBV(BV X,BV Y)
604: {
605: PetscFunctionBegin;
607: if (Y) {
609: if (X->matrix) PetscCall(BVMatMult(X,X->matrix,Y));
610: else PetscCall(BVCopy(X,Y));
611: } else PetscCall(BV_IPMatMultBV(X));
612: PetscFunctionReturn(PETSC_SUCCESS);
613: }
615: /*@
616: BVSetSignature - Sets the signature matrix to be used in orthogonalization.
618: Logically Collective
620: Input Parameters:
621: + bv - the basis vectors context
622: - omega - a vector representing the diagonal of the signature matrix
624: Note:
625: The signature matrix Omega = V'*B*V is relevant only for an indefinite B.
627: Level: developer
629: .seealso: BVSetMatrix(), BVGetSignature()
630: @*/
631: PetscErrorCode BVSetSignature(BV bv,Vec omega)
632: {
633: PetscInt i,n;
634: const PetscScalar *pomega;
635: PetscScalar *intern;
637: PetscFunctionBegin;
639: BVCheckSizes(bv,1);
643: PetscCall(VecGetSize(omega,&n));
644: PetscCheck(n==bv->k,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_SIZ,"Vec argument has %" PetscInt_FMT " elements, should be %" PetscInt_FMT,n,bv->k);
645: PetscCall(BV_AllocateSignature(bv));
646: if (bv->indef) {
647: PetscCall(VecGetArrayRead(omega,&pomega));
648: PetscCall(VecGetArray(bv->omega,&intern));
649: for (i=0;i<n;i++) intern[bv->nc+i] = pomega[i];
650: PetscCall(VecRestoreArray(bv->omega,&intern));
651: PetscCall(VecRestoreArrayRead(omega,&pomega));
652: } else PetscCall(PetscInfo(bv,"Ignoring signature because BV is not indefinite\n"));
653: PetscCall(PetscObjectStateIncrease((PetscObject)bv));
654: PetscFunctionReturn(PETSC_SUCCESS);
655: }
657: /*@
658: BVGetSignature - Retrieves the signature matrix from last orthogonalization.
660: Not Collective
662: Input Parameter:
663: . bv - the basis vectors context
665: Output Parameter:
666: . omega - a vector representing the diagonal of the signature matrix
668: Note:
669: The signature matrix Omega = V'*B*V is relevant only for an indefinite B.
671: Level: developer
673: .seealso: BVSetMatrix(), BVSetSignature()
674: @*/
675: PetscErrorCode BVGetSignature(BV bv,Vec omega)
676: {
677: PetscInt i,n;
678: PetscScalar *pomega;
679: const PetscScalar *intern;
681: PetscFunctionBegin;
683: BVCheckSizes(bv,1);
687: PetscCall(VecGetSize(omega,&n));
688: PetscCheck(n==bv->k,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_SIZ,"Vec argument has %" PetscInt_FMT " elements, should be %" PetscInt_FMT,n,bv->k);
689: if (bv->indef && bv->omega) {
690: PetscCall(VecGetArray(omega,&pomega));
691: PetscCall(VecGetArrayRead(bv->omega,&intern));
692: for (i=0;i<n;i++) pomega[i] = intern[bv->nc+i];
693: PetscCall(VecRestoreArrayRead(bv->omega,&intern));
694: PetscCall(VecRestoreArray(omega,&pomega));
695: } else PetscCall(VecSet(omega,1.0));
696: PetscFunctionReturn(PETSC_SUCCESS);
697: }
699: /*@
700: BVSetBufferVec - Attach a vector object to be used as buffer space for
701: several operations.
703: Collective
705: Input Parameters:
706: + bv - the basis vectors context)
707: - buffer - the vector
709: Notes:
710: Use BVGetBufferVec() to retrieve the vector (for example, to free it
711: at the end of the computations).
713: The vector must be sequential of length (nc+m)*m, where m is the number
714: of columns of bv and nc is the number of constraints.
716: Level: developer
718: .seealso: BVGetBufferVec(), BVSetSizes(), BVGetNumConstraints()
719: @*/
720: PetscErrorCode BVSetBufferVec(BV bv,Vec buffer)
721: {
722: PetscInt ld,n;
723: PetscMPIInt size;
725: PetscFunctionBegin;
728: BVCheckSizes(bv,1);
729: PetscCall(VecGetSize(buffer,&n));
730: ld = bv->m+bv->nc;
731: PetscCheck(n==ld*bv->m,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_SIZ,"Buffer size must be %" PetscInt_FMT,ld*bv->m);
732: PetscCallMPI(MPI_Comm_size(PetscObjectComm((PetscObject)buffer),&size));
733: PetscCheck(size==1,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Buffer must be a sequential vector");
735: PetscCall(PetscObjectReference((PetscObject)buffer));
736: PetscCall(VecDestroy(&bv->buffer));
737: bv->buffer = buffer;
738: PetscFunctionReturn(PETSC_SUCCESS);
739: }
741: /*@
742: BVGetBufferVec - Obtain the buffer vector associated with the BV object.
744: Collective
746: Input Parameters:
747: . bv - the basis vectors context
749: Output Parameter:
750: . buffer - vector
752: Notes:
753: The vector is created if not available previously. It is a sequential vector
754: of length (nc+m)*m, where m is the number of columns of bv and nc is the number
755: of constraints.
757: Developer Notes:
758: The buffer vector is viewed as a column-major matrix with leading dimension
759: ld=nc+m, and m columns at most. In the most common usage, it has the structure
760: .vb
761: | | C |
762: |s|---|
763: | | H |
764: .ve
765: where H is an upper Hessenberg matrix of order m x (m-1), C contains coefficients
766: related to orthogonalization against constraints (first nc rows), and s is the
767: first column that contains scratch values computed during Gram-Schmidt
768: orthogonalization. In particular, BVDotColumn() and BVMultColumn() use s to
769: store the coefficients.
771: Level: developer
773: .seealso: BVSetBufferVec(), BVSetSizes(), BVGetNumConstraints(), BVDotColumn(), BVMultColumn()
774: @*/
775: PetscErrorCode BVGetBufferVec(BV bv,Vec *buffer)
776: {
777: PetscInt ld;
779: PetscFunctionBegin;
781: PetscAssertPointer(buffer,2);
782: BVCheckSizes(bv,1);
783: if (!bv->buffer) {
784: ld = bv->m+bv->nc;
785: PetscCall(VecCreate(PETSC_COMM_SELF,&bv->buffer));
786: PetscCall(VecSetSizes(bv->buffer,PETSC_DECIDE,ld*bv->m));
787: PetscCall(VecSetType(bv->buffer,bv->vtype));
788: }
789: *buffer = bv->buffer;
790: PetscFunctionReturn(PETSC_SUCCESS);
791: }
793: /*@
794: BVSetRandomContext - Sets the PetscRandom object associated with the BV,
795: to be used in operations that need random numbers.
797: Collective
799: Input Parameters:
800: + bv - the basis vectors context
801: - rand - the random number generator context
803: Level: advanced
805: .seealso: BVGetRandomContext(), BVSetRandom(), BVSetRandomNormal(), BVSetRandomColumn(), BVSetRandomCond()
806: @*/
807: PetscErrorCode BVSetRandomContext(BV bv,PetscRandom rand)
808: {
809: PetscFunctionBegin;
812: PetscCheckSameComm(bv,1,rand,2);
813: PetscCall(PetscObjectReference((PetscObject)rand));
814: PetscCall(PetscRandomDestroy(&bv->rand));
815: bv->rand = rand;
816: PetscFunctionReturn(PETSC_SUCCESS);
817: }
819: /*@
820: BVGetRandomContext - Gets the PetscRandom object associated with the BV.
822: Collective
824: Input Parameter:
825: . bv - the basis vectors context
827: Output Parameter:
828: . rand - the random number generator context
830: Level: advanced
832: .seealso: BVSetRandomContext(), BVSetRandom(), BVSetRandomNormal(), BVSetRandomColumn(), BVSetRandomCond()
833: @*/
834: PetscErrorCode BVGetRandomContext(BV bv,PetscRandom* rand)
835: {
836: PetscFunctionBegin;
838: PetscAssertPointer(rand,2);
839: if (!bv->rand) {
840: PetscCall(PetscRandomCreate(PetscObjectComm((PetscObject)bv),&bv->rand));
841: if (bv->cuda) PetscCall(PetscRandomSetType(bv->rand,PETSCCURAND));
842: if (bv->sfocalled) PetscCall(PetscRandomSetFromOptions(bv->rand));
843: if (bv->rrandom) {
844: PetscCall(PetscRandomSetSeed(bv->rand,0x12345678));
845: PetscCall(PetscRandomSeed(bv->rand));
846: }
847: }
848: *rand = bv->rand;
849: PetscFunctionReturn(PETSC_SUCCESS);
850: }
852: /*@
853: BVSetFromOptions - Sets BV options from the options database.
855: Collective
857: Input Parameter:
858: . bv - the basis vectors context
860: Level: beginner
862: .seealso: BVSetOptionsPrefix()
863: @*/
864: PetscErrorCode BVSetFromOptions(BV bv)
865: {
866: char type[256];
867: PetscBool flg1,flg2,flg3,flg4;
868: PetscReal r;
869: BVOrthogType otype;
870: BVOrthogRefineType orefine;
871: BVOrthogBlockType oblock;
873: PetscFunctionBegin;
875: PetscCall(BVRegisterAll());
876: PetscObjectOptionsBegin((PetscObject)bv);
877: PetscCall(PetscOptionsFList("-bv_type","Basis Vectors type","BVSetType",BVList,(char*)(((PetscObject)bv)->type_name?((PetscObject)bv)->type_name:BVMAT),type,sizeof(type),&flg1));
878: if (flg1) PetscCall(BVSetType(bv,type));
879: else if (!((PetscObject)bv)->type_name) PetscCall(BVSetType(bv,BVMAT));
881: otype = bv->orthog_type;
882: PetscCall(PetscOptionsEnum("-bv_orthog_type","Orthogonalization method","BVSetOrthogonalization",BVOrthogTypes,(PetscEnum)otype,(PetscEnum*)&otype,&flg1));
883: orefine = bv->orthog_ref;
884: PetscCall(PetscOptionsEnum("-bv_orthog_refine","Iterative refinement mode during orthogonalization","BVSetOrthogonalization",BVOrthogRefineTypes,(PetscEnum)orefine,(PetscEnum*)&orefine,&flg2));
885: r = bv->orthog_eta;
886: PetscCall(PetscOptionsReal("-bv_orthog_eta","Parameter of iterative refinement during orthogonalization","BVSetOrthogonalization",r,&r,&flg3));
887: oblock = bv->orthog_block;
888: PetscCall(PetscOptionsEnum("-bv_orthog_block","Block orthogonalization method","BVSetOrthogonalization",BVOrthogBlockTypes,(PetscEnum)oblock,(PetscEnum*)&oblock,&flg4));
889: if (flg1 || flg2 || flg3 || flg4) PetscCall(BVSetOrthogonalization(bv,otype,orefine,r,oblock));
891: PetscCall(PetscOptionsEnum("-bv_matmult","Method for BVMatMult","BVSetMatMultMethod",BVMatMultTypes,(PetscEnum)bv->vmm,(PetscEnum*)&bv->vmm,NULL));
893: PetscCall(PetscOptionsReal("-bv_definite_tol","Tolerance for checking a definite inner product","BVSetDefiniteTolerance",r,&r,&flg1));
894: if (flg1) PetscCall(BVSetDefiniteTolerance(bv,r));
896: /* undocumented option to generate random vectors that are independent of the number of processes */
897: PetscCall(PetscOptionsGetBool(NULL,NULL,"-bv_reproducible_random",&bv->rrandom,NULL));
899: if (bv->ops->create) bv->defersfo = PETSC_TRUE; /* defer call to setfromoptions */
900: else PetscTryTypeMethod(bv,setfromoptions,PetscOptionsObject);
901: PetscCall(PetscObjectProcessOptionsHandlers((PetscObject)bv,PetscOptionsObject));
902: PetscOptionsEnd();
903: bv->sfocalled = PETSC_TRUE;
904: PetscFunctionReturn(PETSC_SUCCESS);
905: }
907: /*@
908: BVSetOrthogonalization - Specifies the method used for the orthogonalization of
909: vectors (classical or modified Gram-Schmidt with or without refinement), and
910: for the block-orthogonalization (simultaneous orthogonalization of a set of
911: vectors).
913: Logically Collective
915: Input Parameters:
916: + bv - the basis vectors context
917: . type - the method of vector orthogonalization
918: . refine - type of refinement
919: . eta - parameter for selective refinement
920: - block - the method of block orthogonalization
922: Options Database Keys:
923: + -bv_orthog_type <type> - Where <type> is cgs for Classical Gram-Schmidt orthogonalization
924: (default) or mgs for Modified Gram-Schmidt orthogonalization
925: . -bv_orthog_refine <ref> - Where <ref> is one of never, ifneeded (default) or always
926: . -bv_orthog_eta <eta> - For setting the value of eta
927: - -bv_orthog_block <block> - Where <block> is the block-orthogonalization method
929: Notes:
930: The default settings work well for most problems.
932: The parameter eta should be a real value between 0 and 1, that is used only when
933: the refinement type is "ifneeded". Use PETSC_DETERMINE to set a reasonable
934: default value. Use PETSC_CURRENT to leave the current value unchanged.
936: When using several processors, MGS is likely to result in bad scalability.
938: If the method set for block orthogonalization is GS, then the computation
939: is done column by column with the vector orthogonalization.
941: Level: advanced
943: .seealso: BVOrthogonalizeColumn(), BVGetOrthogonalization(), BVOrthogType, BVOrthogRefineType, BVOrthogBlockType
944: @*/
945: PetscErrorCode BVSetOrthogonalization(BV bv,BVOrthogType type,BVOrthogRefineType refine,PetscReal eta,BVOrthogBlockType block)
946: {
947: PetscFunctionBegin;
953: switch (type) {
954: case BV_ORTHOG_CGS:
955: case BV_ORTHOG_MGS:
956: bv->orthog_type = type;
957: break;
958: default:
959: SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Unknown orthogonalization type");
960: }
961: switch (refine) {
962: case BV_ORTHOG_REFINE_NEVER:
963: case BV_ORTHOG_REFINE_IFNEEDED:
964: case BV_ORTHOG_REFINE_ALWAYS:
965: bv->orthog_ref = refine;
966: break;
967: default:
968: SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Unknown refinement type");
969: }
970: if (eta == (PetscReal)PETSC_DETERMINE) {
971: bv->orthog_eta = 0.7071;
972: } else if (eta != (PetscReal)PETSC_CURRENT) {
973: PetscCheck(eta>0.0 && eta<=1.0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Invalid eta value");
974: bv->orthog_eta = eta;
975: }
976: switch (block) {
977: case BV_ORTHOG_BLOCK_GS:
978: case BV_ORTHOG_BLOCK_CHOL:
979: case BV_ORTHOG_BLOCK_TSQR:
980: case BV_ORTHOG_BLOCK_TSQRCHOL:
981: case BV_ORTHOG_BLOCK_SVQB:
982: bv->orthog_block = block;
983: break;
984: default:
985: SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Unknown block orthogonalization type");
986: }
987: PetscFunctionReturn(PETSC_SUCCESS);
988: }
990: /*@
991: BVGetOrthogonalization - Gets the orthogonalization settings from the BV object.
993: Not Collective
995: Input Parameter:
996: . bv - basis vectors context
998: Output Parameters:
999: + type - the method of vector orthogonalization
1000: . refine - type of refinement
1001: . eta - parameter for selective refinement
1002: - block - the method of block orthogonalization
1004: Level: advanced
1006: .seealso: BVOrthogonalizeColumn(), BVSetOrthogonalization(), BVOrthogType, BVOrthogRefineType, BVOrthogBlockType
1007: @*/
1008: PetscErrorCode BVGetOrthogonalization(BV bv,BVOrthogType *type,BVOrthogRefineType *refine,PetscReal *eta,BVOrthogBlockType *block)
1009: {
1010: PetscFunctionBegin;
1012: if (type) *type = bv->orthog_type;
1013: if (refine) *refine = bv->orthog_ref;
1014: if (eta) *eta = bv->orthog_eta;
1015: if (block) *block = bv->orthog_block;
1016: PetscFunctionReturn(PETSC_SUCCESS);
1017: }
1019: /*@
1020: BVSetMatMultMethod - Specifies the method used for the BVMatMult() operation.
1022: Logically Collective
1024: Input Parameters:
1025: + bv - the basis vectors context
1026: - method - the method for the BVMatMult() operation
1028: Options Database Keys:
1029: . -bv_matmult <meth> - choose one of the methods: vecs, mat
1031: Notes:
1032: Allowed values are
1033: + BV_MATMULT_VECS - perform a matrix-vector multiply per each column
1034: . BV_MATMULT_MAT - carry out a Mat-Mat product with a dense matrix
1035: - BV_MATMULT_MAT_SAVE - this case is deprecated
1037: The default is BV_MATMULT_MAT except in the case of BVVECS.
1039: Level: advanced
1041: .seealso: BVMatMult(), BVGetMatMultMethod(), BVMatMultType
1042: @*/
1043: PetscErrorCode BVSetMatMultMethod(BV bv,BVMatMultType method)
1044: {
1045: PetscFunctionBegin;
1048: switch (method) {
1049: case BV_MATMULT_VECS:
1050: case BV_MATMULT_MAT:
1051: bv->vmm = method;
1052: break;
1053: case BV_MATMULT_MAT_SAVE:
1054: PetscCall(PetscInfo(bv,"BV_MATMULT_MAT_SAVE is deprecated, using BV_MATMULT_MAT\n"));
1055: bv->vmm = BV_MATMULT_MAT;
1056: break;
1057: default:
1058: SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Unknown matmult method");
1059: }
1060: PetscFunctionReturn(PETSC_SUCCESS);
1061: }
1063: /*@
1064: BVGetMatMultMethod - Gets the method used for the BVMatMult() operation.
1066: Not Collective
1068: Input Parameter:
1069: . bv - basis vectors context
1071: Output Parameter:
1072: . method - the method for the BVMatMult() operation
1074: Level: advanced
1076: .seealso: BVMatMult(), BVSetMatMultMethod(), BVMatMultType
1077: @*/
1078: PetscErrorCode BVGetMatMultMethod(BV bv,BVMatMultType *method)
1079: {
1080: PetscFunctionBegin;
1082: PetscAssertPointer(method,2);
1083: *method = bv->vmm;
1084: PetscFunctionReturn(PETSC_SUCCESS);
1085: }
1087: /*@
1088: BVGetColumn - Returns a Vec object that contains the entries of the
1089: requested column of the basis vectors object.
1091: Logically Collective
1093: Input Parameters:
1094: + bv - the basis vectors context
1095: - j - the index of the requested column
1097: Output Parameter:
1098: . v - vector containing the jth column
1100: Notes:
1101: The returned Vec must be seen as a reference (not a copy) of the BV
1102: column, that is, modifying the Vec will change the BV entries as well.
1104: The returned Vec must not be destroyed. BVRestoreColumn() must be
1105: called when it is no longer needed. At most, two columns can be fetched,
1106: that is, this function can only be called twice before the corresponding
1107: BVRestoreColumn() is invoked.
1109: A negative index j selects the i-th constraint, where i=-j. Constraints
1110: should not be modified.
1112: Level: beginner
1114: .seealso: BVRestoreColumn(), BVInsertConstraints()
1115: @*/
1116: PetscErrorCode BVGetColumn(BV bv,PetscInt j,Vec *v)
1117: {
1118: PetscInt l;
1120: PetscFunctionBegin;
1123: BVCheckSizes(bv,1);
1124: BVCheckOp(bv,1,getcolumn);
1126: PetscCheck(j>=0 || -j<=bv->nc,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"You requested constraint %" PetscInt_FMT " but only %" PetscInt_FMT " are available",-j,bv->nc);
1127: PetscCheck(j<bv->m,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"You requested column %" PetscInt_FMT " but only %" PetscInt_FMT " are available",j,bv->m);
1128: PetscCheck(j!=bv->ci[0] && j!=bv->ci[1],PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"Column %" PetscInt_FMT " already fetched in a previous call to BVGetColumn",j);
1129: l = BVAvailableVec;
1130: PetscCheck(l!=-1,PetscObjectComm((PetscObject)bv),PETSC_ERR_SUP,"Too many requested columns; you must call BVRestoreColumn for one of the previously fetched columns");
1131: PetscUseTypeMethod(bv,getcolumn,j,v);
1132: bv->ci[l] = j;
1133: PetscCall(VecGetState(bv->cv[l],&bv->st[l]));
1134: PetscCall(PetscObjectGetId((PetscObject)bv->cv[l],&bv->id[l]));
1135: *v = bv->cv[l];
1136: PetscFunctionReturn(PETSC_SUCCESS);
1137: }
1139: /*@
1140: BVRestoreColumn - Restore a column obtained with BVGetColumn().
1142: Logically Collective
1144: Input Parameters:
1145: + bv - the basis vectors context
1146: . j - the index of the column
1147: - v - vector obtained with BVGetColumn()
1149: Note:
1150: The arguments must match the corresponding call to BVGetColumn().
1152: Level: beginner
1154: .seealso: BVGetColumn()
1155: @*/
1156: PetscErrorCode BVRestoreColumn(BV bv,PetscInt j,Vec *v)
1157: {
1158: PetscObjectId id;
1159: PetscObjectState st;
1160: PetscInt l;
1162: PetscFunctionBegin;
1165: BVCheckSizes(bv,1);
1167: PetscAssertPointer(v,3);
1169: PetscCheck(j>=0 || -j<=bv->nc,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"You requested constraint %" PetscInt_FMT " but only %" PetscInt_FMT " are available",-j,bv->nc);
1170: PetscCheck(j<bv->m,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"You requested column %" PetscInt_FMT " but only %" PetscInt_FMT " are available",j,bv->m);
1171: PetscCheck(j==bv->ci[0] || j==bv->ci[1],PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Column %" PetscInt_FMT " has not been fetched with a call to BVGetColumn",j);
1172: l = (j==bv->ci[0])? 0: 1;
1173: PetscCall(PetscObjectGetId((PetscObject)*v,&id));
1174: PetscCheck(id==bv->id[l],PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Argument 3 is not the same Vec that was obtained with BVGetColumn");
1175: PetscCall(VecGetState(*v,&st));
1176: if (st!=bv->st[l]) PetscCall(PetscObjectStateIncrease((PetscObject)bv));
1177: PetscUseTypeMethod(bv,restorecolumn,j,v);
1178: bv->ci[l] = -bv->nc-1;
1179: bv->st[l] = -1;
1180: bv->id[l] = 0;
1181: *v = NULL;
1182: PetscFunctionReturn(PETSC_SUCCESS);
1183: }
1185: /*@C
1186: BVGetArray - Returns a pointer to a contiguous array that contains this
1187: processor's portion of the BV data.
1189: Logically Collective
1191: Input Parameters:
1192: . bv - the basis vectors context
1194: Output Parameter:
1195: . a - location to put pointer to the array
1197: Notes:
1198: BVRestoreArray() must be called when access to the array is no longer needed.
1199: This operation may imply a data copy, for BV types that do not store
1200: data contiguously in memory.
1202: The pointer will normally point to the first entry of the first column,
1203: but if the BV has constraints then these go before the regular columns.
1205: Note that for manipulating the pointer to the BV array, one must take into
1206: account the leading dimension, which might be different from the local
1207: number of rows, see BVGetLeadingDimension().
1209: Use BVGetArrayRead() for read-only access.
1211: Level: advanced
1213: .seealso: BVRestoreArray(), BVInsertConstraints(), BVGetLeadingDimension(), BVGetArrayRead()
1214: @*/
1215: PetscErrorCode BVGetArray(BV bv,PetscScalar **a)
1216: {
1217: PetscFunctionBegin;
1220: BVCheckSizes(bv,1);
1221: BVCheckOp(bv,1,getarray);
1222: PetscUseTypeMethod(bv,getarray,a);
1223: PetscFunctionReturn(PETSC_SUCCESS);
1224: }
1226: /*@C
1227: BVRestoreArray - Restore the BV object after BVGetArray() has been called.
1229: Logically Collective
1231: Input Parameters:
1232: + bv - the basis vectors context
1233: - a - location of pointer to array obtained from BVGetArray()
1235: Note:
1236: This operation may imply a data copy, for BV types that do not store
1237: data contiguously in memory.
1239: Level: advanced
1241: .seealso: BVGetColumn()
1242: @*/
1243: PetscErrorCode BVRestoreArray(BV bv,PetscScalar **a)
1244: {
1245: PetscFunctionBegin;
1248: BVCheckSizes(bv,1);
1249: PetscTryTypeMethod(bv,restorearray,a);
1250: if (a) *a = NULL;
1251: PetscCall(PetscObjectStateIncrease((PetscObject)bv));
1252: PetscFunctionReturn(PETSC_SUCCESS);
1253: }
1255: /*@C
1256: BVGetArrayRead - Returns a read-only pointer to a contiguous array that
1257: contains this processor's portion of the BV data.
1259: Not Collective
1261: Input Parameters:
1262: . bv - the basis vectors context
1264: Output Parameter:
1265: . a - location to put pointer to the array
1267: Notes:
1268: BVRestoreArrayRead() must be called when access to the array is no
1269: longer needed. This operation may imply a data copy, for BV types that
1270: do not store data contiguously in memory.
1272: The pointer will normally point to the first entry of the first column,
1273: but if the BV has constraints then these go before the regular columns.
1275: Level: advanced
1277: .seealso: BVRestoreArray(), BVInsertConstraints(), BVGetLeadingDimension(), BVGetArray()
1278: @*/
1279: PetscErrorCode BVGetArrayRead(BV bv,const PetscScalar **a)
1280: {
1281: PetscFunctionBegin;
1284: BVCheckSizes(bv,1);
1285: BVCheckOp(bv,1,getarrayread);
1286: PetscUseTypeMethod(bv,getarrayread,a);
1287: PetscFunctionReturn(PETSC_SUCCESS);
1288: }
1290: /*@C
1291: BVRestoreArrayRead - Restore the BV object after BVGetArrayRead() has
1292: been called.
1294: Not Collective
1296: Input Parameters:
1297: + bv - the basis vectors context
1298: - a - location of pointer to array obtained from BVGetArrayRead()
1300: Level: advanced
1302: .seealso: BVGetColumn()
1303: @*/
1304: PetscErrorCode BVRestoreArrayRead(BV bv,const PetscScalar **a)
1305: {
1306: PetscFunctionBegin;
1309: BVCheckSizes(bv,1);
1310: PetscTryTypeMethod(bv,restorearrayread,a);
1311: if (a) *a = NULL;
1312: PetscFunctionReturn(PETSC_SUCCESS);
1313: }
1315: /*@
1316: BVCreateVec - Creates a new Vec object with the same type and dimensions
1317: as the columns of the basis vectors object.
1319: Collective
1321: Input Parameter:
1322: . bv - the basis vectors context
1324: Output Parameter:
1325: . v - the new vector
1327: Note:
1328: The user is responsible of destroying the returned vector.
1330: Level: beginner
1332: .seealso: BVCreateMat(), BVCreateVecEmpty()
1333: @*/
1334: PetscErrorCode BVCreateVec(BV bv,Vec *v)
1335: {
1336: PetscFunctionBegin;
1338: BVCheckSizes(bv,1);
1339: PetscAssertPointer(v,2);
1340: PetscCall(VecCreate(PetscObjectComm((PetscObject)bv),v));
1341: PetscCall(VecSetLayout(*v,bv->map));
1342: PetscCall(VecSetType(*v,bv->vtype));
1343: PetscCall(VecSetUp(*v));
1344: PetscFunctionReturn(PETSC_SUCCESS);
1345: }
1347: /*@
1348: BVCreateVecEmpty - Creates a new Vec object with the same type and dimensions
1349: as the columns of the basis vectors object, but without internal array.
1351: Collective
1353: Input Parameter:
1354: . bv - the basis vectors context
1356: Output Parameter:
1357: . v - the new vector
1359: Note:
1360: This works as BVCreateVec(), but the new vector does not have the array allocated,
1361: so the intended usage is with VecPlaceArray().
1363: Level: developer
1365: .seealso: BVCreateVec()
1366: @*/
1367: PetscErrorCode BVCreateVecEmpty(BV bv,Vec *v)
1368: {
1369: PetscBool standard,cuda,hip,mpi;
1370: PetscInt N,nloc,bs;
1372: PetscFunctionBegin;
1374: BVCheckSizes(bv,1);
1375: PetscAssertPointer(v,2);
1377: PetscCall(PetscStrcmpAny(bv->vtype,&standard,VECSEQ,VECMPI,""));
1378: PetscCall(PetscStrcmpAny(bv->vtype,&cuda,VECSEQCUDA,VECMPICUDA,""));
1379: PetscCall(PetscStrcmpAny(bv->vtype,&hip,VECSEQHIP,VECMPIHIP,""));
1380: if (standard || cuda || hip) {
1381: PetscCall(PetscStrcmpAny(bv->vtype,&mpi,VECMPI,VECMPICUDA,VECMPIHIP,""));
1382: PetscCall(PetscLayoutGetLocalSize(bv->map,&nloc));
1383: PetscCall(PetscLayoutGetSize(bv->map,&N));
1384: PetscCall(PetscLayoutGetBlockSize(bv->map,&bs));
1385: if (cuda) {
1386: #if defined(PETSC_HAVE_CUDA)
1387: if (mpi) PetscCall(VecCreateMPICUDAWithArray(PetscObjectComm((PetscObject)bv),bs,nloc,N,NULL,v));
1388: else PetscCall(VecCreateSeqCUDAWithArray(PetscObjectComm((PetscObject)bv),bs,N,NULL,v));
1389: #endif
1390: } else if (hip) {
1391: #if defined(PETSC_HAVE_HIP)
1392: if (mpi) PetscCall(VecCreateMPIHIPWithArray(PetscObjectComm((PetscObject)bv),bs,nloc,N,NULL,v));
1393: else PetscCall(VecCreateSeqHIPWithArray(PetscObjectComm((PetscObject)bv),bs,N,NULL,v));
1394: #endif
1395: } else {
1396: if (mpi) PetscCall(VecCreateMPIWithArray(PetscObjectComm((PetscObject)bv),bs,nloc,N,NULL,v));
1397: else PetscCall(VecCreateSeqWithArray(PetscObjectComm((PetscObject)bv),bs,N,NULL,v));
1398: }
1399: } else PetscCall(BVCreateVec(bv,v)); /* standard duplicate, with internal array */
1400: PetscFunctionReturn(PETSC_SUCCESS);
1401: }
1403: /*@
1404: BVSetVecType - Set the vector type to be used when creating vectors via BVCreateVec().
1406: Collective
1408: Input Parameters:
1409: + bv - the basis vectors context
1410: - vtype - the vector type
1412: Level: advanced
1414: Note:
1415: This is not needed if the BV object is set up with BVSetSizesFromVec(), but may be
1416: required in the case of BVSetSizes() if one wants to work with non-standard vectors.
1418: .seealso: BVGetVecType(), BVSetSizesFromVec(), BVSetSizes()
1419: @*/
1420: PetscErrorCode BVSetVecType(BV bv,VecType vtype)
1421: {
1422: PetscBool std;
1423: PetscMPIInt size;
1425: PetscFunctionBegin;
1427: PetscCall(PetscFree(bv->vtype));
1428: PetscCall(PetscStrcmp(vtype,VECSTANDARD,&std));
1429: if (std) {
1430: PetscCallMPI(MPI_Comm_size(PetscObjectComm((PetscObject)bv),&size));
1431: PetscCall(PetscStrallocpy((size==1)?VECSEQ:VECMPI,(char**)&bv->vtype));
1432: } else PetscCall(PetscStrallocpy(vtype,(char**)&bv->vtype));
1433: PetscFunctionReturn(PETSC_SUCCESS);
1434: }
1436: /*@
1437: BVGetVecType - Get the vector type to be used when creating vectors via BVCreateVec().
1439: Not Collective
1441: Input Parameter:
1442: . bv - the basis vectors context
1444: Output Parameter:
1445: . vtype - the vector type
1447: Level: advanced
1449: .seealso: BVSetVecType()
1450: @*/
1451: PetscErrorCode BVGetVecType(BV bv,VecType *vtype)
1452: {
1453: PetscFunctionBegin;
1455: PetscAssertPointer(vtype,2);
1456: *vtype = bv->vtype;
1457: PetscFunctionReturn(PETSC_SUCCESS);
1458: }
1460: /*@
1461: BVCreateMat - Creates a new Mat object of dense type and copies the contents
1462: of the BV object.
1464: Collective
1466: Input Parameter:
1467: . bv - the basis vectors context
1469: Output Parameter:
1470: . A - the new matrix
1472: Notes:
1473: The user is responsible of destroying the returned matrix.
1475: The matrix contains all columns of the BV, not just the active columns.
1477: Level: intermediate
1479: .seealso: BVCreateFromMat(), BVCreateVec(), BVGetMat()
1480: @*/
1481: PetscErrorCode BVCreateMat(BV bv,Mat *A)
1482: {
1483: PetscInt ksave,lsave;
1484: Mat B;
1486: PetscFunctionBegin;
1488: BVCheckSizes(bv,1);
1489: PetscAssertPointer(A,2);
1491: PetscCall(MatCreateDenseFromVecType(PetscObjectComm((PetscObject)bv),bv->vtype,bv->n,PETSC_DECIDE,bv->N,bv->m,bv->ld,NULL,A));
1492: lsave = bv->l;
1493: ksave = bv->k;
1494: bv->l = 0;
1495: bv->k = bv->m;
1496: PetscCall(BVGetMat(bv,&B));
1497: PetscCall(MatCopy(B,*A,SAME_NONZERO_PATTERN));
1498: PetscCall(BVRestoreMat(bv,&B));
1499: bv->l = lsave;
1500: bv->k = ksave;
1501: PetscFunctionReturn(PETSC_SUCCESS);
1502: }
1504: PetscErrorCode BVGetMat_Default(BV bv,Mat *A)
1505: {
1506: PetscScalar *vv,*aa;
1507: PetscBool create=PETSC_FALSE;
1508: PetscInt m,cols;
1510: PetscFunctionBegin;
1511: m = bv->k-bv->l;
1512: if (!bv->Aget) create=PETSC_TRUE;
1513: else {
1514: PetscCall(MatDenseGetArray(bv->Aget,&aa));
1515: PetscCheck(!aa,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"BVGetMat already called on this BV");
1516: PetscCall(MatGetSize(bv->Aget,NULL,&cols));
1517: if (cols!=m) {
1518: PetscCall(MatDestroy(&bv->Aget));
1519: create=PETSC_TRUE;
1520: }
1521: }
1522: PetscCall(BVGetArray(bv,&vv));
1523: if (create) {
1524: PetscCall(MatCreateDenseFromVecType(PetscObjectComm((PetscObject)bv),bv->vtype,bv->n,PETSC_DECIDE,bv->N,m,bv->ld,vv,&bv->Aget)); /* pass a pointer to avoid allocation of storage */
1525: PetscCall(MatDenseReplaceArray(bv->Aget,NULL)); /* replace with a null pointer, the value after BVRestoreMat */
1526: }
1527: PetscCall(MatDensePlaceArray(bv->Aget,vv+(bv->nc+bv->l)*bv->ld)); /* set the actual pointer */
1528: *A = bv->Aget;
1529: PetscFunctionReturn(PETSC_SUCCESS);
1530: }
1532: /*@
1533: BVGetMat - Returns a Mat object of dense type that shares the memory of
1534: the BV object.
1536: Collective
1538: Input Parameter:
1539: . bv - the basis vectors context
1541: Output Parameter:
1542: . A - the matrix
1544: Notes:
1545: The returned matrix contains only the active columns. If the content of
1546: the Mat is modified, these changes are also done in the BV object. The
1547: user must call BVRestoreMat() when no longer needed.
1549: This operation implies a call to BVGetArray(), which may result in data
1550: copies.
1552: Level: advanced
1554: .seealso: BVRestoreMat(), BVCreateMat(), BVGetArray()
1555: @*/
1556: PetscErrorCode BVGetMat(BV bv,Mat *A)
1557: {
1558: char name[64];
1560: PetscFunctionBegin;
1562: BVCheckSizes(bv,1);
1563: PetscAssertPointer(A,2);
1564: PetscUseTypeMethod(bv,getmat,A);
1565: if (((PetscObject)bv)->name) { /* set A's name based on BV name */
1566: PetscCall(PetscStrncpy(name,"Mat_",sizeof(name)));
1567: PetscCall(PetscStrlcat(name,((PetscObject)bv)->name,sizeof(name)));
1568: PetscCall(PetscObjectSetName((PetscObject)*A,name));
1569: }
1570: PetscFunctionReturn(PETSC_SUCCESS);
1571: }
1573: PetscErrorCode BVRestoreMat_Default(BV bv,Mat *A)
1574: {
1575: PetscScalar *vv,*aa;
1577: PetscFunctionBegin;
1578: PetscCall(MatDenseGetArray(bv->Aget,&aa));
1579: vv = aa-(bv->nc+bv->l)*bv->ld;
1580: PetscCall(MatDenseResetArray(bv->Aget));
1581: PetscCall(BVRestoreArray(bv,&vv));
1582: *A = NULL;
1583: PetscFunctionReturn(PETSC_SUCCESS);
1584: }
1586: /*@
1587: BVRestoreMat - Restores the Mat obtained with BVGetMat().
1589: Logically Collective
1591: Input Parameters:
1592: + bv - the basis vectors context
1593: - A - the fetched matrix
1595: Note:
1596: A call to this function must match a previous call of BVGetMat().
1597: The effect is that the contents of the Mat are copied back to the
1598: BV internal data structures.
1600: Level: advanced
1602: .seealso: BVGetMat(), BVRestoreArray()
1603: @*/
1604: PetscErrorCode BVRestoreMat(BV bv,Mat *A)
1605: {
1606: PetscFunctionBegin;
1608: BVCheckSizes(bv,1);
1609: PetscAssertPointer(A,2);
1610: PetscCheck(bv->Aget,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"BVRestoreMat must match a previous call to BVGetMat");
1611: PetscCheck(bv->Aget==*A,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Mat argument is not the same as the one obtained with BVGetMat");
1612: PetscUseTypeMethod(bv,restoremat,A);
1613: PetscFunctionReturn(PETSC_SUCCESS);
1614: }
1616: /*
1617: Copy all user-provided attributes of V to another BV object W
1618: */
1619: static inline PetscErrorCode BVDuplicate_Private(BV V,BV W)
1620: {
1621: PetscFunctionBegin;
1622: PetscCall(PetscLayoutReference(V->map,&W->map));
1623: PetscCall(BVSetVecType(W,V->vtype));
1624: W->ld = V->ld;
1625: PetscCall(BVSetType(W,((PetscObject)V)->type_name));
1626: W->orthog_type = V->orthog_type;
1627: W->orthog_ref = V->orthog_ref;
1628: W->orthog_eta = V->orthog_eta;
1629: W->orthog_block = V->orthog_block;
1630: if (V->matrix) PetscCall(PetscObjectReference((PetscObject)V->matrix));
1631: W->matrix = V->matrix;
1632: W->indef = V->indef;
1633: W->vmm = V->vmm;
1634: W->rrandom = V->rrandom;
1635: W->deftol = V->deftol;
1636: if (V->rand) PetscCall(PetscObjectReference((PetscObject)V->rand));
1637: W->rand = V->rand;
1638: W->sfocalled = V->sfocalled;
1639: PetscTryTypeMethod(V,duplicate,W);
1640: PetscCall(PetscObjectStateIncrease((PetscObject)W));
1641: PetscFunctionReturn(PETSC_SUCCESS);
1642: }
1644: /*@
1645: BVDuplicate - Creates a new basis vector object of the same type and
1646: dimensions as an existing one.
1648: Collective
1650: Input Parameter:
1651: . V - basis vectors context
1653: Output Parameter:
1654: . W - location to put the new BV
1656: Notes:
1657: The new BV has the same type and dimensions as V. Also, the inner
1658: product matrix and orthogonalization options are copied.
1660: BVDuplicate() DOES NOT COPY the entries, but rather allocates storage
1661: for the new basis vectors. Use BVCopy() to copy the contents.
1663: Level: intermediate
1665: .seealso: BVDuplicateResize(), BVCreate(), BVSetSizesFromVec(), BVCopy()
1666: @*/
1667: PetscErrorCode BVDuplicate(BV V,BV *W)
1668: {
1669: PetscFunctionBegin;
1672: BVCheckSizes(V,1);
1673: PetscAssertPointer(W,2);
1674: PetscCall(BVCreate(PetscObjectComm((PetscObject)V),W));
1675: (*W)->N = V->N;
1676: (*W)->n = V->n;
1677: (*W)->m = V->m;
1678: (*W)->k = V->m;
1679: PetscCall(BVDuplicate_Private(V,*W));
1680: PetscFunctionReturn(PETSC_SUCCESS);
1681: }
1683: /*@
1684: BVDuplicateResize - Creates a new basis vector object of the same type and
1685: dimensions as an existing one, but with possibly different number of columns.
1687: Collective
1689: Input Parameters:
1690: + V - basis vectors context
1691: - m - the new number of columns
1693: Output Parameter:
1694: . W - location to put the new BV
1696: Note:
1697: This is equivalent of a call to BVDuplicate() followed by BVResize(). The
1698: contents of V are not copied to W.
1700: Level: intermediate
1702: .seealso: BVDuplicate(), BVResize()
1703: @*/
1704: PetscErrorCode BVDuplicateResize(BV V,PetscInt m,BV *W)
1705: {
1706: PetscFunctionBegin;
1709: BVCheckSizes(V,1);
1711: PetscAssertPointer(W,3);
1712: PetscCall(BVCreate(PetscObjectComm((PetscObject)V),W));
1713: (*W)->N = V->N;
1714: (*W)->n = V->n;
1715: (*W)->m = m;
1716: (*W)->k = m;
1717: PetscCall(BVDuplicate_Private(V,*W));
1718: PetscFunctionReturn(PETSC_SUCCESS);
1719: }
1721: /*@
1722: BVGetCachedBV - Returns a BV object stored internally that holds the
1723: result of B*X after a call to BVApplyMatrixBV().
1725: Collective
1727: Input Parameter:
1728: . bv - the basis vectors context
1730: Output Parameter:
1731: . cached - the cached BV
1733: Note:
1734: The cached BV is created if not available previously.
1736: Level: developer
1738: .seealso: BVApplyMatrixBV()
1739: @*/
1740: PetscErrorCode BVGetCachedBV(BV bv,BV *cached)
1741: {
1742: PetscFunctionBegin;
1744: PetscAssertPointer(cached,2);
1745: BVCheckSizes(bv,1);
1746: if (!bv->cached) {
1747: PetscCall(BVCreate(PetscObjectComm((PetscObject)bv),&bv->cached));
1748: bv->cached->N = bv->N;
1749: bv->cached->n = bv->n;
1750: bv->cached->m = bv->m;
1751: bv->cached->k = bv->m;
1752: PetscCall(BVDuplicate_Private(bv,bv->cached));
1753: }
1754: *cached = bv->cached;
1755: PetscFunctionReturn(PETSC_SUCCESS);
1756: }
1758: /*@
1759: BVCopy - Copies a basis vector object into another one, W <- V.
1761: Logically Collective
1763: Input Parameter:
1764: . V - basis vectors context
1766: Output Parameter:
1767: . W - the copy
1769: Note:
1770: Both V and W must be distributed in the same manner; local copies are
1771: done. Only active columns (excluding the leading ones) are copied.
1772: In the destination W, columns are overwritten starting from the leading ones.
1773: Constraints are not copied.
1775: Level: beginner
1777: .seealso: BVCopyVec(), BVCopyColumn(), BVDuplicate(), BVSetActiveColumns()
1778: @*/
1779: PetscErrorCode BVCopy(BV V,BV W)
1780: {
1781: PetscScalar *womega;
1782: const PetscScalar *vomega;
1784: PetscFunctionBegin;
1787: BVCheckSizes(V,1);
1788: BVCheckOp(V,1,copy);
1791: BVCheckSizes(W,2);
1792: PetscCheckSameTypeAndComm(V,1,W,2);
1793: PetscCheck(V->n==W->n,PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_INCOMP,"Mismatching local dimension V %" PetscInt_FMT ", W %" PetscInt_FMT,V->n,W->n);
1794: PetscCheck(V->k-V->l<=W->m-W->l,PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_SIZ,"W has %" PetscInt_FMT " non-leading columns, not enough to store %" PetscInt_FMT " columns",W->m-W->l,V->k-V->l);
1795: if (V==W || !V->n) PetscFunctionReturn(PETSC_SUCCESS);
1797: PetscCall(PetscLogEventBegin(BV_Copy,V,W,0,0));
1798: if (V->indef && V->matrix && V->indef==W->indef && V->matrix==W->matrix) {
1799: /* copy signature */
1800: PetscCall(BV_AllocateSignature(W));
1801: PetscCall(VecGetArrayRead(V->omega,&vomega));
1802: PetscCall(VecGetArray(W->omega,&womega));
1803: PetscCall(PetscArraycpy(womega+W->nc+W->l,vomega+V->nc+V->l,V->k-V->l));
1804: PetscCall(VecRestoreArray(W->omega,&womega));
1805: PetscCall(VecRestoreArrayRead(V->omega,&vomega));
1806: }
1807: PetscUseTypeMethod(V,copy,W);
1808: PetscCall(PetscLogEventEnd(BV_Copy,V,W,0,0));
1809: PetscCall(PetscObjectStateIncrease((PetscObject)W));
1810: PetscFunctionReturn(PETSC_SUCCESS);
1811: }
1813: /*@
1814: BVCopyVec - Copies one of the columns of a basis vectors object into a Vec.
1816: Logically Collective
1818: Input Parameters:
1819: + V - basis vectors context
1820: - j - the column number to be copied
1822: Output Parameter:
1823: . w - the copied column
1825: Note:
1826: Both V and w must be distributed in the same manner; local copies are done.
1828: Level: beginner
1830: .seealso: BVCopy(), BVCopyColumn(), BVInsertVec()
1831: @*/
1832: PetscErrorCode BVCopyVec(BV V,PetscInt j,Vec w)
1833: {
1834: PetscInt n,N;
1835: Vec z;
1837: PetscFunctionBegin;
1840: BVCheckSizes(V,1);
1843: PetscCheckSameComm(V,1,w,3);
1845: PetscCall(VecGetSize(w,&N));
1846: PetscCall(VecGetLocalSize(w,&n));
1847: PetscCheck(N==V->N && n==V->n,PetscObjectComm((PetscObject)V),PETSC_ERR_ARG_INCOMP,"Vec sizes (global %" PetscInt_FMT ", local %" PetscInt_FMT ") do not match BV sizes (global %" PetscInt_FMT ", local %" PetscInt_FMT ")",N,n,V->N,V->n);
1849: PetscCall(PetscLogEventBegin(BV_Copy,V,w,0,0));
1850: PetscCall(BVGetColumn(V,j,&z));
1851: PetscCall(VecCopy(z,w));
1852: PetscCall(BVRestoreColumn(V,j,&z));
1853: PetscCall(PetscLogEventEnd(BV_Copy,V,w,0,0));
1854: PetscFunctionReturn(PETSC_SUCCESS);
1855: }
1857: /*@
1858: BVCopyColumn - Copies the values from one of the columns to another one.
1860: Logically Collective
1862: Input Parameters:
1863: + V - basis vectors context
1864: . j - the number of the source column
1865: - i - the number of the destination column
1867: Level: beginner
1869: .seealso: BVCopy(), BVCopyVec()
1870: @*/
1871: PetscErrorCode BVCopyColumn(BV V,PetscInt j,PetscInt i)
1872: {
1873: PetscScalar *omega;
1875: PetscFunctionBegin;
1878: BVCheckSizes(V,1);
1881: if (j==i) PetscFunctionReturn(PETSC_SUCCESS);
1883: PetscCall(PetscLogEventBegin(BV_Copy,V,0,0,0));
1884: if (V->omega) {
1885: PetscCall(VecGetArray(V->omega,&omega));
1886: omega[i] = omega[j];
1887: PetscCall(VecRestoreArray(V->omega,&omega));
1888: }
1889: PetscUseTypeMethod(V,copycolumn,j,i);
1890: PetscCall(PetscLogEventEnd(BV_Copy,V,0,0,0));
1891: PetscCall(PetscObjectStateIncrease((PetscObject)V));
1892: PetscFunctionReturn(PETSC_SUCCESS);
1893: }
1895: static PetscErrorCode BVGetSplit_Private(BV bv,PetscBool left,BV *split)
1896: {
1897: PetscInt ncols;
1899: PetscFunctionBegin;
1900: ncols = left? bv->nc+bv->l: bv->m-bv->l;
1901: if (*split && (ncols!=(*split)->m || bv->N!=(*split)->N)) PetscCall(BVDestroy(split));
1902: if (!*split) {
1903: PetscCall(BVCreate(PetscObjectComm((PetscObject)bv),split));
1904: (*split)->issplit = left? 1: 2;
1905: (*split)->splitparent = bv;
1906: (*split)->N = bv->N;
1907: (*split)->n = bv->n;
1908: (*split)->m = bv->m;
1909: (*split)->k = bv->m;
1910: PetscCall(BVDuplicate_Private(bv,*split));
1911: }
1912: (*split)->l = 0;
1913: (*split)->k = left? bv->l: bv->k-bv->l;
1914: (*split)->nc = left? bv->nc: 0;
1915: (*split)->m = ncols-(*split)->nc;
1916: if ((*split)->nc) {
1917: (*split)->ci[0] = -(*split)->nc-1;
1918: (*split)->ci[1] = -(*split)->nc-1;
1919: }
1920: if (left) PetscCall(PetscObjectStateGet((PetscObject)*split,&bv->lstate));
1921: else PetscCall(PetscObjectStateGet((PetscObject)*split,&bv->rstate));
1922: PetscFunctionReturn(PETSC_SUCCESS);
1923: }
1925: /*@
1926: BVGetSplit - Splits the BV object into two BV objects that share the
1927: internal data, one of them containing the leading columns and the other
1928: one containing the remaining columns.
1930: Collective
1932: Input Parameter:
1933: . bv - the basis vectors context
1935: Output Parameters:
1936: + L - left BV containing leading columns (can be NULL)
1937: - R - right BV containing remaining columns (can be NULL)
1939: Notes:
1940: The columns are split in two sets. The leading columns (including the
1941: constraints) are assigned to the left BV and the remaining columns
1942: are assigned to the right BV. The number of leading columns, as
1943: specified with BVSetActiveColumns(), must be between 1 and m-1 (to
1944: guarantee that both L and R have at least one column).
1946: The returned BV's must be seen as references (not copies) of the input
1947: BV, that is, modifying them will change the entries of bv as well.
1948: The returned BV's must not be destroyed. BVRestoreSplit() must be called
1949: when they are no longer needed.
1951: Pass NULL for any of the output BV's that is not needed.
1953: Level: advanced
1955: .seealso: BVRestoreSplit(), BVSetActiveColumns(), BVSetNumConstraints(), BVGetSplitRows()
1956: @*/
1957: PetscErrorCode BVGetSplit(BV bv,BV *L,BV *R)
1958: {
1959: PetscFunctionBegin;
1962: BVCheckSizes(bv,1);
1963: PetscCheck(bv->l,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Must indicate the number of leading columns with BVSetActiveColumns()");
1964: PetscCheck(bv->lsplit>=0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Cannot call BVGetSplit() after BVGetSplitRows()");
1965: PetscCheck(!bv->lsplit,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Cannot get the split BV's twice before restoring them with BVRestoreSplit()");
1966: bv->lsplit = bv->nc+bv->l;
1967: PetscCall(BVGetSplit_Private(bv,PETSC_TRUE,&bv->L));
1968: PetscCall(BVGetSplit_Private(bv,PETSC_FALSE,&bv->R));
1969: if (L) *L = bv->L;
1970: if (R) *R = bv->R;
1971: PetscFunctionReturn(PETSC_SUCCESS);
1972: }
1974: /*@
1975: BVRestoreSplit - Restore the BV objects obtained with BVGetSplit().
1977: Logically Collective
1979: Input Parameters:
1980: + bv - the basis vectors context
1981: . L - left BV obtained with BVGetSplit()
1982: - R - right BV obtained with BVGetSplit()
1984: Note:
1985: The arguments must match the corresponding call to BVGetSplit().
1987: Level: advanced
1989: .seealso: BVGetSplit()
1990: @*/
1991: PetscErrorCode BVRestoreSplit(BV bv,BV *L,BV *R)
1992: {
1993: PetscFunctionBegin;
1996: BVCheckSizes(bv,1);
1997: PetscCheck(bv->lsplit>0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Must call BVGetSplit first");
1998: PetscCheck(!L || *L==bv->L,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Argument 2 is not the same BV that was obtained with BVGetSplit");
1999: PetscCheck(!R || *R==bv->R,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Argument 3 is not the same BV that was obtained with BVGetSplit");
2000: PetscCheck(!L || ((*L)->ci[0]<=(*L)->nc-1 && (*L)->ci[1]<=(*L)->nc-1),PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Argument 2 has unrestored columns, use BVRestoreColumn()");
2001: PetscCheck(!R || ((*R)->ci[0]<=(*R)->nc-1 && (*R)->ci[1]<=(*R)->nc-1),PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Argument 3 has unrestored columns, use BVRestoreColumn()");
2003: PetscTryTypeMethod(bv,restoresplit,L,R);
2004: bv->lsplit = 0;
2005: if (L) *L = NULL;
2006: if (R) *R = NULL;
2007: PetscFunctionReturn(PETSC_SUCCESS);
2008: }
2010: /*
2011: Copy all user-provided attributes of V to another BV object W with different layout
2012: */
2013: static inline PetscErrorCode BVDuplicateNewLayout_Private(BV V,BV W)
2014: {
2015: PetscFunctionBegin;
2016: PetscCall(PetscLayoutCreateFromSizes(PetscObjectComm((PetscObject)V),W->n,W->N,1,&W->map));
2017: PetscCall(BVSetVecType(W,V->vtype));
2018: W->ld = V->ld;
2019: PetscCall(BVSetType(W,((PetscObject)V)->type_name));
2020: W->orthog_type = V->orthog_type;
2021: W->orthog_ref = V->orthog_ref;
2022: W->orthog_eta = V->orthog_eta;
2023: W->orthog_block = V->orthog_block;
2024: W->vmm = V->vmm;
2025: W->rrandom = V->rrandom;
2026: W->deftol = V->deftol;
2027: if (V->rand) PetscCall(PetscObjectReference((PetscObject)V->rand));
2028: W->rand = V->rand;
2029: W->sfocalled = V->sfocalled;
2030: PetscTryTypeMethod(V,duplicate,W);
2031: PetscCall(PetscObjectStateIncrease((PetscObject)W));
2032: PetscFunctionReturn(PETSC_SUCCESS);
2033: }
2035: static PetscErrorCode BVGetSplitRows_Private(BV bv,PetscBool top,IS is,BV *split)
2036: {
2037: PetscInt rstart,rend,lstart;
2038: PetscInt N,n;
2039: PetscBool contig;
2041: PetscFunctionBegin;
2042: PetscCall(PetscLayoutGetRange(bv->map,&rstart,&rend));
2043: PetscCall(ISContiguousLocal(is,rstart,rend,&lstart,&contig));
2044: PetscCheck(contig,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"%s index set is not contiguous",(top==PETSC_TRUE)?"Upper":"Lower");
2045: if (top) PetscCheck(lstart==0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONG,"Upper index set should start at first local row");
2046: else bv->lsplit = -lstart;
2047: PetscCall(ISGetSize(is,&N));
2048: PetscCall(ISGetLocalSize(is,&n));
2049: if (*split && (bv->m!=(*split)->m || N!=(*split)->N)) PetscCall(BVDestroy(split));
2050: if (!*split) {
2051: PetscCall(BVCreate(PetscObjectComm((PetscObject)bv),split));
2052: (*split)->issplit = top? -1: -2;
2053: (*split)->splitparent = bv;
2054: (*split)->N = N;
2055: (*split)->n = n;
2056: (*split)->m = bv->m;
2057: PetscCall(BVDuplicateNewLayout_Private(bv,*split));
2058: }
2059: (*split)->k = bv->k;
2060: (*split)->l = bv->l;
2061: (*split)->nc = bv->nc;
2062: if ((*split)->nc) {
2063: (*split)->ci[0] = -(*split)->nc-1;
2064: (*split)->ci[1] = -(*split)->nc-1;
2065: }
2066: if (top) PetscCall(PetscObjectStateGet((PetscObject)*split,&bv->rstate));
2067: else PetscCall(PetscObjectStateGet((PetscObject)*split,&bv->lstate));
2068: PetscFunctionReturn(PETSC_SUCCESS);
2069: }
2071: /*@
2072: BVGetSplitRows - Splits the BV object into two BV objects that share the
2073: internal data, using a disjoint horizontal splitting.
2075: Collective
2077: Input Parameters:
2078: + bv - the basis vectors context
2079: . isup - the index set that defines the upper part of the horizontal splitting
2080: - islo - the index set that defines the lower part of the horizontal splitting
2082: Output Parameters:
2083: + U - the resulting BV containing the upper rows
2084: - L - the resulting BV containing the lower rows
2086: Notes:
2087: The index sets must be such that every MPI process can extract the selected
2088: rows from its local part of the input BV, and this part must be contiguous.
2089: With one process, isup will list contiguous indices starting from 0, and islo
2090: will contain the remaining indices, hence we refer to upper and lower part.
2091: However, with several processes the indices will be interleaved because
2092: isup will refer to the upper part of the local array.
2094: The intended use of this function is with matrices of MATNEST type, where
2095: MatNestGetISs() will return the appropriate index sets.
2097: The returned BV's must be seen as references (not copies) of the input
2098: BV, that is, modifying them will change the entries of bv as well.
2099: The returned BV's must not be destroyed. BVRestoreSplitRows() must be called
2100: when they are no longer needed.
2102: Pass NULL for any of the output BV's that is not needed.
2104: Level: advanced
2106: .seealso: BVRestoreSplitRows(), BVGetSplit()
2107: @*/
2108: PetscErrorCode BVGetSplitRows(BV bv,IS isup,IS islo,BV *U,BV *L)
2109: {
2110: PetscFunctionBegin;
2113: BVCheckSizes(bv,1);
2116: PetscCheck(bv->lsplit<=0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Cannot call BVGetSplitRows() after BVGetSplit()");
2117: PetscCheck(!bv->lsplit,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Cannot get the split BV's twice before restoring them with BVRestoreSplitRows()");
2118: if (U) {
2119: PetscCall(BVGetSplitRows_Private(bv,PETSC_TRUE,isup,&bv->R));
2120: *U = bv->R;
2121: }
2122: if (L) {
2123: PetscCall(BVGetSplitRows_Private(bv,PETSC_FALSE,islo,&bv->L));
2124: *L = bv->L;
2125: }
2126: PetscFunctionReturn(PETSC_SUCCESS);
2127: }
2129: /*@
2130: BVRestoreSplitRows - Restore the BV objects obtained with BVGetSplitRows().
2132: Logically Collective
2134: Input Parameters:
2135: + bv - the basis vectors context
2136: . isup - the index set that defines the upper part of the horizontal splitting
2137: . islo - the index set that defines the lower part of the horizontal splitting
2138: . U - the BV containing the upper rows
2139: - L - the BV containing the lower rows
2141: Note:
2142: The arguments must match the corresponding call to BVGetSplitRows().
2144: Level: advanced
2146: .seealso: BVGetSplitRows()
2147: @*/
2148: PetscErrorCode BVRestoreSplitRows(BV bv,IS isup,IS islo,BV *U,BV *L)
2149: {
2150: PetscFunctionBegin;
2153: BVCheckSizes(bv,1);
2154: PetscCheck(bv->lsplit<0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"Must call BVGetSplitRows first");
2155: PetscCheck(!U || ((*U)->ci[0]<=(*U)->nc-1 && (*U)->ci[1]<=(*U)->nc-1),PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"The upper BV has unrestored columns, use BVRestoreColumn()");
2156: PetscCheck(!L || ((*L)->ci[0]<=(*L)->nc-1 && (*L)->ci[1]<=(*L)->nc-1),PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_WRONGSTATE,"The lower BV has unrestored columns, use BVRestoreColumn()");
2157: PetscTryTypeMethod(bv,restoresplitrows,isup,islo,U,L);
2158: bv->lsplit = 0;
2159: PetscFunctionReturn(PETSC_SUCCESS);
2160: }
2162: /*@
2163: BVSetDefiniteTolerance - Set the tolerance to be used when checking a
2164: definite inner product.
2166: Logically Collective
2168: Input Parameters:
2169: + bv - basis vectors
2170: - deftol - the tolerance
2172: Options Database Key:
2173: . -bv_definite_tol <deftol> - the tolerance
2175: Notes:
2176: When using a non-standard inner product, see BVSetMatrix(), the solver needs
2177: to compute sqrt(z'*B*z) for various vectors z. If the inner product has not
2178: been declared indefinite, the value z'*B*z must be positive, but due to
2179: rounding error a tiny value may become negative. A tolerance is used to
2180: detect this situation. Likewise, in complex arithmetic z'*B*z should be
2181: real, and we use the same tolerance to check whether a nonzero imaginary part
2182: can be considered negligible.
2184: This function sets this tolerance, which defaults to 10*eps, where eps is
2185: the machine epsilon. The default value should be good for most applications.
2187: Level: advanced
2189: .seealso: BVSetMatrix()
2190: @*/
2191: PetscErrorCode BVSetDefiniteTolerance(BV bv,PetscReal deftol)
2192: {
2193: PetscFunctionBegin;
2196: if (deftol == (PetscReal)PETSC_DEFAULT || deftol == (PetscReal)PETSC_DECIDE) bv->deftol = 10*PETSC_MACHINE_EPSILON;
2197: else {
2198: PetscCheck(deftol>0.0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of deftol. Must be > 0");
2199: bv->deftol = deftol;
2200: }
2201: PetscFunctionReturn(PETSC_SUCCESS);
2202: }
2204: /*@
2205: BVGetDefiniteTolerance - Returns the tolerance for checking a definite
2206: inner product.
2208: Not Collective
2210: Input Parameter:
2211: . bv - the basis vectors
2213: Output Parameter:
2214: . deftol - the tolerance
2216: Level: advanced
2218: .seealso: BVSetDefiniteTolerance()
2219: @*/
2220: PetscErrorCode BVGetDefiniteTolerance(BV bv,PetscReal *deftol)
2221: {
2222: PetscFunctionBegin;
2224: PetscAssertPointer(deftol,2);
2225: *deftol = bv->deftol;
2226: PetscFunctionReturn(PETSC_SUCCESS);
2227: }
2229: /*@
2230: BVSetLeadingDimension - Set the leading dimension to be used for storing the BV data.
2232: Not Collective
2234: Input Parameters:
2235: + bv - basis vectors
2236: - ld - the leading dimension
2238: Notes:
2239: This parameter is relevant for BVMAT, though it might be employed in other types
2240: as well.
2242: When the internal data of the BV is stored as a dense matrix, the leading dimension
2243: has the same meaning as in MatDenseSetLDA(), i.e., the distance in number of
2244: elements from one entry of the matrix to the one in the next column at the same
2245: row. The leading dimension refers to the local array, and hence can be different
2246: in different processes.
2248: The user does not need to change this parameter. The default value is equal to the
2249: number of local rows, but this value may be increased a little to guarantee alignment
2250: (especially in the case of GPU storage).
2252: Level: advanced
2254: .seealso: BVGetLeadingDimension()
2255: @*/
2256: PetscErrorCode BVSetLeadingDimension(BV bv,PetscInt ld)
2257: {
2258: PetscFunctionBegin;
2261: PetscCheck((bv->n<0 && bv->N<0) || !bv->ops->create,PetscObjectComm((PetscObject)bv),PETSC_ERR_ORDER,"Must call BVSetLeadingDimension() before setting the BV type and sizes");
2262: if (ld == PETSC_DEFAULT || ld == PETSC_DECIDE) bv->ld = 0;
2263: else {
2264: PetscCheck(ld>0,PetscObjectComm((PetscObject)bv),PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of ld. Must be > 0");
2265: bv->ld = ld;
2266: }
2267: PetscFunctionReturn(PETSC_SUCCESS);
2268: }
2270: /*@
2271: BVGetLeadingDimension - Returns the leading dimension of the BV.
2273: Not Collective
2275: Input Parameter:
2276: . bv - the basis vectors
2278: Output Parameter:
2279: . ld - the leading dimension
2281: Level: advanced
2283: Notes:
2284: The returned value may be different in different processes.
2286: The leading dimension must be used when accessing the internal array via
2287: BVGetArray() or BVGetArrayRead().
2289: .seealso: BVSetLeadingDimension(), BVGetArray(), BVGetArrayRead()
2290: @*/
2291: PetscErrorCode BVGetLeadingDimension(BV bv,PetscInt *ld)
2292: {
2293: PetscFunctionBegin;
2295: PetscAssertPointer(ld,2);
2296: *ld = bv->ld;
2297: PetscFunctionReturn(PETSC_SUCCESS);
2298: }