2: #include <petsc-private/pcimpl.h>
  3: #include <petsc-private/kspimpl.h>

  5: static const char *const PCSides_Shifted[] = {"DEFAULT","LEFT","RIGHT","SYMMETRIC","PCSide","PC_",0};
  6: const char *const *const PCSides = PCSides_Shifted + 1;
  7: const char *PCASMTypes[]       = {"NONE","RESTRICT","INTERPOLATE","BASIC","PCASMType","PC_ASM_",0};
  8: const char *PCGASMTypes[]       = {"NONE","RESTRICT","INTERPOLATE","BASIC","PCGASMType","PC_GASM_",0};
  9: const char *PCCompositeTypes[] = {"ADDITIVE","MULTIPLICATIVE","SYMMETRIC_MULTIPLICATIVE","SPECIAL","SCHUR","PCCompositeType","PC_COMPOSITE",0};
 10: const char *PCPARMSGlobalTypes[] = {"RAS","SCHUR","BJ","PCPARMSGlobalType","PC_PARMS_",0};
 11: const char *PCPARMSLocalTypes[]  = {"ILU0","ILUK","ILUT","ARMS","PCPARMSLocalType","PC_PARMS_",0};

 13: static PetscBool  PCPackageInitialized = PETSC_FALSE;
 16: /*@C
 17:   PCFinalizePackage - This function destroys everything in the Petsc interface to the characteristics package. It is
 18:   called from PetscFinalize().

 20:   Level: developer

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

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

 41:   Input Parameter:
 42:   path - The dynamic library path, or PETSC_NULL

 44:   Level: developer

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

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

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

106: static PetscBool  KSPPackageInitialized = PETSC_FALSE;
109: /*@C
110:   KSPFinalizePackage - This function destroys everything in the Petsc interface to the KSP package. It is
111:   called from PetscFinalize().

113:   Level: developer

115: .keywords: Petsc, destroy, package, mathematica
116: .seealso: PetscFinalize()
117: @*/
118: PetscErrorCode  KSPFinalizePackage(void)
119: {
121:   KSPPackageInitialized = PETSC_FALSE;
122:   KSPList               = 0;
123:   KSPRegisterAllCalled  = PETSC_FALSE;
124:   return(0);
125: }

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

134:   Input Parameter:
135:   path - The dynamic library path, or PETSC_NULL

137:   Level: developer

139: .keywords: KSP, initialize, package
140: .seealso: PetscInitialize()
141: @*/
142: PetscErrorCode  KSPInitializePackage(const char path[])
143: {
144:   char              logList[256];
145:   char              *className;
146:   PetscBool         opt;
147:   PetscErrorCode    ierr;

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

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

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

190:   Input Parameter:
191:   path - library path
192:  */
193: PetscErrorCode  PetscDLLibraryRegister_petscksp(const char path[])
194: {

198:   PCInitializePackage(path);
199:   KSPInitializePackage(path);
200:   return(0);
201: }
202: EXTERN_C_END

204: #endif /* PETSC_USE_DYNAMIC_LIBRARIES */