Parallel CGNS Routines

• Miscellaneous Routines
  • cgp_mpi_comm - Set the MPI communicator
  • cgp_mpi_info - Set the MPI info object
  • cgp_pio_mode - Set the parallel IO mode
  • BINDING DEPRECATED, Deprecated since CGNS-3.3.0 cgp_queue_set - Enable/Disable queued output
  • BINDING DEPRECATED, Deprecated since CGNS-3.3.0 cgp_queue_flush - Flush the output queue
  • cgp_error_exit - Exit with error message
• File Operations
  • cgp_open - Open a file for parallel IO
  • cgp_close - Close a file
• Grid Coordinate Data
  • cgp_coord_write - Create a coordinate data node
  • cgp_coord_write_data - Write coordinate data in parallel
  • cgp_coord_general_write_data - Write shaped array to a subset of grid coordinates in parallel
  • cgp_coord_read_data - Read coordinate data in parallel
  • cgp_coord_general_read_data - Read subset of grid coordinates to a shaped array in parallel
• Element Connectivity Data
  • cgp_section_write - Create a section data node
  • cgp_poly_section_write - Create a section data node
  • cgp_elements_write_data - Write element data in parallel
  • cgp_poly_elements_write_data - Write element data in parallel
  • cgp_elements_read_data - Read element data in parallel
• Solution Data
  • cgp_field_write - Create a solution field data node
  • cgp_field_write_data - Write field data in parallel
  • cgp_field_general_write_data - Write shaped array to a subset of flow solution field in parallel
  • cgp_field_read_data - Read field data in parallel
  • cgp_field_general_read_data - Read subset of flow solution field to a shaped array in parallel
• Array Data
  • cgp_array_write - Create an array data node
  • cgp_array_write_data - Write array data in parallel
  • cgp_array_general_write_data - Write shaped array to a subset of data array in parallel
  • cgp_array_read_data - Read array data in parallel
  • cgp_array_general_read_data - Read subset of data array to a shaped array in parallel

Miscellaneous Routines

The routine cgp_mpi_comm sets the MPI communicator for parallel operations by the CGNS library. The default value is MPI_COMM_WORLD.

The routine cgp_mpi_info passes the MPI info object for parallel operations to the CGNS library. Notes for Fortran: the data type for info is an INTEGER.

The routine cgp_pio_mode sets the mode for parallel data reads and writes. The default value is CGP_COLLECTIVE, which allows any number of processes to access the data. When set to CGP_COLLECTIVE, all processes must access the data.

If cgp_queue_set is called with a non-zero argument, then output data will not be written to the file, but rather stored in a queue. The queued data will then be written out when cgp_queue_flush is called.

Note: The data array to be written is NOT duplicated in the queue. Rather a pointer to the data is stored. Thus, the data must be persistent within the user's program until cgp_queue_flush is called.

The routine cgp_error_exit is similar to cg_error_exit in that the process will exit with an error message. However, it will also print the process rank, and call MPI_Abort with an exit code of 1.

File Operations

The routines cgp_open and cgp_close are similar to cg_open and cg_close, and call those routines. The differences are that cgp_open explicitly sets an internal CGNS flag to indicate parallel access.

Grid Coordinate Data

The above functions are used to read and write grid coordinate data by multiple processes in a parallel fashion. To write the data in parallel, first call cgp_coord_write to create an empty data node. This call is indentical to cg_coord_write with coord_array set to NULL (no data written). The actual data is then written to the node in parallel using either cgp_coord_write_data or cgp_coord_general_write_data where range_min and range_max specify the subset of coordinate data to be written by a given process. The routines cgp_coord_read_data and cgp_coord_general_read_data perform the same function for reading the coordinate data in parallel.

Note: The routines cgp_coord_general_write_data and cgp_coord_general_read_data perform data conversions if datatype is different from mem_datatype. For other routines, it is the responsibility of the application to ensure that the data type for the coordinate data matches that as defined in the file; no conversions are done.

Element Connectivity Data

Note: These routines only work for constant sized elements, since it is not possible to compute file offsets for variable sized elements without knowledge of the entire element connectivity data.

The above functions are used to read and write element connectivity data by multiple processes in a parallel fashion. To write the element data in parallel, first call cgp_section_write to create an empty data node. This call is indentical to cg_section_write with Elements set to NULL (no data written). The actual element data is then written to the node in parallel using cgp_element_write_data where start and end specify the range of the elements to be written by a given process. The routine cgp_element_read_data performs the same function for reading the solution data in parallel.

Note: It is the responsibility of the application to ensure that cgsize_t in the application is the same size as that defined in the file; no conversions are done.

Solution Data

The above functions are used to read and write solution arrays by multiple processes in a parallel fashion. To write the data in parallel, first call cgp_field_write to create an empty data node. This call is indentical to cg_field_write with solution_array set to NULL (no data written). The actual data is then written to the node in parallel using either cgp_field_write_data or cgp_field_general_write_data where range_min and range_max specify the subset of the solution data to be written by a given process. The routines cgp_field_read_data and cgp_field_general_read_data perform the same function for reading the solution data in parallel.

Note: The routines cgp_field_general_write_data and cgp_field_general_read_data perform data conversions if datatype is different from mem_datatype. For other routines, it is the responsibility of the application to ensure that the data type for the solution data matches that as defined in the file; no conversions are done.

Array Data

The above functions are used to read and write data arrays by multiple processes in a parallel fashion. To write the data in parallel, first call cg_goto to set the position for the DataArray_t node, then call cgp_array_write to create an empty data node. This call is similar to cg_array_write with Data set to NULL (no data written). This function will return the array index, A, which is used to write the actual data to the node in parallel using either cgp_array_write_data or cgp_array_general_write_data where range_min and range_max specify the subset of the array data to be written by a given process. The routines cgp_array_read_data and cgp_array_general_read_data perform the same function for reading the array data in parallel.

Note: The routines cgp_array_general_write_data and cgp_array_general_read_data perform data conversions if datatype is different from mem_datatype. For other routines, it is the responsibility of the application to ensure that the data type for the array data matches that as defined in the file; no conversions are done.