#include <NCHelperScrip.hpp>

Inheritance diagram for moab::NCHelperScrip:

Collaboration diagram for moab::NCHelperScrip:

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

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

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

virtual	~ScdNCHelper ()

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, int fileId)

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
ErrorCode	assign_local_vertex_global_ids (Range &verts)
	Number the given vertices 1..n in GLOBAL_ID, for the serial read path where ParallelComm::assign_global_ids() is not available. Downstream consumers (notably the coverage-mesh migration in Intx2MeshOnSphere) key vertices by GLOBAL_ID. More...

virtual ErrorCode	init_mesh_vals ()
	Interfaces to be implemented in child classes. More...

virtual std::string	get_mesh_type_name ()

Private Attributes
int	grid_corners

int	grid_size

int	grid_rank

int	nLocalCells

Range	localGidCells

bool	degrees

Additional Inherited Members
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::ScdNCHelper
int	gDims [6]
	Dimensions of global grid in file. More...

int	lDims [6]
	Dimensions of my local part of grid. More...

int	gCDims [6]
	Center dimensions of global grid in file. More...

int	lCDims [6]
	Center dimensions of my local part of grid. More...

std::vector< double >	ilVals
	Values for i/j. More...

std::vector< double >	jlVals

std::vector< double >	ilCVals
	Center values for i/j. More...

std::vector< double >	jlCVals

int	iDim
	Dimension numbers for i/j. More...

int	jDim

int	iCDim
	Center dimension numbers for i/j. More...

int	jCDim

int	locallyPeriodic [3]
	Whether mesh is locally periodic in i or j or k. More...

int	globallyPeriodic [3]
	Whether mesh is globally periodic in i or j or k. More...

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 16 of file NCHelperScrip.hpp.

Constructor & Destructor Documentation

◆ NCHelperScrip()

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

inline

Definition at line 19 of file NCHelperScrip.hpp.

         : ScdNCHelper( readNC, fileId, opts, fileSet ), grid_corners( 0 ), grid_size( 0 ), grid_rank( 1 ),
           nLocalCells( 0 ), degrees( true )
     {
     }

Member Function Documentation

◆ assign_local_vertex_global_ids()

ErrorCode moab::NCHelperScrip::assign_local_vertex_global_ids ( Range & verts )

private

Number the given vertices 1..n in GLOBAL_ID, for the serial read path where ParallelComm::assign_global_ids() is not available. Downstream consumers (notably the coverage-mesh migration in Intx2MeshOnSphere) key vertices by GLOBAL_ID.

Definition at line 95 of file NCHelperScrip.cpp.

 {
     Interface*& mbImpl = _readNC->mbImpl;
     if( verts.empty() ) return MB_SUCCESS;
  
     Tag gidTag = mbImpl->globalId_tag();
     std::vector< int > gids( verts.size() );
     int id = 1;
     for( size_t i = 0; i < gids.size(); i++ )
         gids[i] = id++;
     MB_CHK_SET_ERR( mbImpl->tag_set_data( gidTag, verts, &gids[0] ),
                     "Failed to assign GLOBAL_ID to SCRIP vertices" );
     return MB_SUCCESS;
 }

References moab::NCHelper::_readNC, moab::Range::empty(), moab::Interface::globalId_tag(), MB_CHK_SET_ERR, MB_SUCCESS, moab::ReadNC::mbImpl, moab::Range::size(), and moab::Interface::tag_set_data().

Referenced by create_mesh().

◆ can_read_file()

bool moab::NCHelperScrip::can_read_file	(	ReadNC *	readNC,
		int	fileId
	)

static

Definition at line 19 of file NCHelperScrip.cpp.

 {
     std::vector< std::string >& dimNames = readNC->dimNames;
  
     // If dimension names "grid_size" AND "grid_corners" AND "grid_rank" exist then it should be the Scrip grid
     if( ( std::find( dimNames.begin(), dimNames.end(), std::string( "grid_size" ) ) != dimNames.end() ) &&
         ( std::find( dimNames.begin(), dimNames.end(), std::string( "grid_corners" ) ) != dimNames.end() ) &&
         ( std::find( dimNames.begin(), dimNames.end(), std::string( "grid_rank" ) ) != dimNames.end() ) )
     {
         return true;
     }
  
     return false;
 }

References moab::ReadNC::dimNames.

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

◆ create_mesh()

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

virtual

Implementation of NCHelper::create_mesh()

Reimplemented from moab::ScdNCHelper.

Definition at line 110 of file NCHelperScrip.cpp.

 {
     Interface*& mbImpl  = _readNC->mbImpl;
     DebugOutput& dbgOut = _readNC->dbgOut;
     Tag& mGlobalIdTag   = _readNC->mGlobalIdTag;
     ErrorCode rval;
  
 #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 * grid_size / procs ) );
  
         // The starting global cell index in the MPAS file for this proc
         int start_cell_idx = shifted_rank * nLocalCells;
  
         // Number of extra cells after equal split over procs
         int iextra = grid_size % 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 = grid_size;
         localGidCells.insert( 1, nLocalCells );
     }
 #else
     nLocalCells = grid_size;
     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() );
  
     // double grid_corner_lat(grid_size, grid_corners) ;
     // double grid_corner_lon(grid_size, grid_corners) ;
     int xvId, yvId;
     int success = NCFUNC( inq_varid )( _fileId, "grid_corner_lon", &xvId );
     if( success ) MB_SET_ERR( MB_FAILURE, "Failed to get variable id of grid_corner_lon" );
     success = NCFUNC( inq_varid )( _fileId, "grid_corner_lat", &yvId );
     if( success ) MB_SET_ERR( MB_FAILURE, "Failed to get variable id of grid_corner_lat" );
  
     // important upgrade: read masks if they exist, and save them as tags
     int gmId      = -1;
     int sizeMasks = 0;
 #ifdef MOAB_HAVE_PNETCDF
     int factorRequests = 2;  // we would read in general only 2 variables, xv and yv
 #endif
     success     = NCFUNC( inq_varid )( _fileId, "grid_imask", &gmId );
     Tag maskTag = 0;  // not sure yet if we have the masks or not
     if( success )
     {
         gmId = -1;  // we do not have masks
     }
     else
     {
         sizeMasks = nLocalCells;
 #ifdef MOAB_HAVE_PNETCDF
         factorRequests = 3;  // we also need to read masks distributed
 #endif
         // create the maskTag GRID_IMASK, with default value of 1
         int def_val = 1;
         MB_CHK_SET_ERR( mbImpl->tag_get_handle( "GRID_IMASK", 1, MB_TYPE_INTEGER, maskTag, MB_TAG_DENSE | MB_TAG_CREAT,
                                                 &def_val ),
                         "Trouble creating GRID_IMASK tag" );
     }
  
     std::vector< double > xv( nLocalCells * grid_corners );
     std::vector< double > yv( nLocalCells * grid_corners );
     std::vector< int > masks( sizeMasks );
 #ifdef MOAB_HAVE_PNETCDF
     size_t nb_reads = localGidCells.psize();
     std::vector< int > requests( nb_reads * factorRequests );
     std::vector< int > statuss( nb_reads * factorRequests );
     size_t idxReq = 0;
 #endif
     size_t indexInArray     = 0;
     size_t indexInMaskArray = 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 >( grid_corners ) };
  
         // Do a partial read in each subrange
 #ifdef MOAB_HAVE_PNETCDF
         success = NCFUNCREQG( _vara_double )( _fileId, xvId, read_starts, read_counts, &( xv[indexInArray] ),
                                               &requests[idxReq++] );
 #else
         success = NCFUNCAG( _vara_double )( _fileId, xvId, read_starts, read_counts, &( xv[indexInArray] ) );
 #endif
         if( success ) MB_SET_ERR( MB_FAILURE, "Failed to read grid_corner_lon data in a loop" );
  
         // Do a partial read in each subrange
 #ifdef MOAB_HAVE_PNETCDF
         success = NCFUNCREQG( _vara_double )( _fileId, yvId, read_starts, read_counts, &( yv[indexInArray] ),
                                               &requests[idxReq++] );
 #else
         success = NCFUNCAG( _vara_double )( _fileId, yvId, read_starts, read_counts, &( yv[indexInArray] ) );
 #endif
         if( success ) MB_SET_ERR( MB_FAILURE, "Failed to read grid_corner_lat data in a loop" );
         // Increment the index for next subrange
         indexInArray += ( endh - starth + 1 ) * grid_corners;
  
         if( gmId >= 0 )  // it means we need to read masks too, distributed:
         {
             NCDF_SIZE read_st = static_cast< NCDF_SIZE >( starth - 1 );
             NCDF_SIZE read_ct = static_cast< NCDF_SIZE >( endh - starth + 1 );
             // Do a partial read in each subrange, for mask variable:
 #ifdef MOAB_HAVE_PNETCDF
             success = NCFUNCREQG( _vara_int )( _fileId, gmId, &read_st, &read_ct, &( masks[indexInMaskArray] ),
                                                &requests[idxReq++] );
 #else
             success = NCFUNCAG( _vara_int )( _fileId, gmId, &read_st, &read_ct, &( masks[indexInMaskArray] ) );
 #endif
             if( success ) MB_SET_ERR( MB_FAILURE, "Failed on mask read " );
             indexInMaskArray += 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
  
     // int grid_dims(grid_rank)
     {
         int gdId;
         int success = NCFUNC( inq_varid )( _fileId, "grid_dims", &gdId );
         if( success ) MB_SET_ERR( MB_FAILURE, "Failed to get variable id of grid_dims" );
  
         // If rectilinear attribute present, mark it
         std::vector< int > vecDimSizes( 3, 0 );
         Tag rectilinearTag;
         // Tag data contains: guessed mesh type,     mesh size1,     mesh size 2
         //          Example:  CS(0)/ICO(1)/ICOD(2),  num_elements,   num_nodes
         //                 :       RLL(3),           num_lat,        num_lon
  
         // create the maskTag GRID_IMASK, with default value of 1
  
         vecDimSizes[0] = ( grid_rank == 2 ? 1 /* moab::TempestRemapper::RLL */ : 0 /* moab::TempestRemapper::CS */ );
         vecDimSizes[1] = grid_size;  // number of elements
         vecDimSizes[2] = grid_size;  // number of elements
         rval           = mbImpl->tag_get_handle( "ClimateMetadata", 3, MB_TYPE_INTEGER, rectilinearTag,
                                                  MB_TAG_SPARSE | MB_TAG_CREAT, vecDimSizes.data() );
         if( MB_ALREADY_ALLOCATED != rval && MB_SUCCESS != rval )
             MB_CHK_SET_ERR( rval, "can't create rectilinear sizes tag" );
  
         if( grid_rank == 2 )
         {
             NCDF_SIZE read_starts[1] = { static_cast< NCDF_SIZE >( 0 ) };
             NCDF_SIZE read_counts[1] = { static_cast< NCDF_SIZE >( grid_rank ) };
  
             // Do a partial read in each subrange
 #ifdef MOAB_HAVE_PNETCDF
             std::vector< int > requeststatus( 2 );
             success = NCFUNCREQG( _vara_int )( _fileId, gdId, read_starts, read_counts, vecDimSizes.data() + 1,
                                                &requeststatus[0] );
             if( success ) MB_SET_ERR( MB_FAILURE, "Failed to read grid_dims data" );
  
             // Wait outside the loop
             success = NCFUNC( wait_all )( _fileId, 1, &requeststatus[0], &requeststatus[1] );
             if( success ) MB_SET_ERR( MB_FAILURE, "Failed on wait_all" );
 #else
             success = NCFUNCAG( _vara_int )( _fileId, gdId, read_starts, read_counts, vecDimSizes.data() + 1 );
             if( success ) MB_SET_ERR( MB_FAILURE, "Failed to read grid_dims data" );
 #endif
         }
  
         rval = mbImpl->tag_set_data( rectilinearTag, &_fileSet, 1, vecDimSizes.data() );
     }
  
     // so we read xv, yv for all corners in the local mesh, and masks if they exist
  
     // Create vertices; first identify different ones, with a tolerance
     std::map< Node3D, EntityHandle > vertex_map;
  
     // Set vertex coordinates
     // will read all xv, yv, but use only those with correct mask on
  
     int elem_index = 0;   // local index in netcdf arrays
     double pideg   = 1.;  // radians
     if( degrees ) pideg = acos( -1.0 ) / 180.0;
  
     for( ; elem_index < nLocalCells; elem_index++ )
     {
         // set area and fraction on those elements too
         for( int k = 0; k < grid_corners; k++ )
         {
             int index_v_arr = grid_corners * elem_index + k;
             double x, y;
             x             = xv[index_v_arr];
             y             = yv[index_v_arr];
             double cosphi = cos( pideg * y );
             double zmult  = sin( pideg * y );
             double xmult  = cosphi * cos( x * pideg );
             double ymult  = cosphi * sin( x * pideg );
             Node3D pt( xmult, ymult, zmult );
             vertex_map[pt] = 0;
         }
     }
     int nLocalVertices = (int)vertex_map.size();
     std::vector< double* > arrays;
     EntityHandle start_vertex, vtx_handle;
     MB_CHK_SET_ERR( _readNC->readMeshIface->get_node_coords( 3, nLocalVertices, 0, start_vertex, arrays ),
                     "Failed to create local vertices" );
  
     vtx_handle = start_vertex;
     // Copy vertex coordinates into entity sequence coordinate arrays
     // and copy handle into vertex_map.
     double *x = arrays[0], *y = arrays[1], *z = arrays[2];
     for( auto i = vertex_map.begin(); i != vertex_map.end(); ++i )
     {
         i->second = vtx_handle;
         ++vtx_handle;
         *x = i->first.coords[0];
         ++x;
         *y = i->first.coords[1];
         ++y;
         *z = i->first.coords[2];
         ++z;
     }
  
     EntityHandle start_cell;
     int nv              = grid_corners;
     EntityType mdb_type = MBVERTEX;
     if( nv == 3 )
         mdb_type = MBTRI;
     else if( nv == 4 )
         mdb_type = MBQUAD;
     else if( nv > 4 )  // (nv > 4)
         mdb_type = MBPOLYGON;
  
     Range tmp_range;
     EntityHandle* conn_arr;
  
     MB_CHK_SET_ERR( _readNC->readMeshIface->get_element_connect( nLocalCells, nv, mdb_type, 0, start_cell, conn_arr ),
                     "Failed to create local cells" );
     tmp_range.insert( start_cell, start_cell + nLocalCells - 1 );
  
     elem_index = 0;
  
     for( ; elem_index < nLocalCells; elem_index++ )
     {
         for( int k = 0; k < nv; k++ )
         {
             int index_v_arr = nv * elem_index + k;
             if( nv > 1 )
             {
                 double x      = xv[index_v_arr];
                 double y      = yv[index_v_arr];
                 double cosphi = cos( pideg * y );
                 double zmult  = sin( pideg * y );
                 double xmult  = cosphi * cos( x * pideg );
                 double ymult  = cosphi * sin( x * pideg );
                 Node3D pt( xmult, ymult, zmult );
                 conn_arr[elem_index * nv + k] = vertex_map[pt];
             }
         }
         EntityHandle cell = start_cell + elem_index;
         // set other tags, like xc, yc, frac, area
         /*MB_CHK_SET_ERR( mbImpl->tag_set_data( xcTag, &cell, 1, &xc[elem_index] ), "Failed to set xc tag"  );
         MB_CHK_SET_ERR( mbImpl->tag_set_data( ycTag, &cell, 1, &yc[elem_index] ), "Failed to set yc tag"  );
         MB_CHK_SET_ERR( mbImpl->tag_set_data( areaTag, &cell, 1, &area[elem_index] ), "Failed to set area tag"  );
         MB_CHK_SET_ERR( mbImpl->tag_set_data( fracTag, &cell, 1, &frac[elem_index] ), "Failed to set frac tag"  );
 */
         // set the global id too:
         int globalId = localGidCells[elem_index];
  
         MB_CHK_SET_ERR( mbImpl->tag_set_data( mGlobalIdTag, &cell, 1, &globalId ), "Failed to set global id tag" );
         if( gmId >= 0 )
         {
             int localMask = masks[elem_index];
             MB_CHK_SET_ERR( mbImpl->tag_set_data( maskTag, &cell, 1, &localMask ), "Failed to set mask tag" );
         }
     }
  
     MB_CHK_SET_ERR( mbImpl->add_entities( _fileSet, tmp_range ), "Failed to add new cells to current file set" );
  
     // modify local file set, to merge coincident vertices, and to correct repeated vertices in elements
     std::vector< Tag > tagList;
     tagList.push_back( mGlobalIdTag );
     if( gmId >= 0 ) tagList.push_back( maskTag );
     MB_CHK_SET_ERR( IntxUtils::remove_padded_vertices( mbImpl, _fileSet, tagList ),
                     "Failed to remove duplicate vertices" );
  
     MB_CHK_ERR( mbImpl->get_entities_by_dimension( _fileSet, 2, faces ) );
     Range all_verts;
     MB_CHK_ERR( mbImpl->get_connectivity( faces, all_verts ) );
     MB_CHK_ERR( mbImpl->add_entities( _fileSet, all_verts ) );
     // need to add adjacencies; TODO: fix this for all nc readers
     // copy this logic from migrate mesh in par comm graph
     Core* mb                 = (Core*)mbImpl;
     AEntityFactory* adj_fact = mb->a_entity_factory();
     if( !adj_fact->vert_elem_adjacencies() )
         adj_fact->create_vert_elem_adjacencies();
     else
     {
         for( Range::iterator it = faces.begin(); it != faces.end(); ++it )
         {
             EntityHandle eh          = *it;
             const EntityHandle* conn = NULL;
             int num_nodes            = 0;
             MB_CHK_ERR( mb->get_connectivity( eh, conn, num_nodes ) );
             adj_fact->notify_create_entity( eh, conn, num_nodes );
         }
     }
  
 #ifdef MOAB_HAVE_MPI
     if( myPcomm )
     {
         double tol = 1.e-12;  // this is the same as static tolerance in NCHelper
         ParallelMergeMesh pmm( myPcomm, tol );
         MB_CHK_SET_ERR( pmm.merge( _fileSet,
                                    /* do not do local merge*/ false,
                                    /*  2d cells*/ 2 ),
                         "Failed to merge vertices in parallel" );
  
         // assign global ids only for vertices, cells have them fine
         MB_CHK_ERR( myPcomm->assign_global_ids( _fileSet, /*dim*/ 0 ) );
         // remove all sets, edges and vertices from the file set
         Range edges, vertices;
         MB_CHK_ERR( mbImpl->get_entities_by_dimension( _fileSet, 1, edges, /*recursive*/ true ) );
         MB_CHK_ERR( mbImpl->get_entities_by_dimension( _fileSet, 0, vertices, /*recursive*/ true ) );
         MB_CHK_ERR( mbImpl->remove_entities( _fileSet, edges ) );
         MB_CHK_ERR( mbImpl->remove_entities( _fileSet, vertices ) );
  
         Range intfSets = myPcomm->interface_sets();
         // empty intf sets
         MB_CHK_ERR( mbImpl->clear_meshset( intfSets ) );
         // delete the sets without shame :)
         //sets.merge(intfSets);
         //MB_CHK_ERR( myPcomm->delete_entities(sets) ); // will also clean shared ents !
         MB_CHK_ERR( myPcomm->delete_entities( edges ) );  // will also clean shared ents !
     }
     else
     {
         // Serial read (no ParallelComm): still number the vertices.  Consumers such as
         // Intx2MeshOnSphere::construct_covering_set() identify vertices across ranks purely
         // by GLOBAL_ID, so a mesh written out here and re-read in parallel later must carry
         // one; otherwise every vertex reads back as the tag default (-1) and migrated cells
         // collapse to a single repeated corner.
         MB_CHK_ERR( assign_local_vertex_global_ids( all_verts ) );
         MB_CHK_ERR( mbImpl->remove_entities( _fileSet, all_verts ) );
     }
 #else
     MB_CHK_ERR( assign_local_vertex_global_ids( all_verts ) );
     MB_CHK_ERR( mbImpl->remove_entities( _fileSet, all_verts ) );
 #endif
  
     return MB_SUCCESS;
 }

References moab::NCHelper::_fileId, moab::NCHelper::_fileSet, moab::NCHelper::_readNC, moab::Interface::add_entities(), moab::ParallelComm::assign_global_ids(), assign_local_vertex_global_ids(), moab::Range::begin(), moab::Interface::clear_meshset(), moab::AEntityFactory::create_vert_elem_adjacencies(), moab::ReadNC::dbgOut, degrees, moab::ParallelComm::delete_entities(), moab::Range::end(), ErrorCode, moab::Interface::get_connectivity(), moab::ReadUtilIface::get_element_connect(), moab::Interface::get_entities_by_dimension(), moab::ReadUtilIface::get_node_coords(), grid_corners, grid_rank, grid_size, moab::Range::insert(), moab::ParallelComm::interface_sets(), moab::ReadNC::isParallel, localGidCells, mb, MB_ALREADY_ALLOCATED, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TAG_SPARSE, MB_TYPE_INTEGER, moab::ReadNC::mbImpl, MBPOLYGON, MBQUAD, MBTRI, MBVERTEX, moab::ParallelMergeMesh::merge(), moab::ReadNC::mGlobalIdTag, NCDF_SIZE, NCFUNC, NCFUNCAG, NCFUNCREQG, nLocalCells, moab::AEntityFactory::notify_create_entity(), moab::Range::pair_begin(), moab::Range::pair_end(), moab::pideg, moab::ParallelComm::proc_config(), moab::ProcConfig::proc_rank(), moab::ProcConfig::proc_size(), moab::Range::psize(), moab::ReadNC::readMeshIface, moab::Interface::remove_entities(), moab::IntxUtils::remove_padded_vertices(), moab::Range::size(), moab::Interface::tag_get_handle(), moab::Interface::tag_set_data(), moab::DebugOutput::tprintf(), moab::ReadNC::trivialPartitionShift, and moab::AEntityFactory::vert_elem_adjacencies().

◆ get_mesh_type_name()

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

inlineprivatevirtual

Implements moab::NCHelper.

Definition at line 40 of file NCHelperScrip.hpp.

     {
         return "SCRIP";
     }

◆ init_mesh_vals()

ErrorCode moab::NCHelperScrip::init_mesh_vals ( )

privatevirtual

Interfaces to be implemented in child classes.

Implements moab::NCHelper.

Definition at line 33 of file NCHelperScrip.cpp.

 {
     Interface*& mbImpl                   = _readNC->mbImpl;
     std::vector< std::string >& dimNames = _readNC->dimNames;
     std::vector< int >& dimLens          = _readNC->dimLens;
  
     unsigned int idx;
     std::vector< std::string >::iterator vit;
  
     // get grid_size
     if( ( vit = std::find( dimNames.begin(), dimNames.end(), "grid_size" ) ) != dimNames.end() )
     {
         idx       = vit - dimNames.begin();
         grid_size = dimLens[idx];
     }
  
     // get grid_corners
     if( ( vit = std::find( dimNames.begin(), dimNames.end(), "grid_corners" ) ) != dimNames.end() )
     {
         idx          = vit - dimNames.begin();
         grid_corners = dimLens[idx];
     }
  
     // get grid_rank
     if( ( vit = std::find( dimNames.begin(), dimNames.end(), "grid_rank" ) ) != dimNames.end() )
     {
         idx       = vit - dimNames.begin();
         grid_rank = dimLens[idx];
     }
  
     // do not need conventional tags
     Tag convTagsCreated = 0;
     int def_val         = 0;
     MB_CHK_SET_ERR( mbImpl->tag_get_handle( "__CONV_TAGS_CREATED", 1, MB_TYPE_INTEGER, convTagsCreated,
                                             MB_TAG_SPARSE | MB_TAG_CREAT, &def_val ),
                     "Trouble getting _CONV_TAGS_CREATED tag" );
     int create_conv_tags_flag = 1;
     MB_CHK_SET_ERR( mbImpl->tag_set_data( convTagsCreated, &_fileSet, 1, &create_conv_tags_flag ),
                     "Trouble setting _CONV_TAGS_CREATED tag" );
  
     // decide now the units, by looking at grid_center_lon
     int xCellVarId;
     int success = NCFUNC( inq_varid )( _fileId, "grid_center_lon", &xCellVarId );
     if( success ) MB_CHK_SET_ERR( MB_FAILURE, "Trouble getting grid_center_lon" );
     std::map< std::string, ReadNC::VarData >& varInfo = _readNC->varInfo;
     auto vmit                                         = varInfo.find( "grid_center_lon" );
     if( varInfo.end() == vmit ) MB_SET_ERR( MB_FAILURE, "Couldn't find variable " << "grid_center_lon" );
     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;
     }
  
     return MB_SUCCESS;
 }

References moab::NCHelper::_fileId, moab::NCHelper::_fileSet, moab::NCHelper::_readNC, degrees, moab::ReadNC::dimLens, moab::ReadNC::dimNames, grid_corners, grid_rank, grid_size, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, moab::ReadNC::mbImpl, NCFUNC, moab::Interface::tag_get_handle(), moab::Interface::tag_set_data(), moab::ReadNC::VarData::varAtts, and moab::ReadNC::varInfo.

Member Data Documentation

◆ degrees

bool moab::NCHelperScrip::degrees

private

Definition at line 50 of file NCHelperScrip.hpp.

Referenced by create_mesh(), and init_mesh_vals().

◆ grid_corners

int moab::NCHelperScrip::grid_corners

private

Definition at line 45 of file NCHelperScrip.hpp.

Referenced by create_mesh(), and init_mesh_vals().

◆ grid_rank

int moab::NCHelperScrip::grid_rank

private

Definition at line 47 of file NCHelperScrip.hpp.

Referenced by create_mesh(), and init_mesh_vals().

◆ grid_size

int moab::NCHelperScrip::grid_size

private

Definition at line 46 of file NCHelperScrip.hpp.

Referenced by create_mesh(), and init_mesh_vals().

◆ localGidCells

Range moab::NCHelperScrip::localGidCells

private

Definition at line 49 of file NCHelperScrip.hpp.

Referenced by create_mesh().

◆ nLocalCells

int moab::NCHelperScrip::nLocalCells

private

Definition at line 48 of file NCHelperScrip.hpp.

Referenced by create_mesh().

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

◆ NCHelperScrip()

Member Function Documentation

◆ assign_local_vertex_global_ids()

◆ can_read_file()

◆ create_mesh()

◆ get_mesh_type_name()

◆ init_mesh_vals()

Member Data Documentation

◆ degrees

◆ grid_corners

◆ grid_rank

◆ grid_size

◆ localGidCells

◆ nLocalCells