Actual source code: slepcinit.c
slepc-3.22.2 2024-12-02
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: /*@
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. You 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. You 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. You 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. You 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. You 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. You 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. You 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. You 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.22\",\n"
228: " institution = \"D. Sistemes Inform\\`atics i Computaci\\'o, Universitat Polit\\`ecnica de Val\\`encia\",\n"
229: " year = \"2024\"\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: PetscStackClearTop;
305: return PETSC_SUCCESS;
306: }
308: /*@C
309: SlepcInitializeNoArguments - Calls SlepcInitialize() from C/C++ without
310: the command line arguments.
312: Collective
314: Level: advanced
316: .seealso: SlepcInitialize(), SlepcInitializeFortran()
317: @*/
318: PetscErrorCode SlepcInitializeNoArguments(void)
319: {
320: int argc = 0;
321: char **args = NULL;
323: PetscFunctionBegin;
324: PetscCall(SlepcInitialize(&argc,&args,NULL,NULL));
325: PetscFunctionReturn(PETSC_SUCCESS);
326: }
328: /*@
329: SlepcInitialized - Determine whether SLEPc is initialized.
331: Output Parameter:
332: . isInitialized - the result
334: Level: beginner
336: .seealso: SlepcInitialize(), SlepcInitializeFortran()
337: @*/
338: PetscErrorCode SlepcInitialized(PetscBool *isInitialized)
339: {
340: PetscFunctionBegin;
341: *isInitialized = SlepcInitializeCalled;
342: PetscFunctionReturn(PETSC_SUCCESS);
343: }
345: /*@
346: SlepcFinalized - Determine whether SlepcFinalize() has been called.
348: Output Parameter:
349: . isFinalized - the result
351: Level: developer
353: .seealso: SlepcFinalize()
354: @*/
355: PetscErrorCode SlepcFinalized(PetscBool *isFinalized)
356: {
357: PetscFunctionBegin;
358: *isFinalized = SlepcFinalizeCalled;
359: PetscFunctionReturn(PETSC_SUCCESS);
360: }
362: PETSC_EXTERN PetscBool PetscBeganMPI;
364: /*@C
365: SlepcInitializeNoPointers - Calls SlepcInitialize() from C/C++ without the pointers
366: to argc and args (analogue to PetscInitializeNoPointers).
368: Collective
370: Input Parameters:
371: + argc - count of number of command line arguments
372: . args - the command line arguments
373: . file - [optional] PETSc database file, defaults to ~username/.petscrc
374: (use NULL for default)
375: - help - [optional] Help message to print, use NULL for no message
377: Level: advanced
379: .seealso: SlepcInitialize()
380: @*/
381: PetscErrorCode SlepcInitializeNoPointers(int argc,char **args,const char *file,const char *help)
382: {
383: int myargc = argc;
384: char **myargs = args;
386: PetscFunctionBegin;
387: PetscCall(SlepcInitialize(&myargc,&myargs,file,help));
388: PetscCall(PetscPopSignalHandler());
389: PetscBeganMPI = PETSC_FALSE;
390: PetscFunctionReturn(PETSC_SUCCESS);
391: }