#include <NCHelperESMF.hpp>

Inheritance diagram for moab::NCHelperESMF:

Collaboration diagram for moab::NCHelperESMF:

Public Member Functions
	NCHelperESMF (ReadNC *readNC, int fileId, const FileOptions &opts, EntityHandle fileSet)

Public Member Functions inherited from moab::UcdNCHelper
	UcdNCHelper (ReadNC *readNC, int fileId, const FileOptions &opts, EntityHandle fileSet)

virtual	~UcdNCHelper ()

Public Member Functions inherited from moab::NCHelper
	NCHelper (ReadNC *readNC, int fileId, const FileOptions &opts, EntityHandle fileSet)

virtual	~NCHelper ()

ErrorCode	create_conventional_tags (const std::vector< int > &tstep_nums)
	Create NC conventional tags. More...

ErrorCode	update_time_tag_vals ()
	Update time tag values if timesteps spread across files. More...

Static Public Member Functions
static bool	can_read_file (ReadNC *readNC)

Static Public Member Functions inherited from moab::NCHelper
static ReadNC::NCFormatType	get_nc_format (ReadNC *readNC, int fileId)
	Get appropriate format to read the file. More...

static std::string	get_default_ncformat_options (ReadNC::NCFormatType format)
	Get appropriate format to read the file. More...

static NCHelper *	get_nc_helper (ReadNC *readNC, int fileId, const FileOptions &opts, EntityHandle fileSet)
	Get appropriate helper instance for ReadNC class. More...

Private Member Functions
virtual ErrorCode	init_mesh_vals ()
	Implementation of NCHelper::init_mesh_vals() More...

virtual ErrorCode	create_mesh (Range &faces)
	Implementation of NCHelper::create_mesh() More...

virtual std::string	get_mesh_type_name ()
	Implementation of NCHelper::get_mesh_type_name() More...

ErrorCode	create_local_vertices (const std::vector< int > &vertices_on_local_cells, EntityHandle &start_vertex)
	Create local vertices. More...

ErrorCode	create_local_cells (const std::vector< int > &vertices_on_local_cells, const std::vector< int > &num_edges_on_local_cells, EntityHandle start_vertex, Range &faces)
	Create local cells without padding (cells are divided into groups based on the number of edges) More...

ErrorCode	create_padded_local_cells (const std::vector< int > &vertices_on_local_cells, EntityHandle start_vertex, Range &faces)
	Create local cells with padding (padded cells will have the same number of edges) More...

virtual ErrorCode	check_existing_mesh ()

virtual ErrorCode	read_ucd_variables_to_nonset_allocate (std::vector< ReadNC::VarData > &, std::vector< int > &)
	Implementation of UcdNCHelper::read_ucd_variables_to_nonset_allocate() More...

virtual ErrorCode	read_ucd_variables_to_nonset (std::vector< ReadNC::VarData > &, std::vector< int > &)
	Implementation of UcdNCHelper::read_ucd_variables_to_nonset() More...

Private Attributes
int	maxEdgesPerCell

int	coordDim

int	centerCoordsId

bool	degrees

Range	facesOwned

Additional Inherited Members
Protected Member Functions inherited from moab::UcdNCHelper
template<typename T >
void	kji_to_jik_stride (size_t, size_t nj, size_t nk, void dest, T source, Range &localGid)
	This version takes as input the moab range, from which we actually need just the size of each sequence, for a proper transpose of the data. More...

Protected Member Functions inherited from moab::NCHelper
ErrorCode	read_variables_setup (std::vector< std::string > &var_names, std::vector< int > &tstep_nums, std::vector< ReadNC::VarData > &vdatas, std::vector< ReadNC::VarData > &vsetdatas)
	Separate set and non-set variables (common to scd mesh and ucd mesh) More...

ErrorCode	read_variables_to_set (std::vector< ReadNC::VarData > &vdatas, std::vector< int > &tstep_nums)
	Read set variables (common to scd mesh and ucd mesh) More...

ErrorCode	read_coordinate (const char *var_name, int lmin, int lmax, std::vector< double > &cvals)

ErrorCode	get_tag_to_set (ReadNC::VarData &var_data, int tstep_num, Tag &tagh)

ErrorCode	get_tag_to_nonset (ReadNC::VarData &var_data, int tstep_num, Tag &tagh, int num_lev)

ErrorCode	create_attrib_string (const std::map< std::string, ReadNC::AttData > &attMap, std::string &attString, std::vector< int > &attLen)
	Create a character string attString of attMap. with '\0' terminating each attribute name, ';' separating the data type and value, and ';' separating one name/data type/value from the next'. attLen stores the end position for each name/data type/ value. More...

ErrorCode	create_dummy_variables ()
	For a dimension that does not have a corresponding coordinate variable (e.g. ncol for HOMME), create a dummy variable with a sparse tag to store the dimension length. More...

Protected Attributes inherited from moab::UcdNCHelper
int	nCells
	Dimensions of global grid in file. More...

int	nEdges

int	nVertices

int	nLocalCells
	Dimensions of my local part of grid. More...

int	nLocalEdges

int	nLocalVertices

std::vector< double >	xVertVals
	Coordinate values for vertices. More...

std::vector< double >	yVertVals

std::vector< double >	zVertVals

int	cDim
	Dimension numbers for nCells, nEdges and nVertices. More...

int	eDim

int	vDim

Range	localGidCells
	Local global ID for cells, edges and vertices. More...

Range	localGidEdges

Range	localGidVerts

Protected Attributes inherited from moab::NCHelper
ReadNC *	_readNC
	Allow NCHelper to directly access members of ReadNC. More...

int	_fileId
	Cache some information from ReadNC. More...

const FileOptions &	_opts

EntityHandle	_fileSet

int	nTimeSteps
	Dimensions of time and level. More...

int	nLevels

std::vector< double >	tVals
	Values for time and level. More...

std::vector< double >	levVals

int	tDim
	Dimension numbers for time and level. More...

int	levDim

std::set< std::string >	ignoredVarNames
	Ignored variables. More...

std::set< std::string >	dummyVarNames
	Dummy variables. More...

Detailed Description

Definition at line 18 of file NCHelperESMF.hpp.

Constructor & Destructor Documentation

◆ NCHelperESMF()

moab::NCHelperESMF::NCHelperESMF	(	ReadNC *	readNC,
		int	fileId,
		const FileOptions &	opts,
		EntityHandle	fileSet
	)

Definition at line 24 of file NCHelperESMF.cpp.

     : UcdNCHelper( readNC, fileId, opts, fileSet ), maxEdgesPerCell( DEFAULT_MAX_EDGES_PER_CELL ), coordDim( 0 ),
       centerCoordsId( -1 ), degrees( true )
 {
 }

Member Function Documentation

◆ can_read_file()

bool moab::NCHelperESMF::can_read_file ( ReadNC * readNC )

static

Definition at line 30 of file NCHelperESMF.cpp.

 {
     std::vector< std::string >& dimNames = readNC->dimNames;
     if( ( std::find( dimNames.begin(), dimNames.end(), std::string( "nodeCount" ) ) != dimNames.end() ) &&
         ( std::find( dimNames.begin(), dimNames.end(), std::string( "elementCount" ) ) != dimNames.end() ) &&
         ( std::find( dimNames.begin(), dimNames.end(), std::string( "maxNodePElement" ) ) != dimNames.end() ) &&
         ( std::find( dimNames.begin(), dimNames.end(), std::string( "coordDim" ) ) != dimNames.end() ) )
     {
         return true;
     }
  
     return false;
 }

References moab::ReadNC::dimNames.

Referenced by moab::NCHelper::get_nc_format().

◆ check_existing_mesh()

virtual ErrorCode moab::NCHelperESMF::check_existing_mesh ( )

inlineprivatevirtual

Implements moab::NCHelper.

Definition at line 56 of file NCHelperESMF.hpp.

     {
         return MB_SUCCESS;
     }

References MB_SUCCESS.

◆ create_local_cells()

ErrorCode moab::NCHelperESMF::create_local_cells	(	const std::vector< int > &	vertices_on_local_cells,
		const std::vector< int > &	num_edges_on_local_cells,
		EntityHandle	start_vertex,
		Range &	faces
	)

private

Create local cells without padding (cells are divided into groups based on the number of edges)

Definition at line 627 of file NCHelperESMF.cpp.

 {
     Interface*& mbImpl = _readNC->mbImpl;
     Tag& mGlobalIdTag  = _readNC->mGlobalIdTag;
  
     // Divide local cells into groups based on the number of edges
     Range local_cells_with_n_edges[DEFAULT_MAX_EDGES_PER_CELL + 1];
     // Insert larger values before smaller ones to increase efficiency
     for( int i = nLocalCells - 1; i >= 0; i-- )
     {
         int num_edges = num_edges_on_local_cells[i];
         local_cells_with_n_edges[num_edges].insert( localGidCells[i] );  // Global cell index
     }
  
     std::vector< int > num_edges_on_cell_groups;
     for( int i = 3; i <= maxEdgesPerCell; i++ )
     {
         if( local_cells_with_n_edges[i].size() > 0 ) num_edges_on_cell_groups.push_back( i );
     }
     int numCellGroups = (int)num_edges_on_cell_groups.size();
     EntityHandle* conn_arr_local_cells_with_n_edges[DEFAULT_MAX_EDGES_PER_CELL + 1];
     for( int i = 0; i < numCellGroups; i++ )
     {
         int num_edges_per_cell = num_edges_on_cell_groups[i];
         int num_group_cells    = (int)local_cells_with_n_edges[num_edges_per_cell].size();
  
         EntityType typeEl = MBTRI;
         if( num_edges_per_cell == 4 ) typeEl = MBQUAD;
         if( num_edges_per_cell > 4 ) typeEl = MBPOLYGON;
         // Create local cells for each non-empty cell group
         EntityHandle start_element;
         MB_CHK_SET_ERR( _readNC->readMeshIface->get_element_connect(
                             num_group_cells, num_edges_per_cell, typeEl, 0, start_element,
                             conn_arr_local_cells_with_n_edges[num_edges_per_cell], num_group_cells ),
                         "Failed to create local cells" );
         faces.insert( start_element, start_element + num_group_cells - 1 );
  
         // Add local cells to current file set
         Range local_cells_range( start_element, start_element + num_group_cells - 1 );
         MB_CHK_SET_ERR( _readNC->mbImpl->add_entities( _fileSet, local_cells_range ),
                         "Failed to add local cells to current file set" );
  
         // Get ptr to gid memory for local cells
         int count  = 0;
         void* data = NULL;
         MB_CHK_SET_ERR( mbImpl->tag_iterate( mGlobalIdTag, local_cells_range.begin(), local_cells_range.end(), count,
                                              data ),
                         "Failed to iterate global id tag on local cells" );
         assert( count == num_group_cells );
         int* gid_data = (int*)data;
         std::copy( local_cells_with_n_edges[num_edges_per_cell].begin(),
                    local_cells_with_n_edges[num_edges_per_cell].end(), gid_data );
  
         // Set connectivity array with proper local vertices handles
         for( int j = 0; j < num_group_cells; j++ )
         {
             EntityHandle global_cell_idx =
                 local_cells_with_n_edges[num_edges_per_cell][j];          // Global cell index, 1 based
             int local_cell_idx = localGidCells.index( global_cell_idx );  // Local cell index, 0 based
             assert( local_cell_idx != -1 );
  
             for( int k = 0; k < num_edges_per_cell; k++ )
             {
                 EntityHandle global_vert_idx =
                     vertices_on_local_cells[local_cell_idx * maxEdgesPerCell + k];  // Global vertex index, 1 based
                 int local_vert_idx = localGidVerts.index( global_vert_idx );        // Local vertex index, 0 based
                 assert( local_vert_idx != -1 );
                 conn_arr_local_cells_with_n_edges[num_edges_per_cell][j * num_edges_per_cell + k] =
                     start_vertex + local_vert_idx;
             }
         }
     }
  
     return MB_SUCCESS;
 }

References moab::NCHelper::_fileSet, moab::NCHelper::_readNC, moab::Interface::add_entities(), moab::Range::begin(), moab::DEFAULT_MAX_EDGES_PER_CELL, moab::Range::end(), moab::ReadUtilIface::get_element_connect(), moab::Range::index(), moab::Range::insert(), moab::UcdNCHelper::localGidCells, moab::UcdNCHelper::localGidVerts, maxEdgesPerCell, MB_CHK_SET_ERR, MB_SUCCESS, moab::ReadNC::mbImpl, MBPOLYGON, MBQUAD, MBTRI, moab::ReadNC::mGlobalIdTag, moab::UcdNCHelper::nLocalCells, moab::ReadNC::readMeshIface, and moab::Interface::tag_iterate().

Referenced by create_mesh().

◆ create_local_vertices()

ErrorCode moab::NCHelperESMF::create_local_vertices	(	const std::vector< int > &	vertices_on_local_cells,
		EntityHandle &	start_vertex
	)

private

Create local vertices.

Definition at line 504 of file NCHelperESMF.cpp.

 {
     Interface*& mbImpl      = _readNC->mbImpl;
     Tag& mGlobalIdTag       = _readNC->mGlobalIdTag;
     const Tag*& mpFileIdTag = _readNC->mpFileIdTag;
     DebugOutput& dbgOut     = _readNC->dbgOut;
  
     // Make a copy of vertices_on_local_cells for sorting (keep original one to set cell
     // connectivity later)
     std::vector< int > vertices_on_local_cells_sorted( vertices_on_local_cells );
     std::sort( vertices_on_local_cells_sorted.begin(), vertices_on_local_cells_sorted.end() );
     std::copy( vertices_on_local_cells_sorted.rbegin(), vertices_on_local_cells_sorted.rend(),
                range_inserter( localGidVerts ) );
     nLocalVertices = localGidVerts.size();
  
     dbgOut.tprintf( 1, "   localGidVerts.psize() = %d\n", (int)localGidVerts.psize() );
     dbgOut.tprintf( 1, "   localGidVerts.size() = %d\n", (int)localGidVerts.size() );
  
     // Create local vertices
     std::vector< double* > arrays;
     MB_CHK_SET_ERR( _readNC->readMeshIface->get_node_coords( 3, nLocalVertices, 0, start_vertex, arrays,
                                                              nLocalVertices ),
                     "Failed to create local vertices" );
  
     // Add local vertices to current file set
     Range local_verts_range( start_vertex, start_vertex + nLocalVertices - 1 );
     MB_CHK_SET_ERR( _readNC->mbImpl->add_entities( _fileSet, local_verts_range ),
                     "Failed to add local vertices to current file set" );
  
     // Get ptr to GID memory for local vertices
     int count  = 0;
     void* data = NULL;
     MB_CHK_SET_ERR( mbImpl->tag_iterate( mGlobalIdTag, local_verts_range.begin(), local_verts_range.end(), count,
                                          data ),
                     "Failed to iterate global id tag on local vertices" );
     assert( count == nLocalVertices );
     int* gid_data = (int*)data;
     std::copy( localGidVerts.begin(), localGidVerts.end(), gid_data );
  
     // Duplicate GID data, which will be used to resolve sharing
     if( mpFileIdTag )
     {
         MB_CHK_SET_ERR( mbImpl->tag_iterate( *mpFileIdTag, local_verts_range.begin(), local_verts_range.end(), count,
                                              data ),
                         "Failed to iterate file id tag on local vertices" );
         assert( count == nLocalVertices );
         int bytes_per_tag = 4;
         MB_CHK_SET_ERR( mbImpl->tag_get_bytes( *mpFileIdTag, bytes_per_tag ),
                         "Can't get number of bytes for file id tag" );
         if( 4 == bytes_per_tag )
         {
             gid_data = (int*)data;
             std::copy( localGidVerts.begin(), localGidVerts.end(), gid_data );
         }
         else if( 8 == bytes_per_tag )
         {  // Should be a handle tag on 64 bit machine?
             long* handle_tag_data = (long*)data;
             std::copy( localGidVerts.begin(), localGidVerts.end(), handle_tag_data );
         }
     }
  
 #ifdef MOAB_HAVE_PNETCDF
     size_t nb_reads = localGidVerts.psize();
     std::vector< int > requests( nb_reads );
     std::vector< int > statuss( nb_reads );
     size_t idxReq = 0;
 #endif
  
     // Read  nodeCoords for local vertices
     double* coords = new double[localGidVerts.size() * coordDim];
     int nodeCoordVarId;
     int success = NCFUNC( inq_varid )( _fileId, "nodeCoords", &nodeCoordVarId );
     if( success ) MB_SET_ERR( MB_FAILURE, "Failed to get variable id of nodeCoords" );
     size_t indexInArray = 0;
     for( Range::pair_iterator pair_iter = localGidVerts.pair_begin(); pair_iter != localGidVerts.pair_end();
          ++pair_iter )
     {
         EntityHandle starth      = pair_iter->first;
         EntityHandle endh        = pair_iter->second;
         NCDF_SIZE read_starts[2] = { static_cast< NCDF_SIZE >( starth - 1 ), 0 };
         NCDF_SIZE read_counts[2] = { static_cast< NCDF_SIZE >( endh - starth + 1 ),
                                      static_cast< NCDF_SIZE >( coordDim ) };
  
         // Do a partial read in each subrange
 #ifdef MOAB_HAVE_PNETCDF
         success = NCFUNCREQG( _vara_double )( _fileId, nodeCoordVarId, read_starts, read_counts, &coords[indexInArray],
                                               &requests[idxReq++] );
 #else
         success = NCFUNCAG( _vara_double )( _fileId, nodeCoordVarId, read_starts, read_counts, &coords[indexInArray] );
 #endif
         if( success ) MB_SET_ERR( MB_FAILURE, "Failed to read nodeCoords data in a loop" );
  
         // Increment the index for next subrange
         indexInArray += ( endh - starth + 1 ) * coordDim;
     }
  
 #ifdef MOAB_HAVE_PNETCDF
     // Wait outside the loop
     success = NCFUNC( wait_all )( _fileId, requests.size(), &requests[0], &statuss[0] );
     if( success ) MB_SET_ERR( MB_FAILURE, "Failed on wait_all" );
 #endif
  
     // now convert from lat/lon to 3d
     if( 2 == coordDim )
     {
         // basically convert from degrees to xyz on a sphere
         double factor = 1;
         if( degrees ) factor = pideg;
         for( int i = 0; i < (int)localGidVerts.size(); i++ )
         {
             double lon    = coords[i * 2] * factor;
             double lat    = coords[i * 2 + 1] * factor;
             double cosphi = cos( lat );
             arrays[2][i]  = sin( lat );
             arrays[0][i]  = cosphi * cos( lon );
             arrays[1][i]  = cosphi * sin( lon );
         }
     }
     delete[] coords;
     return MB_SUCCESS;
 }

References moab::NCHelper::_fileId, moab::NCHelper::_fileSet, moab::NCHelper::_readNC, moab::Interface::add_entities(), moab::Range::begin(), coordDim, moab::ReadNC::dbgOut, degrees, moab::Range::end(), moab::ReadUtilIface::get_node_coords(), moab::UcdNCHelper::localGidVerts, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, moab::ReadNC::mbImpl, moab::ReadNC::mGlobalIdTag, moab::ReadNC::mpFileIdTag, NCDF_SIZE, NCFUNC, NCFUNCAG, moab::UcdNCHelper::nLocalVertices, moab::Range::pair_begin(), moab::Range::pair_end(), moab::pideg, moab::Range::psize(), moab::ReadNC::readMeshIface, moab::Range::size(), moab::Interface::tag_get_bytes(), moab::Interface::tag_iterate(), and moab::DebugOutput::tprintf().

Referenced by create_mesh().

◆ create_mesh()

ErrorCode moab::NCHelperESMF::create_mesh ( Range & faces )

privatevirtual

Implementation of NCHelper::create_mesh()

Implements moab::NCHelper.

Definition at line 136 of file NCHelperESMF.cpp.

 {
     bool& noMixedElements = _readNC->noMixedElements;
     DebugOutput& dbgOut   = _readNC->dbgOut;
  
 #ifdef MOAB_HAVE_MPI
     int rank              = 0;
     int procs             = 1;
     bool& isParallel      = _readNC->isParallel;
     ParallelComm* myPcomm = NULL;
     if( isParallel )
     {
         myPcomm = _readNC->myPcomm;
         rank    = myPcomm->proc_config().proc_rank();
         procs   = myPcomm->proc_config().proc_size();
     }
  
     if( procs >= 2 )
     {
         // Shift rank to obtain a rotated trivial partition
         int shifted_rank           = rank;
         int& trivialPartitionShift = _readNC->trivialPartitionShift;
         if( trivialPartitionShift > 0 ) shifted_rank = ( rank + trivialPartitionShift ) % procs;
  
         // Compute the number of local cells on this proc
         nLocalCells = int( std::floor( 1.0 * nCells / procs ) );
  
         // The starting global cell index in the ESMF file for this proc
         int start_cell_idx = shifted_rank * nLocalCells;
  
         // Number of extra cells after equal split over procs
         int iextra = nCells % procs;
  
         // Allocate extra cells over procs
         if( shifted_rank < iextra ) nLocalCells++;
         start_cell_idx += std::min( shifted_rank, iextra );
  
         start_cell_idx++;  // 0 based -> 1 based
  
         // Redistribute local cells after trivial partition (e.g. apply Zoltan partition)
         MB_CHK_SET_ERR( redistribute_local_cells( start_cell_idx, myPcomm ),
                         "Failed to redistribute local cells after trivial partition" );
     }
     else
     {
         nLocalCells = nCells;
         localGidCells.insert( 1, nLocalCells );
     }
 #else
     nLocalCells = nCells;
     localGidCells.insert( 1, nLocalCells );
 #endif
     dbgOut.tprintf( 1, " localGidCells.psize() = %d\n", (int)localGidCells.psize() );
     dbgOut.tprintf( 1, " localGidCells.size() = %d\n", (int)localGidCells.size() );
  
     // Read number of edges on each local cell, to calculate actual maxEdgesPerCell
     int nEdgesOnCellVarId;
     int success = NCFUNC( inq_varid )( _fileId, "numElementConn", &nEdgesOnCellVarId );
     if( success ) MB_SET_ERR( MB_FAILURE, "Failed to get variable id of numElementConn" );
     std::vector< int > num_edges_on_local_cells( nLocalCells );
  
 #ifdef MOAB_HAVE_PNETCDF
     size_t nb_reads = localGidCells.psize();
     std::vector< int > requests( nb_reads );
     std::vector< int > statuss( nb_reads );
     size_t idxReq = 0;
 #endif
     size_t indexInArray = 0;
     for( Range::pair_iterator pair_iter = localGidCells.pair_begin(); pair_iter != localGidCells.pair_end();
          ++pair_iter )
     {
         EntityHandle starth  = pair_iter->first;
         EntityHandle endh    = pair_iter->second;
         NCDF_SIZE read_start = (NCDF_SIZE)( starth - 1 );
         NCDF_SIZE read_count = (NCDF_SIZE)( endh - starth + 1 );
  
         // Do a partial read in each subrange
 #ifdef MOAB_HAVE_PNETCDF
         success = NCFUNCREQG( _vara_int )( _fileId, nEdgesOnCellVarId, &read_start, &read_count,
                                            &( num_edges_on_local_cells[indexInArray] ), &requests[idxReq++] );
 #else
         success = NCFUNCAG( _vara_int )( _fileId, nEdgesOnCellVarId, &read_start, &read_count,
                                          &( num_edges_on_local_cells[indexInArray] ) );
 #endif
         if( success ) MB_SET_ERR( MB_FAILURE, "Failed to read nEdgesOnCell data in a loop" );
  
         // Increment the index for next subrange
         indexInArray += ( endh - starth + 1 );
     }
  
 #ifdef MOAB_HAVE_PNETCDF
     // Wait outside the loop
     success = NCFUNC( wait_all )( _fileId, requests.size(), &requests[0], &statuss[0] );
     if( success ) MB_SET_ERR( MB_FAILURE, "Failed on wait_all" );
 #endif
  
     // Read vertices on each local cell, to get localGidVerts and cell connectivity later
     int verticesOnCellVarId;
     success = NCFUNC( inq_varid )( _fileId, "elementConn", &verticesOnCellVarId );
     if( success ) MB_SET_ERR( MB_FAILURE, "Failed to get variable id of elementConn" );
     std::vector< int > vertices_on_local_cells( nLocalCells * maxEdgesPerCell );
 #ifdef MOAB_HAVE_PNETCDF
     idxReq = 0;
 #endif
     indexInArray = 0;
     for( Range::pair_iterator pair_iter = localGidCells.pair_begin(); pair_iter != localGidCells.pair_end();
          ++pair_iter )
     {
         EntityHandle starth      = pair_iter->first;
         EntityHandle endh        = pair_iter->second;
         NCDF_SIZE read_starts[2] = { static_cast< NCDF_SIZE >( starth - 1 ), 0 };
         NCDF_SIZE read_counts[2] = { static_cast< NCDF_SIZE >( endh - starth + 1 ),
                                      static_cast< NCDF_SIZE >( maxEdgesPerCell ) };
  
         // Do a partial read in each subrange
 #ifdef MOAB_HAVE_PNETCDF
         success = NCFUNCREQG( _vara_int )( _fileId, verticesOnCellVarId, read_starts, read_counts,
                                            &( vertices_on_local_cells[indexInArray] ), &requests[idxReq++] );
 #else
         success = NCFUNCAG( _vara_int )( _fileId, verticesOnCellVarId, read_starts, read_counts,
                                          &( vertices_on_local_cells[indexInArray] ) );
 #endif
         if( success ) MB_SET_ERR( MB_FAILURE, "Failed to read verticesOnCell data in a loop" );
  
         // Increment the index for next subrange
         indexInArray += ( endh - starth + 1 ) * maxEdgesPerCell;
     }
  
 #ifdef MOAB_HAVE_PNETCDF
     // Wait outside the loop
     success = NCFUNC( wait_all )( _fileId, requests.size(), &requests[0], &statuss[0] );
     if( success ) MB_SET_ERR( MB_FAILURE, "Failed on wait_all" );
 #endif
  
     // Correct local cell vertices array, replace the padded vertices with the last vertices
     // in the corresponding cells; sometimes the padded vertices are 0, sometimes a large
     // vertex id. Make sure they are consistent to our padded option
     for( int local_cell_idx = 0; local_cell_idx < nLocalCells; local_cell_idx++ )
     {
         int num_edges             = num_edges_on_local_cells[local_cell_idx];
         int idx_in_local_vert_arr = local_cell_idx * maxEdgesPerCell;
         int last_vert_idx         = vertices_on_local_cells[idx_in_local_vert_arr + num_edges - 1];
         for( int i = num_edges; i < maxEdgesPerCell; i++ )
             vertices_on_local_cells[idx_in_local_vert_arr + i] = last_vert_idx;
     }
  
     // Create local vertices
     EntityHandle start_vertex;
     MB_CHK_SET_ERR( create_local_vertices( vertices_on_local_cells, start_vertex ),
                     "Failed to create local vertices for MPAS mesh" );
  
     // Create local cells, either unpadded or padded
     if( noMixedElements )
     {
         MB_CHK_SET_ERR( create_padded_local_cells( vertices_on_local_cells, start_vertex, faces ),
                         "Failed to create padded local cells for MPAS mesh" );
     }
     else
     {
         MB_CHK_SET_ERR( create_local_cells( vertices_on_local_cells, num_edges_on_local_cells, start_vertex, faces ),
                         "Failed to create local cells for MPAS mesh" );
     }
  
     return MB_SUCCESS;
 }

References moab::NCHelper::_fileId, moab::NCHelper::_readNC, create_local_cells(), create_local_vertices(), create_padded_local_cells(), moab::ReadNC::dbgOut, moab::Range::insert(), moab::ReadNC::isParallel, moab::UcdNCHelper::localGidCells, maxEdgesPerCell, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, NCDF_SIZE, moab::UcdNCHelper::nCells, NCFUNC, NCFUNCAG, moab::UcdNCHelper::nLocalCells, moab::ReadNC::noMixedElements, moab::Range::pair_begin(), moab::Range::pair_end(), moab::ParallelComm::proc_config(), moab::ProcConfig::proc_rank(), moab::ProcConfig::proc_size(), moab::Range::psize(), moab::Range::size(), moab::DebugOutput::tprintf(), and moab::ReadNC::trivialPartitionShift.

◆ create_padded_local_cells()

ErrorCode moab::NCHelperESMF::create_padded_local_cells	(	const std::vector< int > &	vertices_on_local_cells,
		EntityHandle	start_vertex,
		Range &	faces
	)

private

Create local cells with padding (padded cells will have the same number of edges)

Definition at line 706 of file NCHelperESMF.cpp.

 {
     Interface*& mbImpl = _readNC->mbImpl;
     Tag& mGlobalIdTag  = _readNC->mGlobalIdTag;
  
     // Create cells for this cell group
     EntityHandle start_element;
     EntityHandle* conn_arr_local_cells = NULL;
     MB_CHK_SET_ERR( _readNC->readMeshIface->get_element_connect( nLocalCells, maxEdgesPerCell, MBPOLYGON, 0,
                                                                  start_element, conn_arr_local_cells, nLocalCells ),
                     "Failed to create local cells" );
     faces.insert( start_element, start_element + nLocalCells - 1 );
  
     // Add local cells to current file set
     Range local_cells_range( start_element, start_element + nLocalCells - 1 );
     MB_CHK_SET_ERR( _readNC->mbImpl->add_entities( _fileSet, local_cells_range ),
                     "Failed to add local cells to current file set" );
  
     // Get ptr to GID memory for local cells
     int count  = 0;
     void* data = NULL;
     MB_CHK_SET_ERR( mbImpl->tag_iterate( mGlobalIdTag, local_cells_range.begin(), local_cells_range.end(), count,
                                          data ),
                     "Failed to iterate global id tag on local cells" );
     assert( count == nLocalCells );
     int* gid_data = (int*)data;
     std::copy( localGidCells.begin(), localGidCells.end(), gid_data );
  
     // Set connectivity array with proper local vertices handles
     // vertices_on_local_cells array was already corrected to have the last vertices padded
     // no need for extra checks considering
     for( int local_cell_idx = 0; local_cell_idx < nLocalCells; local_cell_idx++ )
     {
         for( int i = 0; i < maxEdgesPerCell; i++ )
         {
             EntityHandle global_vert_idx =
                 vertices_on_local_cells[local_cell_idx * maxEdgesPerCell + i];  // Global vertex index, 1 based
             int local_vert_idx = localGidVerts.index( global_vert_idx );        // Local vertex index, 0 based
             assert( local_vert_idx != -1 );
             conn_arr_local_cells[local_cell_idx * maxEdgesPerCell + i] = start_vertex + local_vert_idx;
         }
     }
  
     return MB_SUCCESS;
 }

References moab::NCHelper::_fileSet, moab::NCHelper::_readNC, moab::Interface::add_entities(), moab::Range::begin(), moab::Range::end(), moab::ReadUtilIface::get_element_connect(), moab::Range::index(), moab::Range::insert(), moab::UcdNCHelper::localGidCells, moab::UcdNCHelper::localGidVerts, maxEdgesPerCell, MB_CHK_SET_ERR, MB_SUCCESS, moab::ReadNC::mbImpl, MBPOLYGON, moab::ReadNC::mGlobalIdTag, moab::UcdNCHelper::nLocalCells, moab::ReadNC::readMeshIface, and moab::Interface::tag_iterate().

Referenced by create_mesh().

◆ get_mesh_type_name()

virtual std::string moab::NCHelperESMF::get_mesh_type_name ( )

inlineprivatevirtual

Implementation of NCHelper::get_mesh_type_name()

Implements moab::NCHelper.

Definition at line 31 of file NCHelperESMF.hpp.

     {
         return "ESMF";
     }

◆ init_mesh_vals()

ErrorCode moab::NCHelperESMF::init_mesh_vals ( )

privatevirtual

Implementation of NCHelper::init_mesh_vals()

Implements moab::NCHelper.

Definition at line 44 of file NCHelperESMF.cpp.

 {
     std::vector< std::string >& dimNames              = _readNC->dimNames;
     std::vector< int >& dimLens                       = _readNC->dimLens;
     std::map< std::string, ReadNC::VarData >& varInfo = _readNC->varInfo;
  
     unsigned int idx;
     std::vector< std::string >::iterator vit;
  
     // Get max edges per cell reported in the ESMF file header
     if( ( vit = std::find( dimNames.begin(), dimNames.end(), "maxNodePElement" ) ) != dimNames.end() )
     {
         idx             = vit - dimNames.begin();
         maxEdgesPerCell = dimLens[idx];
         if( maxEdgesPerCell > DEFAULT_MAX_EDGES_PER_CELL )
         {
             MB_SET_ERR( MB_INVALID_SIZE,
                         "maxEdgesPerCell read from the ESMF file header has exceeded " << DEFAULT_MAX_EDGES_PER_CELL );
         }
     }
  
     // Get number of cells
     if( ( vit = std::find( dimNames.begin(), dimNames.end(), "elementCount" ) ) != dimNames.end() )
         idx = vit - dimNames.begin();
     else
     {
         MB_SET_ERR( MB_FAILURE, "Couldn't find 'elementCount' dimension" );
     }
     cDim   = idx;
     nCells = dimLens[idx];
  
     // Get number of vertices per cell (max)
     if( ( vit = std::find( dimNames.begin(), dimNames.end(), "maxNodePElement" ) ) != dimNames.end() )
         idx = vit - dimNames.begin();
     else
     {
         MB_SET_ERR( MB_FAILURE, "Couldn't find 'maxNodePElement' dimension" );
     }
  
     maxEdgesPerCell = dimLens[idx];
  
     // Get number of vertices
     vDim = -1;
     if( ( vit = std::find( dimNames.begin(), dimNames.end(), "nodeCount" ) ) != dimNames.end() )
         idx = vit - dimNames.begin();
     else
     {
         MB_SET_ERR( MB_FAILURE, "Couldn't find 'nodeCount' dimension" );
     }
     vDim      = idx;
     nVertices = dimLens[idx];
  
     // Get number of coord dimensions
     if( ( vit = std::find( dimNames.begin(), dimNames.end(), "coordDim" ) ) != dimNames.end() )
         idx = vit - dimNames.begin();
     else
     {
         MB_SET_ERR( MB_FAILURE, "Couldn't find 'coordDim' dimension" );
     }
  
     coordDim = dimLens[idx];
  
     int success = NCFUNC( inq_varid )( _fileId, "centerCoords", &centerCoordsId );
     if( success ) centerCoordsId = -1;  // no center coords variable
  
     // decide now the units, by looking at nodeCoords; they should always exist
     int nodeCoordsId;
     success = NCFUNC( inq_varid )( _fileId, "nodeCoords", &nodeCoordsId );
     if( success ) MB_CHK_SET_ERR( MB_FAILURE, "Trouble getting nodeCoords" );
  
     auto vmit = varInfo.find( "nodeCoords" );
     if( varInfo.end() == vmit ) MB_SET_ERR( MB_FAILURE, "Couldn't find variable " << "nodeCoords" );
     ReadNC::VarData& glData = vmit->second;
     auto attIt              = glData.varAtts.find( "units" );
     if( attIt != glData.varAtts.end() )
     {
         unsigned int sz = attIt->second.attLen;
         std::string att_data;
         att_data.resize( sz + 1 );
         att_data[sz] = '\000';
         success =
             NCFUNC( get_att_text )( _fileId, attIt->second.attVarId, attIt->second.attName.c_str(), &att_data[0] );
         if( 0 == success && att_data.find( "radians" ) != std::string::npos ) degrees = false;
     }
  
     // Hack: create dummy variables for dimensions (like nCells) with no corresponding coordinate
     // variables
     MB_CHK_SET_ERR( create_dummy_variables(), "Failed to create dummy variables" );
  
     return MB_SUCCESS;
 }

References moab::NCHelper::_fileId, moab::NCHelper::_readNC, moab::UcdNCHelper::cDim, centerCoordsId, coordDim, moab::NCHelper::create_dummy_variables(), moab::DEFAULT_MAX_EDGES_PER_CELL, degrees, moab::ReadNC::dimLens, moab::ReadNC::dimNames, maxEdgesPerCell, MB_CHK_SET_ERR, MB_INVALID_SIZE, MB_SET_ERR, MB_SUCCESS, moab::UcdNCHelper::nCells, NCFUNC, moab::UcdNCHelper::nVertices, moab::ReadNC::VarData::varAtts, moab::ReadNC::varInfo, and moab::UcdNCHelper::vDim.

◆ read_ucd_variables_to_nonset()

virtual ErrorCode moab::NCHelperESMF::read_ucd_variables_to_nonset	(	std::vector< ReadNC::VarData > &	,
		std::vector< int > &
	)

inlineprivatevirtual

Implementation of UcdNCHelper::read_ucd_variables_to_nonset()

Implements moab::UcdNCHelper.

Definition at line 77 of file NCHelperESMF.hpp.

     {
         return MB_SUCCESS;
     }

References MB_SUCCESS.

◆ read_ucd_variables_to_nonset_allocate()

virtual ErrorCode moab::NCHelperESMF::read_ucd_variables_to_nonset_allocate	(	std::vector< ReadNC::VarData > &	,
		std::vector< int > &
	)

inlineprivatevirtual

Implementation of UcdNCHelper::read_ucd_variables_to_nonset_allocate()

Implements moab::UcdNCHelper.

Definition at line 62 of file NCHelperESMF.hpp.

     {
         return MB_SUCCESS;
     }

References MB_SUCCESS.

Member Data Documentation

◆ centerCoordsId

int moab::NCHelperESMF::centerCoordsId

private

Definition at line 87 of file NCHelperESMF.hpp.

Referenced by init_mesh_vals().

◆ coordDim

int moab::NCHelperESMF::coordDim

private

Definition at line 86 of file NCHelperESMF.hpp.

Referenced by create_local_vertices(), and init_mesh_vals().

◆ degrees

bool moab::NCHelperESMF::degrees

private

Definition at line 88 of file NCHelperESMF.hpp.

Referenced by create_local_vertices(), and init_mesh_vals().

◆ facesOwned

Range moab::NCHelperESMF::facesOwned

private

Definition at line 89 of file NCHelperESMF.hpp.

◆ maxEdgesPerCell

int moab::NCHelperESMF::maxEdgesPerCell

private

Definition at line 85 of file NCHelperESMF.hpp.

Referenced by create_local_cells(), create_mesh(), create_padded_local_cells(), and init_mesh_vals().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ NCHelperESMF()

Member Function Documentation

◆ can_read_file()

◆ check_existing_mesh()

◆ create_local_cells()

◆ create_local_vertices()

◆ create_mesh()

◆ create_padded_local_cells()

◆ get_mesh_type_name()

◆ init_mesh_vals()

◆ read_ucd_variables_to_nonset()

◆ read_ucd_variables_to_nonset_allocate()

Member Data Documentation

◆ centerCoordsId

◆ coordDim

◆ degrees

◆ facesOwned

◆ maxEdgesPerCell