Actual source code: bag.c
petsc-3.9.4 2018-09-11
2: #include <petsc/private/bagimpl.h>
3: #include <petscviewer.h>
5: /*
6: Adds item to the linked list in a bag
7: */
8: static PetscErrorCode PetscBagRegister_Private(PetscBag bag,PetscBagItem item,const char *name,const char *help)
9: {
13: PetscStrncpy(item->name,name,PETSC_BAG_NAME_LENGTH-1);
14: PetscStrncpy(item->help,help,PETSC_BAG_HELP_LENGTH-1);
15: if (!bag->bagitems) bag->bagitems = item;
16: else {
17: PetscBagItem nitem = bag->bagitems;
18: while (nitem->next) {
19: nitem = nitem->next;
20: }
21: nitem->next = item;
22: }
23: bag->count++;
24: return(0);
25: }
27: /*@C
28: PetscBagRegisterEnum - add an enum value to the bag
30: Logically Collective on PetscBag
32: Input Parameter:
33: + bag - the bag of values
34: . addr - location of enum in struct
35: . mdefault - the initial value
36: . list - array of strings containing names of enum values followed by enum name followed by enum prefix
37: - help - longer string with more information about the value
39: Level: beginner
41: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
42: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
43: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName()
45: @*/
46: PetscErrorCode PetscBagRegisterEnum(PetscBag bag,void *addr,const char *const *list,PetscEnum mdefault, const char *name, const char *help)
47: {
49: PetscBagItem item;
50: char nname[PETSC_BAG_NAME_LENGTH+1];
51: PetscBool printhelp;
52: PetscInt i = 0;
55: nname[0] = '-';
56: nname[1] = 0;
57: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
58: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
59: if (printhelp) {
60: while (list[i++]) ;
61: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%s>: (%s) %s (choose one of) ",bag->bagprefix ? bag->bagprefix : "",name,list[mdefault],list[i-3],help);
62: for (i=0; list[i+2]; i++) {
63: (*PetscHelpPrintf)(bag->bagcomm," %s",list[i]);
64: }
65: (*PetscHelpPrintf)(bag->bagcomm,"\n");
66: }
67: PetscOptionsGetEnum(NULL,bag->bagprefix,nname,list,&mdefault,NULL);
69: PetscNew(&item);
70: item->dtype = PETSC_ENUM;
71: item->offset = ((char*)addr) - ((char*)bag);
72: 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);
73: item->next = 0;
74: item->msize = 1;
75: PetscStrArrayallocpy(list,(char***)&item->list);
76: *(PetscEnum*)addr = mdefault;
77: PetscBagRegister_Private(bag,item,name,help);
78: return(0);
79: }
81: /*@C
82: PetscBagRegisterIntArray - add an integer value to the bag
84: Logically Collective on PetscBag
86: Input Parameter:
87: + bag - the bag of values
88: . addr - location of integer in struct
89: . msize - number of entries in array
90: . name - name of the integer array
91: - help - longer string with more information about the value
93: Level: beginner
95: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
96: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
97: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
99: @*/
100: PetscErrorCode PetscBagRegisterIntArray(PetscBag bag,void *addr,PetscInt msize, const char *name, const char *help)
101: {
103: PetscBagItem item;
104: char nname[PETSC_BAG_NAME_LENGTH+1];
105: PetscBool printhelp;
106: PetscInt i,tmp = msize;
109: /* PetscMemzero(addr,msize*sizeof(PetscInt));*/
110: nname[0] = '-';
111: nname[1] = 0;
112: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
113: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
114: if (printhelp) {
115: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <",bag->bagprefix ? bag->bagprefix : "",name);
116: for (i=0; i<msize; i++) {
117: (*PetscHelpPrintf)(bag->bagcomm,"%D ",*((PetscInt*)addr)+i);
118: }
119: (*PetscHelpPrintf)(bag->bagcomm,">: %s \n",help);
120: }
121: PetscOptionsGetIntArray(NULL,bag->bagprefix,nname,(PetscInt*)addr,&tmp,NULL);
123: PetscNew(&item);
124: item->dtype = PETSC_INT;
125: item->offset = ((char*)addr) - ((char*)bag);
126: 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);
127: item->next = 0;
128: item->msize = msize;
129: PetscBagRegister_Private(bag,item,name,help);
130: return(0);
131: }
133: /*@C
134: PetscBagRegisterRealArray - add an real array to the bag
136: Logically Collective on PetscBag
138: Input Parameter:
139: + bag - the bag of values
140: . addr - location of real array in struct
141: . msize - number of entries in array
142: . name - name of the integer array
143: - help - longer string with more information about the value
145: Level: beginner
147: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
148: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
149: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
151: @*/
152: PetscErrorCode PetscBagRegisterRealArray(PetscBag bag,void *addr,PetscInt msize, const char *name, const char *help)
153: {
155: PetscBagItem item;
156: char nname[PETSC_BAG_NAME_LENGTH+1];
157: PetscBool printhelp;
158: PetscInt i,tmp = msize;
161: /* PetscMemzero(addr,msize*sizeof(PetscInt));*/
162: nname[0] = '-';
163: nname[1] = 0;
164: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
165: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
166: if (printhelp) {
167: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <",bag->bagprefix ? bag->bagprefix : "",name);
168: for (i=0; i<msize; i++) {
169: (*PetscHelpPrintf)(bag->bagcomm,"%g ",(double)*((PetscReal*)addr)+i);
170: }
171: (*PetscHelpPrintf)(bag->bagcomm,">: %s \n",help);
172: }
173: PetscOptionsGetRealArray(NULL,bag->bagprefix,nname,(PetscReal*)addr,&tmp,NULL);
175: PetscNew(&item);
176: item->dtype = PETSC_REAL;
177: item->offset = ((char*)addr) - ((char*)bag);
178: 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);
179: item->next = 0;
180: item->msize = msize;
181: PetscBagRegister_Private(bag,item,name,help);
182: return(0);
183: }
185: /*@C
186: PetscBagRegisterInt - add an integer value to the bag
188: Logically Collective on PetscBag
190: Input Parameter:
191: + bag - the bag of values
192: . addr - location of integer in struct
193: . mdefault - the initial value
194: . name - name of the integer
195: - help - longer string with more information about the value
197: Level: beginner
199: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
200: PetscBagRegisterInt64(), PetscBagRegisterBool(), PetscBagRegisterScalar()
201: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
203: @*/
204: PetscErrorCode PetscBagRegisterInt(PetscBag bag,void *addr,PetscInt mdefault,const char *name,const char *help)
205: {
207: PetscBagItem item;
208: char nname[PETSC_BAG_NAME_LENGTH+1];
209: PetscBool printhelp;
212: nname[0] = '-';
213: nname[1] = 0;
214: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
215: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
216: if (printhelp) {
217: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%d>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,mdefault,help);
218: }
219: PetscOptionsGetInt(NULL,bag->bagprefix,nname,&mdefault,NULL);
221: PetscNew(&item);
222: item->dtype = PETSC_INT;
223: item->offset = ((char*)addr) - ((char*)bag);
224: 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);
225: item->next = 0;
226: item->msize = 1;
227: *(PetscInt*)addr = mdefault;
228: PetscBagRegister_Private(bag,item,name,help);
229: return(0);
230: }
232: /*@C
233: PetscBagRegisterInt64 - add an integer value to the bag
235: Logically Collective on PetscBag
237: Input Parameter:
238: + bag - the bag of values
239: . addr - location of integer in struct
240: . mdefault - the initial value
241: . name - name of the integer
242: - help - longer string with more information about the value
244: Level: beginner
246: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
247: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
248: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
250: @*/
251: PetscErrorCode PetscBagRegisterInt64(PetscBag bag,void *addr,PetscInt64 mdefault,const char *name,const char *help)
252: {
254: PetscBagItem item;
255: char nname[PETSC_BAG_NAME_LENGTH+1];
256: PetscBool printhelp;
257: PetscInt odefault = (PetscInt)mdefault;
258: PetscBool flg;
259:
261: nname[0] = '-';
262: nname[1] = 0;
263: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
264: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
265: if (printhelp) {
266: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%d>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,odefault,help);
267: }
268: PetscOptionsGetInt(NULL,bag->bagprefix,nname,&odefault,&flg);
269: if (flg) mdefault = (PetscInt64)odefault;
271: PetscNew(&item);
272: item->dtype = PETSC_INT;
273: item->offset = ((char*)addr) - ((char*)bag);
274: 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);
275: item->next = 0;
276: item->msize = 1;
277: *(PetscInt64*)addr = mdefault;
278: PetscBagRegister_Private(bag,item,name,help);
279: return(0);
280: }
282: /*@C
283: PetscBagRegisterBoolArray - add a n logical values to the bag
285: Logically Collective on PetscBag
287: Input Parameter:
288: + bag - the bag of values
289: . addr - location of boolean array in struct
290: . msize - number of entries in array
291: . name - name of the boolean array
292: - help - longer string with more information about the value
294: Level: beginner
296: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
297: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
298: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
300: @*/
301: PetscErrorCode PetscBagRegisterBoolArray(PetscBag bag,void *addr,PetscInt msize, const char* name, const char* help)
302: {
304: PetscBagItem item;
305: char nname[PETSC_BAG_NAME_LENGTH+1];
306: PetscBool printhelp;
307: PetscInt i,tmp = msize;
310: nname[0] = '-';
311: nname[1] = 0;
312: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
313: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
314: if (printhelp) {
315: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <",bag->bagprefix?bag->bagprefix:"",name);
316: for (i=0; i<msize; i++) {
317: (*PetscHelpPrintf)(bag->bagcomm,"%D ",*((PetscInt*)addr)+i);
318: }
319: (*PetscHelpPrintf)(bag->bagcomm,">: %s \n",help);
320: }
321: PetscOptionsGetBoolArray(NULL,bag->bagprefix,nname,(PetscBool*)addr,&tmp,NULL);
323: PetscNew(&item);
324: item->dtype = PETSC_BOOL;
325: item->offset = ((char*)addr) - ((char*)bag);
326: 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);
327: item->next = 0;
328: item->msize = msize;
329: PetscBagRegister_Private(bag,item,name,help);
330: return(0);
331: }
333: /*@C
334: PetscBagRegisterString - add a string value to the bag
336: Logically Collective on PetscBag
338: Input Parameter:
339: + bag - the bag of values
340: . addr - location of start of string in struct
341: . msize - length of the string space in the struct
342: . mdefault - the initial value
343: . name - name of the string
344: - help - longer string with more information about the value
346: Level: beginner
348: Note: The struct should have the field char mystring[msize]; not char *mystring
350: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
351: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
352: PetscBagSetFromOptions(),PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
354: @*/
355: PetscErrorCode PetscBagRegisterString(PetscBag bag,void *addr,PetscInt msize,const char* mdefault,const char* name,const char* help)
356: {
358: PetscBagItem item;
359: char nname[PETSC_BAG_NAME_LENGTH+1];
360: PetscBool printhelp;
363: nname[0] = '-';
364: nname[1] = 0;
365: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
366: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
367: if (printhelp) {
368: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%s>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,mdefault,help);
369: }
371: PetscNew(&item);
372: item->dtype = PETSC_CHAR;
373: item->offset = ((char*)addr) - ((char*)bag);
374: 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);
375: item->next = 0;
376: item->msize = msize;
377: if (mdefault != (char*)addr) {
378: PetscStrncpy((char*)addr,mdefault,msize-1);
379: }
380: PetscOptionsGetString(NULL,bag->bagprefix,nname,(char*)addr,msize,NULL);
381: PetscBagRegister_Private(bag,item,name,help);
382: return(0);
383: }
385: /*@C
386: PetscBagRegisterReal - add a real value to the bag
388: Logically Collective on PetscBag
390: Input Parameter:
391: + bag - the bag of values
392: . addr - location of double in struct
393: . mdefault - the initial value
394: . name - name of the variable
395: - help - longer string with more information about the value
397: Level: beginner
399: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
400: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
401: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
403: @*/
404: PetscErrorCode PetscBagRegisterReal(PetscBag bag,void *addr,PetscReal mdefault, const char *name, const char *help)
405: {
407: PetscBagItem item;
408: char nname[PETSC_BAG_NAME_LENGTH+1];
409: PetscBool printhelp;
412: nname[0] = '-';
413: nname[1] = 0;
414: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
415: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
416: if (printhelp) {
417: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%g>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,(double)mdefault,help);
418: }
419: PetscOptionsGetReal(NULL,bag->bagprefix,nname,&mdefault,NULL);
421: PetscNew(&item);
422: item->dtype = PETSC_REAL;
423: item->offset = ((char*)addr) - ((char*)bag);
424: 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);
425: item->next = 0;
426: item->msize = 1;
427: *(PetscReal*)addr = mdefault;
428: PetscBagRegister_Private(bag,item,name,help);
429: return(0);
430: }
432: /*@C
433: PetscBagRegisterScalar - add a real or complex number value to the bag
435: Logically Collective on PetscBag
437: Input Parameter:
438: + bag - the bag of values
439: . addr - location of scalar in struct
440: . mdefault - the initial value
441: . name - name of the variable
442: - help - longer string with more information about the value
445: Level: beginner
447: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
448: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
449: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
451: @*/
452: PetscErrorCode PetscBagRegisterScalar(PetscBag bag,void *addr,PetscScalar mdefault,const char *name,const char *help)
453: {
455: PetscBagItem item;
456: char nname[PETSC_BAG_NAME_LENGTH+1];
457: PetscBool printhelp;
460: nname[0] = '-';
461: nname[1] = 0;
462: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
463: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
464: if (printhelp) {
465: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%g + %gi>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,(double)PetscRealPart(mdefault),(double)PetscImaginaryPart(mdefault),help);
466: }
467: PetscOptionsGetScalar(NULL,bag->bagprefix,nname,&mdefault,NULL);
469: PetscNew(&item);
470: item->dtype = PETSC_SCALAR;
471: item->offset = ((char*)addr) - ((char*)bag);
472: 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);
473: item->next = 0;
474: item->msize = 1;
475: *(PetscScalar*)addr = mdefault;
476: PetscBagRegister_Private(bag,item,name,help);
477: return(0);
478: }
480: /*@C
481: PetscBagRegisterBool - add a logical value to the bag
483: Logically Collective on PetscBag
485: Input Parameter:
486: + bag - the bag of values
487: . addr - location of logical in struct
488: . mdefault - the initial value
489: . name - name of the variable
490: - help - longer string with more information about the value
493: Level: beginner
495: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
496: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
497: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
499: @*/
500: PetscErrorCode PetscBagRegisterBool(PetscBag bag,void *addr,PetscBool mdefault,const char *name,const char *help)
501: {
503: PetscBagItem item;
504: char nname[PETSC_BAG_NAME_LENGTH+1];
505: PetscBool printhelp;
508: /* the checks here with != PETSC_FALSE and PETSC_TRUE is a special case; here we truly demand that the value be 0 or 1 */
509: 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);
510: nname[0] = '-';
511: nname[1] = 0;
512: PetscStrlcat(nname,name,PETSC_BAG_NAME_LENGTH);
513: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
514: if (printhelp) {
515: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%s>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,PetscBools[mdefault],help);
516: }
517: PetscOptionsGetBool(NULL,bag->bagprefix,nname,&mdefault,NULL);
519: PetscNew(&item);
520: item->dtype = PETSC_BOOL;
521: item->offset = ((char*)addr) - ((char*)bag);
522: 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);
523: item->next = 0;
524: item->msize = 1;
525: *(PetscBool*)addr = mdefault;
526: PetscBagRegister_Private(bag,item,name,help);
527: return(0);
528: }
530: /*@C
531: PetscBagDestroy - Destroys a bag values
533: Collective on PetscBag
535: Input Parameter:
536: . bag - the bag of values
538: Level: beginner
540: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
541: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
542: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
544: @*/
545: PetscErrorCode PetscBagDestroy(PetscBag *bag)
546: {
548: PetscBagItem nitem = (*bag)->bagitems,item;
551: while (nitem) {
552: item = nitem->next;
553: if (nitem->list) {
554: PetscStrArrayDestroy(&nitem->list);
555: }
556: PetscFree(nitem);
557: nitem = item;
558: }
559: if ((*bag)->bagprefix) { PetscFree((*bag)->bagprefix); }
560: PetscFree(*bag);
561: return(0);
562: }
564: /*@
565: PetscBagSetFromOptions - Allows setting options from a bag
567: Collective on PetscBag
569: Input Parameter:
570: . bag - the bag of values
572: Level: beginner
574: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagLoad(), PetscBagGetData()
575: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
576: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagView(), PetscBagRegisterEnum()
578: @*/
579: PetscErrorCode PetscBagSetFromOptions(PetscBag bag)
580: {
582: PetscBagItem nitem = bag->bagitems;
583: char name[PETSC_BAG_NAME_LENGTH+1],helpname[PETSC_BAG_NAME_LENGTH+PETSC_BAG_HELP_LENGTH+3];
584: PetscInt n;
587: PetscStrncpy(helpname,bag->bagname,sizeof(helpname));
588: PetscStrlcat(helpname," ",sizeof(helpname));
589: PetscStrlcat(helpname,bag->baghelp,sizeof(helpname));
590: PetscOptionsBegin(bag->bagcomm,bag->bagprefix,helpname,0);
591: while (nitem) {
592: name[0] = '-';
593: name[1] = 0;
594: PetscStrlcat(name,nitem->name,sizeof(name));
595: if (nitem->dtype == PETSC_CHAR) { /* special handling for fortran required? [due to space padding vs null termination] */
596: char *value = (char*)(((char*)bag) + nitem->offset);
597: PetscOptionsString(name,nitem->help,"",value,value,nitem->msize,NULL);
598: } else if (nitem->dtype == PETSC_REAL) {
599: PetscReal *value = (PetscReal*)(((char*)bag) + nitem->offset);
600: if (nitem->msize == 1) {
601: PetscOptionsReal(name,nitem->help,"",*value,value,NULL);
602: } else {
603: n = nitem->msize;
604: PetscOptionsRealArray(name,nitem->help,"",value,&n,NULL);
605: }
606: } else if (nitem->dtype == PETSC_SCALAR) {
607: PetscScalar *value = (PetscScalar*)(((char*)bag) + nitem->offset);
608: PetscOptionsScalar(name,nitem->help,"",*value,value,NULL);
609: } else if (nitem->dtype == PETSC_INT) {
610: PetscInt *value = (PetscInt*)(((char*)bag) + nitem->offset);
611: if (nitem->msize == 1) {
612: PetscOptionsInt(name,nitem->help,"",*value,value,NULL);
613: } else {
614: n = nitem->msize;
615: PetscOptionsIntArray(name,nitem->help,"",value,&n,NULL);
616: }
617: } else if (nitem->dtype == PETSC_ENUM) {
618: PetscEnum *value = (PetscEnum*)(((char*)bag) + nitem->offset);
619: PetscInt i = 0;
620: while (nitem->list[i++]) ;
621: PetscOptionsEnum(name,nitem->help,nitem->list[i-3],(const char*const*)nitem->list,*value,value,NULL);
622: } else if (nitem->dtype == PETSC_BOOL) {
623: PetscBool *value = (PetscBool*)(((char*)bag) + nitem->offset);
624: if (nitem->msize == 1) {
625: PetscOptionsBool(name,nitem->help,"",*value,value,NULL);
626: } else {
627: n = nitem->msize;
628: PetscOptionsBoolArray(name,nitem->help,"",value,&n,NULL);
629: }
630: }
631: nitem = nitem->next;
632: }
633: PetscOptionsEnd();
634: return(0);
635: }
637: /*@C
638: PetscBagView - Views a bag of values as either ASCII text or a binary file
640: Collective on PetscBag
642: Input Parameter:
643: + bag - the bag of values
644: - viewer - location to view the values
646: Level: beginner
648: Warning: Currently PETSc bags saved in a binary file can only be read back
649: in on a machine of the same architecture. Let us know when this is a problem
650: and we'll fix it.
652: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagLoad(), PetscBagGetData()
653: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar(), PetscBagRegisterEnum()
654: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName()
656: @*/
657: PetscErrorCode PetscBagView(PetscBag bag,PetscViewer view)
658: {
659: PetscBool isascii,isbinary;
661: PetscBagItem nitem = bag->bagitems;
664: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERASCII,&isascii);
665: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERBINARY,&isbinary);
666: if (isascii) {
667: if (bag->bagprefix) {
668: PetscViewerASCIIPrintf(view,"PetscBag Object: %s (%s) %s\n",bag->bagname,bag->bagprefix,bag->baghelp);
669: } else {
670: PetscViewerASCIIPrintf(view,"PetscBag Object: %s %s\n",bag->bagname,bag->baghelp);
671: }
672: while (nitem) {
673: if (nitem->dtype == PETSC_CHAR) {
674: char *value = (char*)(((char*)bag) + nitem->offset);
675: char tmp = value[nitem->msize-1]; /* special handling for fortran chars wihout null terminator */
676: value[nitem->msize-1] =0;
677: PetscViewerASCIIPrintf(view," %s = %s; %s\n",nitem->name,value,nitem->help);
678: value[nitem->msize-1] = tmp;
679: } else if (nitem->dtype == PETSC_REAL) {
680: PetscReal *value = (PetscReal*)(((char*)bag) + nitem->offset);
681: PetscInt i;
682: PetscViewerASCIIPrintf(view," %s = ",nitem->name);
683: for (i=0; i<nitem->msize; i++) {
684: PetscViewerASCIIPrintf(view,"%g ",(double)value[i]);
685: }
686: PetscViewerASCIIPrintf(view,"; %s\n",nitem->help);
687: } else if (nitem->dtype == PETSC_SCALAR) {
688: PetscScalar value = *(PetscScalar*)(((char*)bag) + nitem->offset);
689: #if defined(PETSC_USE_COMPLEX)
690: if ((double)PetscImaginaryPart(value)) {
691: PetscViewerASCIIPrintf(view," %s = %g + %gi; %s\n",nitem->name,(double)PetscRealPart(value),(double)PetscImaginaryPart(value),nitem->help);
692: } else {
693: PetscViewerASCIIPrintf(view," %s = %g; %s\n",nitem->name,(double)PetscRealPart(value),nitem->help);
694: }
695: #else
696: PetscViewerASCIIPrintf(view," %s = %g; %s\n",nitem->name,(double)value,nitem->help);
697: #endif
698: } else if (nitem->dtype == PETSC_INT) {
699: PetscInt i,*value = (PetscInt*)(((char*)bag) + nitem->offset);
700: PetscViewerASCIIPrintf(view," %s = ",nitem->name);
701: for (i=0; i<nitem->msize; i++) {
702: PetscViewerASCIIPrintf(view,"%D ",value[i]);
703: }
704: PetscViewerASCIIPrintf(view,"; %s\n",nitem->help);
705: } else if (nitem->dtype == PETSC_BOOL) {
706: PetscBool *value = (PetscBool*)(((char*)bag) + nitem->offset);
707: PetscInt i;
708: /* some Fortran compilers use -1 as boolean */
709: PetscViewerASCIIPrintf(view," %s = ",nitem->name);
710: for (i=0; i<nitem->msize; i++) {
711: if (((int) value[i]) == -1) value[i] = PETSC_TRUE;
712: /* the checks here with != PETSC_FALSE and PETSC_TRUE is a special case; here we truly demand that the value be 0 or 1 */
713: if (value[i] != PETSC_FALSE && value[i] != PETSC_TRUE) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Boolean value for %s %s is corrupt; integer value %d",nitem->name,nitem->help,value);
714: PetscViewerASCIIPrintf(view," %s",PetscBools[value[i]]);
715: }
716: PetscViewerASCIIPrintf(view,"; %s\n",nitem->help);
717: } else if (nitem->dtype == PETSC_ENUM) {
718: PetscEnum value = *(PetscEnum*)(((char*)bag) + nitem->offset);
719: PetscInt i = 0;
720: while (nitem->list[i++]) ;
721: PetscViewerASCIIPrintf(view," %s = %s; (%s) %s\n",nitem->name,nitem->list[value],nitem->list[i-3],nitem->help);
722: }
723: nitem = nitem->next;
724: }
725: } else if (isbinary) {
726: PetscInt classid = PETSC_BAG_FILE_CLASSID, dtype;
727: PetscInt deprecatedbagsize = 0;
728: PetscViewerFormat format;
729: PetscViewerBinaryWrite(view,&classid,1,PETSC_INT,PETSC_TRUE);
730: PetscViewerBinaryWrite(view,&deprecatedbagsize,1,PETSC_INT,PETSC_FALSE);
731: PetscViewerBinaryWrite(view,&bag->count,1,PETSC_INT,PETSC_FALSE);
732: PetscViewerBinaryWrite(view,bag->bagname,PETSC_BAG_NAME_LENGTH,PETSC_CHAR,PETSC_FALSE);
733: PetscViewerBinaryWrite(view,bag->baghelp,PETSC_BAG_HELP_LENGTH,PETSC_CHAR,PETSC_FALSE);
734: while (nitem) {
735: PetscViewerBinaryWrite(view,&nitem->offset,1,PETSC_INT,PETSC_FALSE);
736: dtype = (PetscInt)nitem->dtype;
737: PetscViewerBinaryWrite(view,&dtype,1,PETSC_INT,PETSC_FALSE);
738: PetscViewerBinaryWrite(view,nitem->name,PETSC_BAG_NAME_LENGTH,PETSC_CHAR,PETSC_FALSE);
739: PetscViewerBinaryWrite(view,nitem->help,PETSC_BAG_HELP_LENGTH,PETSC_CHAR,PETSC_FALSE);
740: PetscViewerBinaryWrite(view,&nitem->msize,1,PETSC_INT,PETSC_FALSE);
741: /* some Fortran compilers use -1 as boolean */
742: if (dtype == PETSC_BOOL && ((*(int*) (((char*)bag) + nitem->offset) == -1))) *(int*) (((char*)bag) + nitem->offset) = PETSC_TRUE;
744: PetscViewerBinaryWrite(view,(((char*)bag) + nitem->offset),nitem->msize,nitem->dtype,PETSC_FALSE);
745: if (dtype == PETSC_ENUM) {
746: PetscViewerBinaryWriteStringArray(view,(const char* const*)nitem->list);
747: }
748: nitem = nitem->next;
749: }
750: PetscViewerGetFormat(view,&format);
751: if (format == PETSC_VIEWER_BINARY_MATLAB) {
752: MPI_Comm comm;
753: FILE *info;
754: PetscObjectGetComm((PetscObject)view,&comm);
755: PetscViewerBinaryGetInfoPointer(view,&info);
756: PetscFPrintf(comm,info,"#--- begin code written by PetscViewerBinary for MATLAB format ---#\n");
757: PetscFPrintf(comm,info,"#$$ Set.%s = PetscBinaryRead(fd);\n",bag->bagname);
758: PetscFPrintf(comm,info,"#--- end code written by PetscViewerBinary for MATLAB format ---#\n\n");
759: }
760: }
761: return(0);
762: }
764: /*@C
765: PetscBagLoad - Loads a bag of values from a binary file
767: Collective on PetscViewer
769: Input Parameter:
770: + viewer - file to load values from
771: - bag - the bag of values
773: Notes: You must have created and registered all the fields in the bag before loading into it.
775: Notes:
776: Level: beginner
778: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagView(), PetscBagGetData()
779: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
780: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
782: @*/
783: PetscErrorCode PetscBagLoad(PetscViewer view,PetscBag bag)
784: {
786: PetscBool isbinary;
787: PetscInt classid,bagcount,i,dtype,msize,offset,deprecatedbagsize;
788: char name[PETSC_BAG_NAME_LENGTH],help[PETSC_BAG_HELP_LENGTH],**list;
789: PetscBagItem nitem;
790: MPI_Comm comm;
791: PetscMPIInt flag;
794: PetscObjectGetComm((PetscObject)view,&comm);
795: MPI_Comm_compare(comm,bag->bagcomm,&flag);
796: if (flag != MPI_CONGRUENT && flag != MPI_IDENT) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NOTSAMECOMM,"Different communicators in the viewer and bag"); \
797: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERBINARY,&isbinary);
798: if (!isbinary) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for this viewer type");
800: PetscViewerBinaryRead(view,&classid,1,NULL,PETSC_INT);
801: if (classid != PETSC_BAG_FILE_CLASSID) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Not PetscBag next in binary file");
802: PetscViewerBinaryRead(view,&deprecatedbagsize,1,NULL,PETSC_INT);
803: PetscViewerBinaryRead(view,&bagcount,1,NULL,PETSC_INT);
804: 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);
805: PetscViewerBinaryRead(view,bag->bagname,PETSC_BAG_NAME_LENGTH,NULL,PETSC_CHAR);
806: PetscViewerBinaryRead(view,bag->baghelp,PETSC_BAG_HELP_LENGTH,NULL,PETSC_CHAR);
808: nitem = bag->bagitems;
809: for (i=0; i<bagcount; i++) {
810: PetscViewerBinaryRead(view,&offset,1,NULL,PETSC_INT);
811: /* ignore the offset in the file */
812: PetscViewerBinaryRead(view,&dtype,1,NULL,PETSC_INT);
813: PetscViewerBinaryRead(view,name,PETSC_BAG_NAME_LENGTH,NULL,PETSC_CHAR);
814: PetscViewerBinaryRead(view,help,PETSC_BAG_HELP_LENGTH,NULL,PETSC_CHAR);
815: PetscViewerBinaryRead(view,&msize,1,NULL,PETSC_INT);
817: if (dtype == (PetscInt) PETSC_CHAR) {
818: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,NULL,PETSC_CHAR);
819: } else if (dtype == (PetscInt) PETSC_REAL) {
820: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,NULL,PETSC_REAL);
821: } else if (dtype == (PetscInt) PETSC_SCALAR) {
822: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,1,NULL,PETSC_SCALAR);
823: } else if (dtype == (PetscInt) PETSC_INT) {
824: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,NULL,PETSC_INT);
825: } else if (dtype == (PetscInt) PETSC_BOOL) {
826: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,NULL,PETSC_BOOL);
827: } else if (dtype == (PetscInt) PETSC_ENUM) {
828: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,1,NULL,PETSC_ENUM);
829: PetscViewerBinaryReadStringArray(view,&list);
830: /* don't need to save list because it is already registered in the bag */
831: PetscFree(list);
832: }
833: nitem = nitem->next;
834: }
835: return(0);
836: }
838: /*@C
839: PetscBagCreate - Create a bag of values
841: Collective on MPI_Comm
843: Level: Intermediate
845: Input Parameters:
846: + comm - communicator to share bag
847: - bagsize - size of the C structure holding the values
849: Output Parameter:
850: . bag - the bag of values
852: Notes:
853: The size of the A struct must be small enough to fit in a PetscInt; by default
854: PetscInt is 4 bytes; this means a bag cannot be larger than 2 gigabytes in length.
855: The warning about casting to a shorter length can be ignored below unless your A struct is too large
857: .seealso: PetscBag, PetscBagGetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
858: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
859: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
860: @*/
861: PetscErrorCode PetscBagCreate(MPI_Comm comm, size_t bagsize, PetscBag *bag)
862: {
864: size_t totalsize = bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar);
867: PetscInfo1(NULL,"Creating Bag with total size %d\n",(int)totalsize);
868: PetscMalloc(totalsize,bag);
869: PetscMemzero(*bag,bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar));
871: (*bag)->bagsize = bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar);
872: (*bag)->bagcomm = comm;
873: (*bag)->bagprefix = NULL;
874: (*bag)->structlocation = (void*)(((char*)(*bag)) + sizeof(PetscScalar)*(sizeof(struct _n_PetscBag)/sizeof(PetscScalar)) + sizeof(PetscScalar));
875: return(0);
876: }
878: /*@C
879: PetscBagSetName - Sets the name of a bag of values
881: Not Collective
883: Level: Intermediate
885: Input Parameters:
886: + bag - the bag of values
887: . name - the name assigned to the bag
888: - help - help message for bag
890: .seealso: PetscBag, PetscBagGetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
891: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
892: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
893: @*/
895: PetscErrorCode PetscBagSetName(PetscBag bag, const char *name, const char *help)
896: {
900: PetscStrncpy(bag->bagname,name,PETSC_BAG_NAME_LENGTH-1);
901: PetscStrncpy(bag->baghelp,help,PETSC_BAG_HELP_LENGTH-1);
902: return(0);
903: }
906: /*@C
907: PetscBagGetName - Gets the name of a bag of values
909: Not Collective
911: Level: Intermediate
913: Input Parameter:
914: . bag - the bag of values
916: Output Parameter:
917: . name - the name assigned to the bag
919: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
920: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
921: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
922: @*/
923: PetscErrorCode PetscBagGetName(PetscBag bag, char **name)
924: {
926: *name = bag->bagname;
927: return(0);
928: }
930: /*@C
931: PetscBagGetData - Gives back the user - access to memory that
932: should be used for storing user-data-structure
934: Not Collective
936: Level: Intermediate
938: Input Parameter:
939: . bag - the bag of values
941: Output Parameter:
942: . data - pointer to memory that will have user-data-structure
944: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad()
945: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
946: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
947: @*/
948: PetscErrorCode PetscBagGetData(PetscBag bag, void **data)
949: {
951: *data = bag->structlocation;
952: return(0);
953: }
955: /*@C
956: PetscBagSetOptionsPrefix - Sets the prefix used for searching for all
957: PetscBag items in the options database.
959: Logically collective on Bag.
961: Level: Intermediate
963: Input Parameters:
964: + bag - the bag of values
965: - prefix - the prefix to prepend all Bag item names with.
967: NOTES: Must be called prior to registering any of the bag items.
969: .seealso: PetscBag, PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
970: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
971: @*/
973: PetscErrorCode PetscBagSetOptionsPrefix(PetscBag bag, const char pre[])
974: {
978: if (!pre) {
979: PetscFree(bag->bagprefix);
980: } else {
981: if (pre[0] == '-') SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Options prefix should not begin with a hypen");
982: PetscFree(bag->bagprefix);
983: PetscStrallocpy(pre,&(bag->bagprefix));
984: }
985: return(0);
986: }
988: /*@C
989: PetscBagGetNames - Get the names of all entries in the bag
991: Not collective
993: Input Parameters:
994: + bag - the bag of values
995: - names - array of the correct size to hold names
997: Output Parameter:
998: . names - array of char pointers for names
1000: Level: intermediate
1002: .seealso: PetscBag, PetscBagGetName(), PetscBagSetName(), PetscBagCreate(), PetscBagGetData()
1003: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar(), PetscBagRegisterEnum()
1004: @*/
1005: PetscErrorCode PetscBagGetNames(PetscBag bag, const char *names[])
1006: {
1007: PetscBagItem nitem = bag->bagitems;
1008: PetscInt n;
1011: for (n = 0; nitem; ++n, nitem = nitem->next) {names[n] = nitem->name;}
1012: return(0);
1013: }