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: PetscLogEvent PETSC_VIEWER_CGNS_Open, PETSC_VIEWER_CGNS_Close, PETSC_VIEWER_CGNS_ReadMeta, PETSC_VIEWER_CGNS_WriteMeta, PETSC_VIEWER_CGNS_ReadData, PETSC_VIEWER_CGNS_WriteData;
13: PetscErrorCode PetscViewerCGNSRegisterLogEvents_Internal()
14: {
15: static PetscBool is_initialized = PETSC_FALSE;
17: PetscFunctionBeginUser;
18: if (is_initialized) PetscFunctionReturn(PETSC_SUCCESS);
19: PetscCall(PetscLogEventRegister("CGNSOpen", PETSC_VIEWER_CLASSID, &PETSC_VIEWER_CGNS_Open));
20: PetscCall(PetscLogEventRegister("CGNSClose", PETSC_VIEWER_CLASSID, &PETSC_VIEWER_CGNS_Close));
21: PetscCall(PetscLogEventRegister("CGNSReadMeta", PETSC_VIEWER_CLASSID, &PETSC_VIEWER_CGNS_ReadMeta));
22: PetscCall(PetscLogEventRegister("CGNSReadData", PETSC_VIEWER_CLASSID, &PETSC_VIEWER_CGNS_ReadData));
23: PetscCall(PetscLogEventRegister("CGNSWriteMeta", PETSC_VIEWER_CLASSID, &PETSC_VIEWER_CGNS_WriteMeta));
24: PetscCall(PetscLogEventRegister("CGNSWriteData", PETSC_VIEWER_CLASSID, &PETSC_VIEWER_CGNS_WriteData));
25: is_initialized = PETSC_TRUE;
26: PetscFunctionReturn(PETSC_SUCCESS);
27: }
29: static PetscErrorCode PetscViewerSetFromOptions_CGNS(PetscViewer v, PetscOptionItems PetscOptionsObject)
30: {
31: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)v->data;
33: PetscFunctionBegin;
34: PetscOptionsHeadBegin(PetscOptionsObject, "CGNS Viewer Options");
35: 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));
36: PetscOptionsHeadEnd();
37: PetscFunctionReturn(PETSC_SUCCESS);
38: }
40: static PetscErrorCode PetscViewerView_CGNS(PetscViewer v, PetscViewer viewer)
41: {
42: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)v->data;
44: PetscFunctionBegin;
45: if (cgv->filename) PetscCall(PetscViewerASCIIPrintf(viewer, "Filename: %s\n", cgv->filename));
46: PetscFunctionReturn(PETSC_SUCCESS);
47: }
49: static PetscErrorCode PetscViewerFileClose_CGNS(PetscViewer viewer)
50: {
51: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
53: PetscFunctionBegin;
54: if (cgv->output_times) {
55: PetscCount size, width = 32, *steps;
56: char *solnames;
57: PetscReal *times;
58: cgsize_t num_times;
59: PetscCall(PetscSegBufferGetSize(cgv->output_times, &size));
60: PetscCall(PetscSegBufferExtractInPlace(cgv->output_times, ×));
61: PetscCall(PetscSegBufferExtractInPlace(cgv->output_steps, &steps));
62: num_times = size;
63: PetscCallCGNSWrite(cg_biter_write(cgv->file_num, cgv->base, "TimeIterValues", num_times), viewer, 0);
64: PetscCallCGNS(cg_goto(cgv->file_num, cgv->base, "BaseIterativeData_t", 1, NULL));
65: PetscCallCGNSWrite(cg_array_write("TimeValues", CGNS_ENUMV(RealDouble), 1, &num_times, times), viewer, 0);
66: { // Cast output_steps to long for writing into file
67: int *steps_int;
68: PetscCall(PetscMalloc1(size, &steps_int));
69: for (PetscCount i = 0; i < size; i++) PetscCall(PetscCIntCast(steps[i], &steps_int[i]));
70: PetscCallCGNSWrite(cg_array_write("IterationValues", CGNS_ENUMV(Integer), 1, &num_times, steps_int), viewer, 0);
71: PetscCall(PetscFree(steps_int));
72: }
73: PetscCall(PetscSegBufferDestroy(&cgv->output_times));
74: PetscCallCGNSWrite(cg_ziter_write(cgv->file_num, cgv->base, cgv->zone, "ZoneIterativeData"), viewer, 0);
75: PetscCallCGNS(cg_goto(cgv->file_num, cgv->base, "Zone_t", cgv->zone, "ZoneIterativeData_t", 1, NULL));
76: PetscCall(PetscMalloc(size * width + 1, &solnames));
77: for (PetscCount i = 0; i < size; i++) PetscCall(PetscSNPrintf(&solnames[i * width], width + 1, "FlowSolution%-20zu", (size_t)steps[i]));
78: PetscCall(PetscSegBufferDestroy(&cgv->output_steps));
79: cgsize_t shape[2] = {(cgsize_t)width, (cgsize_t)size};
80: PetscCallCGNSWrite(cg_array_write("FlowSolutionPointers", CGNS_ENUMV(Character), 2, shape, solnames), viewer, 0);
81: // The VTK reader looks for names like FlowSolution*Pointers.
82: for (PetscCount i = 0; i < size; i++) PetscCall(PetscSNPrintf(&solnames[i * width], width + 1, "%-32s", "CellInfo"));
83: PetscCallCGNSWrite(cg_array_write("FlowSolutionCellInfoPointers", CGNS_ENUMV(Character), 2, shape, solnames), viewer, 0);
84: PetscCall(PetscFree(solnames));
86: PetscCallCGNSWrite(cg_simulation_type_write(cgv->file_num, cgv->base, CGNS_ENUMV(TimeAccurate)), viewer, 0);
87: }
88: PetscCall(PetscFree(cgv->filename));
89: #if defined(PETSC_HDF5_HAVE_PARALLEL)
90: if (cgv->file_num) PetscCallCGNSClose(cgp_close(cgv->file_num), viewer, 0);
91: #else
92: if (cgv->file_num) PetscCallCGNSClose(cg_close(cgv->file_num), viewer, 0);
93: #endif
94: cgv->file_num = 0;
95: PetscCall(PetscFree(cgv->node_l2g));
96: PetscCall(PetscFree(cgv->nodal_field));
97: PetscFunctionReturn(PETSC_SUCCESS);
98: }
100: PetscErrorCode PetscViewerCGNSFileOpen_Internal(PetscViewer viewer, PetscInt sequence_number)
101: {
102: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
103: int cg_file_mode = -1;
105: PetscFunctionBegin;
106: PetscCheck((cgv->filename == NULL) ^ (sequence_number < 0), PetscObjectComm((PetscObject)viewer), PETSC_ERR_ARG_INCOMP, "Expect either a template filename or non-negative sequence number");
107: if (!cgv->filename) {
108: char filename_numbered[PETSC_MAX_PATH_LEN];
109: // Cast sequence_number so %d can be used also when PetscInt is 64-bit. We could upgrade the format string if users
110: // run more than 2B time steps.
111: PetscCall(PetscSNPrintf(filename_numbered, sizeof filename_numbered, cgv->filename_template, (int)sequence_number));
112: PetscCall(PetscStrallocpy(filename_numbered, &cgv->filename));
113: }
114: switch (cgv->btype) {
115: case FILE_MODE_READ:
116: cg_file_mode = CG_MODE_READ;
117: break;
118: case FILE_MODE_WRITE:
119: cg_file_mode = CG_MODE_WRITE;
120: break;
121: case FILE_MODE_UNDEFINED:
122: SETERRQ(PetscObjectComm((PetscObject)viewer), PETSC_ERR_ORDER, "Must call PetscViewerFileSetMode() before PetscViewerFileSetName()");
123: default:
124: SETERRQ(PetscObjectComm((PetscObject)viewer), PETSC_ERR_SUP, "Unsupported file mode %s", PetscFileModes[cgv->btype]);
125: }
126: #if defined(PETSC_HDF5_HAVE_PARALLEL)
127: PetscCallCGNS(cgp_mpi_comm(PetscObjectComm((PetscObject)viewer)));
128: PetscCallCGNSOpen(cgp_open(cgv->filename, cg_file_mode, &cgv->file_num), viewer, 0);
129: #else
130: PetscCallCGNSOpen(cg_open(filename, cg_file_mode, &cgv->file_num), viewer, 0);
131: #endif
132: PetscFunctionReturn(PETSC_SUCCESS);
133: }
135: PetscErrorCode PetscViewerCGNSCheckBatch_Internal(PetscViewer viewer)
136: {
137: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
138: PetscCount num_steps;
140: PetscFunctionBegin;
141: if (!cgv->filename_template) PetscFunctionReturn(PETSC_SUCCESS); // Batches are closed when viewer is destroyed
142: PetscCall(PetscSegBufferGetSize(cgv->output_times, &num_steps));
143: if (num_steps >= (PetscCount)cgv->batch_size) PetscCall(PetscViewerFileClose_CGNS(viewer));
144: PetscFunctionReturn(PETSC_SUCCESS);
145: }
147: static PetscErrorCode PetscViewerDestroy_CGNS(PetscViewer viewer)
148: {
149: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
151: PetscFunctionBegin;
152: PetscCall(PetscViewerFileClose_CGNS(viewer));
153: PetscCall(PetscFree(cgv->solution_name));
154: PetscCall(PetscFree(cgv->filename_template));
155: PetscCall(PetscFree(cgv));
156: PetscCall(PetscObjectComposeFunction((PetscObject)viewer, "PetscViewerFileSetName_C", NULL));
157: PetscCall(PetscObjectComposeFunction((PetscObject)viewer, "PetscViewerFileGetName_C", NULL));
158: PetscCall(PetscObjectComposeFunction((PetscObject)viewer, "PetscViewerFileSetMode_C", NULL));
159: PetscCall(PetscObjectComposeFunction((PetscObject)viewer, "PetscViewerFileGetMode_C", NULL));
160: PetscFunctionReturn(PETSC_SUCCESS);
161: }
163: static PetscErrorCode PetscViewerFileSetMode_CGNS(PetscViewer viewer, PetscFileMode type)
164: {
165: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
167: PetscFunctionBegin;
168: cgv->btype = type;
169: PetscFunctionReturn(PETSC_SUCCESS);
170: }
172: static PetscErrorCode PetscViewerFileGetMode_CGNS(PetscViewer viewer, PetscFileMode *type)
173: {
174: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
176: PetscFunctionBegin;
177: *type = cgv->btype;
178: PetscFunctionReturn(PETSC_SUCCESS);
179: }
181: static PetscErrorCode PetscViewerFileSetName_CGNS(PetscViewer viewer, const char *filename)
182: {
183: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
184: char *has_pattern;
186: PetscFunctionBegin;
187: #if defined(PETSC_HDF5_HAVE_PARALLEL)
188: if (cgv->file_num) PetscCallCGNSClose(cgp_close(cgv->file_num), viewer, 0);
189: #else
190: if (cgv->file_num) PetscCallCGNSClose(cg_close(cgv->file_num), viewer, 0);
191: #endif
192: PetscCall(PetscFree(cgv->filename));
193: PetscCall(PetscFree(cgv->filename_template));
194: PetscCall(PetscStrchr(filename, '%', &has_pattern));
195: if (has_pattern) {
196: PetscCall(PetscStrallocpy(filename, &cgv->filename_template));
197: // Templated file names open lazily, once we know DMGetOutputSequenceNumber()
198: } else {
199: PetscCall(PetscStrallocpy(filename, &cgv->filename));
200: PetscCall(PetscViewerCGNSFileOpen_Internal(viewer, -1));
201: }
202: PetscFunctionReturn(PETSC_SUCCESS);
203: }
205: static PetscErrorCode PetscViewerFileGetName_CGNS(PetscViewer viewer, const char **filename)
206: {
207: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
209: PetscFunctionBegin;
210: *filename = cgv->filename;
211: PetscFunctionReturn(PETSC_SUCCESS);
212: }
214: /*MC
215: PETSCVIEWERCGNS - A viewer for CGNS files
217: Level: beginner
219: Options Database Key:
220: . -viewer_cgns_batch_size SIZE - set max number of output sequence times to write per batch
222: Note:
223: If the filename contains an integer format character, the CGNS viewer will created a batched output sequence. For
224: example, one could use `-ts_monitor_solution cgns:flow-%d.cgns`. This is desirable if one wants to limit file sizes or
225: if the job might crash/be killed by a resource manager before exiting cleanly.
227: .seealso: [](sec_viewers), `PetscViewer`, `PetscViewerCreate()`, `VecView()`, `DMView()`, `PetscViewerFileSetName()`, `PetscViewerFileSetMode()`, `TSSetFromOptions()`
228: M*/
229: PetscErrorCode PetscViewerCreate_CGNS(PetscViewer v)
230: {
231: PetscViewer_CGNS *cgv;
233: PetscFunctionBegin;
234: PetscCall(PetscViewerCGNSRegisterLogEvents_Internal());
235: PetscCall(PetscNew(&cgv));
237: v->data = cgv;
238: v->ops->destroy = PetscViewerDestroy_CGNS;
239: v->ops->setfromoptions = PetscViewerSetFromOptions_CGNS;
240: v->ops->view = PetscViewerView_CGNS;
241: cgv->btype = FILE_MODE_UNDEFINED;
242: cgv->filename = NULL;
243: cgv->batch_size = 20;
244: cgv->solution_index = -1; // Default to use the "last" solution
245: cgv->base = 1;
246: cgv->zone = 1;
247: cgv->previous_output_step = -1; // No previous output step
249: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetName_C", PetscViewerFileSetName_CGNS));
250: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetName_C", PetscViewerFileGetName_CGNS));
251: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetMode_C", PetscViewerFileSetMode_CGNS));
252: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetMode_C", PetscViewerFileGetMode_CGNS));
253: PetscFunctionReturn(PETSC_SUCCESS);
254: }
256: // Find DataArray_t node under the current node (determined by `cg_goto` and friends) that matches `name`
257: // Return the index of that array and (optionally) other data about the array
258: 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[], PetscBool *found)
259: {
260: int narrays; // number of arrays under the current node
261: char array_name[CGIO_MAX_NAME_LENGTH + 1];
262: CGNS_ENUMT(DataType_t) data_type_local;
263: int _dim;
264: cgsize_t _size[12];
265: PetscBool matches_name = PETSC_FALSE;
267: PetscFunctionBeginUser;
268: PetscCallCGNSRead(cg_narrays(&narrays), 0, 0);
269: for (int i = 1; i <= narrays; i++) {
270: PetscCallCGNSRead(cg_array_info(i, array_name, &data_type_local, &_dim, _size), 0, 0);
271: PetscCall(PetscStrcmp(name, array_name, &matches_name));
272: if (matches_name) {
273: *A_index = i;
274: if (data_type) *data_type = data_type_local;
275: if (dim) *dim = _dim;
276: if (size) PetscArraycpy(size, _size, _dim);
277: if (found) *found = PETSC_TRUE;
278: PetscFunctionReturn(PETSC_SUCCESS);
279: }
280: }
281: if (found) *found = PETSC_FALSE;
282: PetscFunctionReturn(PETSC_SUCCESS);
283: }
285: /*@
286: PetscViewerCGNSOpen - Opens a file for CGNS input/output.
288: Collective
290: Input Parameters:
291: + comm - MPI communicator
292: . name - name of file
293: - type - type of file
294: .vb
295: FILE_MODE_WRITE - create new file for binary output
296: FILE_MODE_READ - open existing file for binary input
297: FILE_MODE_APPEND - open existing file for binary output
298: .ve
300: Output Parameter:
301: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file
303: Level: beginner
305: .seealso: `PETSCVIEWERCGNS`, `PetscViewer`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
306: `DMLoad()`, `PetscFileMode`, `PetscViewerSetType()`, `PetscViewerFileSetMode()`, `PetscViewerFileSetName()`
307: @*/
308: PetscErrorCode PetscViewerCGNSOpen(MPI_Comm comm, const char name[], PetscFileMode type, PetscViewer *viewer)
309: {
310: PetscFunctionBegin;
311: PetscAssertPointer(name, 2);
312: PetscAssertPointer(viewer, 4);
313: PetscCall(PetscViewerCreate(comm, viewer));
314: PetscCall(PetscViewerSetType(*viewer, PETSCVIEWERCGNS));
315: PetscCall(PetscViewerFileSetMode(*viewer, type));
316: PetscCall(PetscViewerFileSetName(*viewer, name));
317: PetscCall(PetscViewerSetFromOptions(*viewer));
318: PetscFunctionReturn(PETSC_SUCCESS);
319: }
321: /*@
322: PetscViewerCGNSSetSolutionIndex - Set index of solution
324: Not Collective
326: Input Parameters:
327: + viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file
328: - solution_id - Index of the solution id, or `-1` for the last solution on the file
330: Level: intermediate
332: Notes:
333: By default, `solution_id` is set to `-1` to mean the last solution available in the file.
334: If the file contains a FlowSolutionPointers node, then that array is indexed to determine which FlowSolution_t node to read from.
335: Otherwise, `solution_id` indexes the total available FlowSolution_t nodes in the file.
337: This solution index is used by `VecLoad()` to determine which solution to load from the file
339: .seealso: `PETSCVIEWERCGNS`, `PetscViewerCGNSGetSolutionIndex()`, `PetscViewerCGNSGetSolutionInfo()`
341: @*/
342: PetscErrorCode PetscViewerCGNSSetSolutionIndex(PetscViewer viewer, PetscInt solution_id)
343: {
344: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
346: PetscFunctionBeginUser;
349: 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);
350: cgv->solution_index = solution_id;
351: cgv->solution_file_index = 0; // Reset sol_index when solution_id changes (0 is invalid)
352: PetscFunctionReturn(PETSC_SUCCESS);
353: }
355: /*@
356: PetscViewerCGNSGetSolutionIndex - Get index of solution
358: Not Collective
360: Input Parameter:
361: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file
363: Output Parameter:
364: . solution_id - Index of the solution id
366: Level: intermediate
368: Notes:
369: By default, solution_id is set to `-1` to mean the last solution available in the file
371: .seealso: `PETSCVIEWERCGNS`, `PetscViewerCGNSSetSolutionIndex()`, `PetscViewerCGNSGetSolutionInfo()`
373: @*/
374: PetscErrorCode PetscViewerCGNSGetSolutionIndex(PetscViewer viewer, PetscInt *solution_id)
375: {
376: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
378: PetscFunctionBeginUser;
380: PetscAssertPointer(solution_id, 2);
381: *solution_id = cgv->solution_index;
382: PetscFunctionReturn(PETSC_SUCCESS);
383: }
385: // Gets the index for the solution in this CGNS file
386: PetscErrorCode PetscViewerCGNSGetSolutionFileIndex_Internal(PetscViewer viewer, int *sol_index)
387: {
388: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
389: MPI_Comm comm = PetscObjectComm((PetscObject)viewer);
390: int nsols, cgns_ier;
391: char buffer[CGIO_MAX_NAME_LENGTH + 1];
392: CGNS_ENUMT(GridLocation_t) gridloc; // Throwaway
394: PetscFunctionBeginUser;
395: if (cgv->solution_file_index > 0) {
396: *sol_index = cgv->solution_file_index;
397: PetscFunctionReturn(PETSC_SUCCESS);
398: }
400: PetscCallCGNSRead(cg_nsols(cgv->file_num, cgv->base, cgv->zone, &nsols), viewer, 0);
401: cgns_ier = cg_goto(cgv->file_num, cgv->base, "Zone_t", cgv->zone, "ZoneIterativeData_t", 1, "FlowSolutionPointers", 0, NULL);
402: if (cgns_ier == CG_NODE_NOT_FOUND) {
403: // If FlowSolutionPointers does not exist, then just index off of nsols (which can include non-solution data)
404: 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);
406: cgv->solution_file_index = cgv->solution_index == -1 ? nsols : cgv->solution_index;
407: } else {
408: // If FlowSolutionPointers exists, then solution_id should index that array of FlowSolutions
409: char *pointer_id_name;
410: PetscBool matches_name = PETSC_FALSE;
411: int sol_id;
413: PetscCheck(cgns_ier == CG_OK, PETSC_COMM_SELF, PETSC_ERR_LIB, "CGNS error %d %s", cgns_ier, cg_get_error());
414: cgns_ier = cg_goto(cgv->file_num, cgv->base, "Zone_t", cgv->zone, "ZoneIterativeData_t", 1, NULL);
416: { // Get FlowSolutionPointer name corresponding to solution_id
417: cgsize_t size[12];
418: int dim, A_index;
419: char *pointer_names, *pointer_id_name_ref;
420: PetscBool found_array;
422: PetscCall(CGNS_Find_Array(comm, "FlowSolutionPointers", &A_index, NULL, &dim, size, &found_array));
423: PetscCheck(found_array, comm, PETSC_ERR_SUP, "Cannot find FlowSolutionPointers array under current CGNS node");
424: 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]);
425: 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
426: PetscCallCGNSRead(cg_array_read_as(1, CGNS_ENUMV(Character), pointer_names), viewer, 0);
427: cgv->solution_file_pointer_index = cgv->solution_index == -1 ? size[1] : cgv->solution_index;
428: pointer_id_name_ref = &pointer_names[size[0] * (cgv->solution_file_pointer_index - 1)];
429: { // Set last non-whitespace character of the pointer name to \0 (CGNS pads with spaces)
430: int str_idx;
431: for (str_idx = size[0] - 1; str_idx > 0; str_idx--) {
432: if (!isspace((unsigned char)pointer_id_name_ref[str_idx])) break;
433: }
434: pointer_id_name_ref[str_idx + 1] = '\0';
435: }
436: PetscCall(PetscStrallocpy(pointer_id_name_ref, &pointer_id_name));
437: PetscCall(PetscFree(pointer_names));
438: }
440: // Find FlowSolution_t node that matches pointer_id_name
441: for (sol_id = 1; sol_id <= nsols; sol_id++) {
442: PetscCallCGNSRead(cg_sol_info(cgv->file_num, cgv->base, cgv->zone, sol_id, buffer, &gridloc), viewer, 0);
443: PetscCall(PetscStrcmp(pointer_id_name, buffer, &matches_name));
444: if (matches_name) break;
445: }
446: PetscCheck(matches_name, comm, PETSC_ERR_LIB, "Cannot find FlowSolution_t node %s in file", pointer_id_name);
447: cgv->solution_file_index = sol_id;
448: PetscCall(PetscFree(pointer_id_name));
449: }
451: *sol_index = cgv->solution_file_index;
452: PetscFunctionReturn(PETSC_SUCCESS);
453: }
455: /*@
456: PetscViewerCGNSGetSolutionTime - Gets the solution time for the FlowSolution of the viewer
458: Collective
460: Input Parameter:
461: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file
463: Output Parameters:
464: + time - Solution time of the FlowSolution_t node
465: - set - Whether the time data is in the file
467: Level: intermediate
469: Notes:
470: Reads data from a DataArray named `TimeValues` under a `BaseIterativeData_t` node
472: .seealso: `PETSCVIEWERCGNS`, `PetscViewer`, `PetscViewerCGNSGetSolutionIteration()`, `PetscViewerCGNSSetSolutionIndex()`, `PetscViewerCGNSGetSolutionIndex()`, `PetscViewerCGNSGetSolutionName()`
473: @*/
474: PetscErrorCode PetscViewerCGNSGetSolutionTime(PetscViewer viewer, PetscReal *time, PetscBool *set)
475: {
476: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
477: int cgns_ier, A_index = 0, sol_id;
478: PetscReal *times;
479: cgsize_t size[12];
481: PetscFunctionBeginUser;
483: PetscAssertPointer(time, 2);
484: PetscAssertPointer(set, 3);
485: cgns_ier = cg_goto(cgv->file_num, cgv->base, "BaseIterativeData_t", 1, NULL);
486: if (cgns_ier == CG_NODE_NOT_FOUND) {
487: *set = PETSC_FALSE;
488: PetscFunctionReturn(PETSC_SUCCESS);
489: } else PetscCallCGNS(cgns_ier);
490: PetscCall(CGNS_Find_Array(PetscObjectComm((PetscObject)viewer), "TimeValues", &A_index, NULL, NULL, size, set));
491: if (!*set) PetscFunctionReturn(PETSC_SUCCESS);
492: PetscCall(PetscMalloc1(size[0], ×));
493: PetscCallCGNSRead(cg_array_read_as(A_index, CGNS_ENUMV(RealDouble), times), viewer, 0);
494: PetscCall(PetscViewerCGNSGetSolutionFileIndex_Internal(viewer, &sol_id)); // Call to set file pointer index
495: *time = times[cgv->solution_file_pointer_index - 1];
496: PetscCall(PetscFree(times));
497: PetscFunctionReturn(PETSC_SUCCESS);
498: }
500: /*@
501: PetscViewerCGNSGetSolutionIteration - Gets the solution iteration for the FlowSolution of the viewer
503: Collective
505: Input Parameter:
506: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file
508: Output Parameters:
509: + iteration - Solution iteration of the FlowSolution_t node
510: - set - Whether the time data is in the file
512: Level: intermediate
514: Notes:
515: Reads data from a DataArray named `IterationValues` under a `BaseIterativeData_t` node
517: .seealso: `PETSCVIEWERCGNS`, `PetscViewer`, `PetscViewerCGNSGetSolutionTime()`, `PetscViewerCGNSSetSolutionIndex()`, `PetscViewerCGNSGetSolutionIndex()`, `PetscViewerCGNSGetSolutionName()`
518: @*/
519: PetscErrorCode PetscViewerCGNSGetSolutionIteration(PetscViewer viewer, PetscInt *iteration, PetscBool *set)
520: {
521: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
522: int cgns_ier, A_index = 0, sol_id;
523: int *steps;
524: cgsize_t size[12];
526: PetscFunctionBeginUser;
528: PetscAssertPointer(iteration, 2);
529: PetscAssertPointer(set, 3);
530: cgns_ier = cg_goto(cgv->file_num, cgv->base, "BaseIterativeData_t", 1, NULL);
531: if (cgns_ier == CG_NODE_NOT_FOUND) {
532: *set = PETSC_FALSE;
533: PetscFunctionReturn(PETSC_SUCCESS);
534: } else PetscCallCGNS(cgns_ier);
535: PetscCall(CGNS_Find_Array(PetscObjectComm((PetscObject)viewer), "IterationValues", &A_index, NULL, NULL, size, set));
536: if (!*set) PetscFunctionReturn(PETSC_SUCCESS);
537: PetscCall(PetscMalloc1(size[0], &steps));
538: PetscCallCGNSRead(cg_array_read_as(A_index, CGNS_ENUMV(Integer), steps), viewer, 0);
539: PetscCall(PetscViewerCGNSGetSolutionFileIndex_Internal(viewer, &sol_id)); // Call to set file pointer index
540: *iteration = (PetscInt)steps[cgv->solution_file_pointer_index - 1];
541: PetscCall(PetscFree(steps));
542: PetscFunctionReturn(PETSC_SUCCESS);
543: }
545: /*@
546: PetscViewerCGNSGetSolutionName - Gets name of FlowSolution of the viewer
548: Collective
550: Input Parameter:
551: . viewer - `PETSCVIEWERCGNS` `PetscViewer` for CGNS input/output to use with the specified file
553: Output Parameter:
554: . name - Name of the FlowSolution_t node corresponding to the solution index
556: Level: intermediate
558: Notes:
559: Currently assumes there is only one Zone in the CGNS file
561: .seealso: `PETSCVIEWERCGNS`, `PetscViewer`, `PetscViewerCGNSSetSolutionIndex()`, `PetscViewerCGNSGetSolutionIndex()`, `PetscViewerCGNSGetSolutionTime()`
562: @*/
563: PetscErrorCode PetscViewerCGNSGetSolutionName(PetscViewer viewer, const char *name[])
564: {
565: PetscViewer_CGNS *cgv = (PetscViewer_CGNS *)viewer->data;
566: int sol_id;
567: char buffer[CGIO_MAX_NAME_LENGTH + 1];
568: CGNS_ENUMT(GridLocation_t) gridloc; // Throwaway
570: PetscFunctionBeginUser;
572: PetscAssertPointer(name, 2);
573: PetscCall(PetscViewerCGNSGetSolutionFileIndex_Internal(viewer, &sol_id));
575: PetscCallCGNSRead(cg_sol_info(cgv->file_num, cgv->base, cgv->zone, sol_id, buffer, &gridloc), viewer, 0);
576: if (cgv->solution_name) PetscCall(PetscFree(cgv->solution_name));
577: PetscCall(PetscStrallocpy(buffer, &cgv->solution_name));
578: *name = cgv->solution_name;
579: PetscFunctionReturn(PETSC_SUCCESS);
580: }