Actual source code: dlregisksp.c

  1: #define PETSCKSP_DLL

 3:  #include private/pcimpl.h
 4:  #include private/kspimpl.h


  7: const char *PCSides[]          = {"LEFT","RIGHT","SYMMETRIC","PCSide","PC_",0};
  8: const char *PCASMTypes[]       = {"NONE","RESTRICT","INTERPOLATE","BASIC","PCASMType","PC_ASM_",0};
  9: const char *PCCompositeTypes[] = {"ADDITIVE","MULTIPLICATIVE","SYMMETRIC_MULTIPLICATIVE","SPECIAL","SCHUR","PCCompositeType","PC_COMPOSITE",0};

 11: static PetscTruth PCPackageInitialized = PETSC_FALSE;
 14: /*@C
 15:   PCFinalizePackage - This function destroys everything in the Petsc interface to the charactoristics package. It is
 16:   called from PetscFinalize().

 18:   Level: developer

 20: .keywords: Petsc, destroy, package, mathematica
 21: .seealso: PetscFinalize()
 22: @*/
 23: PetscErrorCode  PCFinalizePackage(void)
 24: {
 26:   PCPackageInitialized = PETSC_FALSE;
 27:   PCRegisterAllCalled  = PETSC_FALSE;
 28:   PCList               = 0;
 29:   return(0);
 30: }

 34: /*@C
 35:   PCInitializePackage - This function initializes everything in the PC package. It is called
 36:   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to PCCreate()
 37:   when using static libraries.

 39:   Input Parameter:
 40:   path - The dynamic library path, or PETSC_NULL

 42:   Level: developer

 44: .keywords: PC, initialize, package
 45: .seealso: PetscInitialize()
 46: @*/
 47: PetscErrorCode  PCInitializePackage(const char path[])
 48: {
 49:   char              logList[256];
 50:   char             *className;
 51:   PetscTruth        opt;
 52:   PetscErrorCode    ierr;

 55:   if (PCPackageInitialized) return(0);
 56:   PCPackageInitialized = PETSC_TRUE;
 57:   /* Register Classes */
 58:   PetscCookieRegister("Preconditioner",&PC_COOKIE);
 59:   /* Register Constructors */
 60:   PCRegisterAll(path);
 61:   /* Register Events */
 62:   PetscLogEventRegister("PCSetUp",          PC_COOKIE,&PC_SetUp);
 63:   PetscLogEventRegister("PCSetUpOnBlocks",  PC_COOKIE,&PC_SetUpOnBlocks);
 64:   PetscLogEventRegister("PCApplyOnBlocks",  PC_COOKIE,&PC_ApplyOnBlocks);
 65:   PetscLogEventRegister("PCApply",          PC_COOKIE,&PC_Apply);
 66:   PetscLogEventRegister("PCApplyCoarse",    PC_COOKIE,&PC_ApplyCoarse);
 67:   PetscLogEventRegister("PCApplyMultiple",  PC_COOKIE,&PC_ApplyMultiple);
 68:   PetscLogEventRegister("PCApplySymmLeft",  PC_COOKIE,&PC_ApplySymmetricLeft);
 69:   PetscLogEventRegister("PCApplySymmRight", PC_COOKIE,&PC_ApplySymmetricRight);
 70:   PetscLogEventRegister("PCModifySubMatri", PC_COOKIE,&PC_ModifySubMatrices);
 71:   /* Process info exclusions */
 72:   PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);
 73:   if (opt) {
 74:     PetscStrstr(logList, "pc", &className);
 75:     if (className) {
 76:       PetscInfoDeactivateClass(PC_COOKIE);
 77:     }
 78:   }
 79:   /* Process summary exclusions */
 80:   PetscOptionsGetString(PETSC_NULL, "-log_summary_exclude", logList, 256, &opt);
 81:   if (opt) {
 82:     PetscStrstr(logList, "pc", &className);
 83:     if (className) {
 84:       PetscLogEventDeactivateClass(PC_COOKIE);
 85:     }
 86:   }
 87:   PetscRegisterFinalize(PCFinalizePackage);
 88:   return(0);
 89: }

 91: const char *KSPCGTypes[]                  = {"SYMMETRIC","HERMITIAN","KSPCGType","KSP_CG_",0};
 92: const char *KSPGMRESCGSRefinementTypes[]  = {"REFINE_NEVER", "REFINE_IFNEEDED", "REFINE_ALWAYS","KSPGMRESRefinementType","KSP_GMRES_CGS_",0};
 93: const char *KSPNormTypes[]                = {"NO","PRECONDITIONED","UNPRECONDITIONED","NATURAL","KSPNormType","KSP_NORM_",0};
 94: const char *KSPConvergedReasons_Shifted[] = {"DIVERGED_INDEFINITE_MAT","DIVERGED_NAN","DIVERGED_INDEFINITE_PC",
 95:                                              "DIVERGED_NONSYMMETRIC", "DIVERGED_BREAKDOWN_BICG","DIVERGED_BREAKDOWN",
 96:                                              "DIVERGED_DTOL","DIVERGED_ITS","DIVERGED_NULL","","CONVERGED_ITERATING",
 97:                                              "","CONVERGED_RTOL","CONVERGED_ATOL","CONVERGED_ITS",
 98:                                              "CONVERGED_CG_NEG_CURVE","CONVERGED_CG_CONSTRAINED","CONVERGED_STEP_LENGTH",
 99:                                              "CONVERGED_HAPPY_BREAKDOWN","KSPConvergedReason","KSP_",0};
100: const char **KSPConvergedReasons = KSPConvergedReasons_Shifted + 10;

102: static PetscTruth KSPPackageInitialized = PETSC_FALSE;
105: /*@C
106:   KSPFinalizePackage - This function destroys everything in the Petsc interface to the charactoristics package. It is
107:   called from PetscFinalize().

109:   Level: developer

111: .keywords: Petsc, destroy, package, mathematica
112: .seealso: PetscFinalize()
113: @*/
114: PetscErrorCode  KSPFinalizePackage(void)
115: {
117:   KSPPackageInitialized = PETSC_FALSE;
118:   KSPList               = 0;
119:   KSPRegisterAllCalled  = PETSC_FALSE;
120:   return(0);
121: }

125: /*@C
126:   KSPInitializePackage - This function initializes everything in the KSP package. It is called
127:   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to KSPCreate()
128:   when using static libraries.

130:   Input Parameter:
131:   path - The dynamic library path, or PETSC_NULL

133:   Level: developer

135: .keywords: KSP, initialize, package
136: .seealso: PetscInitialize()
137: @*/
138: PetscErrorCode  KSPInitializePackage(const char path[])
139: {
140:   char              logList[256];
141:   char              *className;
142:   PetscTruth        opt;
143:   PetscErrorCode    ierr;

146:   if (KSPPackageInitialized) return(0);
147:   KSPPackageInitialized = PETSC_TRUE;
148:   /* Register Classes */
149:   PetscCookieRegister("Krylov Solver",&KSP_COOKIE);
150:   /* Register Constructors */
151:   KSPRegisterAll(path);
152:   /* Register Events */
153:   PetscLogEventRegister("KSPGMRESOrthog",   KSP_COOKIE,&KSP_GMRESOrthogonalization);
154:   PetscLogEventRegister("KSPSetup",         KSP_COOKIE,&KSP_SetUp);
155:   PetscLogEventRegister("KSPSolve",         KSP_COOKIE,&KSP_Solve);
156:   /* Process info exclusions */
157:   PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);
158:   if (opt) {
159:     PetscStrstr(logList, "ksp", &className);
160:     if (className) {
161:       PetscInfoDeactivateClass(KSP_COOKIE);
162:     }
163:   }
164:   /* Process summary exclusions */
165:   PetscOptionsGetString(PETSC_NULL, "-log_summary_exclude", logList, 256, &opt);
166:   if (opt) {
167:     PetscStrstr(logList, "ksp", &className);
168:     if (className) {
169:       PetscLogEventDeactivateClass(KSP_COOKIE);
170:     }
171:   }
172:   PetscRegisterFinalize(KSPFinalizePackage);
173:   return(0);
174: }

176: #ifdef PETSC_USE_DYNAMIC_LIBRARIES
180: /*
181:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

183:   This one registers all the KSP and PC methods that are in the basic PETSc libpetscksp
184:   library.

186:   Input Parameter:
187:   path - library path
188:  */
189: PetscErrorCode  PetscDLLibraryRegister_petscksp(const char path[])
190: {

193:   PetscInitializeNoArguments(); if (ierr) return 1;

196:   /*
197:       If we got here then PETSc was properly loaded
198:   */
199:   PCInitializePackage(path);
200:   KSPInitializePackage(path);
201:   return(0);
202: }

205: #endif /* PETSC_USE_DYNAMIC_LIBRARIES */