Actual source code: slepcinit.c
slepc-3.17.2 2022-08-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: */
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: #if (SLEPC_VERSION_RELEASE == 1)
37: PetscSNPrintf(version,len,"SLEPc Release Version %d.%d.%d, %s",SLEPC_VERSION_MAJOR,SLEPC_VERSION_MINOR,SLEPC_VERSION_SUBMINOR,SLEPC_VERSION_DATE);
38: #else
39: PetscSNPrintf(version,len,"SLEPc Development GIT revision: %s GIT Date: %s",SLEPC_VERSION_GIT,SLEPC_VERSION_DATE_GIT);
40: #endif
41: PetscFunctionReturn(0);
42: }
44: /*@C
45: SlepcGetVersionNumber - Gets the SLEPc version information from the library.
47: Not collective
49: Output Parameters:
50: + major - the major version
51: . minor - the minor version
52: . subminor - the subminor version (patch number)
53: - release - indicates the library is from a release
55: Notes:
56: Pass NULL in any argument that is not requested.
58: The C macros SLEPC_VERSION_MAJOR, SLEPC_VERSION_MINOR, SLEPC_VERSION_SUBMINOR,
59: SLEPC_VERSION_RELEASE provide the information at compile time. This can be used to confirm
60: that the shared library being loaded at runtime has the appropriate version updates.
62: This function can be called before SlepcInitialize().
64: Level: intermediate
66: .seealso: SlepcGetVersion(), SlepcInitialize()
67: @*/
68: PetscErrorCode SlepcGetVersionNumber(PetscInt *major,PetscInt *minor,PetscInt *subminor,PetscInt *release)
69: {
70: if (major) *major = SLEPC_VERSION_MAJOR;
71: if (minor) *minor = SLEPC_VERSION_MINOR;
72: if (subminor) *subminor = SLEPC_VERSION_SUBMINOR;
73: if (release) *release = SLEPC_VERSION_RELEASE;
74: return 0;
75: }
77: /*
78: SlepcPrintVersion - Prints SLEPc version info.
80: Collective
81: */
82: static PetscErrorCode SlepcPrintVersion(MPI_Comm comm)
83: {
84: char version[256];
86: SlepcGetVersion(version,256);
87: (*PetscHelpPrintf)(comm,"%s\n",version);
88: (*PetscHelpPrintf)(comm,SLEPC_AUTHOR_INFO);
89: (*PetscHelpPrintf)(comm,"See docs/manual.html for help.\n");
90: (*PetscHelpPrintf)(comm,"SLEPc libraries linked from %s\n",SLEPC_LIB_DIR);
91: PetscFunctionReturn(0);
92: }
94: /*
95: SlepcPrintHelpIntro - Prints introductory SLEPc help info.
97: Collective
98: */
99: static PetscErrorCode SlepcPrintHelpIntro(MPI_Comm comm)
100: {
101: (*PetscHelpPrintf)(comm,"SLEPc help information includes that for the PETSc libraries, which provide\n");
102: (*PetscHelpPrintf)(comm,"low-level system infrastructure and linear algebra tools.\n");
103: (*PetscHelpPrintf)(comm,"----------------------------------------\n");
104: PetscFunctionReturn(0);
105: }
107: /* ------------------------Nasty global variables -------------------------------*/
108: /*
109: Indicates whether SLEPc started PETSc, or whether it was
110: already started before SLEPc was initialized.
111: */
112: PetscBool SlepcBeganPetsc = PETSC_FALSE;
113: PetscBool SlepcInitializeCalled = PETSC_FALSE;
114: PetscBool SlepcFinalizeCalled = PETSC_FALSE;
116: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES)
117: static PetscErrorCode SlepcLoadDynamicLibrary(const char *name,PetscBool *found)
118: {
119: char libs[PETSC_MAX_PATH_LEN],dlib[PETSC_MAX_PATH_LEN];
121: PetscStrcpy(libs,SLEPC_LIB_DIR);
122: PetscStrlcat(libs,"/libslepc",sizeof(libs));
123: PetscStrlcat(libs,name,sizeof(libs));
124: PetscDLLibraryRetrieve(PETSC_COMM_WORLD,libs,dlib,sizeof(dlib),found);
125: if (*found) PetscDLLibraryAppend(PETSC_COMM_WORLD,&PetscDLLibrariesLoaded,dlib);
126: PetscFunctionReturn(0);
127: }
128: #endif
130: #if defined(PETSC_USE_SINGLE_LIBRARY) && !(defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES))
131: SLEPC_EXTERN PetscErrorCode STInitializePackage(void);
132: SLEPC_EXTERN PetscErrorCode DSInitializePackage(void);
133: SLEPC_EXTERN PetscErrorCode FNInitializePackage(void);
134: SLEPC_EXTERN PetscErrorCode BVInitializePackage(void);
135: SLEPC_EXTERN PetscErrorCode RGInitializePackage(void);
136: SLEPC_EXTERN PetscErrorCode EPSInitializePackage(void);
137: SLEPC_EXTERN PetscErrorCode SVDInitializePackage(void);
138: SLEPC_EXTERN PetscErrorCode PEPInitializePackage(void);
139: SLEPC_EXTERN PetscErrorCode NEPInitializePackage(void);
140: SLEPC_EXTERN PetscErrorCode MFNInitializePackage(void);
141: SLEPC_EXTERN PetscErrorCode LMEInitializePackage(void);
142: #endif
144: /*
145: SlepcInitialize_DynamicLibraries - Adds the default dynamic link libraries to the
146: search path.
147: */
148: PetscErrorCode SlepcInitialize_DynamicLibraries(void)
149: {
150: PetscBool preload = PETSC_FALSE;
152: #if defined(PETSC_HAVE_THREADSAFETY)
153: /* These must be all initialized here because it is not safe for individual threads to call these initialize routines */
154: preload = PETSC_TRUE;
155: #endif
157: PetscOptionsGetBool(NULL,NULL,"-library_preload",&preload,NULL);
158: if (preload) {
159: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES)
160: PetscBool found;
161: #if defined(PETSC_USE_SINGLE_LIBRARY)
162: SlepcLoadDynamicLibrary("",&found);
164: #else
165: SlepcLoadDynamicLibrary("sys",&found);
167: SlepcLoadDynamicLibrary("eps",&found);
169: SlepcLoadDynamicLibrary("pep",&found);
171: SlepcLoadDynamicLibrary("nep",&found);
173: SlepcLoadDynamicLibrary("svd",&found);
175: SlepcLoadDynamicLibrary("mfn",&found);
177: SlepcLoadDynamicLibrary("lme",&found);
179: #endif
180: #else /* defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES) */
181: #if defined(PETSC_USE_SINGLE_LIBRARY)
182: STInitializePackage();
183: DSInitializePackage();
184: FNInitializePackage();
185: BVInitializePackage();
186: RGInitializePackage();
187: EPSInitializePackage();
188: SVDInitializePackage();
189: PEPInitializePackage();
190: NEPInitializePackage();
191: MFNInitializePackage();
192: LMEInitializePackage();
193: #else
194: SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Cannot use -library_preload with multiple static SLEPc libraries");
195: #endif
196: #endif /* defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES) */
197: }
199: #if defined(SLEPC_HAVE_HPDDM)
200: KSPRegister(KSPHPDDM,KSPCreate_HPDDM);
201: PCRegister(PCHPDDM,PCCreate_HPDDM);
202: #endif
203: PetscFunctionReturn(0);
204: }
206: PetscErrorCode SlepcCitationsInitialize()
207: {
208: PetscCall(PetscCitationsRegister("@Article{slepc-toms,\n"
209: " author = \"Vicente Hernandez and Jose E. Roman and Vicente Vidal\",\n"
210: " title = \"{SLEPc}: A Scalable and Flexible Toolkit for the Solution of Eigenvalue Problems\",\n"
211: " journal = \"{ACM} Trans. Math. Software\",\n"
212: " volume = \"31\",\n"
213: " number = \"3\",\n"
214: " pages = \"351--362\",\n"
215: " year = \"2005,\"\n"
216: " doi = \"https://doi.org/10.1145/1089014.1089019\"\n"
217: "}\n",NULL));
218: PetscCall(PetscCitationsRegister("@TechReport{slepc-manual,\n"
219: " author = \"J. E. Roman and C. Campos and L. Dalcin and E. Romero and A. Tomas\",\n"
220: " title = \"{SLEPc} Users Manual\",\n"
221: " number = \"DSIC-II/24/02 - Revision 3.17\",\n"
222: " institution = \"D. Sistemes Inform\\`atics i Computaci\\'o, Universitat Polit\\`ecnica de Val\\`encia\",\n"
223: " year = \"2022\"\n"
224: "}\n",NULL));
225: PetscFunctionReturn(0);
226: }
228: /*@C
229: SlepcInitialize - Initializes the SLEPc library. SlepcInitialize() calls
230: PetscInitialize() if that has not been called yet, so this routine should
231: always be called near the beginning of your program.
233: Collective on MPI_COMM_WORLD or PETSC_COMM_WORLD if it has been set
235: Input Parameters:
236: + argc - count of number of command line arguments
237: . args - the command line arguments
238: . file - [optional] PETSc database file, defaults to ~username/.petscrc
239: (use NULL for default)
240: - help - [optional] Help message to print, use NULL for no message
242: Fortran Notes:
243: Fortran syntax is very similar to that of PetscInitialize()
245: Level: beginner
247: .seealso: SlepcFinalize(), PetscInitialize()
248: @*/
249: PetscErrorCode SlepcInitialize(int *argc,char ***args,const char file[],const char help[])
250: {
251: PetscBool flg;
253: if (SlepcInitializeCalled) PetscFunctionReturn(0);
254: PetscSetHelpVersionFunctions(SlepcPrintHelpIntro,SlepcPrintVersion);
255: PetscInitialized(&flg);
256: if (!flg) {
257: PetscInitialize(argc,args,file,help);
258: SlepcBeganPetsc = PETSC_TRUE;
259: }
261: SlepcCitationsInitialize();
263: /* Load the dynamic libraries (on machines that support them), this registers all the solvers etc. */
264: SlepcInitialize_DynamicLibraries();
266: SlepcInitializeCalled = PETSC_TRUE;
267: SlepcFinalizeCalled = PETSC_FALSE;
268: PetscInfo(0,"SLEPc successfully started\n");
269: PetscFunctionReturn(0);
270: }
272: /*@C
273: SlepcFinalize - Checks for options to be called at the conclusion
274: of the SLEPc program and calls PetscFinalize().
276: Collective on PETSC_COMM_WORLD
278: Level: beginner
280: .seealso: SlepcInitialize(), PetscFinalize()
281: @*/
282: PetscErrorCode SlepcFinalize(void)
283: {
284: if (PetscUnlikely(!SlepcInitializeCalled)) {
285: fprintf(PETSC_STDOUT,"SlepcInitialize() must be called before SlepcFinalize()\n");
286: PetscStackClearTop;
287: return PETSC_ERR_ARG_WRONGSTATE;
288: }
289: PetscInfo(NULL,"SlepcFinalize() called\n");
290: if (SlepcBeganPetsc) {
291: PetscFinalize();
292: SlepcBeganPetsc = PETSC_FALSE;
293: }
294: SlepcInitializeCalled = PETSC_FALSE;
295: SlepcFinalizeCalled = PETSC_TRUE;
297: PetscStackClearTop;
298: return 0;
299: }
301: /*@C
302: SlepcInitializeNoArguments - Calls SlepcInitialize() from C/C++ without
303: the command line arguments.
305: Collective
307: Level: advanced
309: .seealso: SlepcInitialize(), SlepcInitializeFortran()
310: @*/
311: PetscErrorCode SlepcInitializeNoArguments(void)
312: {
313: int argc = 0;
314: char **args = 0;
316: SlepcInitialize(&argc,&args,NULL,NULL);
317: PetscFunctionReturn(0);
318: }
320: /*@
321: SlepcInitialized - Determine whether SLEPc is initialized.
323: Output Parameter:
324: . isInitialized - the result
326: Level: beginner
328: .seealso: SlepcInitialize(), SlepcInitializeFortran()
329: @*/
330: PetscErrorCode SlepcInitialized(PetscBool *isInitialized)
331: {
332: *isInitialized = SlepcInitializeCalled;
333: PetscFunctionReturn(0);
334: }
336: /*@
337: SlepcFinalized - Determine whether SlepcFinalize() has been called.
339: Output Parameter:
340: . isFinalized - the result
342: Level: developer
344: .seealso: SlepcFinalize()
345: @*/
346: PetscErrorCode SlepcFinalized(PetscBool *isFinalized)
347: {
348: *isFinalized = SlepcFinalizeCalled;
349: PetscFunctionReturn(0);
350: }
352: PETSC_EXTERN PetscBool PetscBeganMPI;
354: /*@C
355: SlepcInitializeNoPointers - Calls SlepcInitialize() from C/C++ without the pointers
356: to argc and args (analogue to PetscInitializeNoPointers).
358: Collective
360: Input Parameters:
361: + argc - count of number of command line arguments
362: . args - the command line arguments
363: . file - [optional] PETSc database file, defaults to ~username/.petscrc
364: (use NULL for default)
365: - help - [optional] Help message to print, use NULL for no message
367: Level: advanced
369: .seealso: SlepcInitialize()
370: @*/
371: PetscErrorCode SlepcInitializeNoPointers(int argc,char **args,const char *file,const char *help)
372: {
373: int myargc = argc;
374: char **myargs = args;
376: SlepcInitialize(&myargc,&myargs,file,help);
377: PetscPopSignalHandler();
378: PetscBeganMPI = PETSC_FALSE;
379: PetscFunctionReturn(0);
380: }