Date: 2016-07-24T16:47:56+00:00

Actual source code: aoptions.c
petsc-3.7.3 2016-07-24
Report Typos and Errors

      3: /*
      4:    Implements the higher-level options database querying methods. These are self-documenting and can attach at runtime to
      5:    GUI code to display the options and get values from the users.

      7: */

      9: #include <petsc/private/petscimpl.h>        /*I  "petscsys.h"   I*/
     10: #include <petscviewer.h>

     12: #define ManSection(str) ((str) ? (str) : "None")

     14: /*
     15:     Keep a linked list of options that have been posted and we are waiting for
     16:    user selection. See the manual page for PetscOptionsBegin()

     18:     Eventually we'll attach this beast to a MPI_Comm
     19: */

     24: /*
     25:     Handles setting up the data structure in a call to PetscOptionsBegin()
     26: */
     27: PetscErrorCode PetscOptionsBegin_Private(PetscOptionItems *PetscOptionsObject,MPI_Comm comm,const char prefix[],const char title[],const char mansec[])
     28: {

     32:   if (!PetscOptionsObject->alreadyprinted) {
     33:     if (!PetscOptionsHelpPrintedSingleton) {
     34:       PetscOptionsHelpPrintedCreate(&PetscOptionsHelpPrintedSingleton);
     35:     }
     36:     PetscOptionsHelpPrintedCheck(PetscOptionsHelpPrintedSingleton,prefix,title,&PetscOptionsObject->alreadyprinted);
     37:   }
     38:   PetscOptionsObject->next          = 0;
     39:   PetscOptionsObject->comm          = comm;
     40:   PetscOptionsObject->changedmethod = PETSC_FALSE;

     42:   PetscStrallocpy(prefix,&PetscOptionsObject->prefix);
     43:   PetscStrallocpy(title,&PetscOptionsObject->title);

     45:   PetscOptionsHasName(PetscOptionsObject->options,NULL,"-help",&PetscOptionsObject->printhelp);
     46:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1) {
     47:     if (!PetscOptionsObject->alreadyprinted) {
     48:       (*PetscHelpPrintf)(comm,"%s -------------------------------------------------\n",title);
     49:     }
     50:   }
     51:   return(0);
     52: }

     56: /*
     57:     Handles setting up the data structure in a call to PetscObjectOptionsBegin()
     58: */
     59: PetscErrorCode PetscObjectOptionsBegin_Private(PetscOptionItems *PetscOptionsObject,PetscObject obj)
     60: {
     62:   char           title[256];
     63:   PetscBool      flg;

     67:   PetscOptionsObject->object         = obj;
     68:   PetscOptionsObject->alreadyprinted = obj->optionsprinted;

     70:   PetscStrcmp(obj->description,obj->class_name,&flg);
     71:   if (flg) {
     72:     PetscSNPrintf(title,sizeof(title),"%s options",obj->class_name);
     73:   } else {
     74:     PetscSNPrintf(title,sizeof(title),"%s (%s) options",obj->description,obj->class_name);
     75:   }
     76:   PetscOptionsBegin_Private(PetscOptionsObject,obj->comm,obj->prefix,title,obj->mansec);
     77:   return(0);
     78: }

     80: /*
     81:      Handles adding another option to the list of options within this particular PetscOptionsBegin() PetscOptionsEnd()
     82: */
     85: static int PetscOptionItemCreate_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscOptionType t,PetscOptionItem *amsopt)
     86: {
     87:   int             ierr;
     88:   PetscOptionItem next;
     89:   PetscBool       valid;

     92:   PetscOptionsValidKey(opt,&valid);
     93:   if (!valid) SETERRQ1(PETSC_COMM_WORLD,PETSC_ERR_ARG_INCOMP,"The option '%s' is not a valid key",opt);

     95:   PetscNew(amsopt);
     96:   (*amsopt)->next = 0;
     97:   (*amsopt)->set  = PETSC_FALSE;
     98:   (*amsopt)->type = t;
     99:   (*amsopt)->data = 0;

    101:   PetscStrallocpy(text,&(*amsopt)->text);
    102:   PetscStrallocpy(opt,&(*amsopt)->option);
    103:   PetscStrallocpy(man,&(*amsopt)->man);

    105:   if (!PetscOptionsObject->next) PetscOptionsObject->next = *amsopt;
    106:   else {
    107:     next = PetscOptionsObject->next;
    108:     while (next->next) next = next->next;
    109:     next->next = *amsopt;
    110:   }
    111:   return(0);
    112: }

    116: /*
    117:     PetscScanString -  Gets user input via stdin from process and broadcasts to all processes

    119:     Collective on MPI_Comm

    121:    Input Parameters:
    122: +     commm - communicator for the broadcast, must be PETSC_COMM_WORLD
    123: .     n - length of the string, must be the same on all processes
    124: -     str - location to store input

    126:     Bugs:
    127: .   Assumes process 0 of the given communicator has access to stdin

    129: */
    130: static PetscErrorCode PetscScanString(MPI_Comm comm,size_t n,char str[])
    131: {
    132:   size_t         i;
    133:   char           c;
    134:   PetscMPIInt    rank,nm;

    138:   MPI_Comm_rank(comm,&rank);
    139:   if (!rank) {
    140:     c = (char) getchar();
    141:     i = 0;
    142:     while (c != '\n' && i < n-1) {
    143:       str[i++] = c;
    144:       c = (char)getchar();
    145:     }
    146:     str[i] = 0;
    147:   }
    148:   PetscMPIIntCast(n,&nm);
    149:   MPI_Bcast(str,nm,MPI_CHAR,0,comm);
    150:   return(0);
    151: }

    155: /*
    156:     This is needed because certain strings may be freed by SAWs, hence we cannot use PetscStrallocpy()
    157: */
    158: static PetscErrorCode  PetscStrdup(const char s[],char *t[])
    159: {
    161:   size_t         len;
    162:   char           *tmp = 0;

    165:   if (s) {
    166:     PetscStrlen(s,&len);
    167:     tmp = (char*) malloc((len+1)*sizeof(char));
    168:     if (!tmp) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"No memory to duplicate string");
    169:     PetscStrcpy(tmp,s);
    170:   }
    171:   *t = tmp;
    172:   return(0);
    173: }

    178: /*
    179:     PetscOptionsGetFromTextInput - Presents all the PETSc Options processed by the program so the user may change them at runtime

    181:     Notes: this isn't really practical, it is just to demonstrate the principle

    183:     A carriage return indicates no change from the default; but this like -ksp_monitor <stdout>  the default is actually not stdout the default
    184:     is to do nothing so to get it to use stdout you need to type stdout. This is kind of bug?

    186:     Bugs:
    187: +    All processes must traverse through the exact same set of option queries due to the call to PetscScanString()
    188: .    Internal strings have arbitrary length and string copies are not checked that they fit into string space
    189: -    Only works for PetscInt == int, PetscReal == double etc

    191:     Developer Notes: Normally the GUI that presents the options the user and retrieves the values would be running in a different
    192:      address space and communicating with the PETSc program

    194: */
    195: PetscErrorCode PetscOptionsGetFromTextInput(PetscOptionItems *PetscOptionsObject)
    196: {
    197:   PetscErrorCode  ierr;
    198:   PetscOptionItem next = PetscOptionsObject->next;
    199:   char            str[512];
    200:   PetscBool       bid;
    201:   PetscReal       ir,*valr;
    202:   PetscInt        *vald;
    203:   size_t          i;

    206:   (*PetscPrintf)(PETSC_COMM_WORLD,"%s -------------------------------------------------\n",PetscOptionsObject->title);
    207:   while (next) {
    208:     switch (next->type) {
    209:     case OPTION_HEAD:
    210:       break;
    211:     case OPTION_INT_ARRAY:
    212:       PetscPrintf(PETSC_COMM_WORLD,"-%s%s <",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",next->option+1);
    213:       vald = (PetscInt*) next->data;
    214:       for (i=0; i<next->arraylength; i++) {
    215:         PetscPrintf(PETSC_COMM_WORLD,"%d",vald[i]);
    216:         if (i < next->arraylength-1) {
    217:           PetscPrintf(PETSC_COMM_WORLD,",");
    218:         }
    219:       }
    220:       PetscPrintf(PETSC_COMM_WORLD,">: %s (%s) ",next->text,next->man);
    221:       PetscScanString(PETSC_COMM_WORLD,512,str);
    222:       if (str[0]) {
    223:         PetscToken token;
    224:         PetscInt   n=0,nmax = next->arraylength,*dvalue = (PetscInt*)next->data,start,end;
    225:         size_t     len;
    226:         char       *value;
    227:         PetscBool  foundrange;

    229:         next->set = PETSC_TRUE;
    230:         value     = str;
    231:         PetscTokenCreate(value,',',&token);
    232:         PetscTokenFind(token,&value);
    233:         while (n < nmax) {
    234:           if (!value) break;

    236:           /* look for form  d-D where d and D are integers */
    237:           foundrange = PETSC_FALSE;
    238:           PetscStrlen(value,&len);
    239:           if (value[0] == '-') i=2;
    240:           else i=1;
    241:           for (;i<len; i++) {
    242:             if (value[i] == '-') {
    243:               if (i == len-1) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_USER,"Error in %D-th array entry %s\n",n,value);
    244:               value[i] = 0;
    245:               PetscOptionsStringToInt(value,&start);
    246:               PetscOptionsStringToInt(value+i+1,&end);
    247:               if (end <= start) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_USER,"Error in %D-th array entry, %s-%s cannot have decreasing list",n,value,value+i+1);
    248:               if (n + end - start - 1 >= nmax) SETERRQ4(PETSC_COMM_SELF,PETSC_ERR_USER,"Error in %D-th array entry, not enough space in left in array (%D) to contain entire range from %D to %D",n,nmax-n,start,end);
    249:               for (; start<end; start++) {
    250:                 *dvalue = start; dvalue++;n++;
    251:               }
    252:               foundrange = PETSC_TRUE;
    253:               break;
    254:             }
    255:           }
    256:           if (!foundrange) {
    257:             PetscOptionsStringToInt(value,dvalue);
    258:             dvalue++;
    259:             n++;
    260:           }
    261:           PetscTokenFind(token,&value);
    262:         }
    263:         PetscTokenDestroy(&token);
    264:       }
    265:       break;
    266:     case OPTION_REAL_ARRAY:
    267:       PetscPrintf(PETSC_COMM_WORLD,"-%s%s <",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",next->option+1);
    268:       valr = (PetscReal*) next->data;
    269:       for (i=0; i<next->arraylength; i++) {
    270:         PetscPrintf(PETSC_COMM_WORLD,"%g",valr[i]);
    271:         if (i < next->arraylength-1) {
    272:           PetscPrintf(PETSC_COMM_WORLD,",");
    273:         }
    274:       }
    275:       PetscPrintf(PETSC_COMM_WORLD,">: %s (%s) ",next->text,next->man);
    276:       PetscScanString(PETSC_COMM_WORLD,512,str);
    277:       if (str[0]) {
    278:         PetscToken token;
    279:         PetscInt   n = 0,nmax = next->arraylength;
    280:         PetscReal  *dvalue = (PetscReal*)next->data;
    281:         char       *value;

    283:         next->set = PETSC_TRUE;
    284:         value     = str;
    285:         PetscTokenCreate(value,',',&token);
    286:         PetscTokenFind(token,&value);
    287:         while (n < nmax) {
    288:           if (!value) break;
    289:           PetscOptionsStringToReal(value,dvalue);
    290:           dvalue++;
    291:           n++;
    292:           PetscTokenFind(token,&value);
    293:         }
    294:         PetscTokenDestroy(&token);
    295:       }
    296:       break;
    297:     case OPTION_INT:
    298:       PetscPrintf(PETSC_COMM_WORLD,"-%s%s <%d>: %s (%s) ",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",next->option+1,*(int*)next->data,next->text,next->man);
    299:       PetscScanString(PETSC_COMM_WORLD,512,str);
    300:       if (str[0]) {
    301: #if defined(PETSC_SIZEOF_LONG_LONG)
    302:         long long lid;
    303:         sscanf(str,"%lld",&lid);
    304:         if (lid > PETSC_MAX_INT || lid < PETSC_MIN_INT) SETERRQ3(PETSC_COMM_WORLD,PETSC_ERR_ARG_OUTOFRANGE,"Argument: -%s%s %lld",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",next->option+1,lid);
    305: #else
    306:         long  lid;
    307:         sscanf(str,"%ld",&lid);
    308:         if (lid > PETSC_MAX_INT || lid < PETSC_MIN_INT) SETERRQ3(PETSC_COMM_WORLD,PETSC_ERR_ARG_OUTOFRANGE,"Argument: -%s%s %ld",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",next->option+1,lid);
    309: #endif

    311:         next->set = PETSC_TRUE;
    312:         *((PetscInt*)next->data) = (PetscInt)lid;
    313:       }
    314:       break;
    315:     case OPTION_REAL:
    316:       PetscPrintf(PETSC_COMM_WORLD,"-%s%s <%g>: %s (%s) ",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",next->option+1,*(double*)next->data,next->text,next->man);
    317:       PetscScanString(PETSC_COMM_WORLD,512,str);
    318:       if (str[0]) {
    319: #if defined(PETSC_USE_REAL_SINGLE)
    320:         sscanf(str,"%e",&ir);
    321: #elif defined(PETSC_USE_REAL_DOUBLE)
    322:         sscanf(str,"%le",&ir);
    323: #elif defined(PETSC_USE_REAL___FLOAT128)
    324:         ir = strtoflt128(str,0);
    325: #else
    326:         SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"Unknown scalar type");
    327: #endif
    328:         next->set                 = PETSC_TRUE;
    329:         *((PetscReal*)next->data) = ir;
    330:       }
    331:       break;
    332:     case OPTION_BOOL:
    333:       PetscPrintf(PETSC_COMM_WORLD,"-%s%s <%s>: %s (%s) ",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",next->option+1,*(PetscBool*)next->data ? "true": "false",next->text,next->man);
    334:       PetscScanString(PETSC_COMM_WORLD,512,str);
    335:       if (str[0]) {
    336:         PetscOptionsStringToBool(str,&bid);
    337:         next->set = PETSC_TRUE;
    338:         *((PetscBool*)next->data) = bid;
    339:       }
    340:       break;
    341:     case OPTION_STRING:
    342:       PetscPrintf(PETSC_COMM_WORLD,"-%s%s <%s>: %s (%s) ",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",next->option+1,(char*)next->data,next->text,next->man);
    343:       PetscScanString(PETSC_COMM_WORLD,512,str);
    344:       if (str[0]) {
    345:         next->set = PETSC_TRUE;
    346:         /* must use system malloc since SAWs may free this */
    347:         PetscStrdup(str,(char**)&next->data);
    348:       }
    349:       break;
    350:     case OPTION_FLIST:
    351:       PetscFunctionListPrintTypes(PETSC_COMM_WORLD,stdout,PetscOptionsObject->prefix,next->option,next->text,next->man,next->flist,(char*)next->data);
    352:       PetscScanString(PETSC_COMM_WORLD,512,str);
    353:       if (str[0]) {
    354:         PetscOptionsObject->changedmethod = PETSC_TRUE;
    355:         next->set = PETSC_TRUE;
    356:         /* must use system malloc since SAWs may free this */
    357:         PetscStrdup(str,(char**)&next->data);
    358:       }
    359:       break;
    360:     default:
    361:       break;
    362:     }
    363:     next = next->next;
    364:   }
    365:   return(0);
    366: }

    368: #if defined(PETSC_HAVE_SAWS)
    369: #include <petscviewersaws.h>

    371: static int count = 0;

    375: PetscErrorCode PetscOptionsSAWsDestroy(void)
    376: {
    378:   return(0);
    379: }

    381: static const char *OptionsHeader = "<head>\n"
    382:                                    "<script type=\"text/javascript\" src=\"http://www.mcs.anl.gov/research/projects/saws/js/jquery-1.9.1.js\"></script>\n"
    383:                                    "<script type=\"text/javascript\" src=\"http://www.mcs.anl.gov/research/projects/saws/js/SAWs.js\"></script>\n"
    384:                                    "<script type=\"text/javascript\" src=\"js/PETSc.js\"></script>\n"
    385:                                    "<script>\n"
    386:                                       "jQuery(document).ready(function() {\n"
    387:                                          "PETSc.getAndDisplayDirectory(null,\"#variablesInfo\")\n"
    388:                                       "})\n"
    389:                                   "</script>\n"
    390:                                   "</head>\n";

    392: /*  Determines the size and style of the scroll region where PETSc options selectable from users are displayed */
    393: static const char *OptionsBodyBottom = "<div id=\"variablesInfo\" style=\"background-color:lightblue;height:auto;max-height:500px;overflow:scroll;\"></div>\n<br>\n</body>";

    397: /*
    398:     PetscOptionsSAWsInput - Presents all the PETSc Options processed by the program so the user may change them at runtime using the SAWs

    400:     Bugs:
    401: +    All processes must traverse through the exact same set of option queries do to the call to PetscScanString()
    402: .    Internal strings have arbitrary length and string copies are not checked that they fit into string space
    403: -    Only works for PetscInt == int, PetscReal == double etc

    406: */
    407: PetscErrorCode PetscOptionsSAWsInput(PetscOptionItems *PetscOptionsObject)
    408: {
    409:   PetscErrorCode  ierr;
    410:   PetscOptionItem next     = PetscOptionsObject->next;
    411:   static int      mancount = 0;
    412:   char            options[16];
    413:   PetscBool       changedmethod = PETSC_FALSE;
    414:   PetscBool       stopasking    = PETSC_FALSE;
    415:   char            manname[16],textname[16];
    416:   char            dir[1024];

    419:   /* the next line is a bug, this will only work if all processors are here, the comm passed in is ignored!!! */
    420:   sprintf(options,"Options_%d",count++);

    422:   PetscOptionsObject->pprefix = PetscOptionsObject->prefix; /* SAWs will change this, so cannot pass prefix directly */

    424:   PetscSNPrintf(dir,1024,"/PETSc/Options/%s","_title");
    425:   PetscStackCallSAWs(SAWs_Register,(dir,&PetscOptionsObject->title,1,SAWs_READ,SAWs_STRING));
    426:   PetscSNPrintf(dir,1024,"/PETSc/Options/%s","prefix");
    427:   PetscStackCallSAWs(SAWs_Register,(dir,&PetscOptionsObject->pprefix,1,SAWs_READ,SAWs_STRING));
    428:   PetscStackCallSAWs(SAWs_Register,("/PETSc/Options/ChangedMethod",&changedmethod,1,SAWs_WRITE,SAWs_BOOLEAN));
    429:   PetscStackCallSAWs(SAWs_Register,("/PETSc/Options/StopAsking",&stopasking,1,SAWs_WRITE,SAWs_BOOLEAN));

    431:   while (next) {
    432:     sprintf(manname,"_man_%d",mancount);
    433:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",manname);
    434:     PetscStackCallSAWs(SAWs_Register,(dir,&next->man,1,SAWs_READ,SAWs_STRING));
    435:     sprintf(textname,"_text_%d",mancount++);
    436:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",textname);
    437:     PetscStackCallSAWs(SAWs_Register,(dir,&next->text,1,SAWs_READ,SAWs_STRING));

    439:     switch (next->type) {
    440:     case OPTION_HEAD:
    441:       break;
    442:     case OPTION_INT_ARRAY:
    443:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    444:       PetscStackCallSAWs(SAWs_Register,(dir,next->data,next->arraylength,SAWs_WRITE,SAWs_INT));
    445:       break;
    446:     case OPTION_REAL_ARRAY:
    447:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    448:       PetscStackCallSAWs(SAWs_Register,(dir,next->data,next->arraylength,SAWs_WRITE,SAWs_DOUBLE));
    449:       break;
    450:     case OPTION_INT:
    451:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    452:       PetscStackCallSAWs(SAWs_Register,(dir,next->data,1,SAWs_WRITE,SAWs_INT));
    453:       break;
    454:     case OPTION_REAL:
    455:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    456:       PetscStackCallSAWs(SAWs_Register,(dir,next->data,1,SAWs_WRITE,SAWs_DOUBLE));
    457:       break;
    458:     case OPTION_BOOL:
    459:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    460:       PetscStackCallSAWs(SAWs_Register,(dir,next->data,1,SAWs_WRITE,SAWs_BOOLEAN));
    461:       break;
    462:     case OPTION_BOOL_ARRAY:
    463:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    464:       PetscStackCallSAWs(SAWs_Register,(dir,next->data,next->arraylength,SAWs_WRITE,SAWs_BOOLEAN));
    465:       break;
    466:     case OPTION_STRING:
    467:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    468:       PetscStackCallSAWs(SAWs_Register,(dir,&next->data,1,SAWs_WRITE,SAWs_STRING));
    469:       break;
    470:     case OPTION_STRING_ARRAY:
    471:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    472:       PetscStackCallSAWs(SAWs_Register,(dir,next->data,next->arraylength,SAWs_WRITE,SAWs_STRING));
    473:       break;
    474:     case OPTION_FLIST:
    475:       {
    476:       PetscInt ntext;
    477:       PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    478:       PetscStackCallSAWs(SAWs_Register,(dir,&next->data,1,SAWs_WRITE,SAWs_STRING));
    479:       PetscFunctionListGet(next->flist,(const char***)&next->edata,&ntext);
    480:       PetscStackCallSAWs(SAWs_Set_Legal_Variable_Values,(dir,ntext,next->edata));
    481:       }
    482:       break;
    483:     case OPTION_ELIST:
    484:       {
    485:       PetscInt ntext = next->nlist;
    486:       PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    487:       PetscStackCallSAWs(SAWs_Register,(dir,&next->data,1,SAWs_WRITE,SAWs_STRING));
    488:       PetscMalloc1((ntext+1),(char***)&next->edata);
    489:       PetscMemcpy(next->edata,next->list,ntext*sizeof(char*));
    490:       PetscStackCallSAWs(SAWs_Set_Legal_Variable_Values,(dir,ntext,next->edata));
    491:       }
    492:       break;
    493:     default:
    494:       break;
    495:     }
    496:     next = next->next;
    497:   }

    499:   /* wait until accessor has unlocked the memory */
    500:   PetscStackCallSAWs(SAWs_Push_Header,("index.html",OptionsHeader));
    501:   PetscStackCallSAWs(SAWs_Push_Body,("index.html",2,OptionsBodyBottom));
    502:   PetscSAWsBlock();
    503:   PetscStackCallSAWs(SAWs_Pop_Header,("index.html"));
    504:   PetscStackCallSAWs(SAWs_Pop_Body,("index.html",2));

    506:   /* determine if any values have been set in GUI */
    507:   next = PetscOptionsObject->next;
    508:   while (next) {
    509:     PetscSNPrintf(dir,1024,"/PETSc/Options/%s",next->option);
    510:     PetscStackCallSAWs(SAWs_Selected,(dir,(int*)&next->set));
    511:     next = next->next;
    512:   }

    514:   /* reset counter to -2; this updates the screen with the new options for the selected method */
    515:   if (changedmethod) PetscOptionsObject->count = -2;

    517:   if (stopasking) {
    518:     PetscOptionsPublish      = PETSC_FALSE;
    519:     PetscOptionsObject->count = 0;//do not ask for same thing again
    520:   }

    522:   PetscStackCallSAWs(SAWs_Delete,("/PETSc/Options"));
    523:   return(0);
    524: }
    525: #endif

    529: PetscErrorCode PetscOptionsEnd_Private(PetscOptionItems *PetscOptionsObject)
    530: {
    531:   PetscErrorCode  ierr;
    532:   PetscOptionItem last;
    533:   char            option[256],value[1024],tmp[32];
    534:   size_t          j;

    537:   if (PetscOptionsObject->next) {
    538:     if (!PetscOptionsObject->count) {
    539: #if defined(PETSC_HAVE_SAWS)
    540:       PetscOptionsSAWsInput(PetscOptionsObject);
    541: #else
    542:       PetscOptionsGetFromTextInput(PetscOptionsObject);
    543: #endif
    544:     }
    545:   }

    547:   PetscFree(PetscOptionsObject->title);

    549:   /* reset counter to -2; this updates the screen with the new options for the selected method */
    550:   if (PetscOptionsObject->changedmethod) PetscOptionsObject->count = -2;
    551:   /* reset alreadyprinted flag */
    552:   PetscOptionsObject->alreadyprinted = PETSC_FALSE;
    553:   if (PetscOptionsObject->object) PetscOptionsObject->object->optionsprinted = PETSC_TRUE;
    554:   PetscOptionsObject->object = NULL;

    556:   while (PetscOptionsObject->next) {
    557:     if (PetscOptionsObject->next->set) {
    558:       if (PetscOptionsObject->prefix) {
    559:         PetscStrcpy(option,"-");
    560:         PetscStrcat(option,PetscOptionsObject->prefix);
    561:         PetscStrcat(option,PetscOptionsObject->next->option+1);
    562:       } else {
    563:         PetscStrcpy(option,PetscOptionsObject->next->option);
    564:       }

    566:       switch (PetscOptionsObject->next->type) {
    567:       case OPTION_HEAD:
    568:         break;
    569:       case OPTION_INT_ARRAY:
    570:         sprintf(value,"%d",(int)((PetscInt*)PetscOptionsObject->next->data)[0]);
    571:         for (j=1; j<PetscOptionsObject->next->arraylength; j++) {
    572:           sprintf(tmp,"%d",(int)((PetscInt*)PetscOptionsObject->next->data)[j]);
    573:           PetscStrcat(value,",");
    574:           PetscStrcat(value,tmp);
    575:         }
    576:         break;
    577:       case OPTION_INT:
    578:         sprintf(value,"%d",(int) *(PetscInt*)PetscOptionsObject->next->data);
    579:         break;
    580:       case OPTION_REAL:
    581:         sprintf(value,"%g",(double) *(PetscReal*)PetscOptionsObject->next->data);
    582:         break;
    583:       case OPTION_REAL_ARRAY:
    584:         sprintf(value,"%g",(double)((PetscReal*)PetscOptionsObject->next->data)[0]);
    585:         for (j=1; j<PetscOptionsObject->next->arraylength; j++) {
    586:           sprintf(tmp,"%g",(double)((PetscReal*)PetscOptionsObject->next->data)[j]);
    587:           PetscStrcat(value,",");
    588:           PetscStrcat(value,tmp);
    589:         }
    590:         break;
    591:       case OPTION_SCALAR_ARRAY:
    592:         sprintf(value,"%g+%gi",(double)PetscRealPart(((PetscScalar*)PetscOptionsObject->next->data)[0]),(double)PetscImaginaryPart(((PetscScalar*)PetscOptionsObject->next->data)[0]));
    593:         for (j=1; j<PetscOptionsObject->next->arraylength; j++) {
    594:           sprintf(tmp,"%g+%gi",(double)PetscRealPart(((PetscScalar*)PetscOptionsObject->next->data)[j]),(double)PetscImaginaryPart(((PetscScalar*)PetscOptionsObject->next->data)[j]));
    595:           PetscStrcat(value,",");
    596:           PetscStrcat(value,tmp);
    597:         }
    598:         break;
    599:       case OPTION_BOOL:
    600:         sprintf(value,"%d",*(int*)PetscOptionsObject->next->data);
    601:         break;
    602:       case OPTION_BOOL_ARRAY:
    603:         sprintf(value,"%d",(int)((PetscBool*)PetscOptionsObject->next->data)[0]);
    604:         for (j=1; j<PetscOptionsObject->next->arraylength; j++) {
    605:           sprintf(tmp,"%d",(int)((PetscBool*)PetscOptionsObject->next->data)[j]);
    606:           PetscStrcat(value,",");
    607:           PetscStrcat(value,tmp);
    608:         }
    609:         break;
    610:       case OPTION_FLIST:
    611:         PetscStrcpy(value,(char*)PetscOptionsObject->next->data);
    612:         break;
    613:       case OPTION_ELIST:
    614:         PetscStrcpy(value,(char*)PetscOptionsObject->next->data);
    615:         break;
    616:       case OPTION_STRING:
    617:         PetscStrcpy(value,(char*)PetscOptionsObject->next->data);
    618:         break;
    619:       case OPTION_STRING_ARRAY:
    620:         sprintf(value,"%s",((char**)PetscOptionsObject->next->data)[0]);
    621:         for (j=1; j<PetscOptionsObject->next->arraylength; j++) {
    622:           sprintf(tmp,"%s",((char**)PetscOptionsObject->next->data)[j]);
    623:           PetscStrcat(value,",");
    624:           PetscStrcat(value,tmp);
    625:         }
    626:         break;
    627:       }
    628:       PetscOptionsSetValue(PetscOptionsObject->options,option,value);
    629:     }
    630:     if (PetscOptionsObject->next->type == OPTION_ELIST) {
    631:       PetscStrNArrayDestroy(PetscOptionsObject->next->nlist,(char ***)&PetscOptionsObject->next->list);
    632:     }
    633:     PetscFree(PetscOptionsObject->next->text);
    634:     PetscFree(PetscOptionsObject->next->option);
    635:     PetscFree(PetscOptionsObject->next->man);
    636:     PetscFree(PetscOptionsObject->next->edata);

    638:     if ((PetscOptionsObject->next->type == OPTION_STRING) || (PetscOptionsObject->next->type == OPTION_FLIST) || (PetscOptionsObject->next->type == OPTION_ELIST)){
    639:       free(PetscOptionsObject->next->data);
    640:     } else {
    641:       PetscFree(PetscOptionsObject->next->data);
    642:     }

    644:     last                    = PetscOptionsObject->next;
    645:     PetscOptionsObject->next = PetscOptionsObject->next->next;
    646:     PetscFree(last);
    647:   }
    648:   PetscFree(PetscOptionsObject->prefix);
    649:   PetscOptionsObject->next = 0;
    650:   return(0);
    651: }

    655: /*@C
    656:    PetscOptionsEnum - Gets the enum value for a particular option in the database.

    658:    Logically Collective on the communicator passed in PetscOptionsBegin()

    660:    Input Parameters:
    661: +  opt - option name
    662: .  text - short string that describes the option
    663: .  man - manual page with additional information on option
    664: .  list - array containing the list of choices, followed by the enum name, followed by the enum prefix, followed by a null
    665: -  currentvalue - the current value; caller is responsible for setting this value correctly. Normally this is done with either
    666: $                 PetscOptionsEnum(..., obj->value,&object->value,...) or
    667: $                 value = defaultvalue
    668: $                 PetscOptionsEnum(..., value,&value,&flg);
    669: $                 if (flg) {

    671:    Output Parameter:
    672: +  value - the  value to return
    673: -  set - PETSC_TRUE if found, else PETSC_FALSE

    675:    Level: beginner

    677:    Concepts: options database

    679:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    681:           list is usually something like PCASMTypes or some other predefined list of enum names

    683: .seealso: PetscOptionsGetReal(), PetscOptionsHasName(), PetscOptionsGetString(), PetscOptionsGetInt(),
    684:           PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool()
    685:           PetscOptionsInt(), PetscOptionsString(), PetscOptionsReal(), PetscOptionsBool(),
    686:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    687:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    688:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    689:           PetscOptionsFList(), PetscOptionsEList()
    690: @*/
    691: PetscErrorCode  PetscOptionsEnum_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],const char *const *list,PetscEnum currentvalue,PetscEnum *value,PetscBool  *set)
    692: {
    694:   PetscInt       ntext = 0;
    695:   PetscInt       tval;
    696:   PetscBool      tflg;

    699:   while (list[ntext++]) {
    700:     if (ntext > 50) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"List argument appears to be wrong or have more than 50 entries");
    701:   }
    702:   if (ntext < 3) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"List argument must have at least two entries: typename and type prefix");
    703:   ntext -= 3;
    704:   PetscOptionsEList_Private(PetscOptionsObject,opt,text,man,list,ntext,list[currentvalue],&tval,&tflg);
    705:   /* with PETSC_USE_64BIT_INDICES sizeof(PetscInt) != sizeof(PetscEnum) */
    706:   if (tflg) *value = (PetscEnum)tval;
    707:   if (set)  *set   = tflg;
    708:   return(0);
    709: }

    713: /*@C
    714:    PetscOptionsEnumArray - Gets an array of enum values for a particular
    715:    option in the database.

    717:    Logically Collective on the communicator passed in PetscOptionsBegin()

    719:    Input Parameters:
    720: +  opt - the option one is seeking
    721: .  text - short string describing option
    722: .  man - manual page for option
    723: -  n - maximum number of values

    725:    Output Parameter:
    726: +  value - location to copy values
    727: .  n - actual number of values found
    728: -  set - PETSC_TRUE if found, else PETSC_FALSE

    730:    Level: beginner

    732:    Notes:
    733:    The array must be passed as a comma separated list.

    735:    There must be no intervening spaces between the values.

    737:    Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    739:    Concepts: options database^array of enums

    741: .seealso: PetscOptionsGetInt(), PetscOptionsGetReal(),
    742:           PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    743:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    744:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    745:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    746:           PetscOptionsFList(), PetscOptionsEList(), PetscOptionsRealArray()
    747: @*/
    748: PetscErrorCode  PetscOptionsEnumArray_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],const char *const *list,PetscEnum value[],PetscInt *n,PetscBool  *set)
    749: {
    750:   PetscInt        i,nlist = 0;
    751:   PetscOptionItem amsopt;
    752:   PetscErrorCode  ierr;

    755:   while (list[nlist++]) if (nlist > 50) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"List argument appears to be wrong or have more than 50 entries");
    756:   if (nlist < 3) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"List argument must have at least two entries: typename and type prefix");
    757:   nlist -= 3; /* drop enum name, prefix, and null termination */
    758:   if (0 && !PetscOptionsObject->count) { /* XXX Requires additional support */
    759:     PetscEnum *vals;
    760:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_INT_ARRAY/*XXX OPTION_ENUM_ARRAY*/,&amsopt);
    761:     PetscStrNArrayallocpy(nlist,list,(char***)&amsopt->list);
    762:     amsopt->nlist = nlist;
    763:     PetscMalloc1(*n,(PetscEnum**)&amsopt->data);
    764:     amsopt->arraylength = *n;
    765:     vals = (PetscEnum*)amsopt->data;
    766:     for (i=0; i<*n; i++) vals[i] = value[i];
    767:   }
    768:   PetscOptionsGetEnumArray(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,list,value,n,set);
    769:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    770:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%s",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,list[value[0]]);
    771:     for (i=1; i<*n; i++) {(*PetscHelpPrintf)(PetscOptionsObject->comm,",%s",list[value[i]]);}
    772:     (*PetscHelpPrintf)(PetscOptionsObject->comm,">: %s (choose from)",text);
    773:     for (i=0; i<nlist; i++) {(*PetscHelpPrintf)(PetscOptionsObject->comm," %s",list[i]);}
    774:     (*PetscHelpPrintf)(PetscOptionsObject->comm," (%s)\n",ManSection(man));
    775:   }
    776:   return(0);
    777: }

    779: /* -------------------------------------------------------------------------------------------------------------*/
    782: /*@C
    783:    PetscOptionsInt - Gets the integer value for a particular option in the database.

    785:    Logically Collective on the communicator passed in PetscOptionsBegin()

    787:    Input Parameters:
    788: +  opt - option name
    789: .  text - short string that describes the option
    790: .  man - manual page with additional information on option
    791: -  currentvalue - the current value; caller is responsible for setting this value correctly. Normally this is done with either
    792: $                 PetscOptionsInt(..., obj->value,&object->value,...) or
    793: $                 value = defaultvalue
    794: $                 PetscOptionsInt(..., value,&value,&flg);
    795: $                 if (flg) {

    797:    Output Parameter:
    798: +  value - the integer value to return
    799: -  flg - PETSC_TRUE if found, else PETSC_FALSE

    801:    Level: beginner

    803:    Concepts: options database^has int

    805:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    807: .seealso: PetscOptionsGetReal(), PetscOptionsHasName(), PetscOptionsGetString(), PetscOptionsGetInt(),
    808:           PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool()
    809:           PetscOptionsInt(), PetscOptionsString(), PetscOptionsReal(), PetscOptionsBool(),
    810:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    811:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    812:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    813:           PetscOptionsFList(), PetscOptionsEList()
    814: @*/
    815: PetscErrorCode  PetscOptionsInt_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscInt currentvalue,PetscInt *value,PetscBool  *set)
    816: {
    817:   PetscErrorCode  ierr;
    818:   PetscOptionItem amsopt;
    819:   PetscBool       wasset;

    822:   if (!PetscOptionsObject->count) {
    823:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_INT,&amsopt);
    824:     PetscMalloc(sizeof(PetscInt),&amsopt->data);
    825:     *(PetscInt*)amsopt->data = currentvalue;

    827:     PetscOptionsGetInt(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,&currentvalue,&wasset);
    828:     if (wasset) {
    829:       *(PetscInt*)amsopt->data = currentvalue;
    830:     }
    831:   }
    832:   PetscOptionsGetInt(NULL,PetscOptionsObject->prefix,opt,value,set);
    833:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    834:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%d>: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,currentvalue,text,ManSection(man));
    835:   }
    836:   return(0);
    837: }

    841: /*@C
    842:    PetscOptionsString - Gets the string value for a particular option in the database.

    844:    Logically Collective on the communicator passed in PetscOptionsBegin()

    846:    Input Parameters:
    847: +  opt - option name
    848: .  text - short string that describes the option
    849: .  man - manual page with additional information on option
    850: .  currentvalue - the current value; caller is responsible for setting this value correctly. This is not used to set value
    851: -  len - length of the result string including null terminator

    853:    Output Parameter:
    854: +  value - the value to return
    855: -  flg - PETSC_TRUE if found, else PETSC_FALSE

    857:    Level: beginner

    859:    Concepts: options database^has int

    861:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    863:    Even if the user provided no string (for example -optionname -someotheroption) the flag is set to PETSC_TRUE (and the string is fulled with nulls).

    865: .seealso: PetscOptionsGetReal(), PetscOptionsHasName(), PetscOptionsGetString(), PetscOptionsGetInt(NULL,),
    866:           PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool()
    867:           PetscOptionsInt(), PetscOptionsReal(), PetscOptionsBool(),
    868:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    869:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    870:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    871:           PetscOptionsFList(), PetscOptionsEList()
    872: @*/
    873: PetscErrorCode  PetscOptionsString_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],const char currentvalue[],char value[],size_t len,PetscBool  *set)
    874: {
    875:   PetscErrorCode  ierr;
    876:   PetscOptionItem amsopt;

    879:   if (!PetscOptionsObject->count) {
    880:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_STRING,&amsopt);
    881:     /* must use system malloc since SAWs may free this */
    882:     PetscStrdup(currentvalue ? currentvalue : "",(char**)&amsopt->data);
    883:   }
    884:   PetscOptionsGetString(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,len,set);
    885:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    886:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%s>: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,currentvalue,text,ManSection(man));
    887:   }
    888:   return(0);
    889: }

    893: /*@C
    894:    PetscOptionsReal - Gets the PetscReal value for a particular option in the database.

    896:    Logically Collective on the communicator passed in PetscOptionsBegin()

    898:    Input Parameters:
    899: +  opt - option name
    900: .  text - short string that describes the option
    901: .  man - manual page with additional information on option
    902: -  currentvalue - the current value; caller is responsible for setting this value correctly. Normally this is done with either
    903: $                 PetscOptionsReal(..., obj->value,&object->value,...) or
    904: $                 value = defaultvalue
    905: $                 PetscOptionsReal(..., value,&value,&flg);
    906: $                 if (flg) {

    908:    Output Parameter:
    909: +  value - the value to return
    910: -  flg - PETSC_TRUE if found, else PETSC_FALSE

    912:    Level: beginner

    914:    Concepts: options database^has int

    916:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    918: .seealso: PetscOptionsGetReal(), PetscOptionsHasName(), PetscOptionsGetString(), PetscOptionsGetInt(NULL,),
    919:           PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool()
    920:           PetscOptionsInt(), PetscOptionsString(), PetscOptionsReal(), PetscOptionsBool(),
    921:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    922:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    923:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    924:           PetscOptionsFList(), PetscOptionsEList()
    925: @*/
    926: PetscErrorCode  PetscOptionsReal_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscReal currentvalue,PetscReal *value,PetscBool  *set)
    927: {
    928:   PetscErrorCode  ierr;
    929:   PetscOptionItem amsopt;

    932:   if (!PetscOptionsObject->count) {
    933:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_REAL,&amsopt);
    934:     PetscMalloc(sizeof(PetscReal),&amsopt->data);

    936:     *(PetscReal*)amsopt->data = currentvalue;
    937:   }
    938:   PetscOptionsGetReal(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,set);
    939:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    940:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%g>: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,(double)currentvalue,text,ManSection(man));
    941:   }
    942:   return(0);
    943: }

    947: /*@C
    948:    PetscOptionsScalar - Gets the scalar value for a particular option in the database.

    950:    Logically Collective on the communicator passed in PetscOptionsBegin()

    952:    Input Parameters:
    953: +  opt - option name
    954: .  text - short string that describes the option
    955: .  man - manual page with additional information on option
    956: -  currentvalue - the current value; caller is responsible for setting this value correctly. Normally this is done with either
    957: $                 PetscOptionsScalar(..., obj->value,&object->value,...) or
    958: $                 value = defaultvalue
    959: $                 PetscOptionsScalar(..., value,&value,&flg);
    960: $                 if (flg) {

    963:    Output Parameter:
    964: +  value - the value to return
    965: -  flg - PETSC_TRUE if found, else PETSC_FALSE

    967:    Level: beginner

    969:    Concepts: options database^has int

    971:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    973: .seealso: PetscOptionsGetReal(), PetscOptionsHasName(), PetscOptionsGetString(), PetscOptionsGetInt(NULL,),
    974:           PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool()
    975:           PetscOptionsInt(), PetscOptionsString(), PetscOptionsReal(), PetscOptionsBool(),
    976:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    977:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    978:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    979:           PetscOptionsFList(), PetscOptionsEList()
    980: @*/
    981: PetscErrorCode  PetscOptionsScalar_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscScalar currentvalue,PetscScalar *value,PetscBool  *set)
    982: {

    986: #if !defined(PETSC_USE_COMPLEX)
    987:   PetscOptionsReal(opt,text,man,currentvalue,value,set);
    988: #else
    989:   PetscOptionsGetScalar(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,set);
    990: #endif
    991:   return(0);
    992: }

    996: /*@C
    997:    PetscOptionsName - Determines if a particular option has been set in the database. This returns true whether the option is a number, string or boolean, even
    998:                       its value is set to false.

    1000:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1002:    Input Parameters:
    1003: +  opt - option name
    1004: .  text - short string that describes the option
    1005: -  man - manual page with additional information on option

    1007:    Output Parameter:
    1008: .  flg - PETSC_TRUE if found, else PETSC_FALSE

    1010:    Level: beginner

    1012:    Concepts: options database^has int

    1014:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1016: .seealso: PetscOptionsGetReal(), PetscOptionsHasName(), PetscOptionsGetString(), PetscOptionsGetInt(NULL,),
    1017:           PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool()
    1018:           PetscOptionsInt(), PetscOptionsString(), PetscOptionsReal(), PetscOptionsBool(),
    1019:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1020:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1021:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1022:           PetscOptionsFList(), PetscOptionsEList()
    1023: @*/
    1024: PetscErrorCode  PetscOptionsName_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscBool  *flg)
    1025: {
    1026:   PetscErrorCode  ierr;
    1027:   PetscOptionItem amsopt;

    1030:   if (!PetscOptionsObject->count) {
    1031:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_BOOL,&amsopt);
    1032:     PetscMalloc(sizeof(PetscBool),&amsopt->data);

    1034:     *(PetscBool*)amsopt->data = PETSC_FALSE;
    1035:   }
    1036:   PetscOptionsHasName(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,flg);
    1037:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1038:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,text,ManSection(man));
    1039:   }
    1040:   return(0);
    1041: }

    1045: /*@C
    1046:      PetscOptionsFList - Puts a list of option values that a single one may be selected from

    1048:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1050:    Input Parameters:
    1051: +  opt - option name
    1052: .  text - short string that describes the option
    1053: .  man - manual page with additional information on option
    1054: .  list - the possible choices
    1055: .  currentvalue - the current value; caller is responsible for setting this value correctly. Normally this is done with
    1056: $                 PetscOptionsFlist(..., obj->value,value,len,&flg);
    1057: $                 if (flg) {
    1058: -  len - the length of the character array value

    1060:    Output Parameter:
    1061: +  value - the value to return
    1062: -  set - PETSC_TRUE if found, else PETSC_FALSE

    1064:    Level: intermediate

    1066:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1068:    See PetscOptionsEList() for when the choices are given in a string array

    1070:    To get a listing of all currently specified options,
    1071:     see PetscOptionsView() or PetscOptionsGetAll()

    1073:    Developer Note: This cannot check for invalid selection because of things like MATAIJ that are not included in the list

    1075:    Concepts: options database^list

    1077: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1078:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1079:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1080:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1081:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1082:           PetscOptionsFList(), PetscOptionsEList(), PetscOptionsEnum()
    1083: @*/
    1084: PetscErrorCode  PetscOptionsFList_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char ltext[],const char man[],PetscFunctionList list,const char currentvalue[],char value[],size_t len,PetscBool  *set)
    1085: {
    1086:   PetscErrorCode  ierr;
    1087:   PetscOptionItem amsopt;

    1090:   if (!PetscOptionsObject->count) {
    1091:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,ltext,man,OPTION_FLIST,&amsopt);
    1092:     /* must use system malloc since SAWs may free this */
    1093:     PetscStrdup(currentvalue ? currentvalue : "",(char**)&amsopt->data);
    1094:     amsopt->flist = list;
    1095:   }
    1096:   PetscOptionsGetString(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,len,set);
    1097:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1098:     PetscFunctionListPrintTypes(PetscOptionsObject->comm,stdout,PetscOptionsObject->prefix,opt,ltext,man,list,currentvalue);
    1099:   }
    1100:   return(0);
    1101: }

    1105: /*@C
    1106:      PetscOptionsEList - Puts a list of option values that a single one may be selected from

    1108:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1110:    Input Parameters:
    1111: +  opt - option name
    1112: .  ltext - short string that describes the option
    1113: .  man - manual page with additional information on option
    1114: .  list - the possible choices (one of these must be selected, anything else is invalid)
    1115: .  ntext - number of choices
    1116: -  currentvalue - the current value; caller is responsible for setting this value correctly. Normally this is done with
    1117: $                 PetscOptionsElist(..., obj->value,&value,&flg);
    1118: $                 if (flg) {

    1121:    Output Parameter:
    1122: +  value - the index of the value to return
    1123: -  set - PETSC_TRUE if found, else PETSC_FALSE

    1125:    Level: intermediate

    1127:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1129:    See PetscOptionsFList() for when the choices are given in a PetscFunctionList()

    1131:    Concepts: options database^list

    1133: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1134:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1135:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1136:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1137:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1138:           PetscOptionsFList(), PetscOptionsEnum()
    1139: @*/
    1140: PetscErrorCode  PetscOptionsEList_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char ltext[],const char man[],const char *const *list,PetscInt ntext,const char currentvalue[],PetscInt *value,PetscBool  *set)
    1141: {
    1142:   PetscErrorCode  ierr;
    1143:   PetscInt        i;
    1144:   PetscOptionItem amsopt;

    1147:   if (!PetscOptionsObject->count) {
    1148:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,ltext,man,OPTION_ELIST,&amsopt);
    1149:     /* must use system malloc since SAWs may free this */
    1150:     PetscStrdup(currentvalue ? currentvalue : "",(char**)&amsopt->data);
    1151:     PetscStrNArrayallocpy(ntext,list,(char***)&amsopt->list);
    1152:     amsopt->nlist = ntext;
    1153:   }
    1154:   PetscOptionsGetEList(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,list,ntext,value,set);
    1155:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1156:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%s> (choose one of)",PetscOptionsObject->prefix?PetscOptionsObject->prefix:"",opt+1,currentvalue);
    1157:     for (i=0; i<ntext; i++) {
    1158:       (*PetscHelpPrintf)(PetscOptionsObject->comm," %s",list[i]);
    1159:     }
    1160:     (*PetscHelpPrintf)(PetscOptionsObject->comm," (%s)\n",ManSection(man));
    1161:   }
    1162:   return(0);
    1163: }

    1167: /*@C
    1168:      PetscOptionsBoolGroupBegin - First in a series of logical queries on the options database for
    1169:        which at most a single value can be true.

    1171:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1173:    Input Parameters:
    1174: +  opt - option name
    1175: .  text - short string that describes the option
    1176: -  man - manual page with additional information on option

    1178:    Output Parameter:
    1179: .  flg - whether that option was set or not

    1181:    Level: intermediate

    1183:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1185:    Must be followed by 0 or more PetscOptionsBoolGroup()s and PetscOptionsBoolGroupEnd()

    1187:     Concepts: options database^logical group

    1189: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1190:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1191:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1192:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1193:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1194:           PetscOptionsFList(), PetscOptionsEList()
    1195: @*/
    1196: PetscErrorCode  PetscOptionsBoolGroupBegin_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscBool  *flg)
    1197: {
    1198:   PetscErrorCode  ierr;
    1199:   PetscOptionItem amsopt;

    1202:   if (!PetscOptionsObject->count) {
    1203:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_BOOL,&amsopt);
    1204:     PetscMalloc(sizeof(PetscBool),&amsopt->data);

    1206:     *(PetscBool*)amsopt->data = PETSC_FALSE;
    1207:   }
    1208:   *flg = PETSC_FALSE;
    1209:   PetscOptionsGetBool(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,flg,NULL);
    1210:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1211:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  Pick at most one of -------------\n");
    1212:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"    -%s%s: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,text,ManSection(man));
    1213:   }
    1214:   return(0);
    1215: }

    1219: /*@C
    1220:      PetscOptionsBoolGroup - One in a series of logical queries on the options database for
    1221:        which at most a single value can be true.

    1223:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1225:    Input Parameters:
    1226: +  opt - option name
    1227: .  text - short string that describes the option
    1228: -  man - manual page with additional information on option

    1230:    Output Parameter:
    1231: .  flg - PETSC_TRUE if found, else PETSC_FALSE

    1233:    Level: intermediate

    1235:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1237:    Must follow a PetscOptionsBoolGroupBegin() and preceded a PetscOptionsBoolGroupEnd()

    1239:     Concepts: options database^logical group

    1241: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1242:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1243:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1244:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1245:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1246:           PetscOptionsFList(), PetscOptionsEList()
    1247: @*/
    1248: PetscErrorCode  PetscOptionsBoolGroup_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscBool  *flg)
    1249: {
    1250:   PetscErrorCode  ierr;
    1251:   PetscOptionItem amsopt;

    1254:   if (!PetscOptionsObject->count) {
    1255:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_BOOL,&amsopt);
    1256:     PetscMalloc(sizeof(PetscBool),&amsopt->data);

    1258:     *(PetscBool*)amsopt->data = PETSC_FALSE;
    1259:   }
    1260:   *flg = PETSC_FALSE;
    1261:   PetscOptionsGetBool(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,flg,NULL);
    1262:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1263:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"    -%s%s: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,text,ManSection(man));
    1264:   }
    1265:   return(0);
    1266: }

    1270: /*@C
    1271:      PetscOptionsBoolGroupEnd - Last in a series of logical queries on the options database for
    1272:        which at most a single value can be true.

    1274:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1276:    Input Parameters:
    1277: +  opt - option name
    1278: .  text - short string that describes the option
    1279: -  man - manual page with additional information on option

    1281:    Output Parameter:
    1282: .  flg - PETSC_TRUE if found, else PETSC_FALSE

    1284:    Level: intermediate

    1286:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1288:    Must follow a PetscOptionsBoolGroupBegin()

    1290:     Concepts: options database^logical group

    1292: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1293:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1294:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1295:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1296:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1297:           PetscOptionsFList(), PetscOptionsEList()
    1298: @*/
    1299: PetscErrorCode  PetscOptionsBoolGroupEnd_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscBool  *flg)
    1300: {
    1301:   PetscErrorCode  ierr;
    1302:   PetscOptionItem amsopt;

    1305:   if (!PetscOptionsObject->count) {
    1306:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_BOOL,&amsopt);
    1307:     PetscMalloc(sizeof(PetscBool),&amsopt->data);

    1309:     *(PetscBool*)amsopt->data = PETSC_FALSE;
    1310:   }
    1311:   *flg = PETSC_FALSE;
    1312:   PetscOptionsGetBool(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,flg,NULL);
    1313:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1314:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"    -%s%s: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,text,ManSection(man));
    1315:   }
    1316:   return(0);
    1317: }

    1321: /*@C
    1322:    PetscOptionsBool - Determines if a particular option is in the database with a true or false

    1324:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1326:    Input Parameters:
    1327: +  opt - option name
    1328: .  text - short string that describes the option
    1329: .  man - manual page with additional information on option
    1330: -  currentvalue - the current value

    1332:    Output Parameter:
    1333: .  flg - PETSC_TRUE or PETSC_FALSE
    1334: .  set - PETSC_TRUE if found, else PETSC_FALSE

    1336:    Level: beginner

    1338:    Concepts: options database^logical

    1340:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1342: .seealso: PetscOptionsGetReal(), PetscOptionsHasName(), PetscOptionsGetString(), PetscOptionsGetInt(NULL,),
    1343:           PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool()
    1344:           PetscOptionsInt(), PetscOptionsString(), PetscOptionsReal(), PetscOptionsBool(),
    1345:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1346:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1347:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1348:           PetscOptionsFList(), PetscOptionsEList()
    1349: @*/
    1350: PetscErrorCode  PetscOptionsBool_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscBool currentvalue,PetscBool  *flg,PetscBool  *set)
    1351: {
    1352:   PetscErrorCode  ierr;
    1353:   PetscBool       iset;
    1354:   PetscOptionItem amsopt;

    1357:   if (!PetscOptionsObject->count) {
    1358:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_BOOL,&amsopt);
    1359:     PetscMalloc(sizeof(PetscBool),&amsopt->data);

    1361:     *(PetscBool*)amsopt->data = currentvalue;
    1362:   }
    1363:   PetscOptionsGetBool(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,flg,&iset);
    1364:   if (set) *set = iset;
    1365:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1366:     const char *v = PetscBools[currentvalue];
    1367:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s: <%s> %s (%s)\n",PetscOptionsObject->prefix?PetscOptionsObject->prefix:"",opt+1,v,text,ManSection(man));
    1368:   }
    1369:   return(0);
    1370: }

    1374: /*@C
    1375:    PetscOptionsRealArray - Gets an array of double values for a particular
    1376:    option in the database. The values must be separated with commas with
    1377:    no intervening spaces.

    1379:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1381:    Input Parameters:
    1382: +  opt - the option one is seeking
    1383: .  text - short string describing option
    1384: .  man - manual page for option
    1385: -  nmax - maximum number of values

    1387:    Output Parameter:
    1388: +  value - location to copy values
    1389: .  nmax - actual number of values found
    1390: -  set - PETSC_TRUE if found, else PETSC_FALSE

    1392:    Level: beginner

    1394:    Notes:
    1395:    The user should pass in an array of doubles

    1397:    Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1399:    Concepts: options database^array of strings

    1401: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1402:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1403:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1404:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1405:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1406:           PetscOptionsFList(), PetscOptionsEList()
    1407: @*/
    1408: PetscErrorCode PetscOptionsRealArray_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscReal value[],PetscInt *n,PetscBool  *set)
    1409: {
    1410:   PetscErrorCode  ierr;
    1411:   PetscInt        i;
    1412:   PetscOptionItem amsopt;

    1415:   if (!PetscOptionsObject->count) {
    1416:     PetscReal *vals;

    1418:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_REAL_ARRAY,&amsopt);
    1419:     PetscMalloc((*n)*sizeof(PetscReal),&amsopt->data);
    1420:     vals = (PetscReal*)amsopt->data;
    1421:     for (i=0; i<*n; i++) vals[i] = value[i];
    1422:     amsopt->arraylength = *n;
    1423:   }
    1424:   PetscOptionsGetRealArray(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,n,set);
    1425:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1426:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%g",PetscOptionsObject->prefix?PetscOptionsObject->prefix:"",opt+1,(double)value[0]);
    1427:     for (i=1; i<*n; i++) {
    1428:       (*PetscHelpPrintf)(PetscOptionsObject->comm,",%g",(double)value[i]);
    1429:     }
    1430:     (*PetscHelpPrintf)(PetscOptionsObject->comm,">: %s (%s)\n",text,ManSection(man));
    1431:   }
    1432:   return(0);
    1433: }

    1437: /*@C
    1438:    PetscOptionsScalarArray - Gets an array of Scalar values for a particular
    1439:    option in the database. The values must be separated with commas with
    1440:    no intervening spaces.

    1442:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1444:    Input Parameters:
    1445: +  opt - the option one is seeking
    1446: .  text - short string describing option
    1447: .  man - manual page for option
    1448: -  nmax - maximum number of values

    1450:    Output Parameter:
    1451: +  value - location to copy values
    1452: .  nmax - actual number of values found
    1453: -  set - PETSC_TRUE if found, else PETSC_FALSE

    1455:    Level: beginner

    1457:    Notes:
    1458:    The user should pass in an array of doubles

    1460:    Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1462:    Concepts: options database^array of strings

    1464: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1465:           PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1466:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1467:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1468:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1469:           PetscOptionsFList(), PetscOptionsEList()
    1470: @*/
    1471: PetscErrorCode PetscOptionsScalarArray_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscScalar value[],PetscInt *n,PetscBool  *set)
    1472: {
    1473:   PetscErrorCode  ierr;
    1474:   PetscInt        i;
    1475:   PetscOptionItem amsopt;

    1478:   if (!PetscOptionsObject->count) {
    1479:     PetscScalar *vals;

    1481:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_SCALAR_ARRAY,&amsopt);
    1482:     PetscMalloc((*n)*sizeof(PetscScalar),&amsopt->data);
    1483:     vals = (PetscScalar*)amsopt->data;
    1484:     for (i=0; i<*n; i++) vals[i] = value[i];
    1485:     amsopt->arraylength = *n;
    1486:   }
    1487:   PetscOptionsGetScalarArray(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,n,set);
    1488:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1489:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%g+%gi",PetscOptionsObject->prefix?PetscOptionsObject->prefix:"",opt+1,(double)PetscRealPart(value[0]),(double)PetscImaginaryPart(value[0]));
    1490:     for (i=1; i<*n; i++) {
    1491:       (*PetscHelpPrintf)(PetscOptionsObject->comm,",%g+%gi",(double)PetscRealPart(value[i]),(double)PetscImaginaryPart(value[i]));
    1492:     }
    1493:     (*PetscHelpPrintf)(PetscOptionsObject->comm,">: %s (%s)\n",text,ManSection(man));
    1494:   }
    1495:   return(0);
    1496: }

    1500: /*@C
    1501:    PetscOptionsIntArray - Gets an array of integers for a particular
    1502:    option in the database.

    1504:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1506:    Input Parameters:
    1507: +  opt - the option one is seeking
    1508: .  text - short string describing option
    1509: .  man - manual page for option
    1510: -  n - maximum number of values

    1512:    Output Parameter:
    1513: +  value - location to copy values
    1514: .  n - actual number of values found
    1515: -  set - PETSC_TRUE if found, else PETSC_FALSE

    1517:    Level: beginner

    1519:    Notes:
    1520:    The array can be passed as
    1521:    a comma separated list:                                 0,1,2,3,4,5,6,7
    1522:    a range (start-end+1):                                  0-8
    1523:    a range with given increment (start-end+1:inc):         0-7:2
    1524:    a combination of values and ranges separated by commas: 0,1-8,8-15:2

    1526:    There must be no intervening spaces between the values.

    1528:    Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1530:    Concepts: options database^array of ints

    1532: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1533:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1534:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1535:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1536:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1537:           PetscOptionsFList(), PetscOptionsEList(), PetscOptionsRealArray()
    1538: @*/
    1539: PetscErrorCode  PetscOptionsIntArray_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscInt value[],PetscInt *n,PetscBool  *set)
    1540: {
    1542:   PetscInt        i;
    1543:   PetscOptionItem amsopt;

    1546:   if (!PetscOptionsObject->count) {
    1547:     PetscInt *vals;

    1549:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_INT_ARRAY,&amsopt);
    1550:     PetscMalloc1(*n,(PetscInt**)&amsopt->data);
    1551:     vals = (PetscInt*)amsopt->data;
    1552:     for (i=0; i<*n; i++) vals[i] = value[i];
    1553:     amsopt->arraylength = *n;
    1554:   }
    1555:   PetscOptionsGetIntArray(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,n,set);
    1556:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1557:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%d",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,value[0]);
    1558:     for (i=1; i<*n; i++) {
    1559:       (*PetscHelpPrintf)(PetscOptionsObject->comm,",%d",value[i]);
    1560:     }
    1561:     (*PetscHelpPrintf)(PetscOptionsObject->comm,">: %s (%s)\n",text,ManSection(man));
    1562:   }
    1563:   return(0);
    1564: }

    1568: /*@C
    1569:    PetscOptionsStringArray - Gets an array of string values for a particular
    1570:    option in the database. The values must be separated with commas with
    1571:    no intervening spaces.

    1573:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1575:    Input Parameters:
    1576: +  opt - the option one is seeking
    1577: .  text - short string describing option
    1578: .  man - manual page for option
    1579: -  nmax - maximum number of strings

    1581:    Output Parameter:
    1582: +  value - location to copy strings
    1583: .  nmax - actual number of strings found
    1584: -  set - PETSC_TRUE if found, else PETSC_FALSE

    1586:    Level: beginner

    1588:    Notes:
    1589:    The user should pass in an array of pointers to char, to hold all the
    1590:    strings returned by this function.

    1592:    The user is responsible for deallocating the strings that are
    1593:    returned. The Fortran interface for this routine is not supported.

    1595:    Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1597:    Concepts: options database^array of strings

    1599: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1600:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1601:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1602:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1603:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1604:           PetscOptionsFList(), PetscOptionsEList()
    1605: @*/
    1606: PetscErrorCode  PetscOptionsStringArray_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],char *value[],PetscInt *nmax,PetscBool  *set)
    1607: {
    1608:   PetscErrorCode  ierr;
    1609:   PetscOptionItem amsopt;

    1612:   if (!PetscOptionsObject->count) {
    1613:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_STRING_ARRAY,&amsopt);
    1614:     PetscMalloc1(*nmax,(char**)&amsopt->data);

    1616:     amsopt->arraylength = *nmax;
    1617:   }
    1618:   PetscOptionsGetStringArray(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,nmax,set);
    1619:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1620:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <string1,string2,...>: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,text,ManSection(man));
    1621:   }
    1622:   return(0);
    1623: }

    1627: /*@C
    1628:    PetscOptionsBoolArray - Gets an array of logical values (true or false) for a particular
    1629:    option in the database. The values must be separated with commas with
    1630:    no intervening spaces.

    1632:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1634:    Input Parameters:
    1635: +  opt - the option one is seeking
    1636: .  text - short string describing option
    1637: .  man - manual page for option
    1638: -  nmax - maximum number of values

    1640:    Output Parameter:
    1641: +  value - location to copy values
    1642: .  nmax - actual number of values found
    1643: -  set - PETSC_TRUE if found, else PETSC_FALSE

    1645:    Level: beginner

    1647:    Notes:
    1648:    The user should pass in an array of doubles

    1650:    Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1652:    Concepts: options database^array of strings

    1654: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1655:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1656:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1657:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1658:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1659:           PetscOptionsFList(), PetscOptionsEList()
    1660: @*/
    1661: PetscErrorCode  PetscOptionsBoolArray_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscBool value[],PetscInt *n,PetscBool *set)
    1662: {
    1663:   PetscErrorCode   ierr;
    1664:   PetscInt         i;
    1665:   PetscOptionItem  amsopt;

    1668:   if (!PetscOptionsObject->count) {
    1669:     PetscBool *vals;

    1671:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_BOOL_ARRAY,&amsopt);
    1672:     PetscMalloc1(*n,(PetscBool**)&amsopt->data);
    1673:     vals = (PetscBool*)amsopt->data;
    1674:     for (i=0; i<*n; i++) vals[i] = value[i];
    1675:     amsopt->arraylength = *n;
    1676:   }
    1677:   PetscOptionsGetBoolArray(PetscOptionsObject->options,PetscOptionsObject->prefix,opt,value,n,set);
    1678:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1679:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%d",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,value[0]);
    1680:     for (i=1; i<*n; i++) {
    1681:       (*PetscHelpPrintf)(PetscOptionsObject->comm,",%d",value[i]);
    1682:     }
    1683:     (*PetscHelpPrintf)(PetscOptionsObject->comm,">: %s (%s)\n",text,ManSection(man));
    1684:   }
    1685:   return(0);
    1686: }

    1690: /*@C
    1691:    PetscOptionsViewer - Gets a viewer appropriate for the type indicated by the user

    1693:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1695:    Input Parameters:
    1696: +  opt - option name
    1697: .  text - short string that describes the option
    1698: -  man - manual page with additional information on option

    1700:    Output Parameter:
    1701: +  viewer - the viewer
    1702: -  set - PETSC_TRUE if found, else PETSC_FALSE

    1704:    Level: beginner

    1706:    Concepts: options database^has int

    1708:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1710:    See PetscOptionsGetViewer() for the format of the supplied viewer and its options

    1712: .seealso: PetscOptionsGetViewer(), PetscOptionsHasName(), PetscOptionsGetString(), PetscOptionsGetInt(NULL,),
    1713:           PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool()
    1714:           PetscOptionsInt(), PetscOptionsString(), PetscOptionsReal(), PetscOptionsBool(),
    1715:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1716:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1717:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1718:           PetscOptionsFList(), PetscOptionsEList()
    1719: @*/
    1720: PetscErrorCode  PetscOptionsViewer_Private(PetscOptionItems *PetscOptionsObject,const char opt[],const char text[],const char man[],PetscViewer *viewer,PetscViewerFormat *format,PetscBool  *set)
    1721: {
    1722:   PetscErrorCode  ierr;
    1723:   PetscOptionItem amsopt;

    1726:   if (!PetscOptionsObject->count) {
    1727:     PetscOptionItemCreate_Private(PetscOptionsObject,opt,text,man,OPTION_STRING,&amsopt);
    1728:     /* must use system malloc since SAWs may free this */
    1729:     PetscStrdup("",(char**)&amsopt->data);
    1730:   }
    1731:   PetscOptionsGetViewer(PetscOptionsObject->comm,PetscOptionsObject->prefix,opt,viewer,format,set);
    1732:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1733:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  -%s%s <%s>: %s (%s)\n",PetscOptionsObject->prefix ? PetscOptionsObject->prefix : "",opt+1,"",text,ManSection(man));
    1734:   }
    1735:   return(0);
    1736: }

    1741: /*@C
    1742:      PetscOptionsHead - Puts a heading before listing any more published options. Used, for example,
    1743:             in KSPSetFromOptions_GMRES().

    1745:    Logically Collective on the communicator passed in PetscOptionsBegin()

    1747:    Input Parameter:
    1748: .   head - the heading text

    1751:    Level: intermediate

    1753:    Notes: Must be between a PetscOptionsBegin() and a PetscOptionsEnd()

    1755:           Can be followed by a call to PetscOptionsTail() in the same function.

    1757:    Concepts: options database^subheading

    1759: .seealso: PetscOptionsGetInt(NULL,), PetscOptionsGetReal(),
    1760:            PetscOptionsHasName(), PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool(),
    1761:           PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(),
    1762:           PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(),
    1763:           PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(),
    1764:           PetscOptionsFList(), PetscOptionsEList()
    1765: @*/
    1766: PetscErrorCode  PetscOptionsHead(PetscOptionItems *PetscOptionsObject,const char head[])
    1767: {

    1771:   if (PetscOptionsObject->printhelp && PetscOptionsObject->count == 1 && !PetscOptionsObject->alreadyprinted) {
    1772:     (*PetscHelpPrintf)(PetscOptionsObject->comm,"  %s\n",head);
    1773:   }
    1774:   return(0);
    1775: }