Actual source code: bag.c
petsc-3.4.5 2014-06-29
2: #include <petsc-private/bagimpl.h> /*I "petscbag.h" I*/
3: #include <petscviewer.h>
7: /*
8: Adds item to the linked list in a bag
9: */
10: static PetscErrorCode PetscBagRegister_Private(PetscBag bag,PetscBagItem item,const char *name,const char *help)
11: {
15: PetscStrncpy(item->name,name,PETSC_BAG_NAME_LENGTH-1);
16: PetscStrncpy(item->help,help,PETSC_BAG_HELP_LENGTH-1);
17: if (!bag->bagitems) bag->bagitems = item;
18: else {
19: PetscBagItem nitem = bag->bagitems;
20: while (nitem->next) {
21: nitem = nitem->next;
22: }
23: nitem->next = item;
24: }
25: bag->count++;
26: return(0);
27: }
31: /*@C
32: PetscBagRegisterEnum - add an enum value to the bag
34: Logically Collective on PetscBag
36: Input Parameter:
37: + bag - the bag of values
38: . addr - location of enum in struct
39: . mdefault - the initial value
40: . list - array of strings containing names of enum values followed by enum name followed by enum prefix
41: - help - longer string with more information about the value
43: Level: beginner
45: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
46: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
47: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName()
49: @*/
50: PetscErrorCode PetscBagRegisterEnum(PetscBag bag,void *addr,const char *const *list,PetscEnum mdefault, const char *name, const char *help)
51: {
53: PetscBagItem item;
54: char nname[PETSC_BAG_NAME_LENGTH+1];
55: PetscBool printhelp;
56: PetscInt i = 0;
59: nname[0] = '-';
60: nname[1] = 0;
61: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
62: PetscOptionsHasName(NULL,"-help",&printhelp);
63: if (printhelp) {
64: while (list[i++]) ;
65: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%s>: (%s) %s (choose one of) ",bag->bagprefix ? bag->bagprefix : "",name,list[mdefault],list[i-3],help);
66: for (i=0; list[i+2]; i++) {
67: (*PetscHelpPrintf)(bag->bagcomm," %s",list[i]);
68: }
69: (*PetscHelpPrintf)(bag->bagcomm,"\n");
70: }
71: PetscOptionsGetEnum(bag->bagprefix,nname,list,&mdefault,NULL);
73: PetscNew(struct _n_PetscBagItem,&item);
74: item->dtype = PETSC_ENUM;
75: item->offset = ((char*)addr) - ((char*)bag);
76: if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
77: item->next = 0;
78: item->msize = 1;
79: PetscStrArrayallocpy(list,(char***)&item->list);
80: *(PetscEnum*)addr = mdefault;
81: PetscBagRegister_Private(bag,item,name,help);
82: return(0);
83: }
87: /*@C
88: PetscBagRegisterIntArray - add an integer value to the bag
90: Logically Collective on PetscBag
92: Input Parameter:
93: + bag - the bag of values
94: . addr - location of integer in struct
95: . msize - number of entries in array
96: . name - name of the integer array
97: - help - longer string with more information about the value
99: Level: beginner
101: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
102: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
103: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
105: @*/
106: PetscErrorCode PetscBagRegisterIntArray(PetscBag bag,void *addr,PetscInt msize, const char *name, const char *help)
107: {
109: PetscBagItem item;
110: char nname[PETSC_BAG_NAME_LENGTH+1];
111: PetscBool printhelp;
112: PetscInt i,tmp = msize;
115: /* PetscMemzero(addr,msize*sizeof(PetscInt));*/
116: nname[0] = '-';
117: nname[1] = 0;
118: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
119: PetscOptionsHasName(NULL,"-help",&printhelp);
120: if (printhelp) {
121: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <",bag->bagprefix ? bag->bagprefix : "",name);
122: for (i=0; i<msize; i++) {
123: (*PetscHelpPrintf)(bag->bagcomm,"%D ",*((PetscInt*)addr)+i);
124: }
125: (*PetscHelpPrintf)(bag->bagcomm,">: %s \n",help);
126: }
127: PetscOptionsGetIntArray(bag->bagprefix,nname,(PetscInt*)addr,&tmp,NULL);
129: PetscNew(struct _n_PetscBagItem,&item);
130: item->dtype = PETSC_INT;
131: item->offset = ((char*)addr) - ((char*)bag);
132: if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
133: item->next = 0;
134: item->msize = msize;
135: PetscBagRegister_Private(bag,item,name,help);
136: return(0);
137: }
141: /*@C
142: PetscBagRegisterRealArray - add an real array to the bag
144: Logically Collective on PetscBag
146: Input Parameter:
147: + bag - the bag of values
148: . addr - location of real array in struct
149: . msize - number of entries in array
150: . name - name of the integer array
151: - help - longer string with more information about the value
153: Level: beginner
155: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
156: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
157: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
159: @*/
160: PetscErrorCode PetscBagRegisterRealArray(PetscBag bag,void *addr,PetscInt msize, const char *name, const char *help)
161: {
163: PetscBagItem item;
164: char nname[PETSC_BAG_NAME_LENGTH+1];
165: PetscBool printhelp;
166: PetscInt i,tmp = msize;
169: /* PetscMemzero(addr,msize*sizeof(PetscInt));*/
170: nname[0] = '-';
171: nname[1] = 0;
172: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
173: PetscOptionsHasName(NULL,"-help",&printhelp);
174: if (printhelp) {
175: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <",bag->bagprefix ? bag->bagprefix : "",name);
176: for (i=0; i<msize; i++) {
177: (*PetscHelpPrintf)(bag->bagcomm,"%G ",*((PetscReal*)addr)+i);
178: }
179: (*PetscHelpPrintf)(bag->bagcomm,">: %s \n",help);
180: }
181: PetscOptionsGetRealArray(bag->bagprefix,nname,(PetscReal*)addr,&tmp,NULL);
183: PetscNew(struct _n_PetscBagItem,&item);
184: item->dtype = PETSC_REAL;
185: item->offset = ((char*)addr) - ((char*)bag);
186: if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
187: item->next = 0;
188: item->msize = msize;
189: PetscBagRegister_Private(bag,item,name,help);
190: return(0);
191: }
195: /*@C
196: PetscBagRegisterInt - add an integer value to the bag
198: Logically Collective on PetscBag
200: Input Parameter:
201: + bag - the bag of values
202: . addr - location of integer in struct
203: . mdefault - the initial value
204: . name - name of the integer
205: - help - longer string with more information about the value
207: Level: beginner
209: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
210: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
211: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
213: @*/
214: PetscErrorCode PetscBagRegisterInt(PetscBag bag,void *addr,PetscInt mdefault,const char *name,const char *help)
215: {
217: PetscBagItem item;
218: char nname[PETSC_BAG_NAME_LENGTH+1];
219: PetscBool printhelp;
222: nname[0] = '-';
223: nname[1] = 0;
224: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
225: PetscOptionsHasName(NULL,"-help",&printhelp);
226: if (printhelp) {
227: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%d>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,mdefault,help);
228: }
229: PetscOptionsGetInt(bag->bagprefix,nname,&mdefault,NULL);
231: PetscNew(struct _n_PetscBagItem,&item);
232: item->dtype = PETSC_INT;
233: item->offset = ((char*)addr) - ((char*)bag);
234: if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
235: item->next = 0;
236: item->msize = 1;
237: *(PetscInt*)addr = mdefault;
238: PetscBagRegister_Private(bag,item,name,help);
239: return(0);
240: }
244: /*@C
245: PetscBagRegisterString - add a string value to the bag
247: Logically Collective on PetscBag
249: Input Parameter:
250: + bag - the bag of values
251: . addr - location of start of string in struct
252: . msize - length of the string space in the struct
253: . mdefault - the initial value
254: . name - name of the string
255: - help - longer string with more information about the value
257: Level: beginner
259: Note: The struct should have the field char mystring[msize]; not char *mystring
261: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
262: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
263: PetscBagSetFromOptions(),PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
265: @*/
266: PetscErrorCode PetscBagRegisterString(PetscBag bag,void *addr,PetscInt msize,const char* mdefault,const char* name,const char* help)
267: {
269: PetscBagItem item;
270: char nname[PETSC_BAG_NAME_LENGTH+1];
271: PetscBool printhelp;
274: nname[0] = '-';
275: nname[1] = 0;
276: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
277: PetscOptionsHasName(NULL,"-help",&printhelp);
278: if (printhelp) {
279: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%s>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,mdefault,help);
280: }
282: PetscNew(struct _n_PetscBagItem,&item);
283: item->dtype = PETSC_CHAR;
284: item->offset = ((char*)addr) - ((char*)bag);
285: if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
286: item->next = 0;
287: item->msize = msize;
288: if (mdefault != (char*)addr) {
289: PetscStrncpy((char*)addr,mdefault,msize-1);
290: }
291: PetscOptionsGetString(bag->bagprefix,nname,(char*)addr,msize,NULL);
292: PetscBagRegister_Private(bag,item,name,help);
293: return(0);
294: }
298: /*@C
299: PetscBagRegisterReal - add a real value to the bag
301: Logically Collective on PetscBag
303: Input Parameter:
304: + bag - the bag of values
305: . addr - location of double in struct
306: . mdefault - the initial value
307: . name - name of the variable
308: - help - longer string with more information about the value
310: Level: beginner
312: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
313: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
314: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
316: @*/
317: PetscErrorCode PetscBagRegisterReal(PetscBag bag,void *addr,PetscReal mdefault, const char *name, const char *help)
318: {
320: PetscBagItem item;
321: char nname[PETSC_BAG_NAME_LENGTH+1];
322: PetscBool printhelp;
325: nname[0] = '-';
326: nname[1] = 0;
327: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
328: PetscOptionsHasName(NULL,"-help",&printhelp);
329: if (printhelp) {
330: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%G>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,mdefault,help);
331: }
332: PetscOptionsGetReal(bag->bagprefix,nname,&mdefault,NULL);
334: PetscNew(struct _n_PetscBagItem,&item);
335: item->dtype = PETSC_REAL;
336: item->offset = ((char*)addr) - ((char*)bag);
337: if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
338: item->next = 0;
339: item->msize = 1;
340: *(PetscReal*)addr = mdefault;
341: PetscBagRegister_Private(bag,item,name,help);
342: return(0);
343: }
347: /*@C
348: PetscBagRegisterScalar - add a real or complex number value to the bag
350: Logically Collective on PetscBag
352: Input Parameter:
353: + bag - the bag of values
354: . addr - location of scalar in struct
355: . mdefault - the initial value
356: . name - name of the variable
357: - help - longer string with more information about the value
360: Level: beginner
362: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
363: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
364: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
366: @*/
367: PetscErrorCode PetscBagRegisterScalar(PetscBag bag,void *addr,PetscScalar mdefault,const char *name,const char *help)
368: {
370: PetscBagItem item;
371: char nname[PETSC_BAG_NAME_LENGTH+1];
372: PetscBool printhelp;
375: nname[0] = '-';
376: nname[1] = 0;
377: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
378: PetscOptionsHasName(NULL,"-help",&printhelp);
379: if (printhelp) {
380: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%G + %Gi>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,PetscRealPart(mdefault),PetscImaginaryPart(mdefault),help);
381: }
382: PetscOptionsGetScalar(bag->bagprefix,nname,&mdefault,NULL);
384: PetscNew(struct _n_PetscBagItem,&item);
385: item->dtype = PETSC_SCALAR;
386: item->offset = ((char*)addr) - ((char*)bag);
387: if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
388: item->next = 0;
389: item->msize = 1;
390: *(PetscScalar*)addr = mdefault;
391: PetscBagRegister_Private(bag,item,name,help);
392: return(0);
393: }
397: /*@C
398: PetscBagRegisterBool - add a logical value to the bag
400: Logically Collective on PetscBag
402: Input Parameter:
403: + bag - the bag of values
404: . addr - location of logical in struct
405: . mdefault - the initial value
406: . name - name of the variable
407: - help - longer string with more information about the value
410: Level: beginner
412: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
413: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
414: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
416: @*/
417: PetscErrorCode PetscBagRegisterBool(PetscBag bag,void *addr,PetscBool mdefault,const char *name,const char *help)
418: {
420: PetscBagItem item;
421: char nname[PETSC_BAG_NAME_LENGTH+1];
422: PetscBool printhelp;
425: /* the checks here with != PETSC_FALSE and PETSC_TRUE is a special case; here we truly demand that the value be 0 or 1 */
426: if (mdefault != PETSC_FALSE && mdefault != PETSC_TRUE) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Boolean %s %s must be boolean; integer value %d",name,help,(int)mdefault);
427: nname[0] = '-';
428: nname[1] = 0;
429: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
430: PetscOptionsHasName(NULL,"-help",&printhelp);
431: if (printhelp) {
432: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%s>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,PetscBools[mdefault],help);
433: }
434: PetscOptionsGetBool(bag->bagprefix,nname,&mdefault,NULL);
436: PetscNew(struct _n_PetscBagItem,&item);
437: item->dtype = PETSC_BOOL;
438: item->offset = ((char*)addr) - ((char*)bag);
439: if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
440: item->next = 0;
441: item->msize = 1;
442: *(PetscBool*)addr = mdefault;
443: PetscBagRegister_Private(bag,item,name,help);
444: return(0);
445: }
449: /*@C
450: PetscBagDestroy - Destroys a bag values
452: Collective on PetscBag
454: Input Parameter:
455: . bag - the bag of values
457: Level: beginner
459: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
460: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
461: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
463: @*/
464: PetscErrorCode PetscBagDestroy(PetscBag *bag)
465: {
467: PetscBagItem nitem = (*bag)->bagitems,item;
470: while (nitem) {
471: item = nitem->next;
472: if (nitem->list) {
473: PetscStrArrayDestroy(&nitem->list);
474: }
475: PetscFree(nitem);
476: nitem = item;
477: }
478: if ((*bag)->bagprefix) { PetscFree((*bag)->bagprefix); }
479: PetscFree(*bag);
480: return(0);
481: }
485: /*@
486: PetscBagSetFromOptions - Allows setting options from a bag
488: Collective on PetscBag
490: Input Parameter:
491: . bag - the bag of values
493: Level: beginner
495: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagLoad(), PetscBagGetData()
496: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
497: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagView(), PetscBagRegisterEnum()
499: @*/
500: PetscErrorCode PetscBagSetFromOptions(PetscBag bag)
501: {
503: PetscBagItem nitem = bag->bagitems;
504: char name[PETSC_BAG_NAME_LENGTH+1],helpname[PETSC_BAG_NAME_LENGTH+PETSC_BAG_HELP_LENGTH+3];
505: PetscInt n;
508: PetscStrcpy(helpname,bag->bagname);
509: PetscStrcat(helpname," ");
510: PetscStrcat(helpname,bag->baghelp);
511: PetscOptionsBegin(bag->bagcomm,bag->bagprefix,helpname,0);
512: while (nitem) {
513: name[0] = '-';
514: name[1] = 0;
515: PetscStrcat(name,nitem->name);
516: if (nitem->dtype == PETSC_CHAR) { /* special handling for fortran required? [due to space padding vs null termination] */
517: char *value = (char*)(((char*)bag) + nitem->offset);
518: PetscOptionsString(name,nitem->help,"",value,value,nitem->msize,NULL);
519: } else if (nitem->dtype == PETSC_REAL) {
520: PetscReal *value = (PetscReal*)(((char*)bag) + nitem->offset);
521: if (nitem->msize == 1) {
522: PetscOptionsReal(name,nitem->help,"",*value,value,NULL);
523: } else {
524: n = nitem->msize;
525: PetscOptionsRealArray(name,nitem->help,"",value,&n,NULL);
526: }
527: } else if (nitem->dtype == PETSC_SCALAR) {
528: PetscScalar *value = (PetscScalar*)(((char*)bag) + nitem->offset);
529: PetscOptionsScalar(name,nitem->help,"",*value,value,NULL);
530: } else if (nitem->dtype == PETSC_INT) {
531: PetscInt *value = (PetscInt*)(((char*)bag) + nitem->offset);
532: if (nitem->msize == 1) {
533: PetscOptionsInt(name,nitem->help,"",*value,value,NULL);
534: } else {
535: n = nitem->msize;
536: PetscOptionsIntArray(name,nitem->help,"",value,&n,NULL);
537: }
538: } else if (nitem->dtype == PETSC_ENUM) {
539: PetscEnum *value = (PetscEnum*)(((char*)bag) + nitem->offset);
540: PetscInt i = 0;
541: while (nitem->list[i++]) ;
542: PetscOptionsEnum(name,nitem->help,nitem->list[i-3],(const char*const*)nitem->list,*value,value,NULL);
543: } else if (nitem->dtype == PETSC_BOOL) {
544: PetscBool *value = (PetscBool*)(((char*)bag) + nitem->offset);
545: PetscOptionsBool(name,nitem->help,"",*value,value,NULL);
546: }
547: nitem = nitem->next;
548: }
549: PetscOptionsEnd();
550: return(0);
551: }
555: /*@C
556: PetscBagView - Views a bag of values as either ASCII text or a binary file
558: Collective on PetscBag
560: Input Parameter:
561: + bag - the bag of values
562: - viewer - location to view the values
564: Level: beginner
566: Warning: Currently PETSc bags saved in a binary file can only be read back
567: in on a machine of the same architecture. Let us know when this is a problem
568: and we'll fix it.
570: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagLoad(), PetscBagGetData()
571: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar(), PetscBagRegisterEnum()
572: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName()
574: @*/
575: PetscErrorCode PetscBagView(PetscBag bag,PetscViewer view)
576: {
577: PetscBool isascii,isbinary;
579: PetscBagItem nitem = bag->bagitems;
582: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERASCII,&isascii);
583: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERBINARY,&isbinary);
584: if (isascii) {
585: PetscViewerASCIIPrintf(view,"PetscBag Object: %s %s\n",bag->bagname,bag->baghelp);
586: while (nitem) {
587: if (nitem->dtype == PETSC_CHAR) {
588: char *value = (char*)(((char*)bag) + nitem->offset);
589: char tmp = value[nitem->msize-1]; /* special handling for fortran chars wihout null terminator */
590: value[nitem->msize-1] =0;
591: PetscViewerASCIIPrintf(view," %s = %s; %s\n",nitem->name,value,nitem->help);
592: value[nitem->msize-1] = tmp;
593: } else if (nitem->dtype == PETSC_REAL) {
594: PetscReal *value = (PetscReal*)(((char*)bag) + nitem->offset);
595: PetscInt i;
596: PetscViewerASCIIPrintf(view," %s = ",nitem->name);
597: for (i=0; i<nitem->msize; i++) {
598: PetscViewerASCIIPrintf(view,"%G ",value[i]);
599: }
600: PetscViewerASCIIPrintf(view,"; %s\n",nitem->help);
601: } else if (nitem->dtype == PETSC_SCALAR) {
602: PetscScalar value = *(PetscScalar*)(((char*)bag) + nitem->offset);
603: #if defined(PETSC_USE_COMPLEX)
604: PetscViewerASCIIPrintf(view," %s = %G + %Gi; %s\n",nitem->name,PetscRealPart(value),PetscImaginaryPart(value),nitem->help);
605: #else
606: PetscViewerASCIIPrintf(view," %s = %G; %s\n",nitem->name,value,nitem->help);
607: #endif
608: } else if (nitem->dtype == PETSC_INT) {
609: PetscInt i,*value = (PetscInt*)(((char*)bag) + nitem->offset);
610: PetscViewerASCIIPrintf(view," %s = ",nitem->name);
611: for (i=0; i<nitem->msize; i++) {
612: PetscViewerASCIIPrintf(view,"%D ",value[i]);
613: }
614: PetscViewerASCIIPrintf(view,"; %s\n",nitem->help);
615: } else if (nitem->dtype == PETSC_BOOL) {
616: PetscBool value = *(PetscBool*)(((char*)bag) + nitem->offset);
617: /* some Fortran compilers use -1 as boolean */
618: if (((int) value) == -1) value = PETSC_TRUE;
619: /* the checks here with != PETSC_FALSE and PETSC_TRUE is a special case; here we truly demand that the value be 0 or 1 */
620: if (value != PETSC_FALSE && value != PETSC_TRUE) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Boolean value for %s %s is corrupt; integer value %d",nitem->name,nitem->help,value);
621: PetscViewerASCIIPrintf(view," %s = %s; %s\n",nitem->name,PetscBools[value],nitem->help);
622: } else if (nitem->dtype == PETSC_ENUM) {
623: PetscEnum value = *(PetscEnum*)(((char*)bag) + nitem->offset);
624: PetscInt i = 0;
625: while (nitem->list[i++]) ;
626: PetscViewerASCIIPrintf(view," %s = %s; (%s) %s\n",nitem->name,nitem->list[value],nitem->list[i-3],nitem->help);
627: }
628: nitem = nitem->next;
629: }
630: } else if (isbinary) {
631: PetscInt classid = PETSC_BAG_FILE_CLASSID, dtype;
632: PetscInt deprecatedbagsize = 0;
633: PetscViewerFormat format;
634: PetscViewerBinaryWrite(view,&classid,1,PETSC_INT,PETSC_TRUE);
635: PetscViewerBinaryWrite(view,&deprecatedbagsize,1,PETSC_INT,PETSC_FALSE);
636: PetscViewerBinaryWrite(view,&bag->count,1,PETSC_INT,PETSC_FALSE);
637: PetscViewerBinaryWrite(view,bag->bagname,PETSC_BAG_NAME_LENGTH,PETSC_CHAR,PETSC_FALSE);
638: PetscViewerBinaryWrite(view,bag->baghelp,PETSC_BAG_HELP_LENGTH,PETSC_CHAR,PETSC_FALSE);
639: while (nitem) {
640: PetscViewerBinaryWrite(view,&nitem->offset,1,PETSC_INT,PETSC_FALSE);
641: dtype = (PetscInt)nitem->dtype;
642: PetscViewerBinaryWrite(view,&dtype,1,PETSC_INT,PETSC_FALSE);
643: PetscViewerBinaryWrite(view,nitem->name,PETSC_BAG_NAME_LENGTH,PETSC_CHAR,PETSC_FALSE);
644: PetscViewerBinaryWrite(view,nitem->help,PETSC_BAG_HELP_LENGTH,PETSC_CHAR,PETSC_FALSE);
645: PetscViewerBinaryWrite(view,&nitem->msize,1,PETSC_INT,PETSC_FALSE);
646: /* some Fortran compilers use -1 as boolean */
647: if (dtype == PETSC_BOOL && ((*(int*) (((char*)bag) + nitem->offset) == -1))) *(int*) (((char*)bag) + nitem->offset) = PETSC_TRUE;
649: PetscViewerBinaryWrite(view,(((char*)bag) + nitem->offset),nitem->msize,nitem->dtype,PETSC_FALSE);
650: if (dtype == PETSC_ENUM) {
651: PetscViewerBinaryWriteStringArray(view,(char**)nitem->list);
652: }
653: nitem = nitem->next;
654: }
655: PetscViewerGetFormat(view,&format);
656: if (format == PETSC_VIEWER_BINARY_MATLAB) {
657: MPI_Comm comm;
658: FILE *info;
659: PetscObjectGetComm((PetscObject)view,&comm);
660: PetscViewerBinaryGetInfoPointer(view,&info);
661: PetscFPrintf(comm,info,"#--- begin code written by PetscViewerBinary for MATLAB format ---#\n");
662: PetscFPrintf(comm,info,"#$$ Set.%s = PetscBinaryRead(fd);\n",bag->bagname);
663: PetscFPrintf(comm,info,"#--- end code written by PetscViewerBinary for MATLAB format ---#\n\n");
664: }
665: }
666: return(0);
667: }
671: /*@C
672: PetscBagLoad - Loads a bag of values from a binary file
674: Collective on PetscViewer
676: Input Parameter:
677: + viewer - file to load values from
678: - bag - the bag of values
680: Notes: You must have created and registered all the fields in the bag before loading into it.
682: Notes:
683: Level: beginner
685: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagView(), PetscBagGetData()
686: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
687: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
689: @*/
690: PetscErrorCode PetscBagLoad(PetscViewer view,PetscBag bag)
691: {
693: PetscBool isbinary;
694: PetscInt classid,bagcount,i,dtype,msize,offset,deprecatedbagsize;
695: char name[PETSC_BAG_NAME_LENGTH],help[PETSC_BAG_HELP_LENGTH],**list;
696: PetscBagItem nitem;
697: MPI_Comm comm;
698: PetscMPIInt flag;
701: PetscObjectGetComm((PetscObject)view,&comm);
702: MPI_Comm_compare(comm,bag->bagcomm,&flag);
703: if (flag != MPI_CONGRUENT && flag != MPI_IDENT) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NOTSAMECOMM,"Different communicators in the viewer and bag"); \
704: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERBINARY,&isbinary);
705: if (!isbinary) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for this viewer type");
707: PetscViewerBinaryRead(view,&classid,1,PETSC_INT);
708: if (classid != PETSC_BAG_FILE_CLASSID) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Not PetscBag next in binary file");
709: PetscViewerBinaryRead(view,&deprecatedbagsize,1,PETSC_INT);
710: PetscViewerBinaryRead(view,&bagcount,1,PETSC_INT);
711: if (bagcount != bag->count) SETERRQ2(comm,PETSC_ERR_ARG_INCOMP,"Bag in file has different number of entries %d then passed in bag %d\n",(int)bagcount,(int)bag->count);
712: PetscViewerBinaryRead(view,bag->bagname,PETSC_BAG_NAME_LENGTH,PETSC_CHAR);
713: PetscViewerBinaryRead(view,bag->baghelp,PETSC_BAG_HELP_LENGTH,PETSC_CHAR);
715: nitem = bag->bagitems;
716: for (i=0; i<bagcount; i++) {
717: PetscViewerBinaryRead(view,&offset,1,PETSC_INT);
718: /* ignore the offset in the file */
719: PetscViewerBinaryRead(view,&dtype,1,PETSC_INT);
720: PetscViewerBinaryRead(view,name,PETSC_BAG_NAME_LENGTH,PETSC_CHAR);
721: PetscViewerBinaryRead(view,help,PETSC_BAG_HELP_LENGTH,PETSC_CHAR);
722: PetscViewerBinaryRead(view,&msize,1,PETSC_INT);
724: if (dtype == (PetscInt) PETSC_CHAR) {
725: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,PETSC_CHAR);
726: } else if (dtype == (PetscInt) PETSC_REAL) {
727: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,PETSC_REAL);
728: } else if (dtype == (PetscInt) PETSC_SCALAR) {
729: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,1,PETSC_SCALAR);
730: } else if (dtype == (PetscInt) PETSC_INT) {
731: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,PETSC_INT);
732: } else if (dtype == (PetscInt) PETSC_BOOL) {
733: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,1,PETSC_BOOL);
734: } else if (dtype == (PetscInt) PETSC_ENUM) {
735: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,1,PETSC_ENUM);
736: PetscViewerBinaryReadStringArray(view,&list);
737: /* don't need to save list because it is already registered in the bag */
738: PetscFree(list);
739: }
740: nitem = nitem->next;
741: }
742: return(0);
743: }
747: /*@
748: PetscBagCreate - Create a bag of values
750: Collective on MPI_Comm
752: Level: Intermediate
754: Input Parameters:
755: + comm - communicator to share bag
756: - bagsize - size of the C structure holding the values
758: Output Parameter:
759: . bag - the bag of values
761: Notes:
762: The size of the A struct must be small enough to fit in a PetscInt; by default
763: PetscInt is 4 bytes; this means a bag cannot be larger than 2 gigabytes in length.
764: The warning about casting to a shorter length can be ignored below unless your A struct is too large
766: .seealso: PetscBag, PetscBagGetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
767: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
768: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
769: @*/
770: PetscErrorCode PetscBagCreate(MPI_Comm comm, size_t bagsize, PetscBag *bag)
771: {
773: size_t totalsize = bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar);
776: PetscInfo1(NULL,"Creating Bag with total size %d\n",(int)totalsize);
777: PetscMalloc(totalsize,bag);
778: PetscMemzero(*bag,bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar));
780: (*bag)->bagsize = bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar);
781: (*bag)->bagcomm = comm;
782: (*bag)->bagprefix = NULL;
783: (*bag)->structlocation = (void*)(((char*)(*bag)) + sizeof(PetscScalar)*(sizeof(struct _n_PetscBag)/sizeof(PetscScalar)) + sizeof(PetscScalar));
784: return(0);
785: }
789: /*@C
790: PetscBagSetName - Sets the name of a bag of values
792: Not Collective
794: Level: Intermediate
796: Input Parameters:
797: + bag - the bag of values
798: . name - the name assigned to the bag
799: - help - help message for bag
801: .seealso: PetscBag, PetscBagGetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
802: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
803: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
804: @*/
806: PetscErrorCode PetscBagSetName(PetscBag bag, const char *name, const char *help)
807: {
811: PetscStrncpy(bag->bagname,name,PETSC_BAG_NAME_LENGTH-1);
812: PetscStrncpy(bag->baghelp,help,PETSC_BAG_HELP_LENGTH-1);
813: return(0);
814: }
819: /*@C
820: PetscBagGetName - Gets the name of a bag of values
822: Not Collective
824: Level: Intermediate
826: Input Parameter:
827: . bag - the bag of values
829: Output Parameter:
830: . name - the name assigned to the bag
832: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
833: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
834: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
835: @*/
836: PetscErrorCode PetscBagGetName(PetscBag bag, char **name)
837: {
839: *name = bag->bagname;
840: return(0);
841: }
845: /*@C
846: PetscBagGetData - Gives back the user - access to memory that
847: should be used for storing user-data-structure
849: Not Collective
851: Level: Intermediate
853: Input Parameter:
854: . bag - the bag of values
856: Output Parameter:
857: . data - pointer to memory that will have user-data-structure
859: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad()
860: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
861: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
862: @*/
863: PetscErrorCode PetscBagGetData(PetscBag bag, void **data)
864: {
866: *data = bag->structlocation;
867: return(0);
868: }
872: /*@C
873: PetscBagSetOptionsPrefix - Sets the prefix used for searching for all
874: PetscBag items in the options database.
876: Logically collective on Bag.
878: Level: Intermediate
880: Input Parameters:
881: + bag - the bag of values
882: - prefix - the prefix to prepend all Bag item names with.
884: NOTES: Must be called prior to registering any of the bag items.
886: .seealso: PetscBag, PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
887: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
888: @*/
890: PetscErrorCode PetscBagSetOptionsPrefix(PetscBag bag, const char pre[])
891: {
895: if (!pre) {
896: PetscFree(bag->bagprefix);
897: } else {
898: if (pre[0] == '-') SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Options prefix should not begin with a hypen");
899: PetscFree(bag->bagprefix);
900: PetscStrallocpy(pre,&(bag->bagprefix));
901: }
902: return(0);
903: }