Actual source code: bag.c
petsc-3.7.7 2017-09-25
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,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(NULL,bag->bagprefix,nname,list,&mdefault,NULL);
73: PetscNew(&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,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(NULL,bag->bagprefix,nname,(PetscInt*)addr,&tmp,NULL);
129: PetscNew(&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,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 ",(double)*((PetscReal*)addr)+i);
178: }
179: (*PetscHelpPrintf)(bag->bagcomm,">: %s \n",help);
180: }
181: PetscOptionsGetRealArray(NULL,bag->bagprefix,nname,(PetscReal*)addr,&tmp,NULL);
183: PetscNew(&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: PetscBagRegister64bitInt(), 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,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(NULL,bag->bagprefix,nname,&mdefault,NULL);
231: PetscNew(&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: PetscBagRegister64bitInt - add an integer value to the bag
247: Logically Collective on PetscBag
249: Input Parameter:
250: + bag - the bag of values
251: . addr - location of integer in struct
252: . mdefault - the initial value
253: . name - name of the integer
254: - help - longer string with more information about the value
256: Level: beginner
258: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
259: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
260: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
262: @*/
263: PetscErrorCode PetscBagRegister64bitInt(PetscBag bag,void *addr,Petsc64bitInt mdefault,const char *name,const char *help)
264: {
266: PetscBagItem item;
267: char nname[PETSC_BAG_NAME_LENGTH+1];
268: PetscBool printhelp;
269: PetscInt odefault = (PetscInt)mdefault;
270: PetscBool flg;
271:
273: nname[0] = '-';
274: nname[1] = 0;
275: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
276: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
277: if (printhelp) {
278: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%d>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,odefault,help);
279: }
280: PetscOptionsGetInt(NULL,bag->bagprefix,nname,&odefault,&flg);
281: if (flg) mdefault = (Petsc64bitInt)odefault;
283: PetscNew(&item);
284: item->dtype = PETSC_INT;
285: item->offset = ((char*)addr) - ((char*)bag);
286: 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);
287: item->next = 0;
288: item->msize = 1;
289: *(Petsc64bitInt*)addr = mdefault;
290: PetscBagRegister_Private(bag,item,name,help);
291: return(0);
292: }
296: /*@C
297: PetscBagRegisterBoolArray - add a n logical values to the bag
299: Logically Collective on PetscBag
301: Input Parameter:
302: + bag - the bag of values
303: . addr - location of boolean array in struct
304: . msize - number of entries in array
305: . name - name of the boolean array
306: - help - longer string with more information about the value
308: Level: beginner
310: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
311: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
312: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
314: @*/
315: PetscErrorCode PetscBagRegisterBoolArray(PetscBag bag,void *addr,PetscInt msize, const char* name, const char* help)
316: {
318: PetscBagItem item;
319: char nname[PETSC_BAG_NAME_LENGTH+1];
320: PetscBool printhelp;
321: PetscInt i,tmp = msize;
324: /* PetscMemzero(addr,msize*sizeof(PetscInt));*/
325: nname[0] = '-';
326: nname[1] = 0;
327: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
328: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
329: if (printhelp) {
330: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <",bag->bagprefix?bag->bagprefix:"",name);
331: for (i=0; i<msize; i++) {
332: (*PetscHelpPrintf)(bag->bagcomm,"%D ",*((PetscInt*)addr)+i);
333: }
334: (*PetscHelpPrintf)(bag->bagcomm,">: %s \n",help);
335: }
336: PetscOptionsGetBoolArray(NULL,bag->bagprefix,nname,(PetscBool*)addr,&tmp,NULL);
338: PetscNew(&item);
339: item->dtype = PETSC_BOOL;
340: item->offset = ((char*)addr) - ((char*)bag);
341: 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);
342: item->next = 0;
343: item->msize = msize;
344: PetscBagRegister_Private(bag,item,name,help);
345: return(0);
346: }
350: /*@C
351: PetscBagRegisterString - add a string value to the bag
353: Logically Collective on PetscBag
355: Input Parameter:
356: + bag - the bag of values
357: . addr - location of start of string in struct
358: . msize - length of the string space in the struct
359: . mdefault - the initial value
360: . name - name of the string
361: - help - longer string with more information about the value
363: Level: beginner
365: Note: The struct should have the field char mystring[msize]; not char *mystring
367: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
368: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
369: PetscBagSetFromOptions(),PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
371: @*/
372: PetscErrorCode PetscBagRegisterString(PetscBag bag,void *addr,PetscInt msize,const char* mdefault,const char* name,const char* help)
373: {
375: PetscBagItem item;
376: char nname[PETSC_BAG_NAME_LENGTH+1];
377: PetscBool printhelp;
380: nname[0] = '-';
381: nname[1] = 0;
382: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
383: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
384: if (printhelp) {
385: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%s>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,mdefault,help);
386: }
388: PetscNew(&item);
389: item->dtype = PETSC_CHAR;
390: item->offset = ((char*)addr) - ((char*)bag);
391: 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);
392: item->next = 0;
393: item->msize = msize;
394: if (mdefault != (char*)addr) {
395: PetscStrncpy((char*)addr,mdefault,msize-1);
396: }
397: PetscOptionsGetString(NULL,bag->bagprefix,nname,(char*)addr,msize,NULL);
398: PetscBagRegister_Private(bag,item,name,help);
399: return(0);
400: }
404: /*@C
405: PetscBagRegisterReal - add a real value to the bag
407: Logically Collective on PetscBag
409: Input Parameter:
410: + bag - the bag of values
411: . addr - location of double in struct
412: . mdefault - the initial value
413: . name - name of the variable
414: - help - longer string with more information about the value
416: Level: beginner
418: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
419: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
420: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
422: @*/
423: PetscErrorCode PetscBagRegisterReal(PetscBag bag,void *addr,PetscReal mdefault, const char *name, const char *help)
424: {
426: PetscBagItem item;
427: char nname[PETSC_BAG_NAME_LENGTH+1];
428: PetscBool printhelp;
431: nname[0] = '-';
432: nname[1] = 0;
433: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
434: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
435: if (printhelp) {
436: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%g>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,(double)mdefault,help);
437: }
438: PetscOptionsGetReal(NULL,bag->bagprefix,nname,&mdefault,NULL);
440: PetscNew(&item);
441: item->dtype = PETSC_REAL;
442: item->offset = ((char*)addr) - ((char*)bag);
443: 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);
444: item->next = 0;
445: item->msize = 1;
446: *(PetscReal*)addr = mdefault;
447: PetscBagRegister_Private(bag,item,name,help);
448: return(0);
449: }
453: /*@C
454: PetscBagRegisterScalar - add a real or complex number value to the bag
456: Logically Collective on PetscBag
458: Input Parameter:
459: + bag - the bag of values
460: . addr - location of scalar in struct
461: . mdefault - the initial value
462: . name - name of the variable
463: - help - longer string with more information about the value
466: Level: beginner
468: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
469: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
470: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
472: @*/
473: PetscErrorCode PetscBagRegisterScalar(PetscBag bag,void *addr,PetscScalar mdefault,const char *name,const char *help)
474: {
476: PetscBagItem item;
477: char nname[PETSC_BAG_NAME_LENGTH+1];
478: PetscBool printhelp;
481: nname[0] = '-';
482: nname[1] = 0;
483: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
484: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
485: if (printhelp) {
486: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%g + %gi>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,(double)PetscRealPart(mdefault),(double)PetscImaginaryPart(mdefault),help);
487: }
488: PetscOptionsGetScalar(NULL,bag->bagprefix,nname,&mdefault,NULL);
490: PetscNew(&item);
491: item->dtype = PETSC_SCALAR;
492: item->offset = ((char*)addr) - ((char*)bag);
493: 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);
494: item->next = 0;
495: item->msize = 1;
496: *(PetscScalar*)addr = mdefault;
497: PetscBagRegister_Private(bag,item,name,help);
498: return(0);
499: }
503: /*@C
504: PetscBagRegisterBool - add a logical value to the bag
506: Logically Collective on PetscBag
508: Input Parameter:
509: + bag - the bag of values
510: . addr - location of logical in struct
511: . mdefault - the initial value
512: . name - name of the variable
513: - help - longer string with more information about the value
516: Level: beginner
518: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
519: PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
520: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
522: @*/
523: PetscErrorCode PetscBagRegisterBool(PetscBag bag,void *addr,PetscBool mdefault,const char *name,const char *help)
524: {
526: PetscBagItem item;
527: char nname[PETSC_BAG_NAME_LENGTH+1];
528: PetscBool printhelp;
531: /* the checks here with != PETSC_FALSE and PETSC_TRUE is a special case; here we truly demand that the value be 0 or 1 */
532: 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);
533: nname[0] = '-';
534: nname[1] = 0;
535: PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);
536: PetscOptionsHasName(NULL,NULL,"-help",&printhelp);
537: if (printhelp) {
538: (*PetscHelpPrintf)(bag->bagcomm," -%s%s <%s>: %s \n",bag->bagprefix ? bag->bagprefix : "",name,PetscBools[mdefault],help);
539: }
540: PetscOptionsGetBool(NULL,bag->bagprefix,nname,&mdefault,NULL);
542: PetscNew(&item);
543: item->dtype = PETSC_BOOL;
544: item->offset = ((char*)addr) - ((char*)bag);
545: 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);
546: item->next = 0;
547: item->msize = 1;
548: *(PetscBool*)addr = mdefault;
549: PetscBagRegister_Private(bag,item,name,help);
550: return(0);
551: }
555: /*@C
556: PetscBagDestroy - Destroys a bag values
558: Collective on PetscBag
560: Input Parameter:
561: . bag - the bag of values
563: Level: beginner
565: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
566: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
567: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
569: @*/
570: PetscErrorCode PetscBagDestroy(PetscBag *bag)
571: {
573: PetscBagItem nitem = (*bag)->bagitems,item;
576: while (nitem) {
577: item = nitem->next;
578: if (nitem->list) {
579: PetscStrArrayDestroy(&nitem->list);
580: }
581: PetscFree(nitem);
582: nitem = item;
583: }
584: if ((*bag)->bagprefix) { PetscFree((*bag)->bagprefix); }
585: PetscFree(*bag);
586: return(0);
587: }
591: /*@
592: PetscBagSetFromOptions - Allows setting options from a bag
594: Collective on PetscBag
596: Input Parameter:
597: . bag - the bag of values
599: Level: beginner
601: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagLoad(), PetscBagGetData()
602: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
603: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagView(), PetscBagRegisterEnum()
605: @*/
606: PetscErrorCode PetscBagSetFromOptions(PetscBag bag)
607: {
609: PetscBagItem nitem = bag->bagitems;
610: char name[PETSC_BAG_NAME_LENGTH+1],helpname[PETSC_BAG_NAME_LENGTH+PETSC_BAG_HELP_LENGTH+3];
611: PetscInt n;
614: PetscStrcpy(helpname,bag->bagname);
615: PetscStrcat(helpname," ");
616: PetscStrcat(helpname,bag->baghelp);
617: PetscOptionsBegin(bag->bagcomm,bag->bagprefix,helpname,0);
618: while (nitem) {
619: name[0] = '-';
620: name[1] = 0;
621: PetscStrcat(name,nitem->name);
622: if (nitem->dtype == PETSC_CHAR) { /* special handling for fortran required? [due to space padding vs null termination] */
623: char *value = (char*)(((char*)bag) + nitem->offset);
624: PetscOptionsString(name,nitem->help,"",value,value,nitem->msize,NULL);
625: } else if (nitem->dtype == PETSC_REAL) {
626: PetscReal *value = (PetscReal*)(((char*)bag) + nitem->offset);
627: if (nitem->msize == 1) {
628: PetscOptionsReal(name,nitem->help,"",*value,value,NULL);
629: } else {
630: n = nitem->msize;
631: PetscOptionsRealArray(name,nitem->help,"",value,&n,NULL);
632: }
633: } else if (nitem->dtype == PETSC_SCALAR) {
634: PetscScalar *value = (PetscScalar*)(((char*)bag) + nitem->offset);
635: PetscOptionsScalar(name,nitem->help,"",*value,value,NULL);
636: } else if (nitem->dtype == PETSC_INT) {
637: PetscInt *value = (PetscInt*)(((char*)bag) + nitem->offset);
638: if (nitem->msize == 1) {
639: PetscOptionsInt(name,nitem->help,"",*value,value,NULL);
640: } else {
641: n = nitem->msize;
642: PetscOptionsIntArray(name,nitem->help,"",value,&n,NULL);
643: }
644: } else if (nitem->dtype == PETSC_ENUM) {
645: PetscEnum *value = (PetscEnum*)(((char*)bag) + nitem->offset);
646: PetscInt i = 0;
647: while (nitem->list[i++]) ;
648: PetscOptionsEnum(name,nitem->help,nitem->list[i-3],(const char*const*)nitem->list,*value,value,NULL);
649: } else if (nitem->dtype == PETSC_BOOL) {
650: PetscBool *value = (PetscBool*)(((char*)bag) + nitem->offset);
651: if (nitem->msize == 1) {
652: PetscOptionsBool(name,nitem->help,"",*value,value,NULL);
653: } else {
654: n = nitem->msize;
655: PetscOptionsBoolArray(name,nitem->help,"",value,&n,NULL);
656: }
657: }
658: nitem = nitem->next;
659: }
660: PetscOptionsEnd();
661: return(0);
662: }
666: /*@C
667: PetscBagView - Views a bag of values as either ASCII text or a binary file
669: Collective on PetscBag
671: Input Parameter:
672: + bag - the bag of values
673: - viewer - location to view the values
675: Level: beginner
677: Warning: Currently PETSc bags saved in a binary file can only be read back
678: in on a machine of the same architecture. Let us know when this is a problem
679: and we'll fix it.
681: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagLoad(), PetscBagGetData()
682: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar(), PetscBagRegisterEnum()
683: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName()
685: @*/
686: PetscErrorCode PetscBagView(PetscBag bag,PetscViewer view)
687: {
688: PetscBool isascii,isbinary;
690: PetscBagItem nitem = bag->bagitems;
693: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERASCII,&isascii);
694: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERBINARY,&isbinary);
695: if (isascii) {
696: if (bag->bagprefix) {
697: PetscViewerASCIIPrintf(view,"PetscBag Object: %s (%s) %s\n",bag->bagname,bag->bagprefix,bag->baghelp);
698: } else {
699: PetscViewerASCIIPrintf(view,"PetscBag Object: %s %s\n",bag->bagname,bag->baghelp);
700: }
701: while (nitem) {
702: if (nitem->dtype == PETSC_CHAR) {
703: char *value = (char*)(((char*)bag) + nitem->offset);
704: char tmp = value[nitem->msize-1]; /* special handling for fortran chars wihout null terminator */
705: value[nitem->msize-1] =0;
706: PetscViewerASCIIPrintf(view," %s = %s; %s\n",nitem->name,value,nitem->help);
707: value[nitem->msize-1] = tmp;
708: } else if (nitem->dtype == PETSC_REAL) {
709: PetscReal *value = (PetscReal*)(((char*)bag) + nitem->offset);
710: PetscInt i;
711: PetscViewerASCIIPrintf(view," %s = ",nitem->name);
712: for (i=0; i<nitem->msize; i++) {
713: PetscViewerASCIIPrintf(view,"%g ",(double)value[i]);
714: }
715: PetscViewerASCIIPrintf(view,"; %s\n",nitem->help);
716: } else if (nitem->dtype == PETSC_SCALAR) {
717: PetscScalar value = *(PetscScalar*)(((char*)bag) + nitem->offset);
718: #if defined(PETSC_USE_COMPLEX)
719: if ((double)PetscImaginaryPart(value)) {
720: PetscViewerASCIIPrintf(view," %s = %g + %gi; %s\n",nitem->name,(double)PetscRealPart(value),(double)PetscImaginaryPart(value),nitem->help);
721: } else {
722: PetscViewerASCIIPrintf(view," %s = %g; %s\n",nitem->name,(double)PetscRealPart(value),nitem->help);
723: }
724: #else
725: PetscViewerASCIIPrintf(view," %s = %g; %s\n",nitem->name,(double)value,nitem->help);
726: #endif
727: } else if (nitem->dtype == PETSC_INT) {
728: PetscInt i,*value = (PetscInt*)(((char*)bag) + nitem->offset);
729: PetscViewerASCIIPrintf(view," %s = ",nitem->name);
730: for (i=0; i<nitem->msize; i++) {
731: PetscViewerASCIIPrintf(view,"%D ",value[i]);
732: }
733: PetscViewerASCIIPrintf(view,"; %s\n",nitem->help);
734: } else if (nitem->dtype == PETSC_BOOL) {
735: PetscBool *value = (PetscBool*)(((char*)bag) + nitem->offset);
736: PetscInt i;
737: /* some Fortran compilers use -1 as boolean */
738: PetscViewerASCIIPrintf(view," %s = ",nitem->name);
739: for (i=0; i<nitem->msize; i++) {
740: if (((int) value[i]) == -1) value[i] = PETSC_TRUE;
741: /* the checks here with != PETSC_FALSE and PETSC_TRUE is a special case; here we truly demand that the value be 0 or 1 */
742: 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);
743: PetscViewerASCIIPrintf(view," %s",PetscBools[value[i]]);
744: }
745: PetscViewerASCIIPrintf(view,"; %s\n",nitem->help);
746: } else if (nitem->dtype == PETSC_ENUM) {
747: PetscEnum value = *(PetscEnum*)(((char*)bag) + nitem->offset);
748: PetscInt i = 0;
749: while (nitem->list[i++]) ;
750: PetscViewerASCIIPrintf(view," %s = %s; (%s) %s\n",nitem->name,nitem->list[value],nitem->list[i-3],nitem->help);
751: }
752: nitem = nitem->next;
753: }
754: } else if (isbinary) {
755: PetscInt classid = PETSC_BAG_FILE_CLASSID, dtype;
756: PetscInt deprecatedbagsize = 0;
757: PetscViewerFormat format;
758: PetscViewerBinaryWrite(view,&classid,1,PETSC_INT,PETSC_TRUE);
759: PetscViewerBinaryWrite(view,&deprecatedbagsize,1,PETSC_INT,PETSC_FALSE);
760: PetscViewerBinaryWrite(view,&bag->count,1,PETSC_INT,PETSC_FALSE);
761: PetscViewerBinaryWrite(view,bag->bagname,PETSC_BAG_NAME_LENGTH,PETSC_CHAR,PETSC_FALSE);
762: PetscViewerBinaryWrite(view,bag->baghelp,PETSC_BAG_HELP_LENGTH,PETSC_CHAR,PETSC_FALSE);
763: while (nitem) {
764: PetscViewerBinaryWrite(view,&nitem->offset,1,PETSC_INT,PETSC_FALSE);
765: dtype = (PetscInt)nitem->dtype;
766: PetscViewerBinaryWrite(view,&dtype,1,PETSC_INT,PETSC_FALSE);
767: PetscViewerBinaryWrite(view,nitem->name,PETSC_BAG_NAME_LENGTH,PETSC_CHAR,PETSC_FALSE);
768: PetscViewerBinaryWrite(view,nitem->help,PETSC_BAG_HELP_LENGTH,PETSC_CHAR,PETSC_FALSE);
769: PetscViewerBinaryWrite(view,&nitem->msize,1,PETSC_INT,PETSC_FALSE);
770: /* some Fortran compilers use -1 as boolean */
771: if (dtype == PETSC_BOOL && ((*(int*) (((char*)bag) + nitem->offset) == -1))) *(int*) (((char*)bag) + nitem->offset) = PETSC_TRUE;
773: PetscViewerBinaryWrite(view,(((char*)bag) + nitem->offset),nitem->msize,nitem->dtype,PETSC_FALSE);
774: if (dtype == PETSC_ENUM) {
775: PetscViewerBinaryWriteStringArray(view,(char**)nitem->list);
776: }
777: nitem = nitem->next;
778: }
779: PetscViewerGetFormat(view,&format);
780: if (format == PETSC_VIEWER_BINARY_MATLAB) {
781: MPI_Comm comm;
782: FILE *info;
783: PetscObjectGetComm((PetscObject)view,&comm);
784: PetscViewerBinaryGetInfoPointer(view,&info);
785: PetscFPrintf(comm,info,"#--- begin code written by PetscViewerBinary for MATLAB format ---#\n");
786: PetscFPrintf(comm,info,"#$$ Set.%s = PetscBinaryRead(fd);\n",bag->bagname);
787: PetscFPrintf(comm,info,"#--- end code written by PetscViewerBinary for MATLAB format ---#\n\n");
788: }
789: }
790: return(0);
791: }
795: /*@C
796: PetscBagLoad - Loads a bag of values from a binary file
798: Collective on PetscViewer
800: Input Parameter:
801: + viewer - file to load values from
802: - bag - the bag of values
804: Notes: You must have created and registered all the fields in the bag before loading into it.
806: Notes:
807: Level: beginner
809: .seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagView(), PetscBagGetData()
810: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
811: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
813: @*/
814: PetscErrorCode PetscBagLoad(PetscViewer view,PetscBag bag)
815: {
817: PetscBool isbinary;
818: PetscInt classid,bagcount,i,dtype,msize,offset,deprecatedbagsize;
819: char name[PETSC_BAG_NAME_LENGTH],help[PETSC_BAG_HELP_LENGTH],**list;
820: PetscBagItem nitem;
821: MPI_Comm comm;
822: PetscMPIInt flag;
825: PetscObjectGetComm((PetscObject)view,&comm);
826: MPI_Comm_compare(comm,bag->bagcomm,&flag);
827: if (flag != MPI_CONGRUENT && flag != MPI_IDENT) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NOTSAMECOMM,"Different communicators in the viewer and bag"); \
828: PetscObjectTypeCompare((PetscObject)view,PETSCVIEWERBINARY,&isbinary);
829: if (!isbinary) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for this viewer type");
831: PetscViewerBinaryRead(view,&classid,1,NULL,PETSC_INT);
832: if (classid != PETSC_BAG_FILE_CLASSID) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Not PetscBag next in binary file");
833: PetscViewerBinaryRead(view,&deprecatedbagsize,1,NULL,PETSC_INT);
834: PetscViewerBinaryRead(view,&bagcount,1,NULL,PETSC_INT);
835: 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);
836: PetscViewerBinaryRead(view,bag->bagname,PETSC_BAG_NAME_LENGTH,NULL,PETSC_CHAR);
837: PetscViewerBinaryRead(view,bag->baghelp,PETSC_BAG_HELP_LENGTH,NULL,PETSC_CHAR);
839: nitem = bag->bagitems;
840: for (i=0; i<bagcount; i++) {
841: PetscViewerBinaryRead(view,&offset,1,NULL,PETSC_INT);
842: /* ignore the offset in the file */
843: PetscViewerBinaryRead(view,&dtype,1,NULL,PETSC_INT);
844: PetscViewerBinaryRead(view,name,PETSC_BAG_NAME_LENGTH,NULL,PETSC_CHAR);
845: PetscViewerBinaryRead(view,help,PETSC_BAG_HELP_LENGTH,NULL,PETSC_CHAR);
846: PetscViewerBinaryRead(view,&msize,1,NULL,PETSC_INT);
848: if (dtype == (PetscInt) PETSC_CHAR) {
849: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,NULL,PETSC_CHAR);
850: } else if (dtype == (PetscInt) PETSC_REAL) {
851: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,NULL,PETSC_REAL);
852: } else if (dtype == (PetscInt) PETSC_SCALAR) {
853: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,1,NULL,PETSC_SCALAR);
854: } else if (dtype == (PetscInt) PETSC_INT) {
855: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,NULL,PETSC_INT);
856: } else if (dtype == (PetscInt) PETSC_BOOL) {
857: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,msize,NULL,PETSC_BOOL);
858: } else if (dtype == (PetscInt) PETSC_ENUM) {
859: PetscViewerBinaryRead(view,((char*)bag)+nitem->offset,1,NULL,PETSC_ENUM);
860: PetscViewerBinaryReadStringArray(view,&list);
861: /* don't need to save list because it is already registered in the bag */
862: PetscFree(list);
863: }
864: nitem = nitem->next;
865: }
866: return(0);
867: }
871: /*@
872: PetscBagCreate - Create a bag of values
874: Collective on MPI_Comm
876: Level: Intermediate
878: Input Parameters:
879: + comm - communicator to share bag
880: - bagsize - size of the C structure holding the values
882: Output Parameter:
883: . bag - the bag of values
885: Notes:
886: The size of the A struct must be small enough to fit in a PetscInt; by default
887: PetscInt is 4 bytes; this means a bag cannot be larger than 2 gigabytes in length.
888: The warning about casting to a shorter length can be ignored below unless your A struct is too large
890: .seealso: PetscBag, PetscBagGetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
891: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
892: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
893: @*/
894: PetscErrorCode PetscBagCreate(MPI_Comm comm, size_t bagsize, PetscBag *bag)
895: {
897: size_t totalsize = bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar);
900: PetscInfo1(NULL,"Creating Bag with total size %d\n",(int)totalsize);
901: PetscMalloc(totalsize,bag);
902: PetscMemzero(*bag,bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar));
904: (*bag)->bagsize = bagsize+sizeof(struct _n_PetscBag)+sizeof(PetscScalar);
905: (*bag)->bagcomm = comm;
906: (*bag)->bagprefix = NULL;
907: (*bag)->structlocation = (void*)(((char*)(*bag)) + sizeof(PetscScalar)*(sizeof(struct _n_PetscBag)/sizeof(PetscScalar)) + sizeof(PetscScalar));
908: return(0);
909: }
913: /*@C
914: PetscBagSetName - Sets the name of a bag of values
916: Not Collective
918: Level: Intermediate
920: Input Parameters:
921: + bag - the bag of values
922: . name - the name assigned to the bag
923: - help - help message for bag
925: .seealso: PetscBag, PetscBagGetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
926: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
927: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
928: @*/
930: PetscErrorCode PetscBagSetName(PetscBag bag, const char *name, const char *help)
931: {
935: PetscStrncpy(bag->bagname,name,PETSC_BAG_NAME_LENGTH-1);
936: PetscStrncpy(bag->baghelp,help,PETSC_BAG_HELP_LENGTH-1);
937: return(0);
938: }
943: /*@C
944: PetscBagGetName - Gets the name of a bag of values
946: Not Collective
948: Level: Intermediate
950: Input Parameter:
951: . bag - the bag of values
953: Output Parameter:
954: . name - the name assigned to the bag
956: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
957: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
958: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
959: @*/
960: PetscErrorCode PetscBagGetName(PetscBag bag, char **name)
961: {
963: *name = bag->bagname;
964: return(0);
965: }
969: /*@C
970: PetscBagGetData - Gives back the user - access to memory that
971: should be used for storing user-data-structure
973: Not Collective
975: Level: Intermediate
977: Input Parameter:
978: . bag - the bag of values
980: Output Parameter:
981: . data - pointer to memory that will have user-data-structure
983: .seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad()
984: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
985: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
986: @*/
987: PetscErrorCode PetscBagGetData(PetscBag bag, void **data)
988: {
990: *data = bag->structlocation;
991: return(0);
992: }
996: /*@C
997: PetscBagSetOptionsPrefix - Sets the prefix used for searching for all
998: PetscBag items in the options database.
1000: Logically collective on Bag.
1002: Level: Intermediate
1004: Input Parameters:
1005: + bag - the bag of values
1006: - prefix - the prefix to prepend all Bag item names with.
1008: NOTES: Must be called prior to registering any of the bag items.
1010: .seealso: PetscBag, PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
1011: PetscBagSetFromOptions(), PetscBagCreate(), PetscBagDestroy(), PetscBagRegisterEnum()
1012: @*/
1014: PetscErrorCode PetscBagSetOptionsPrefix(PetscBag bag, const char pre[])
1015: {
1019: if (!pre) {
1020: PetscFree(bag->bagprefix);
1021: } else {
1022: if (pre[0] == '-') SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Options prefix should not begin with a hypen");
1023: PetscFree(bag->bagprefix);
1024: PetscStrallocpy(pre,&(bag->bagprefix));
1025: }
1026: return(0);
1027: }
1031: /*@C
1032: PetscBagGetNames - Get the names of all entries in the bag
1034: Not collective
1036: Input Parameters:
1037: + bag - the bag of values
1038: - names - array of the correct size to hold names
1040: Output Parameter:
1041: . names - array of char pointers for names
1043: Level: intermediate
1045: .seealso: PetscBag, PetscBagGetName(), PetscBagSetName(), PetscBagCreate(), PetscBagGetData()
1046: PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar(), PetscBagRegisterEnum()
1047: @*/
1048: PetscErrorCode PetscBagGetNames(PetscBag bag, const char *names[])
1049: {
1050: PetscBagItem nitem = bag->bagitems;
1051: PetscInt n;
1054: for (n = 0; nitem; ++n, nitem = nitem->next) {names[n] = nitem->name;}
1055: return(0);
1056: }