Date: 2025-03-28T21:11:10+00:00

Actual source code: cgnsv.c

      1: #include <petsc/private/viewercgnsimpl.h>
      2: #include <petsc/private/dmpleximpl.h>
      3: #if defined(PETSC_HDF5_HAVE_PARALLEL)
      4:   #include <pcgnslib.h>
      5: #else
      6:   #include <cgnslib.h>
      7: #endif
      8: #include <cgns_io.h>
      9: #include <ctype.h>

     11: static PetscErrorCode PetscViewerSetFromOptions_CGNS(PetscViewer v, PetscOptionItems *PetscOptionsObject)
     12: {
     13:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)v->data;

     15:   PetscFunctionBegin;
     16:   PetscOptionsHeadBegin(PetscOptionsObject, "CGNS Viewer Options");
     17:   PetscCall(PetscOptionsInt("-viewer_cgns_batch_size", "Max number of steps to store in single file when using a template cgns:name-\%d.cgns", "", cgv->batch_size, &cgv->batch_size, NULL));
     18:   PetscOptionsHeadEnd();
     19:   PetscFunctionReturn(PETSC_SUCCESS);
     20: }

     22: static PetscErrorCode PetscViewerView_CGNS(PetscViewer v, PetscViewer viewer)
     23: {
     24:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)v->data;

     26:   PetscFunctionBegin;
     27:   if (cgv->filename) PetscCall(PetscViewerASCIIPrintf(viewer, "Filename: %s\n", cgv->filename));
     28:   PetscFunctionReturn(PETSC_SUCCESS);
     29: }

     31: static PetscErrorCode PetscViewerFileClose_CGNS(PetscViewer viewer)
     32: {
     33:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;

     35:   PetscFunctionBegin;
     36:   if (cgv->output_times) {
     37:     PetscCount size, width = 32, *steps;
     38:     char      *solnames;
     39:     PetscReal *times;
     40:     cgsize_t   num_times;
     41:     PetscCall(PetscSegBufferGetSize(cgv->output_times, &size));
     42:     PetscCall(PetscSegBufferExtractInPlace(cgv->output_times, &times));
     43:     num_times = size;
     44:     PetscCallCGNS(cg_biter_write(cgv->file_num, cgv->base, "TimeIterValues", num_times));
     45:     PetscCallCGNS(cg_goto(cgv->file_num, cgv->base, "BaseIterativeData_t", 1, NULL));
     46:     PetscCallCGNS(cg_array_write("TimeValues", CGNS_ENUMV(RealDouble), 1, &num_times, times));
     47:     PetscCall(PetscSegBufferDestroy(&cgv->output_times));
     48:     PetscCallCGNS(cg_ziter_write(cgv->file_num, cgv->base, cgv->zone, "ZoneIterativeData"));
     49:     PetscCallCGNS(cg_goto(cgv->file_num, cgv->base, "Zone_t", cgv->zone, "ZoneIterativeData_t", 1, NULL));
     50:     PetscCall(PetscMalloc(size * width + 1, &solnames));
     51:     PetscCall(PetscSegBufferExtractInPlace(cgv->output_steps, &steps));
     52:     for (PetscCount i = 0; i < size; i++) PetscCall(PetscSNPrintf(&solnames[i * width], width + 1, "FlowSolution%-20zu", (size_t)steps[i]));
     53:     PetscCall(PetscSegBufferDestroy(&cgv->output_steps));
     54:     cgsize_t shape[2] = {(cgsize_t)width, (cgsize_t)size};
     55:     PetscCallCGNS(cg_array_write("FlowSolutionPointers", CGNS_ENUMV(Character), 2, shape, solnames));
     56:     // The VTK reader looks for names like FlowSolution*Pointers.
     57:     for (PetscCount i = 0; i < size; i++) PetscCall(PetscSNPrintf(&solnames[i * width], width + 1, "%-32s", "CellInfo"));
     58:     PetscCallCGNS(cg_array_write("FlowSolutionCellInfoPointers", CGNS_ENUMV(Character), 2, shape, solnames));
     59:     PetscCall(PetscFree(solnames));

     61:     PetscCallCGNS(cg_simulation_type_write(cgv->file_num, cgv->base, CGNS_ENUMV(TimeAccurate)));
     62:   }
     63:   PetscCall(PetscFree(cgv->filename));
     64: #if defined(PETSC_HDF5_HAVE_PARALLEL)
     65:   if (cgv->file_num) PetscCallCGNS(cgp_close(cgv->file_num));
     66: #else
     67:   if (cgv->file_num) PetscCallCGNS(cg_close(cgv->file_num));
     68: #endif
     69:   cgv->file_num = 0;
     70:   PetscCall(PetscFree(cgv->node_l2g));
     71:   PetscCall(PetscFree(cgv->nodal_field));
     72:   PetscFunctionReturn(PETSC_SUCCESS);
     73: }

     75: PetscErrorCode PetscViewerCGNSFileOpen_Internal(PetscViewer viewer, PetscInt sequence_number)
     76: {
     77:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;

     79:   PetscFunctionBegin;
     80:   PetscCheck((cgv->filename == NULL) ^ (sequence_number < 0), PetscObjectComm((PetscObject)viewer), PETSC_ERR_ARG_INCOMP, "Expect either a template filename or non-negative sequence number");
     81:   if (!cgv->filename) {
     82:     char filename_numbered[PETSC_MAX_PATH_LEN];
     83:     // Cast sequence_number so %d can be used also when PetscInt is 64-bit. We could upgrade the format string if users
     84:     // run more than 2B time steps.
     85:     PetscCall(PetscSNPrintf(filename_numbered, sizeof filename_numbered, cgv->filename_template, (int)sequence_number));
     86:     PetscCall(PetscStrallocpy(filename_numbered, &cgv->filename));
     87:   }
     88:   switch (cgv->btype) {
     89:   case FILE_MODE_READ:
     90: #if defined(PETSC_HDF5_HAVE_PARALLEL)
     91:     PetscCallCGNS(cgp_mpi_comm(PetscObjectComm((PetscObject)viewer)));
     92:     PetscCallCGNS(cgp_open(cgv->filename, CG_MODE_READ, &cgv->file_num));
     93: #else
     94:     PetscCallCGNS(cg_open(filename, CG_MODE_READ, &cgv->file_num));
     95: #endif
     96:     break;
     97:   case FILE_MODE_WRITE:
     98: #if defined(PETSC_HDF5_HAVE_PARALLEL)
     99:     PetscCallCGNS(cgp_mpi_comm(PetscObjectComm((PetscObject)viewer)));
    100:     PetscCallCGNS(cgp_open(cgv->filename, CG_MODE_WRITE, &cgv->file_num));
    101: #else
    102:     PetscCallCGNS(cg_open(filename, CG_MODE_WRITE, &cgv->file_num));
    103: #endif
    104:     break;
    105:   case FILE_MODE_UNDEFINED:
    106:     SETERRQ(PetscObjectComm((PetscObject)viewer), PETSC_ERR_ORDER, "Must call PetscViewerFileSetMode() before PetscViewerFileSetName()");
    107:   default:
    108:     SETERRQ(PetscObjectComm((PetscObject)viewer), PETSC_ERR_SUP, "Unsupported file mode %s", PetscFileModes[cgv->btype]);
    109:   }
    110:   PetscFunctionReturn(PETSC_SUCCESS);
    111: }

    113: PetscErrorCode PetscViewerCGNSCheckBatch_Internal(PetscViewer viewer)
    114: {
    115:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
    116:   PetscCount        num_steps;

    118:   PetscFunctionBegin;
    119:   if (!cgv->filename_template) PetscFunctionReturn(PETSC_SUCCESS); // Batches are closed when viewer is destroyed
    120:   PetscCall(PetscSegBufferGetSize(cgv->output_times, &num_steps));
    121:   if (num_steps >= (PetscCount)cgv->batch_size) PetscCall(PetscViewerFileClose_CGNS(viewer));
    122:   PetscFunctionReturn(PETSC_SUCCESS);
    123: }

    125: static PetscErrorCode PetscViewerDestroy_CGNS(PetscViewer viewer)
    126: {
    127:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;

    129:   PetscFunctionBegin;
    130:   PetscCall(PetscViewerFileClose_CGNS(viewer));
    131:   PetscCall(PetscFree(cgv->solution_name));
    132:   PetscCall(PetscFree(cgv));
    133:   PetscCall(PetscObjectComposeFunction((PetscObject)viewer, "PetscViewerFileSetName_C", NULL));
    134:   PetscCall(PetscObjectComposeFunction((PetscObject)viewer, "PetscViewerFileGetName_C", NULL));
    135:   PetscCall(PetscObjectComposeFunction((PetscObject)viewer, "PetscViewerFileSetMode_C", NULL));
    136:   PetscCall(PetscObjectComposeFunction((PetscObject)viewer, "PetscViewerFileGetMode_C", NULL));
    137:   PetscFunctionReturn(PETSC_SUCCESS);
    138: }

    140: static PetscErrorCode PetscViewerFileSetMode_CGNS(PetscViewer viewer, PetscFileMode type)
    141: {
    142:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;

    144:   PetscFunctionBegin;
    145:   cgv->btype = type;
    146:   PetscFunctionReturn(PETSC_SUCCESS);
    147: }

    149: static PetscErrorCode PetscViewerFileGetMode_CGNS(PetscViewer viewer, PetscFileMode *type)
    150: {
    151:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;

    153:   PetscFunctionBegin;
    154:   *type = cgv->btype;
    155:   PetscFunctionReturn(PETSC_SUCCESS);
    156: }

    158: static PetscErrorCode PetscViewerFileSetName_CGNS(PetscViewer viewer, const char *filename)
    159: {
    160:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
    161:   char             *has_pattern;

    163:   PetscFunctionBegin;
    164:   if (cgv->file_num) PetscCallCGNS(cg_close(cgv->file_num));
    165:   PetscCall(PetscFree(cgv->filename));
    166:   PetscCall(PetscFree(cgv->filename_template));
    167:   PetscCall(PetscStrchr(filename, '%', &has_pattern));
    168:   if (has_pattern) {
    169:     PetscCall(PetscStrallocpy(filename, &cgv->filename_template));
    170:     // Templated file names open lazily, once we know DMGetOutputSequenceNumber()
    171:   } else {
    172:     PetscCall(PetscStrallocpy(filename, &cgv->filename));
    173:     PetscCall(PetscViewerCGNSFileOpen_Internal(viewer, -1));
    174:   }
    175:   PetscFunctionReturn(PETSC_SUCCESS);
    176: }

    178: static PetscErrorCode PetscViewerFileGetName_CGNS(PetscViewer viewer, const char **filename)
    179: {
    180:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;

    182:   PetscFunctionBegin;
    183:   *filename = cgv->filename;
    184:   PetscFunctionReturn(PETSC_SUCCESS);
    185: }

    187: /*MC
    188:    PETSCVIEWERCGNS - A viewer for CGNS files

    190:   Level: beginner

    192:   Options Database Key:
    193: . -viewer_cgns_batch_size SIZE - set max number of output sequence times to write per batch

    195:   Note:
    196:   If the filename contains an integer format character, the CGNS viewer will created a batched output sequence. For
    197:   example, one could use `-ts_monitor_solution cgns:flow-%d.cgns`. This is desirable if one wants to limit file sizes or
    198:   if the job might crash/be killed by a resource manager before exiting cleanly.

    200: .seealso: [](sec_viewers), `PetscViewer`, `PetscViewerCreate()`, `VecView()`, `DMView()`, `PetscViewerFileSetName()`, `PetscViewerFileSetMode()`, `TSSetFromOptions()`
    201: M*/

    203: PETSC_EXTERN PetscErrorCode PetscViewerCreate_CGNS(PetscViewer v)
    204: {
    205:   PetscViewer_CGNS *cgv;

    207:   PetscFunctionBegin;
    208:   PetscCall(PetscNew(&cgv));

    210:   v->data                = cgv;
    211:   v->ops->destroy        = PetscViewerDestroy_CGNS;
    212:   v->ops->setfromoptions = PetscViewerSetFromOptions_CGNS;
    213:   v->ops->view           = PetscViewerView_CGNS;
    214:   cgv->btype             = FILE_MODE_UNDEFINED;
    215:   cgv->filename          = NULL;
    216:   cgv->batch_size        = 20;
    217:   cgv->solution_index    = -1; // Default to use the "last" solution
    218:   cgv->base              = 1;
    219:   cgv->zone              = 1;

    221:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetName_C", PetscViewerFileSetName_CGNS));
    222:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetName_C", PetscViewerFileGetName_CGNS));
    223:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetMode_C", PetscViewerFileSetMode_CGNS));
    224:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetMode_C", PetscViewerFileGetMode_CGNS));
    225:   PetscFunctionReturn(PETSC_SUCCESS);
    226: }

    228: // Find DataArray_t node under the current node (determined by `cg_goto` and friends) that matches `name`
    229: // Return the index of that array and (optionally) other data about the array
    230: static inline PetscErrorCode CGNS_Find_Array(MPI_Comm comm, const char name[], int *A_index, CGNS_ENUMT(DataType_t) * data_type, int *dim, cgsize_t size[])
    231: {
    232:   int  narrays; // number of arrays under the current node
    233:   char array_name[CGIO_MAX_NAME_LENGTH + 1];
    234:   CGNS_ENUMT(DataType_t) data_type_local;
    235:   int       _dim;
    236:   cgsize_t  _size[12];
    237:   PetscBool matches_name = PETSC_FALSE;

    239:   PetscFunctionBeginUser;
    240:   PetscCallCGNS(cg_narrays(&narrays));
    241:   for (int i = 1; i <= narrays; i++) {
    242:     PetscCallCGNS(cg_array_info(i, array_name, &data_type_local, &_dim, _size));
    243:     PetscCall(PetscStrcmp(name, array_name, &matches_name));
    244:     if (matches_name) {
    245:       *A_index = i;
    246:       if (data_type) *data_type = data_type_local;
    247:       if (dim) *dim = _dim;
    248:       if (size) PetscArraycpy(size, _size, _dim);
    249:       PetscFunctionReturn(PETSC_SUCCESS);
    250:     }
    251:   }
    252:   SETERRQ(comm, PETSC_ERR_SUP, "Cannot find %s array under current CGNS node", name);
    253: }

    255: /*@
    256:   PetscViewerCGNSOpen - Opens a file for CGNS input/output.

    258:   Collective

    260:   Input Parameters:
    261: + comm - MPI communicator
    262: . name - name of file
    263: - type - type of file
    264: .vb
    265:     FILE_MODE_WRITE - create new file for binary output
    266:     FILE_MODE_READ - open existing file for binary input
    267:     FILE_MODE_APPEND - open existing file for binary output
    268: .ve

    270:   Output Parameter:
    271: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file

    273:   Level: beginner

    275: .seealso: `PETSCVIEWERCGNS`, `PetscViewer`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
    276:           `DMLoad()`, `PetscFileMode`, `PetscViewerSetType()`, `PetscViewerFileSetMode()`, `PetscViewerFileSetName()`
    277: @*/
    278: PetscErrorCode PetscViewerCGNSOpen(MPI_Comm comm, const char name[], PetscFileMode type, PetscViewer *viewer)
    279: {
    280:   PetscFunctionBegin;
    281:   PetscCall(PetscViewerCreate(comm, viewer));
    282:   PetscCall(PetscViewerSetType(*viewer, PETSCVIEWERCGNS));
    283:   PetscCall(PetscViewerFileSetMode(*viewer, type));
    284:   PetscCall(PetscViewerFileSetName(*viewer, name));
    285:   PetscCall(PetscViewerSetFromOptions(*viewer));
    286:   PetscFunctionReturn(PETSC_SUCCESS);
    287: }

    289: /*@
    290:   PetscViewerCGNSSetSolutionIndex - Set index of solution

    292:   Not Collective

    294:   Input Parameters:
    295: + viewer      - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file
    296: - solution_id - Index of the solution id, or `-1` for the last solution on the file

    298:   Level: intermediate

    300:   Notes:
    301:   By default, `solution_id` is set to `-1` to mean the last solution available in the file.
    302:   If the file contains a FlowSolutionPointers node, then that array is indexed to determine which FlowSolution_t node to read from.
    303:   Otherwise, `solution_id` indexes the total available FlowSolution_t nodes in the file.

    305:   This solution index is used by `VecLoad()` to determine which solution to load from the file

    307: .seealso: `PETSCVIEWERCGNS`, `PetscViewerCGNSGetSolutionIndex()`, `PetscViewerCGNSGetSolutionInfo()`

    309: @*/
    310: PetscErrorCode PetscViewerCGNSSetSolutionIndex(PetscViewer viewer, PetscInt solution_id)
    311: {
    312:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;

    314:   PetscFunctionBeginUser;
    315:   PetscCheck((solution_id != 0) && (solution_id > -2), PetscObjectComm((PetscObject)viewer), PETSC_ERR_USER_INPUT, "Solution index must be either -1 or greater than 0, not %" PetscInt_FMT, solution_id);
    316:   cgv->solution_index      = solution_id;
    317:   cgv->solution_file_index = 0; // Reset sol_index when solution_id changes (0 is invalid)
    318:   PetscFunctionReturn(PETSC_SUCCESS);
    319: }

    321: /*@
    322:   PetscViewerCGNSGetSolutionIndex - Get index of solution

    324:   Not Collective

    326:   Input Parameter:
    327: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file

    329:   Output Parameter:
    330: . solution_id - Index of the solution id

    332:   Level: intermediate

    334:   Notes:
    335:   By default, solution_id is set to `-1` to mean the last solution available in the file

    337: .seealso: `PETSCVIEWERCGNS`, `PetscViewerCGNSSetSolutionIndex()`, `PetscViewerCGNSGetSolutionInfo()`

    339: @*/
    340: PetscErrorCode PetscViewerCGNSGetSolutionIndex(PetscViewer viewer, PetscInt *solution_id)
    341: {
    342:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;

    344:   PetscFunctionBeginUser;
    345:   *solution_id = cgv->solution_index;
    346:   PetscFunctionReturn(PETSC_SUCCESS);
    347: }

    349: // Gets the index for the solution in this CGNS file
    350: PetscErrorCode PetscViewerCGNSGetSolutionFileIndex_Internal(PetscViewer viewer, int *sol_index)
    351: {
    352:   PetscViewer_CGNS *cgv  = (PetscViewer_CGNS *)viewer->data;
    353:   MPI_Comm          comm = PetscObjectComm((PetscObject)viewer);
    354:   int               nsols, cgns_ier;
    355:   char              buffer[CGIO_MAX_NAME_LENGTH + 1];
    356:   CGNS_ENUMT(GridLocation_t) gridloc; // Throwaway

    358:   PetscFunctionBeginUser;
    359:   if (cgv->solution_file_index > 0) {
    360:     *sol_index = cgv->solution_file_index;
    361:     PetscFunctionReturn(PETSC_SUCCESS);
    362:   }

    364:   PetscCallCGNS(cg_nsols(cgv->file_num, cgv->base, cgv->zone, &nsols));
    365:   cgns_ier = cg_goto(cgv->file_num, cgv->base, "Zone_t", cgv->zone, "ZoneIterativeData_t", 1, "FlowSolutionPointers", 0, NULL);
    366:   if (cgns_ier == CG_NODE_NOT_FOUND) {
    367:     // If FlowSolutionPointers does not exist, then just index off of nsols (which can include non-solution data)
    368:     PetscCheck(cgv->solution_index == -1 || cgv->solution_index <= nsols, comm, PETSC_ERR_ARG_OUTOFRANGE, "CGNS Solution index (%" PetscInt_FMT ") not in [1, %d]", cgv->solution_index, nsols);

    370:     cgv->solution_file_index = cgv->solution_index == -1 ? nsols : cgv->solution_index;
    371:   } else {
    372:     // If FlowSolutionPointers exists, then solution_id should index that array of FlowSolutions
    373:     char     *pointer_id_name;
    374:     PetscBool matches_name = PETSC_FALSE;
    375:     int       sol_id;

    377:     PetscCheck(cgns_ier == CG_OK, PETSC_COMM_SELF, PETSC_ERR_LIB, "CGNS error %d %s", cgns_ier, cg_get_error());
    378:     cgns_ier = cg_goto(cgv->file_num, cgv->base, "Zone_t", cgv->zone, "ZoneIterativeData_t", 1, NULL);

    380:     { // Get FlowSolutionPointer name corresponding to solution_id
    381:       cgsize_t size[12];
    382:       int      dim, A_index;
    383:       char    *pointer_names, *pointer_id_name_ref;

    385:       PetscCall(CGNS_Find_Array(comm, "FlowSolutionPointers", &A_index, NULL, &dim, size));
    386:       PetscCheck(cgv->solution_index == -1 || cgv->solution_index <= size[1], comm, PETSC_ERR_ARG_OUTOFRANGE, "CGNS Solution index (%" PetscInt_FMT ") not in range of FlowSolutionPointers [1, %" PRIdCGSIZE "]", cgv->solution_index, size[1]);
    387:       PetscCall(PetscCalloc1(size[0] * size[1] + 1, &pointer_names)); // Need the +1 for (possibly) setting \0 for the last pointer name if it's full
    388:       PetscCallCGNS(cg_array_read_as(1, CGNS_ENUMV(Character), pointer_names));
    389:       cgv->solution_file_pointer_index = cgv->solution_index == -1 ? size[1] : cgv->solution_index;
    390:       pointer_id_name_ref              = &pointer_names[size[0] * (cgv->solution_file_pointer_index - 1)];
    391:       { // Set last non-whitespace character of the pointer name to \0 (CGNS pads with spaces)
    392:         int str_idx;
    393:         for (str_idx = size[0] - 1; str_idx > 0; str_idx--) {
    394:           if (!isspace((unsigned char)pointer_id_name_ref[str_idx])) break;
    395:         }
    396:         pointer_id_name_ref[str_idx + 1] = '\0';
    397:       }
    398:       PetscCall(PetscStrallocpy(pointer_id_name_ref, &pointer_id_name));
    399:       PetscCall(PetscFree(pointer_names));
    400:     }

    402:     // Find FlowSolution_t node that matches pointer_id_name
    403:     for (sol_id = 1; sol_id <= nsols; sol_id++) {
    404:       PetscCallCGNS(cg_sol_info(cgv->file_num, cgv->base, cgv->zone, sol_id, buffer, &gridloc));
    405:       PetscCall(PetscStrcmp(pointer_id_name, buffer, &matches_name));
    406:       if (matches_name) break;
    407:     }
    408:     PetscCheck(matches_name, comm, PETSC_ERR_LIB, "Cannot find FlowSolution_t node %s in file", pointer_id_name);
    409:     cgv->solution_file_index = sol_id;
    410:     PetscCall(PetscFree(pointer_id_name));
    411:   }

    413:   *sol_index = cgv->solution_file_index;
    414:   PetscFunctionReturn(PETSC_SUCCESS);
    415: }

    417: /*@
    418:   PetscViewerCGNSGetSolutionTime - Gets the solution time for the FlowSolution of the viewer

    420:   Collective

    422:   Input Parameter:
    423: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file

    425:   Output Parameters:
    426: + time - Solution time of the FlowSolution_t node
    427: - set  - Whether the time data is in the file

    429:   Level: intermediate

    431:   Notes:
    432:   Reads data from a DataArray named `TimeValues` under a `BaseIterativeData_t` node

    434: .seealso: `PETSCVIEWERCGNS`, `PetscViewer`, `PetscViewerCGNSSetSolutionIndex()`, `PetscViewerCGNSGetSolutionIndex()`, `PetscViewerCGNSGetSolutionName()`
    435: @*/
    436: PetscErrorCode PetscViewerCGNSGetSolutionTime(PetscViewer viewer, PetscReal *time, PetscBool *set)
    437: {
    438:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
    439:   int               cgns_ier, A_index = 0, sol_id;
    440:   PetscReal        *times;
    441:   cgsize_t          size[12];

    443:   PetscFunctionBeginUser;
    444:   cgns_ier = cg_goto(cgv->file_num, cgv->base, "BaseIterativeData_t", 1, NULL);
    445:   if (cgns_ier == CG_NODE_NOT_FOUND) {
    446:     *set = PETSC_FALSE;
    447:     PetscFunctionReturn(PETSC_SUCCESS);
    448:   } else PetscCallCGNS(cgns_ier);
    449:   PetscCall(CGNS_Find_Array(PetscObjectComm((PetscObject)viewer), "TimeValues", &A_index, NULL, NULL, size));
    450:   PetscCall(PetscMalloc1(size[0], &times));
    451:   PetscCallCGNS(cg_array_read_as(A_index, CGNS_ENUMV(RealDouble), times));
    452:   PetscCall(PetscViewerCGNSGetSolutionFileIndex_Internal(viewer, &sol_id)); // Call to set file pointer index
    453:   *time = times[cgv->solution_file_pointer_index - 1];
    454:   *set  = PETSC_TRUE;
    455:   PetscCall(PetscFree(times));
    456:   PetscFunctionReturn(PETSC_SUCCESS);
    457: }

    459: /*@
    460:   PetscViewerCGNSGetSolutionName - Gets name of FlowSolution of the viewer

    462:   Collective

    464:   Input Parameter:
    465: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file

    467:   Output Parameter:
    468: . name - Name of the FlowSolution_t node corresponding to the solution index

    470:   Level: intermediate

    472:   Notes:
    473:   Currently assumes there is only one Zone in the CGNS file

    475: .seealso: `PETSCVIEWERCGNS`, `PetscViewer`, `PetscViewerCGNSSetSolutionIndex()`, `PetscViewerCGNSGetSolutionIndex()`, `PetscViewerCGNSGetSolutionTime()`
    476: @*/
    477: PetscErrorCode PetscViewerCGNSGetSolutionName(PetscViewer viewer, const char *name[])
    478: {
    479:   PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
    480:   int               sol_id;
    481:   char              buffer[CGIO_MAX_NAME_LENGTH + 1];
    482:   CGNS_ENUMT(GridLocation_t) gridloc; // Throwaway

    484:   PetscFunctionBeginUser;
    485:   PetscCall(PetscViewerCGNSGetSolutionFileIndex_Internal(viewer, &sol_id));

    487:   PetscCallCGNS(cg_sol_info(cgv->file_num, cgv->base, cgv->zone, sol_id, buffer, &gridloc));
    488:   if (cgv->solution_name) PetscCall(PetscFree(cgv->solution_name));
    489:   PetscCall(PetscStrallocpy(buffer, &cgv->solution_name));
    490:   *name = cgv->solution_name;
    491:   PetscFunctionReturn(PETSC_SUCCESS);
    492: }