Line data Source code
1 : /*
2 : - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
3 : SLEPc - Scalable Library for Eigenvalue Problem Computations
4 : Copyright (c) 2002-, Universitat Politecnica de Valencia, Spain
5 :
6 : This file is part of SLEPc.
7 : SLEPc is distributed under a 2-clause BSD license (see LICENSE).
8 : - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
9 : */
10 : /*
11 : Basic PEP routines
12 : */
13 :
14 : #include <slepc/private/pepimpl.h> /*I "slepcpep.h" I*/
15 :
16 : /* Logging support */
17 : PetscClassId PEP_CLASSID = 0;
18 : PetscLogEvent PEP_SetUp = 0,PEP_Solve = 0,PEP_Refine = 0,PEP_CISS_SVD = 0;
19 :
20 : /* List of registered PEP routines */
21 : PetscFunctionList PEPList = NULL;
22 : PetscBool PEPRegisterAllCalled = PETSC_FALSE;
23 :
24 : /* List of registered PEP monitors */
25 : PetscFunctionList PEPMonitorList = NULL;
26 : PetscFunctionList PEPMonitorCreateList = NULL;
27 : PetscFunctionList PEPMonitorDestroyList = NULL;
28 : PetscBool PEPMonitorRegisterAllCalled = PETSC_FALSE;
29 :
30 : /*@
31 : PEPCreate - Creates the default PEP context.
32 :
33 : Collective
34 :
35 : Input Parameter:
36 : . comm - MPI communicator
37 :
38 : Output Parameter:
39 : . outpep - location to put the PEP context
40 :
41 : Note:
42 : The default PEP type is PEPTOAR
43 :
44 : Level: beginner
45 :
46 : .seealso: PEPSetUp(), PEPSolve(), PEPDestroy(), PEP
47 : @*/
48 166 : PetscErrorCode PEPCreate(MPI_Comm comm,PEP *outpep)
49 : {
50 166 : PEP pep;
51 :
52 166 : PetscFunctionBegin;
53 166 : PetscAssertPointer(outpep,2);
54 166 : *outpep = NULL;
55 166 : PetscCall(PEPInitializePackage());
56 166 : PetscCall(SlepcHeaderCreate(pep,PEP_CLASSID,"PEP","Polynomial Eigenvalue Problem","PEP",comm,PEPDestroy,PEPView));
57 :
58 166 : pep->max_it = PETSC_DEFAULT;
59 166 : pep->nev = 1;
60 166 : pep->ncv = PETSC_DEFAULT;
61 166 : pep->mpd = PETSC_DEFAULT;
62 166 : pep->nini = 0;
63 166 : pep->target = 0.0;
64 166 : pep->tol = PETSC_DEFAULT;
65 166 : pep->conv = PEP_CONV_REL;
66 166 : pep->stop = PEP_STOP_BASIC;
67 166 : pep->which = (PEPWhich)0;
68 166 : pep->basis = PEP_BASIS_MONOMIAL;
69 166 : pep->problem_type = (PEPProblemType)0;
70 166 : pep->scale = PEP_SCALE_NONE;
71 166 : pep->sfactor = 1.0;
72 166 : pep->dsfactor = 1.0;
73 166 : pep->sits = 5;
74 166 : pep->slambda = 1.0;
75 166 : pep->refine = PEP_REFINE_NONE;
76 166 : pep->npart = 1;
77 166 : pep->rtol = PETSC_DEFAULT;
78 166 : pep->rits = PETSC_DEFAULT;
79 166 : pep->scheme = (PEPRefineScheme)0;
80 166 : pep->extract = (PEPExtract)0;
81 166 : pep->trackall = PETSC_FALSE;
82 :
83 166 : pep->converged = PEPConvergedRelative;
84 166 : pep->convergeduser = NULL;
85 166 : pep->convergeddestroy= NULL;
86 166 : pep->stopping = PEPStoppingBasic;
87 166 : pep->stoppinguser = NULL;
88 166 : pep->stoppingdestroy = NULL;
89 166 : pep->convergedctx = NULL;
90 166 : pep->stoppingctx = NULL;
91 166 : pep->numbermonitors = 0;
92 :
93 166 : pep->st = NULL;
94 166 : pep->ds = NULL;
95 166 : pep->V = NULL;
96 166 : pep->rg = NULL;
97 166 : pep->A = NULL;
98 166 : pep->nmat = 0;
99 166 : pep->Dl = NULL;
100 166 : pep->Dr = NULL;
101 166 : pep->IS = NULL;
102 166 : pep->eigr = NULL;
103 166 : pep->eigi = NULL;
104 166 : pep->errest = NULL;
105 166 : pep->perm = NULL;
106 166 : pep->pbc = NULL;
107 166 : pep->solvematcoeffs = NULL;
108 166 : pep->nwork = 0;
109 166 : pep->work = NULL;
110 166 : pep->refineksp = NULL;
111 166 : pep->refinesubc = NULL;
112 166 : pep->data = NULL;
113 :
114 166 : pep->state = PEP_STATE_INITIAL;
115 166 : pep->nconv = 0;
116 166 : pep->its = 0;
117 166 : pep->n = 0;
118 166 : pep->nloc = 0;
119 166 : pep->nrma = NULL;
120 166 : pep->sfactor_set = PETSC_FALSE;
121 166 : pep->lineariz = PETSC_FALSE;
122 166 : pep->reason = PEP_CONVERGED_ITERATING;
123 :
124 166 : PetscCall(PetscNew(&pep->sc));
125 166 : *outpep = pep;
126 166 : PetscFunctionReturn(PETSC_SUCCESS);
127 : }
128 :
129 : /*@C
130 : PEPSetType - Selects the particular solver to be used in the PEP object.
131 :
132 : Logically Collective
133 :
134 : Input Parameters:
135 : + pep - the polynomial eigensolver context
136 : - type - a known method
137 :
138 : Options Database Key:
139 : . -pep_type <method> - Sets the method; use -help for a list
140 : of available methods
141 :
142 : Notes:
143 : See "slepc/include/slepcpep.h" for available methods. The default
144 : is PEPTOAR.
145 :
146 : Normally, it is best to use the PEPSetFromOptions() command and
147 : then set the PEP type from the options database rather than by using
148 : this routine. Using the options database provides the user with
149 : maximum flexibility in evaluating the different available methods.
150 : The PEPSetType() routine is provided for those situations where it
151 : is necessary to set the iterative solver independently of the command
152 : line or options database.
153 :
154 : Level: intermediate
155 :
156 : .seealso: PEPType
157 : @*/
158 166 : PetscErrorCode PEPSetType(PEP pep,PEPType type)
159 : {
160 166 : PetscErrorCode (*r)(PEP);
161 166 : PetscBool match;
162 :
163 166 : PetscFunctionBegin;
164 166 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
165 166 : PetscAssertPointer(type,2);
166 :
167 166 : PetscCall(PetscObjectTypeCompare((PetscObject)pep,type,&match));
168 166 : if (match) PetscFunctionReturn(PETSC_SUCCESS);
169 :
170 166 : PetscCall(PetscFunctionListFind(PEPList,type,&r));
171 166 : PetscCheck(r,PetscObjectComm((PetscObject)pep),PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown PEP type given: %s",type);
172 :
173 166 : PetscTryTypeMethod(pep,destroy);
174 166 : PetscCall(PetscMemzero(pep->ops,sizeof(struct _PEPOps)));
175 :
176 166 : pep->state = PEP_STATE_INITIAL;
177 166 : PetscCall(PetscObjectChangeTypeName((PetscObject)pep,type));
178 166 : PetscCall((*r)(pep));
179 166 : PetscFunctionReturn(PETSC_SUCCESS);
180 : }
181 :
182 : /*@C
183 : PEPGetType - Gets the PEP type as a string from the PEP object.
184 :
185 : Not Collective
186 :
187 : Input Parameter:
188 : . pep - the eigensolver context
189 :
190 : Output Parameter:
191 : . type - name of PEP method
192 :
193 : Level: intermediate
194 :
195 : .seealso: PEPSetType()
196 : @*/
197 6 : PetscErrorCode PEPGetType(PEP pep,PEPType *type)
198 : {
199 6 : PetscFunctionBegin;
200 6 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
201 6 : PetscAssertPointer(type,2);
202 6 : *type = ((PetscObject)pep)->type_name;
203 6 : PetscFunctionReturn(PETSC_SUCCESS);
204 : }
205 :
206 : /*@C
207 : PEPRegister - Adds a method to the polynomial eigenproblem solver package.
208 :
209 : Not Collective
210 :
211 : Input Parameters:
212 : + name - name of a new user-defined solver
213 : - function - routine to create the solver context
214 :
215 : Notes:
216 : PEPRegister() may be called multiple times to add several user-defined solvers.
217 :
218 : Example Usage:
219 : .vb
220 : PEPRegister("my_solver",MySolverCreate);
221 : .ve
222 :
223 : Then, your solver can be chosen with the procedural interface via
224 : $ PEPSetType(pep,"my_solver")
225 : or at runtime via the option
226 : $ -pep_type my_solver
227 :
228 : Level: advanced
229 :
230 : .seealso: PEPRegisterAll()
231 : @*/
232 815 : PetscErrorCode PEPRegister(const char *name,PetscErrorCode (*function)(PEP))
233 : {
234 815 : PetscFunctionBegin;
235 815 : PetscCall(PEPInitializePackage());
236 815 : PetscCall(PetscFunctionListAdd(&PEPList,name,function));
237 815 : PetscFunctionReturn(PETSC_SUCCESS);
238 : }
239 :
240 : /*@C
241 : PEPMonitorRegister - Adds PEP monitor routine.
242 :
243 : Not Collective
244 :
245 : Input Parameters:
246 : + name - name of a new monitor routine
247 : . vtype - a PetscViewerType for the output
248 : . format - a PetscViewerFormat for the output
249 : . monitor - monitor routine
250 : . create - creation routine, or NULL
251 : - destroy - destruction routine, or NULL
252 :
253 : Notes:
254 : PEPMonitorRegister() may be called multiple times to add several user-defined monitors.
255 :
256 : Example Usage:
257 : .vb
258 : PEPMonitorRegister("my_monitor",PETSCVIEWERASCII,PETSC_VIEWER_ASCII_INFO_DETAIL,MyMonitor,NULL,NULL);
259 : .ve
260 :
261 : Then, your monitor can be chosen with the procedural interface via
262 : $ PEPMonitorSetFromOptions(pep,"-pep_monitor_my_monitor","my_monitor",NULL)
263 : or at runtime via the option
264 : $ -pep_monitor_my_monitor
265 :
266 : Level: advanced
267 :
268 : .seealso: PEPMonitorRegisterAll()
269 : @*/
270 978 : PetscErrorCode PEPMonitorRegister(const char name[],PetscViewerType vtype,PetscViewerFormat format,PetscErrorCode (*monitor)(PEP,PetscInt,PetscInt,PetscScalar*,PetscScalar*,PetscReal*,PetscInt,PetscViewerAndFormat*),PetscErrorCode (*create)(PetscViewer,PetscViewerFormat,void*,PetscViewerAndFormat**),PetscErrorCode (*destroy)(PetscViewerAndFormat**))
271 : {
272 978 : char key[PETSC_MAX_PATH_LEN];
273 :
274 978 : PetscFunctionBegin;
275 978 : PetscCall(PEPInitializePackage());
276 978 : PetscCall(SlepcMonitorMakeKey_Internal(name,vtype,format,key));
277 978 : PetscCall(PetscFunctionListAdd(&PEPMonitorList,key,monitor));
278 978 : if (create) PetscCall(PetscFunctionListAdd(&PEPMonitorCreateList,key,create));
279 978 : if (destroy) PetscCall(PetscFunctionListAdd(&PEPMonitorDestroyList,key,destroy));
280 978 : PetscFunctionReturn(PETSC_SUCCESS);
281 : }
282 :
283 : /*@
284 : PEPReset - Resets the PEP context to the initial state (prior to setup)
285 : and destroys any allocated Vecs and Mats.
286 :
287 : Collective
288 :
289 : Input Parameter:
290 : . pep - eigensolver context obtained from PEPCreate()
291 :
292 : Level: advanced
293 :
294 : .seealso: PEPDestroy()
295 : @*/
296 193 : PetscErrorCode PEPReset(PEP pep)
297 : {
298 193 : PetscFunctionBegin;
299 193 : if (pep) PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
300 193 : if (!pep) PetscFunctionReturn(PETSC_SUCCESS);
301 193 : PetscTryTypeMethod(pep,reset);
302 193 : if (pep->st) PetscCall(STReset(pep->st));
303 193 : if (pep->refineksp) PetscCall(KSPReset(pep->refineksp));
304 193 : if (pep->nmat) {
305 173 : PetscCall(MatDestroyMatrices(pep->nmat,&pep->A));
306 173 : PetscCall(PetscFree2(pep->pbc,pep->nrma));
307 173 : PetscCall(PetscFree(pep->solvematcoeffs));
308 173 : pep->nmat = 0;
309 : }
310 193 : PetscCall(VecDestroy(&pep->Dl));
311 193 : PetscCall(VecDestroy(&pep->Dr));
312 193 : PetscCall(BVDestroy(&pep->V));
313 193 : PetscCall(VecDestroyVecs(pep->nwork,&pep->work));
314 193 : pep->nwork = 0;
315 193 : pep->state = PEP_STATE_INITIAL;
316 193 : PetscFunctionReturn(PETSC_SUCCESS);
317 : }
318 :
319 : /*@C
320 : PEPDestroy - Destroys the PEP context.
321 :
322 : Collective
323 :
324 : Input Parameter:
325 : . pep - eigensolver context obtained from PEPCreate()
326 :
327 : Level: beginner
328 :
329 : .seealso: PEPCreate(), PEPSetUp(), PEPSolve()
330 : @*/
331 168 : PetscErrorCode PEPDestroy(PEP *pep)
332 : {
333 168 : PetscFunctionBegin;
334 168 : if (!*pep) PetscFunctionReturn(PETSC_SUCCESS);
335 167 : PetscValidHeaderSpecific(*pep,PEP_CLASSID,1);
336 167 : if (--((PetscObject)*pep)->refct > 0) { *pep = NULL; PetscFunctionReturn(PETSC_SUCCESS); }
337 166 : PetscCall(PEPReset(*pep));
338 166 : PetscTryTypeMethod(*pep,destroy);
339 166 : if ((*pep)->eigr) PetscCall(PetscFree4((*pep)->eigr,(*pep)->eigi,(*pep)->errest,(*pep)->perm));
340 166 : PetscCall(STDestroy(&(*pep)->st));
341 166 : PetscCall(RGDestroy(&(*pep)->rg));
342 166 : PetscCall(DSDestroy(&(*pep)->ds));
343 166 : PetscCall(KSPDestroy(&(*pep)->refineksp));
344 166 : PetscCall(PetscSubcommDestroy(&(*pep)->refinesubc));
345 166 : PetscCall(PetscFree((*pep)->sc));
346 : /* just in case the initial vectors have not been used */
347 166 : PetscCall(SlepcBasisDestroy_Private(&(*pep)->nini,&(*pep)->IS));
348 166 : if ((*pep)->convergeddestroy) PetscCall((*(*pep)->convergeddestroy)((*pep)->convergedctx));
349 166 : PetscCall(PEPMonitorCancel(*pep));
350 166 : PetscCall(PetscHeaderDestroy(pep));
351 166 : PetscFunctionReturn(PETSC_SUCCESS);
352 : }
353 :
354 : /*@
355 : PEPSetBV - Associates a basis vectors object to the polynomial eigensolver.
356 :
357 : Collective
358 :
359 : Input Parameters:
360 : + pep - eigensolver context obtained from PEPCreate()
361 : - bv - the basis vectors object
362 :
363 : Note:
364 : Use PEPGetBV() to retrieve the basis vectors context (for example,
365 : to free it at the end of the computations).
366 :
367 : Level: advanced
368 :
369 : .seealso: PEPGetBV()
370 : @*/
371 0 : PetscErrorCode PEPSetBV(PEP pep,BV bv)
372 : {
373 0 : PetscFunctionBegin;
374 0 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
375 0 : PetscValidHeaderSpecific(bv,BV_CLASSID,2);
376 0 : PetscCheckSameComm(pep,1,bv,2);
377 0 : PetscCall(PetscObjectReference((PetscObject)bv));
378 0 : PetscCall(BVDestroy(&pep->V));
379 0 : pep->V = bv;
380 0 : PetscFunctionReturn(PETSC_SUCCESS);
381 : }
382 :
383 : /*@
384 : PEPGetBV - Obtain the basis vectors object associated to the polynomial
385 : eigensolver object.
386 :
387 : Not Collective
388 :
389 : Input Parameters:
390 : . pep - eigensolver context obtained from PEPCreate()
391 :
392 : Output Parameter:
393 : . bv - basis vectors context
394 :
395 : Level: advanced
396 :
397 : .seealso: PEPSetBV()
398 : @*/
399 175 : PetscErrorCode PEPGetBV(PEP pep,BV *bv)
400 : {
401 175 : PetscFunctionBegin;
402 175 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
403 175 : PetscAssertPointer(bv,2);
404 175 : if (!pep->V) {
405 173 : PetscCall(BVCreate(PetscObjectComm((PetscObject)pep),&pep->V));
406 173 : PetscCall(PetscObjectIncrementTabLevel((PetscObject)pep->V,(PetscObject)pep,0));
407 173 : PetscCall(PetscObjectSetOptions((PetscObject)pep->V,((PetscObject)pep)->options));
408 : }
409 175 : *bv = pep->V;
410 175 : PetscFunctionReturn(PETSC_SUCCESS);
411 : }
412 :
413 : /*@
414 : PEPSetRG - Associates a region object to the polynomial eigensolver.
415 :
416 : Collective
417 :
418 : Input Parameters:
419 : + pep - eigensolver context obtained from PEPCreate()
420 : - rg - the region object
421 :
422 : Note:
423 : Use PEPGetRG() to retrieve the region context (for example,
424 : to free it at the end of the computations).
425 :
426 : Level: advanced
427 :
428 : .seealso: PEPGetRG()
429 : @*/
430 3 : PetscErrorCode PEPSetRG(PEP pep,RG rg)
431 : {
432 3 : PetscFunctionBegin;
433 3 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
434 3 : if (rg) {
435 3 : PetscValidHeaderSpecific(rg,RG_CLASSID,2);
436 3 : PetscCheckSameComm(pep,1,rg,2);
437 : }
438 3 : PetscCall(PetscObjectReference((PetscObject)rg));
439 3 : PetscCall(RGDestroy(&pep->rg));
440 3 : pep->rg = rg;
441 3 : PetscFunctionReturn(PETSC_SUCCESS);
442 : }
443 :
444 : /*@
445 : PEPGetRG - Obtain the region object associated to the
446 : polynomial eigensolver object.
447 :
448 : Not Collective
449 :
450 : Input Parameters:
451 : . pep - eigensolver context obtained from PEPCreate()
452 :
453 : Output Parameter:
454 : . rg - region context
455 :
456 : Level: advanced
457 :
458 : .seealso: PEPSetRG()
459 : @*/
460 190 : PetscErrorCode PEPGetRG(PEP pep,RG *rg)
461 : {
462 190 : PetscFunctionBegin;
463 190 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
464 190 : PetscAssertPointer(rg,2);
465 190 : if (!pep->rg) {
466 163 : PetscCall(RGCreate(PetscObjectComm((PetscObject)pep),&pep->rg));
467 163 : PetscCall(PetscObjectIncrementTabLevel((PetscObject)pep->rg,(PetscObject)pep,0));
468 163 : PetscCall(PetscObjectSetOptions((PetscObject)pep->rg,((PetscObject)pep)->options));
469 : }
470 190 : *rg = pep->rg;
471 190 : PetscFunctionReturn(PETSC_SUCCESS);
472 : }
473 :
474 : /*@
475 : PEPSetDS - Associates a direct solver object to the polynomial eigensolver.
476 :
477 : Collective
478 :
479 : Input Parameters:
480 : + pep - eigensolver context obtained from PEPCreate()
481 : - ds - the direct solver object
482 :
483 : Note:
484 : Use PEPGetDS() to retrieve the direct solver context (for example,
485 : to free it at the end of the computations).
486 :
487 : Level: advanced
488 :
489 : .seealso: PEPGetDS()
490 : @*/
491 0 : PetscErrorCode PEPSetDS(PEP pep,DS ds)
492 : {
493 0 : PetscFunctionBegin;
494 0 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
495 0 : PetscValidHeaderSpecific(ds,DS_CLASSID,2);
496 0 : PetscCheckSameComm(pep,1,ds,2);
497 0 : PetscCall(PetscObjectReference((PetscObject)ds));
498 0 : PetscCall(DSDestroy(&pep->ds));
499 0 : pep->ds = ds;
500 0 : PetscFunctionReturn(PETSC_SUCCESS);
501 : }
502 :
503 : /*@
504 : PEPGetDS - Obtain the direct solver object associated to the
505 : polynomial eigensolver object.
506 :
507 : Not Collective
508 :
509 : Input Parameters:
510 : . pep - eigensolver context obtained from PEPCreate()
511 :
512 : Output Parameter:
513 : . ds - direct solver context
514 :
515 : Level: advanced
516 :
517 : .seealso: PEPSetDS()
518 : @*/
519 166 : PetscErrorCode PEPGetDS(PEP pep,DS *ds)
520 : {
521 166 : PetscFunctionBegin;
522 166 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
523 166 : PetscAssertPointer(ds,2);
524 166 : if (!pep->ds) {
525 166 : PetscCall(DSCreate(PetscObjectComm((PetscObject)pep),&pep->ds));
526 166 : PetscCall(PetscObjectIncrementTabLevel((PetscObject)pep->ds,(PetscObject)pep,0));
527 166 : PetscCall(PetscObjectSetOptions((PetscObject)pep->ds,((PetscObject)pep)->options));
528 : }
529 166 : *ds = pep->ds;
530 166 : PetscFunctionReturn(PETSC_SUCCESS);
531 : }
532 :
533 : /*@
534 : PEPSetST - Associates a spectral transformation object to the eigensolver.
535 :
536 : Collective
537 :
538 : Input Parameters:
539 : + pep - eigensolver context obtained from PEPCreate()
540 : - st - the spectral transformation object
541 :
542 : Note:
543 : Use PEPGetST() to retrieve the spectral transformation context (for example,
544 : to free it at the end of the computations).
545 :
546 : Level: advanced
547 :
548 : .seealso: PEPGetST()
549 : @*/
550 1 : PetscErrorCode PEPSetST(PEP pep,ST st)
551 : {
552 1 : PetscFunctionBegin;
553 1 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
554 1 : PetscValidHeaderSpecific(st,ST_CLASSID,2);
555 1 : PetscCheckSameComm(pep,1,st,2);
556 1 : PetscCall(PetscObjectReference((PetscObject)st));
557 1 : PetscCall(STDestroy(&pep->st));
558 1 : pep->st = st;
559 1 : PetscFunctionReturn(PETSC_SUCCESS);
560 : }
561 :
562 : /*@
563 : PEPGetST - Obtain the spectral transformation (ST) object associated
564 : to the eigensolver object.
565 :
566 : Not Collective
567 :
568 : Input Parameters:
569 : . pep - eigensolver context obtained from PEPCreate()
570 :
571 : Output Parameter:
572 : . st - spectral transformation context
573 :
574 : Level: intermediate
575 :
576 : .seealso: PEPSetST()
577 : @*/
578 18537 : PetscErrorCode PEPGetST(PEP pep,ST *st)
579 : {
580 18537 : PetscFunctionBegin;
581 18537 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
582 18537 : PetscAssertPointer(st,2);
583 18537 : if (!pep->st) {
584 165 : PetscCall(STCreate(PetscObjectComm((PetscObject)pep),&pep->st));
585 165 : PetscCall(PetscObjectIncrementTabLevel((PetscObject)pep->st,(PetscObject)pep,0));
586 165 : PetscCall(PetscObjectSetOptions((PetscObject)pep->st,((PetscObject)pep)->options));
587 : }
588 18537 : *st = pep->st;
589 18537 : PetscFunctionReturn(PETSC_SUCCESS);
590 : }
591 :
592 : /*@
593 : PEPRefineGetKSP - Obtain the ksp object used by the eigensolver
594 : object in the refinement phase.
595 :
596 : Collective
597 :
598 : Input Parameters:
599 : . pep - eigensolver context obtained from PEPCreate()
600 :
601 : Output Parameter:
602 : . ksp - ksp context
603 :
604 : Level: advanced
605 :
606 : .seealso: PEPSetRefine()
607 : @*/
608 184 : PetscErrorCode PEPRefineGetKSP(PEP pep,KSP *ksp)
609 : {
610 184 : MPI_Comm comm;
611 :
612 184 : PetscFunctionBegin;
613 184 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
614 184 : PetscAssertPointer(ksp,2);
615 184 : if (!pep->refineksp) {
616 158 : if (pep->npart>1) {
617 : /* Split in subcomunicators */
618 12 : PetscCall(PetscSubcommCreate(PetscObjectComm((PetscObject)pep),&pep->refinesubc));
619 12 : PetscCall(PetscSubcommSetNumber(pep->refinesubc,pep->npart));
620 12 : PetscCall(PetscSubcommSetType(pep->refinesubc,PETSC_SUBCOMM_CONTIGUOUS));
621 12 : PetscCall(PetscSubcommGetChild(pep->refinesubc,&comm));
622 146 : } else PetscCall(PetscObjectGetComm((PetscObject)pep,&comm));
623 158 : PetscCall(KSPCreate(comm,&pep->refineksp));
624 158 : PetscCall(PetscObjectIncrementTabLevel((PetscObject)pep->refineksp,(PetscObject)pep,0));
625 158 : PetscCall(PetscObjectSetOptions((PetscObject)pep->refineksp,((PetscObject)pep)->options));
626 158 : PetscCall(KSPSetOptionsPrefix(*ksp,((PetscObject)pep)->prefix));
627 158 : PetscCall(KSPAppendOptionsPrefix(*ksp,"pep_refine_"));
628 315 : PetscCall(KSPSetTolerances(pep->refineksp,SlepcDefaultTol(pep->rtol),PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT));
629 : }
630 184 : *ksp = pep->refineksp;
631 184 : PetscFunctionReturn(PETSC_SUCCESS);
632 : }
633 :
634 : /*@
635 : PEPSetTarget - Sets the value of the target.
636 :
637 : Logically Collective
638 :
639 : Input Parameters:
640 : + pep - eigensolver context
641 : - target - the value of the target
642 :
643 : Options Database Key:
644 : . -pep_target <scalar> - the value of the target
645 :
646 : Notes:
647 : The target is a scalar value used to determine the portion of the spectrum
648 : of interest. It is used in combination with PEPSetWhichEigenpairs().
649 :
650 : In the case of complex scalars, a complex value can be provided in the
651 : command line with [+/-][realnumber][+/-]realnumberi with no spaces, e.g.
652 : -pep_target 1.0+2.0i
653 :
654 : Level: intermediate
655 :
656 : .seealso: PEPGetTarget(), PEPSetWhichEigenpairs()
657 : @*/
658 84 : PetscErrorCode PEPSetTarget(PEP pep,PetscScalar target)
659 : {
660 84 : PetscFunctionBegin;
661 84 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
662 336 : PetscValidLogicalCollectiveScalar(pep,target,2);
663 84 : pep->target = target;
664 84 : if (!pep->st) PetscCall(PEPGetST(pep,&pep->st));
665 84 : PetscCall(STSetDefaultShift(pep->st,target));
666 84 : PetscFunctionReturn(PETSC_SUCCESS);
667 : }
668 :
669 : /*@
670 : PEPGetTarget - Gets the value of the target.
671 :
672 : Not Collective
673 :
674 : Input Parameter:
675 : . pep - eigensolver context
676 :
677 : Output Parameter:
678 : . target - the value of the target
679 :
680 : Note:
681 : If the target was not set by the user, then zero is returned.
682 :
683 : Level: intermediate
684 :
685 : .seealso: PEPSetTarget()
686 : @*/
687 2 : PetscErrorCode PEPGetTarget(PEP pep,PetscScalar* target)
688 : {
689 2 : PetscFunctionBegin;
690 2 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
691 2 : PetscAssertPointer(target,2);
692 2 : *target = pep->target;
693 2 : PetscFunctionReturn(PETSC_SUCCESS);
694 : }
695 :
696 : /*@
697 : PEPSetInterval - Defines the computational interval for spectrum slicing.
698 :
699 : Logically Collective
700 :
701 : Input Parameters:
702 : + pep - eigensolver context
703 : . inta - left end of the interval
704 : - intb - right end of the interval
705 :
706 : Options Database Key:
707 : . -pep_interval <a,b> - set [a,b] as the interval of interest
708 :
709 : Notes:
710 : Spectrum slicing is a technique employed for computing all eigenvalues of
711 : symmetric eigenproblems in a given interval. This function provides the
712 : interval to be considered. It must be used in combination with PEP_ALL, see
713 : PEPSetWhichEigenpairs().
714 :
715 : In the command-line option, two values must be provided. For an open interval,
716 : one can give an infinite, e.g., -pep_interval 1.0,inf or -pep_interval -inf,1.0.
717 : An open interval in the programmatic interface can be specified with
718 : PETSC_MAX_REAL and -PETSC_MAX_REAL.
719 :
720 : Level: intermediate
721 :
722 : .seealso: PEPGetInterval(), PEPSetWhichEigenpairs()
723 : @*/
724 9 : PetscErrorCode PEPSetInterval(PEP pep,PetscReal inta,PetscReal intb)
725 : {
726 9 : PetscFunctionBegin;
727 9 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
728 36 : PetscValidLogicalCollectiveReal(pep,inta,2);
729 36 : PetscValidLogicalCollectiveReal(pep,intb,3);
730 9 : PetscCheck(inta<intb,PetscObjectComm((PetscObject)pep),PETSC_ERR_ARG_WRONG,"Badly defined interval, must be inta<intb");
731 9 : if (pep->inta != inta || pep->intb != intb) {
732 9 : pep->inta = inta;
733 9 : pep->intb = intb;
734 9 : pep->state = PEP_STATE_INITIAL;
735 : }
736 9 : PetscFunctionReturn(PETSC_SUCCESS);
737 : }
738 :
739 : /*@
740 : PEPGetInterval - Gets the computational interval for spectrum slicing.
741 :
742 : Not Collective
743 :
744 : Input Parameter:
745 : . pep - eigensolver context
746 :
747 : Output Parameters:
748 : + inta - left end of the interval
749 : - intb - right end of the interval
750 :
751 : Level: intermediate
752 :
753 : Note:
754 : If the interval was not set by the user, then zeros are returned.
755 :
756 : .seealso: PEPSetInterval()
757 : @*/
758 4 : PetscErrorCode PEPGetInterval(PEP pep,PetscReal* inta,PetscReal* intb)
759 : {
760 4 : PetscFunctionBegin;
761 4 : PetscValidHeaderSpecific(pep,PEP_CLASSID,1);
762 4 : if (inta) *inta = pep->inta;
763 4 : if (intb) *intb = pep->intb;
764 4 : PetscFunctionReturn(PETSC_SUCCESS);
765 : }
|
