Actual source code: slepcinit.c

slepc-3.20.1 2023-11-27
Report Typos and Errors
  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: */

 11: #include <slepc/private/slepcimpl.h>

 13: #if defined(SLEPC_HAVE_HPDDM)
 14: #include <petscksp.h>
 15: SLEPC_EXTERN PetscErrorCode KSPCreate_HPDDM(KSP);
 16: SLEPC_EXTERN PetscErrorCode PCCreate_HPDDM(PC);
 17: #endif

 19: /*@C
 20:     SlepcGetVersion - Gets the SLEPc version information in a string.

 22:     Not Collective

 24:     Input Parameter:
 25: .   len - length of the string

 27:     Output Parameter:
 28: .   version - version string

 30:     Level: intermediate

 32: .seealso: SlepcGetVersionNumber()
 33: @*/
 34: PetscErrorCode SlepcGetVersion(char version[],size_t len)
 35: {
 36:   PetscFunctionBegin;
 37: #if (SLEPC_VERSION_RELEASE == 1)
 38:   PetscCall(PetscSNPrintf(version,len,"SLEPc Release Version %d.%d.%d, %s",SLEPC_VERSION_MAJOR,SLEPC_VERSION_MINOR,SLEPC_VERSION_SUBMINOR,SLEPC_VERSION_DATE));
 39: #else
 40:   PetscCall(PetscSNPrintf(version,len,"SLEPc Development GIT revision: %s  GIT Date: %s",SLEPC_VERSION_GIT,SLEPC_VERSION_DATE_GIT));
 41: #endif
 42:   PetscFunctionReturn(PETSC_SUCCESS);
 43: }

 45: /*@C
 46:     SlepcGetVersionNumber - Gets the SLEPc version information from the library.

 48:     Not Collective

 50:     Output Parameters:
 51: +   major    - the major version
 52: .   minor    - the minor version
 53: .   subminor - the subminor version (patch number)
 54: -   release  - indicates the library is from a release

 56:     Notes:
 57:     Pass NULL in any argument that is not requested.

 59:     The C macros SLEPC_VERSION_MAJOR, SLEPC_VERSION_MINOR, SLEPC_VERSION_SUBMINOR,
 60:     SLEPC_VERSION_RELEASE provide the information at compile time. This can be used to confirm
 61:     that the shared library being loaded at runtime has the appropriate version updates.

 63:     This function can be called before SlepcInitialize().

 65:     Level: intermediate

 67: .seealso: SlepcGetVersion(), SlepcInitialize()
 68: @*/
 69: PetscErrorCode SlepcGetVersionNumber(PetscInt *major,PetscInt *minor,PetscInt *subminor,PetscInt *release)
 70: {
 71:   if (major)    *major    = SLEPC_VERSION_MAJOR;
 72:   if (minor)    *minor    = SLEPC_VERSION_MINOR;
 73:   if (subminor) *subminor = SLEPC_VERSION_SUBMINOR;
 74:   if (release)  *release  = SLEPC_VERSION_RELEASE;
 75:   return PETSC_SUCCESS;
 76: }

 78: /*
 79:    SlepcPrintVersion - Prints SLEPc version info.

 81:    Collective
 82: */
 83: static PetscErrorCode SlepcPrintVersion(MPI_Comm comm)
 84: {
 85:   char           version[256];

 87:   PetscFunctionBegin;
 88:   PetscCall(SlepcGetVersion(version,256));
 89:   PetscCall((*PetscHelpPrintf)(comm,"%s\n",version));
 90:   PetscCall((*PetscHelpPrintf)(comm,SLEPC_AUTHOR_INFO));
 91:   PetscCall((*PetscHelpPrintf)(comm,"See https://slepc.upv.es/documentation/ for help.\n"));
 92:   PetscCall((*PetscHelpPrintf)(comm,"SLEPc libraries linked from %s\n",SLEPC_LIB_DIR));
 93:   PetscFunctionReturn(PETSC_SUCCESS);
 94: }

 96: /*
 97:    SlepcPrintHelpIntro - Prints introductory SLEPc help info.

 99:    Collective
100: */
101: static PetscErrorCode SlepcPrintHelpIntro(MPI_Comm comm)
102: {
103:   PetscFunctionBegin;
104:   PetscCall((*PetscHelpPrintf)(comm,"SLEPc help information includes that for the PETSc libraries, which provide\n"));
105:   PetscCall((*PetscHelpPrintf)(comm,"low-level system infrastructure and linear algebra tools.\n"));
106:   PetscCall((*PetscHelpPrintf)(comm,"----------------------------------------\n"));
107:   PetscFunctionReturn(PETSC_SUCCESS);
108: }

110: /* ------------------------Nasty global variables -------------------------------*/
111: /*
112:    Indicates whether SLEPc started PETSc, or whether it was
113:    already started before SLEPc was initialized.
114: */
115: PetscBool SlepcBeganPetsc       = PETSC_FALSE;
116: PetscBool SlepcInitializeCalled = PETSC_FALSE;
117: PetscBool SlepcFinalizeCalled   = PETSC_FALSE;

119: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES)
120: static PetscErrorCode SlepcLoadDynamicLibrary(const char *name,PetscBool *found)
121: {
122:   char           libs[PETSC_MAX_PATH_LEN],dlib[PETSC_MAX_PATH_LEN];

124:   PetscFunctionBegin;
125:   PetscCall(PetscStrcpy(libs,SLEPC_LIB_DIR));
126:   PetscCall(PetscStrlcat(libs,"/libslepc",sizeof(libs)));
127:   PetscCall(PetscStrlcat(libs,name,sizeof(libs)));
128:   PetscCall(PetscDLLibraryRetrieve(PETSC_COMM_WORLD,libs,dlib,sizeof(dlib),found));
129:   if (*found) PetscCall(PetscDLLibraryAppend(PETSC_COMM_WORLD,&PetscDLLibrariesLoaded,dlib));
130:   PetscFunctionReturn(PETSC_SUCCESS);
131: }
132: #endif

134: #if defined(PETSC_USE_SINGLE_LIBRARY) && !(defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES))
135: SLEPC_EXTERN PetscErrorCode STInitializePackage(void);
136: SLEPC_EXTERN PetscErrorCode DSInitializePackage(void);
137: SLEPC_EXTERN PetscErrorCode FNInitializePackage(void);
138: SLEPC_EXTERN PetscErrorCode BVInitializePackage(void);
139: SLEPC_EXTERN PetscErrorCode RGInitializePackage(void);
140: SLEPC_EXTERN PetscErrorCode EPSInitializePackage(void);
141: SLEPC_EXTERN PetscErrorCode SVDInitializePackage(void);
142: SLEPC_EXTERN PetscErrorCode PEPInitializePackage(void);
143: SLEPC_EXTERN PetscErrorCode NEPInitializePackage(void);
144: SLEPC_EXTERN PetscErrorCode MFNInitializePackage(void);
145: SLEPC_EXTERN PetscErrorCode LMEInitializePackage(void);
146: #endif

148: /*
149:     SlepcInitialize_DynamicLibraries - Adds the default dynamic link libraries to the
150:     search path.
151: */
152: PetscErrorCode SlepcInitialize_DynamicLibraries(void)
153: {
154:   PetscBool      preload = PETSC_FALSE;

156:   PetscFunctionBegin;
157: #if defined(PETSC_HAVE_THREADSAFETY)
158:   /* These must be all initialized here because it is not safe for individual threads to call these initialize routines */
159:   preload = PETSC_TRUE;
160: #endif

162:   PetscCall(PetscOptionsGetBool(NULL,NULL,"-library_preload",&preload,NULL));
163:   if (preload) {
164: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES)
165:     PetscBool found;
166: #if defined(PETSC_USE_SINGLE_LIBRARY)
167:     PetscCall(SlepcLoadDynamicLibrary("",&found));
168:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc dynamic library\nYou cannot move the dynamic libraries!");
169: #else
170:     PetscCall(SlepcLoadDynamicLibrary("sys",&found));
171:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc sys dynamic library\nYou cannot move the dynamic libraries!");
172:     PetscCall(SlepcLoadDynamicLibrary("eps",&found));
173:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc EPS dynamic library\nYou cannot move the dynamic libraries!");
174:     PetscCall(SlepcLoadDynamicLibrary("pep",&found));
175:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc PEP dynamic library\nYou cannot move the dynamic libraries!");
176:     PetscCall(SlepcLoadDynamicLibrary("nep",&found));
177:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc NEP dynamic library\nYou cannot move the dynamic libraries!");
178:     PetscCall(SlepcLoadDynamicLibrary("svd",&found));
179:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc SVD dynamic library\nYou cannot move the dynamic libraries!");
180:     PetscCall(SlepcLoadDynamicLibrary("mfn",&found));
181:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc MFN dynamic library\nYou cannot move the dynamic libraries!");
182:     PetscCall(SlepcLoadDynamicLibrary("lme",&found));
183:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc LME dynamic library\nYou cannot move the dynamic libraries!");
184: #endif
185: #else /* defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES) */
186: #if defined(PETSC_USE_SINGLE_LIBRARY)
187:   PetscCall(STInitializePackage());
188:   PetscCall(DSInitializePackage());
189:   PetscCall(FNInitializePackage());
190:   PetscCall(BVInitializePackage());
191:   PetscCall(RGInitializePackage());
192:   PetscCall(EPSInitializePackage());
193:   PetscCall(SVDInitializePackage());
194:   PetscCall(PEPInitializePackage());
195:   PetscCall(NEPInitializePackage());
196:   PetscCall(MFNInitializePackage());
197:   PetscCall(LMEInitializePackage());
198: #else
199:   SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Cannot use -library_preload with multiple static SLEPc libraries");
200: #endif
201: #endif /* defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES) */
202:   }

204: #if defined(SLEPC_HAVE_HPDDM)
205:   PetscCall(KSPRegister(KSPHPDDM,KSPCreate_HPDDM));
206:   PetscCall(PCRegister(PCHPDDM,PCCreate_HPDDM));
207: #endif
208:   PetscFunctionReturn(PETSC_SUCCESS);
209: }

211: PetscErrorCode SlepcCitationsInitialize(void)
212: {
213:   PetscFunctionBegin;
214:   PetscCall(PetscCitationsRegister("@Article{slepc-toms,\n"
215:     "   author = \"Vicente Hernandez and Jose E. Roman and Vicente Vidal\",\n"
216:     "   title = \"{SLEPc}: A Scalable and Flexible Toolkit for the Solution of Eigenvalue Problems\",\n"
217:     "   journal = \"{ACM} Trans. Math. Software\",\n"
218:     "   volume = \"31\",\n"
219:     "   number = \"3\",\n"
220:     "   pages = \"351--362\",\n"
221:     "   year = \"2005\",\n"
222:     "   doi = \"https://doi.org/10.1145/1089014.1089019\"\n"
223:     "}\n",NULL));
224:   PetscCall(PetscCitationsRegister("@TechReport{slepc-manual,\n"
225:     "   author = \"J. E. Roman and C. Campos and L. Dalcin and E. Romero and A. Tomas\",\n"
226:     "   title = \"{SLEPc} Users Manual\",\n"
227:     "   number = \"DSIC-II/24/02 - Revision 3.20\",\n"
228:     "   institution = \"D. Sistemes Inform\\`atics i Computaci\\'o, Universitat Polit\\`ecnica de Val\\`encia\",\n"
229:     "   year = \"2023\"\n"
230:     "}\n",NULL));
231:   PetscFunctionReturn(PETSC_SUCCESS);
232: }

234: /*@C
235:    SlepcInitialize - Initializes the SLEPc library. SlepcInitialize() calls
236:    PetscInitialize() if that has not been called yet, so this routine should
237:    always be called near the beginning of your program.

239:    Collective on MPI_COMM_WORLD or PETSC_COMM_WORLD if it has been set

241:    Input Parameters:
242: +  argc - count of number of command line arguments
243: .  args - the command line arguments
244: .  file - [optional] PETSc database file, defaults to ~username/.petscrc
245:           (use NULL for default)
246: -  help - [optional] Help message to print, use NULL for no message

248:    Fortran Notes:
249:    Fortran syntax is very similar to that of PetscInitialize()

251:    Level: beginner

253: .seealso: SlepcFinalize(), PetscInitialize(), SlepcInitializeFortran()
254: @*/
255: PetscErrorCode SlepcInitialize(int *argc,char ***args,const char file[],const char help[])
256: {
257:   PetscBool      flg;

259:   PetscFunctionBegin;
260:   if (SlepcInitializeCalled) PetscFunctionReturn(PETSC_SUCCESS);
261:   PetscCall(PetscSetHelpVersionFunctions(SlepcPrintHelpIntro,SlepcPrintVersion));
262:   PetscCall(PetscInitialized(&flg));
263:   if (!flg) {
264:     PetscCall(PetscInitialize(argc,args,file,help));
265:     SlepcBeganPetsc = PETSC_TRUE;
266:   }

268:   PetscCall(SlepcCitationsInitialize());

270:   /* Load the dynamic libraries (on machines that support them), this registers all the solvers etc. */
271:   PetscCall(SlepcInitialize_DynamicLibraries());

273:   SlepcInitializeCalled = PETSC_TRUE;
274:   SlepcFinalizeCalled   = PETSC_FALSE;
275:   PetscCall(PetscInfo(0,"SLEPc successfully started\n"));
276:   PetscFunctionReturn(PETSC_SUCCESS);
277: }

279: /*@C
280:    SlepcFinalize - Checks for options to be called at the conclusion
281:    of the SLEPc program and calls PetscFinalize().

283:    Collective on PETSC_COMM_WORLD

285:    Level: beginner

287: .seealso: SlepcInitialize(), PetscFinalize()
288: @*/
289: PetscErrorCode SlepcFinalize(void)
290: {
291:   PetscFunctionBegin;
292:   if (PetscUnlikely(!SlepcInitializeCalled)) {
293:     fprintf(PETSC_STDOUT,"SlepcInitialize() must be called before SlepcFinalize()\n");
294:     PetscStackClearTop;
295:     return PETSC_ERR_ARG_WRONGSTATE;
296:   }
297:   PetscCall(PetscInfo(NULL,"SlepcFinalize() called\n"));
298:   if (SlepcBeganPetsc) {
299:     PetscCall(PetscFinalize());
300:     SlepcBeganPetsc = PETSC_FALSE;
301:   }
302:   SlepcInitializeCalled = PETSC_FALSE;
303:   SlepcFinalizeCalled   = PETSC_TRUE;
304:   PetscFunctionReturn(PETSC_SUCCESS);
305: }

307: /*@C
308:    SlepcInitializeNoArguments - Calls SlepcInitialize() from C/C++ without
309:    the command line arguments.

311:    Collective

313:    Level: advanced

315: .seealso: SlepcInitialize(), SlepcInitializeFortran()
316: @*/
317: PetscErrorCode SlepcInitializeNoArguments(void)
318: {
319:   int  argc = 0;
320:   char **args = NULL;

322:   PetscFunctionBegin;
323:   PetscCall(SlepcInitialize(&argc,&args,NULL,NULL));
324:   PetscFunctionReturn(PETSC_SUCCESS);
325: }

327: /*@
328:    SlepcInitialized - Determine whether SLEPc is initialized.

330:    Output Parameter:
331: .  isInitialized - the result

333:    Level: beginner

335: .seealso: SlepcInitialize(), SlepcInitializeFortran()
336: @*/
337: PetscErrorCode SlepcInitialized(PetscBool *isInitialized)
338: {
339:   PetscFunctionBegin;
340:   *isInitialized = SlepcInitializeCalled;
341:   PetscFunctionReturn(PETSC_SUCCESS);
342: }

344: /*@
345:    SlepcFinalized - Determine whether SlepcFinalize() has been called.

347:    Output Parameter:
348: .  isFinalized - the result

350:    Level: developer

352: .seealso: SlepcFinalize()
353: @*/
354: PetscErrorCode SlepcFinalized(PetscBool *isFinalized)
355: {
356:   PetscFunctionBegin;
357:   *isFinalized = SlepcFinalizeCalled;
358:   PetscFunctionReturn(PETSC_SUCCESS);
359: }

361: PETSC_EXTERN PetscBool PetscBeganMPI;

363: /*@C
364:    SlepcInitializeNoPointers - Calls SlepcInitialize() from C/C++ without the pointers
365:    to argc and args (analogue to PetscInitializeNoPointers).

367:    Collective

369:    Input Parameters:
370: +  argc - count of number of command line arguments
371: .  args - the command line arguments
372: .  file - [optional] PETSc database file, defaults to ~username/.petscrc
373:           (use NULL for default)
374: -  help - [optional] Help message to print, use NULL for no message

376:    Level: advanced

378: .seealso: SlepcInitialize()
379: @*/
380: PetscErrorCode SlepcInitializeNoPointers(int argc,char **args,const char *file,const char *help)
381: {
382:   int            myargc = argc;
383:   char           **myargs = args;

385:   PetscFunctionBegin;
386:   PetscCall(SlepcInitialize(&myargc,&myargs,file,help));
387:   PetscCall(PetscPopSignalHandler());
388:   PetscBeganMPI = PETSC_FALSE;
389:   PetscFunctionReturn(PETSC_SUCCESS);
390: }