1: #ifdef PETSC_RCS_HEADER
  2: static char vcid[] = "$Id: mapreg.c,v 1.2 2000/01/10 03:18:14 knepley Exp $";
  3: #endif

 5:  #include src/vec/vecimpl.h

  7: PetscFList PetscMapList                       = PETSC_NULL;
  8: PetscTruth PetscMapRegisterAllCalled          = PETSC_FALSE;
  9: PetscFList PetscMapSerializeList              = PETSC_NULL;
 10: PetscTruth PetscMapSerializeRegisterAllCalled = PETSC_FALSE;

 12: #undef __FUNCT__  
 14: /*@C
 15:   PetscMapSetType - Builds a map, for a particular map implementation.

 17:   Collective on PetscMap

 19:   Input Parameters:
 20: + map    - The PetscMap object
 21: - method - The name of the map type

 23:   Options Database Command:
 24: . -map_type <method> - Sets the method; use -help for a list
 25:                        of available methods (for instance, mpi)

 27:   Notes:
 28:   See "petsc/include/vec.h" for available vector types (for instance, MAP_MPI).

 30:   Level: intermediate

 32: .keywords: map, set, type
 33: .seealso PetscMapGetType(), PetscMapCreate()
 34: @*/
 35: int PetscMapSetType(PetscMap map, PetscMapType method)
 36: {
 37:   int      (*r)(PetscMap);
 38:   PetscTruth match;
 39:   int        ierr;

 43:   PetscTypeCompare((PetscObject) map, method, &match);
 44:   if (match == PETSC_TRUE) return(0);

 46:   /* Get the function pointers for the method requested */
 47:   if (PetscMapRegisterAllCalled == PETSC_FALSE) {
 48:     PetscMapRegisterAll(PETSC_NULL);
 49:   }
 50:   PetscFListFind(map->comm, PetscMapList, method, (void (**)(void)) &r);
 51:   if (!r) SETERRQ1(PETSC_ERR_ARG_WRONG, "Unknown map type: %s", method);

 53:   if (map->ops->destroy != PETSC_NULL) {
 54:     (*map->ops->destroy)(map);
 55:   }
 56:   (*r)(map);

 58:   PetscObjectChangeTypeName((PetscObject) map, method);
 59:   return(0);
 60: }

 62: #undef __FUNCT__
 64: /*@C
 65:   PetscMapGetType - Gets the map type name (as a string) from the PetscMap.

 67:   Not collective

 69:   Input Parameter:
 70: . map  - The map

 72:   Output Parameter:
 73: . type - The map type name

 75:   Level: intermediate

 77: .keywords: map, get, type, name
 78: .seealso PetscMapSetType(), PetscMapCreate()
 79: @*/
 80: int PetscMapGetType(PetscMap map, PetscMapType *type)
 81: {

 87:   if (PetscMapRegisterAllCalled == PETSC_FALSE) {
 88:     PetscMapRegisterAll(PETSC_NULL);
 89:   }
 90:   *type = map->type_name;
 91:   return(0);
 92: }

 94: #undef __FUNCT__  
 96: /*@C
 97:   PetscMapSetSerializeType - Sets the serialization method for the map.

 99:   Collective on PetscMap

101:   Input Parameters:
102: + map    - The PetscMap object
103: - method - The map serialization type name

105:   Options Database Command:
106: . -map_serialize_type <method> - Sets the method; use -help for a list
107:                                  of available methods (for instance, seq_binary)

109:    Notes:
110:    See "petsc/include/petscvec.h" for available methods (for instance)
111: +  MAP_SER_SEQ_BINARY - Sequential map to binary file
112: -  MAP_SER_MPI_BINARY - MPI map to binary file

114:    Level: intermediate

116: .keywords: PetscMap, set, type, serialization
117: @*/
118: int PetscMapSetSerializeType(PetscMap map, PetscMapSerializeType method)
119: {
120:   int      (*r)(MPI_Comm, PetscMap *, PetscViewer, PetscTruth);
121:   PetscTruth match;
122:   int        ierr;

126:   PetscSerializeCompare((PetscObject) map, method, &match);
127:   if (match == PETSC_TRUE) return(0);

129:   /* Get the function pointers for the method requested but do not call */
130:   if (PetscMapSerializeRegisterAllCalled == PETSC_FALSE) {
131:     PetscMapSerializeRegisterAll(PETSC_NULL);
132:   }
133:   PetscFListFind(map->comm, PetscMapSerializeList, method, (void (**)(void)) &r);
134:   if (!r) SETERRQ1(PETSC_ERR_ARG_WRONG, "Unknown map serialization type: %s", method);

136:   PetscObjectChangeSerializeName((PetscObject) map, method);
137:   return(0);
138: }

140: #undef __FUNCT__
142: /*@C
143:   PetscMapGetSerializeType - Gets the map serialization type name (as a string) from the PetscMap.

145:   Not collective

147:   Input Parameter:
148: . map  - The map

150:   Output Parameter:
151: . type - The map type name

153:   Level: intermediate

155: .keywords: map, get, type, name
156: .seealso PetscMapSetSerializeType(), PetscMapCreate()
157: @*/
158: int PetscMapGetSerializeType(PetscMap map, PetscMapSerializeType *type)
159: {

165:   if (PetscMapSerializeRegisterAllCalled == PETSC_FALSE) {
166:     PetscMapSerializeRegisterAll(PETSC_NULL);
167:   }
168:   *type = map->serialize_name;
169:   return(0);
170: }

172: /*--------------------------------------------------------------------------------------------------------------------*/
173: /*MC
174:   PetscMapRegisterDynamic - Adds a new map component implementation

176:   Synopsis:
177:   PetscMapRegisterDynamic(char *name, char *path, char *func_name, int (*create_func)(PetscMap))

179:   Not Collective

181:   Input Parameters:
182: + name        - The name of a new user-defined creation routine
183: . path        - The path (either absolute or relative) of the library containing this routine
184: . func_name   - The name of routine to create method context
185: - create_func - The creation routine itself

187:   Notes:
188:   PetscMapRegister() may be called multiple times to add several user-defined maptors

190:   If dynamic libraries are used, then the fourth input argument (routine_create) is ignored.

192:   Sample usage:
193: .vb
194:     PetscMapRegisterDynamic("my_map","/home/username/my_lib/lib/libO/solaris/libmy.a", "MyPetscMapCreate", MyPetscMapCreate);
195: .ve

197:   Then, your map type can be chosen with the procedural interface via
198: .vb
199:     PetscMapCreate(MPI_Comm, PetscMap *);
200:     PetscMapSetType(PetscMap,"my_map_name");
201: .ve
202:    or at runtime via the option
203: .vb
204:     -map_type my_map_name
205: .ve

207:   Note: $PETSC_ARCH and $BOPT occuring in pathname will be replaced with appropriate values.

209:   Level: advanced

211: .keywords: PetscMap, register
212: .seealso: PetscMapRegisterAll(), PetscMapRegisterDestroy()
213: M*/

215: #undef __FUNCT__  
217: int PetscMapRegister(const char sname[], const char path[], const char name[], int (*function)(PetscMap))
218: {
219:   char fullname[PETSC_MAX_PATH_LEN];
220:   int  ierr;

223:   PetscStrcpy(fullname, path);
224:   PetscStrcat(fullname, ":");
225:   PetscStrcat(fullname, name);
226:   PetscFListAdd(&PetscMapList, sname, fullname, (void (*)(void)) function);
227:   return(0);
228: }

230: /*CM
231:   PetscMapSerializeRegisterDynamic - Adds a serialization method to the map package.

233:   Synopsis:

235:   PetscMapSerializeRegisterDynamic(char *name, char *path, char *func_name,
236:                               int (*serialize_func)(MPI_Comm, PetscMap *, PetscViewer, PetscTruth))

238:   Not Collective

240:   Input Parameters:
241: + name           - The name of a new user-defined serialization routine
242: . path           - The path (either absolute or relative) of the library containing this routine
243: . func_name      - The name of the serialization routine
244: - serialize_func - The serialization routine itself

246:   Notes:
247:   PetscMapSerializeRegister() may be called multiple times to add several user-defined serializers.

249:   If dynamic libraries are used, then the fourth input argument (serialize_func) is ignored.

251:   Sample usage:
252: .vb
253:   PetscMapSerializeRegisterDynamic("my_store", "/home/username/my_lib/lib/libO/solaris/libmy.a", "MyStoreFunc", MyStoreFunc);
254: .ve

256:   Then, your serialization can be chosen with the procedural interface via
257: .vb
258:     PetscMapSetSerializeType(map, "my_store")
259: .ve
260:   or at runtime via the option
261: .vb
262:     -map_serialize_type my_store
263: .ve

265:   Note: $PETSC_ARCH and $BOPT occuring in pathname will be replaced with appropriate values.

267:   Level: advanced

269: .keywords: PetscMap, register
270: .seealso: PetscMapSerializeRegisterAll(), PetscMapSerializeRegisterDestroy()
271: M*/
272: #undef __FUNCT__  
274: int PetscMapSerializeRegister(const char sname[], const char path[], const char name[],
275:                           int (*function)(MPI_Comm, PetscMap *, PetscViewer, PetscTruth))
276: {
277:   char fullname[PETSC_MAX_PATH_LEN];
278:   int  ierr;

281:   PetscStrcpy(fullname, path);
282:   PetscStrcat(fullname, ":");
283:   PetscStrcat(fullname, name);
284:   PetscFListAdd(&PetscMapSerializeList, sname, fullname, (void (*)(void)) function);
285:   return(0);
286: }

288: /*--------------------------------------------------------------------------------------------------------------------*/
289: #undef __FUNCT__  
291: /*@C
292:   PetscMapRegisterDestroy - Frees the list of PetscMap methods that were registered by PetscMapRegister().

294:   Not collective

296:   Level: advanced

298: .keywords: map, register, destroy
299: .seealso: PetscMapRegister(), PetscMapRegisterAll(), PetscMapSerializeRegisterDestroy()
300: @*/
301: int PetscMapRegisterDestroy()
302: {

306:   if (PetscMapList != PETSC_NULL) {
307:     PetscFListDestroy(&PetscMapList);
308:     PetscMapList = PETSC_NULL;
309:   }
310:   PetscMapRegisterAllCalled = PETSC_FALSE;
311:   return(0);
312: }

314: #undef __FUNCT__  
316: /*@C
317:   PetscMapSerializeRegisterDestroy - Frees the list of serialization routines for
318:   maptors that were registered by PetscMapSerializeRegister().

320:   Not collective

322:   Level: advanced

324: .keywords: PetscMap, map, register, destroy
325: .seealso: PetscMapSerializeRegisterAll()
326: @*/
327: int PetscMapSerializeRegisterDestroy()
328: {

332:   if (PetscMapSerializeList != PETSC_NULL) {
333:     PetscFListDestroy(&PetscMapSerializeList);
334:     PetscMapSerializeList = PETSC_NULL;
335:   }
336:   PetscMapSerializeRegisterAllCalled = PETSC_FALSE;
337:   return(0);
338: }