Date: 2013-09-02T10:09:56+00:00

Actual source code: slepcinit.c

      1: /*
      2:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      3:    SLEPc - Scalable Library for Eigenvalue Problem Computations
      4:    Copyright (c) 2002-2013, Universitat Politecnica de Valencia, Spain

      6:    This file is part of SLEPc.

      8:    SLEPc is free software: you can redistribute it and/or modify it under  the
      9:    terms of version 3 of the GNU Lesser General Public License as published by
     10:    the Free Software Foundation.

     12:    SLEPc  is  distributed in the hope that it will be useful, but WITHOUT  ANY
     13:    WARRANTY;  without even the implied warranty of MERCHANTABILITY or  FITNESS
     14:    FOR  A  PARTICULAR PURPOSE. See the GNU Lesser General Public  License  for
     15:    more details.

     17:    You  should have received a copy of the GNU Lesser General  Public  License
     18:    along with SLEPc. If not, see <http://www.gnu.org/licenses/>.
     19:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     20: */

     22: #include <slepc-private/slepcimpl.h>           /*I "slepcsys.h" I*/
     23: #include <slepc-private/epsimpl.h>
     24: #include <slepc-private/stimpl.h>
     25: #include <slepc-private/svdimpl.h>
     26: #include <slepc-private/qepimpl.h>
     27: #include <slepc-private/nepimpl.h>
     28: #include <slepc-private/mfnimpl.h>
     29: #include <slepc-private/ipimpl.h>
     30: #include <slepc-private/dsimpl.h>
     31: #include <slepc-private/fnimpl.h>
     32: #include <slepc-private/vecimplslepc.h>
     33: #include <stdlib.h>

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

     40:     Input Parameter:
     41: .   len - length of the string

     43:     Output Parameter:
     44: .   version - version string

     46:     Fortran Note:
     47:     This routine is not supported in Fortran.

     49:     Level: developer
     50: @*/
     51: PetscErrorCode SlepcGetVersion(char version[],size_t len)
     52: {

     56: #if (SLEPC_VERSION_RELEASE == 1)
     57:   PetscSNPrintf(version,len,"SLEPc Release Version %d.%d.%d, %s",SLEPC_VERSION_MAJOR,SLEPC_VERSION_MINOR,SLEPC_VERSION_SUBMINOR,SLEPC_VERSION_DATE);
     58: #else
     59:   PetscSNPrintf(version,len,"SLEPc Development GIT revision: %d  GIT Date: %s",SLEPC_VERSION_GIT,SLEPC_VERSION_DATE_GIT);
     60: #endif
     61:   return(0);
     62: }

     66: /*
     67:    SlepcPrintVersion - Prints SLEPc version info.

     69:    Collective on MPI_Comm
     70: */
     71: PetscErrorCode SlepcPrintVersion(MPI_Comm comm)
     72: {
     74:   char           version[256];

     77:   SlepcGetVersion(version,256);
     78:   (*PetscHelpPrintf)(comm,"--------------------------------------------------------------------------\n");
     79:   (*PetscHelpPrintf)(comm,"%s\n",version);
     80:   (*PetscHelpPrintf)(comm,SLEPC_AUTHOR_INFO);
     81:   (*PetscHelpPrintf)(comm,"See docs/manual.html for help.\n");
     82:   (*PetscHelpPrintf)(comm,"SLEPc libraries linked from %s\n",SLEPC_LIB_DIR);
     83:   return(0);
     84: }

     88: /*
     89:    SlepcPrintHelpIntro - Prints introductory SLEPc help info.

     91:    Collective on MPI_Comm
     92: */
     93: PetscErrorCode SlepcPrintHelpIntro(MPI_Comm comm)
     94: {
     95:   PetscErrorCode  ierr;

     98:   (*PetscHelpPrintf)(comm,"SLEPc help information includes that for the PETSc libraries, which provide\n");
     99:   (*PetscHelpPrintf)(comm,"low-level system infrastructure and linear algebra tools.\n");
    100:   (*PetscHelpPrintf)(comm,"--------------------------------------------------------------------------\n");
    101:   return(0);
    102: }

    104: /* ------------------------Nasty global variables -------------------------------*/
    105: /*
    106:    Indicates whether SLEPc started PETSc, or whether it was
    107:    already started before SLEPc was initialized.
    108: */
    109: PetscBool SlepcBeganPetsc = PETSC_FALSE;
    110: PetscBool SlepcInitializeCalled = PETSC_FALSE;

    112: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)

    116: /*
    117:     SlepcInitialize_DynamicLibraries - Adds the default dynamic link libraries to the
    118:     search path.
    119: */
    120: PetscErrorCode SlepcInitialize_DynamicLibraries(void)
    121: {
    123:   PetscBool      found;
    124:   char           libs[PETSC_MAX_PATH_LEN],dlib[PETSC_MAX_PATH_LEN];

    127:   PetscStrcpy(libs,SLEPC_LIB_DIR);
    128:   PetscStrcat(libs,"/libslepc");
    129:   PetscDLLibraryRetrieve(PETSC_COMM_WORLD,libs,dlib,1024,&found);
    130:   if (found) {
    131:     PetscDLLibraryAppend(PETSC_COMM_WORLD,&PetscDLLibrariesLoaded,libs);
    132:   } else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc dynamic library\nYou cannot move the dynamic libraries");
    133:   return(0);
    134: }
    135: #endif

    139: /*
    140:     SlepcInitialize_LogEvents - Initialize log events not pertaining to any object class.
    141: */
    142: PetscErrorCode SlepcInitialize_LogEvents(void)
    143: {

    147:   PetscLogEventRegister("UpdateVectors",0,&SLEPC_UpdateVectors);
    148:   PetscLogEventRegister("VecMAXPBY",0,&SLEPC_VecMAXPBY);
    149:   PetscLogEventRegister("DenseMatProd",EPS_CLASSID,&SLEPC_SlepcDenseMatProd);
    150:   PetscLogEventRegister("DenseMatNorm",EPS_CLASSID,&SLEPC_SlepcDenseNorm);
    151:   PetscLogEventRegister("DenseCopy",EPS_CLASSID,&SLEPC_SlepcDenseCopy);
    152:   PetscLogEventRegister("VecsMult",EPS_CLASSID,&SLEPC_VecsMult);
    153:   return(0);
    154: }

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

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

    165:    Input Parameters:
    166: +  argc - count of number of command line arguments
    167: .  args - the command line arguments
    168: .  file - [optional] PETSc database file, defaults to ~username/.petscrc
    169:           (use NULL for default)
    170: -  help - [optional] Help message to print, use NULL for no message

    172:    Fortran Note:
    173:    Fortran syntax is very similar to that of PetscInitialize()

    175:    Level: beginner

    177: .seealso: SlepcFinalize(), PetscInitialize()
    178: @*/
    179: PetscErrorCode SlepcInitialize(int *argc,char ***args,const char file[],const char help[])
    180: {
    182:   PetscBool      flg;

    185:   if (SlepcInitializeCalled) return(0);
    186:   PetscSetHelpVersionFunctions(SlepcPrintHelpIntro,SlepcPrintVersion);
    187:   PetscInitialized(&flg);
    188:   if (!flg) {
    189:     PetscInitialize(argc,args,file,help);
    190:     SlepcBeganPetsc = PETSC_TRUE;
    191:   }

    193: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
    194:   SlepcInitialize_DynamicLibraries();
    195: #endif
    196:   SlepcInitialize_LogEvents();

    198: #if defined(PETSC_HAVE_DRAND48)
    199:   /* work-around for Cygwin drand48() initialization bug */
    200:   srand48(0);
    201: #endif

    203:   SlepcInitializeCalled = PETSC_TRUE;
    204:   PetscInfo(0,"SLEPc successfully started\n");
    205:   return(0);
    206: }

    210: /*@
    211:    SlepcFinalize - Checks for options to be called at the conclusion
    212:    of the SLEPc program and calls PetscFinalize().

    214:    Collective on PETSC_COMM_WORLD

    216:    Level: beginner

    218: .seealso: SlepcInitialize(), PetscFinalize()
    219: @*/
    220: PetscErrorCode SlepcFinalize(void)
    221: {

    225:   PetscInfo(0,"SlepcFinalize() called\n");
    226:   if (SlepcBeganPetsc) {
    227:     PetscFinalize();
    228:   }
    229:   SlepcInitializeCalled = PETSC_FALSE;
    230:   return(0);
    231: }

    235: /*@C
    236:    SlepcInitializeNoArguments - Calls SlepcInitialize() from C/C++ without
    237:    the command line arguments.

    239:    Collective

    241:    Level: advanced

    243: .seealso: SlepcInitialize(), SlepcInitializeFortran()
    244: @*/
    245: PetscErrorCode SlepcInitializeNoArguments(void)
    246: {
    248:   int            argc = 0;
    249:   char           **args = 0;

    252:   SlepcInitialize(&argc,&args,NULL,NULL);
    253:   PetscFunctionReturn(ierr);
    254: }

    258: /*@
    259:    SlepcInitialized - Determine whether SLEPc is initialized.

    261:    Level: beginner

    263: .seealso: SlepcInitialize(), SlepcInitializeFortran()
    264: @*/
    265: PetscErrorCode SlepcInitialized(PetscBool *isInitialized)
    266: {
    269:   *isInitialized = SlepcInitializeCalled;
    270:   return(0);
    271: }

    273: PETSC_EXTERN PetscBool PetscBeganMPI;

    277: /*
    278:    SlepcInitializeNoPointers - Calls SlepcInitialize() from C/C++ without the pointers
    279:    to argc and args (analogue to PetscInitializeNoPointers).

    281:    Collective

    283:    Level: advanced

    285: .seealso: SlepcInitialize()
    286: */
    287: PetscErrorCode SlepcInitializeNoPointers(int argc,char **args,const char *filename,const char *help)
    288: {
    290:   int            myargc = argc;
    291:   char           **myargs = args;

    294:   SlepcInitialize(&myargc,&myargs,filename,help);
    295:   PetscPopSignalHandler();
    296:   PetscBeganMPI = PETSC_FALSE;
    297:   PetscFunctionReturn(ierr);
    298: }

    300: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)

    304: /*
    305:   PetscDLLibraryRegister - This function is called when the dynamic library
    306:   it is in is opened.

    308:   This one registers all the EPS and ST methods in the libslepc.a
    309:   library.

    311:   Input Parameter:
    312:   path - library path
    313:  */
    314: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_slepc(char *path)
    315: {

    319:   EPSInitializePackage();
    320:   SVDInitializePackage();
    321:   QEPInitializePackage();
    322:   NEPInitializePackage();
    323:   MFNInitializePackage();
    324:   STInitializePackage();
    325:   IPInitializePackage();
    326:   DSInitializePackage();
    327:   FNInitializePackage();
    328:   return(0);
    329: }
    330: #endif /* PETSC_USE_DYNAMIC_LIBRARIES */