Helper class to isolate reading of several different nc file formats. More...

#include <NCHelper.hpp>

Inheritance diagram for moab::NCHelper:

Collaboration diagram for moab::NCHelper:

Classes
class	Node3D

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

virtual	~NCHelper ()

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

virtual ErrorCode	check_existing_mesh ()=0

virtual ErrorCode	create_mesh (Range &faces)=0

virtual ErrorCode	read_variables (std::vector< std::string > &var_names, std::vector< int > &tstep_nums)=0

virtual std::string	get_mesh_type_name ()=0

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 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...

Protected Member Functions
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
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...

Private Member Functions
ErrorCode	read_variables_to_set_allocate (std::vector< ReadNC::VarData > &vdatas, std::vector< int > &tstep_nums)
	Used by read_variables_to_set() More...

Detailed Description

Helper class to isolate reading of several different nc file formats.

Definition at line 24 of file NCHelper.hpp.

Constructor & Destructor Documentation

◆ NCHelper()

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

inline

Definition at line 27 of file NCHelper.hpp.

         : _readNC( readNC ), _fileId( fileId ), _opts( opts ), _fileSet( fileSet ), nTimeSteps( 0 ), nLevels( 1 ),
           tDim( -1 ), levDim( -1 )
     {
     }

◆ ~NCHelper()

virtual moab::NCHelper::~NCHelper ( )

inlinevirtual

Definition at line 32 of file NCHelper.hpp.

32 {}

Member Function Documentation

◆ check_existing_mesh()

virtual ErrorCode moab::NCHelper::check_existing_mesh ( )

pure virtual

Implemented in moab::NCHelperMPAS, moab::NCHelperHOMME, moab::NCHelperGCRM, moab::NCHelperESMF, and moab::ScdNCHelper.

Referenced by moab::ReadNC::load_file().

◆ create_attrib_string()

ErrorCode moab::NCHelper::create_attrib_string	(	const std::map< std::string, ReadNC::AttData > &	attMap,
		std::string &	attString,
		std::vector< int > &	attLen
	)

protected

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.

Definition at line 734 of file NCHelper.cpp.

 {
     int success;
     std::stringstream ssAtt;
     unsigned int sz                                                = 0;
     std::map< std::string, ReadNC::AttData >::const_iterator attIt = attMap.begin();
     for( ; attIt != attMap.end(); ++attIt )
     {
         ssAtt << attIt->second.attName;
         ssAtt << '\0';
         void* attData = NULL;
         switch( attIt->second.attDataType )
         {
             case NC_BYTE:
             case NC_CHAR:
                 sz      = attIt->second.attLen;
                 attData = (char*)malloc( sz );
                 success = NCFUNC( get_att_text )( _fileId, attIt->second.attVarId, attIt->second.attName.c_str(),
                                                   (char*)attData );
                 if( success )
                     MB_SET_ERR( MB_FAILURE, "Failed to read byte/char data for attribute " << attIt->second.attName );
                 ssAtt << "char;";
                 break;
             case NC_SHORT:
                 sz      = attIt->second.attLen * sizeof( short );
                 attData = (short*)malloc( sz );
                 success = NCFUNC( get_att_short )( _fileId, attIt->second.attVarId, attIt->second.attName.c_str(),
                                                    (short*)attData );
                 if( success )
                     MB_SET_ERR( MB_FAILURE, "Failed to read short data for attribute " << attIt->second.attName );
                 ssAtt << "short;";
                 break;
             case NC_INT:
                 sz      = attIt->second.attLen * sizeof( int );
                 attData = (int*)malloc( sz );
                 success = NCFUNC( get_att_int )( _fileId, attIt->second.attVarId, attIt->second.attName.c_str(),
                                                  (int*)attData );
                 if( success )
                     MB_SET_ERR( MB_FAILURE, "Failed to read int data for attribute " << attIt->second.attName );
                 ssAtt << "int;";
                 break;
             case NC_INT64:  // be careful here
                 sz      = attIt->second.attLen * sizeof( long );
                 attData = (long*)malloc( sz );
                 success = NCFUNC( get_att_long )( _fileId, attIt->second.attVarId, attIt->second.attName.c_str(),
                                                   (long*)attData );
                 if( success )
                     MB_SET_ERR( MB_FAILURE, "Failed to read int data for attribute " << attIt->second.attName );
                 ssAtt << "long;";
                 break;
             case NC_FLOAT:
                 sz      = attIt->second.attLen * sizeof( float );
                 attData = (float*)malloc( sz );
                 success = NCFUNC( get_att_float )( _fileId, attIt->second.attVarId, attIt->second.attName.c_str(),
                                                    (float*)attData );
                 if( success )
                     MB_SET_ERR( MB_FAILURE, "Failed to read float data for attribute " << attIt->second.attName );
                 ssAtt << "float;";
                 break;
             case NC_DOUBLE:
                 sz      = attIt->second.attLen * sizeof( double );
                 attData = (double*)malloc( sz );
                 success = NCFUNC( get_att_double )( _fileId, attIt->second.attVarId, attIt->second.attName.c_str(),
                                                     (double*)attData );
                 if( success )
                     MB_SET_ERR( MB_FAILURE, "Failed to read double data for attribute " << attIt->second.attName );
                 ssAtt << "double;";
                 break;
             default:
                 MB_SET_ERR( MB_FAILURE, "Unexpected data type for attribute " << attIt->second.attName );
         }
         char* tmpc = (char*)attData;
         for( unsigned int counter = 0; counter != sz; ++counter )
             ssAtt << tmpc[counter];
         free( attData );
         ssAtt << ';';
         attLen.push_back( ssAtt.str().size() - 1 );
     }
     attVal = ssAtt.str();
  
     return MB_SUCCESS;
 }

References _fileId, MB_SET_ERR, MB_SUCCESS, and NCFUNC.

Referenced by create_conventional_tags().

◆ create_conventional_tags()

ErrorCode moab::NCHelper::create_conventional_tags ( const std::vector< int > & tstep_nums )

Create NC conventional tags.

Definition at line 120 of file NCHelper.cpp.

 {
     Interface*& mbImpl                                   = _readNC->mbImpl;
     std::vector< std::string >& dimNames                 = _readNC->dimNames;
     std::vector< int >& dimLens                          = _readNC->dimLens;
     std::map< std::string, ReadNC::AttData >& globalAtts = _readNC->globalAtts;
     std::map< std::string, ReadNC::VarData >& varInfo    = _readNC->varInfo;
     DebugOutput& dbgOut                                  = _readNC->dbgOut;
     int& partMethod                                      = _readNC->partMethod;
     ScdInterface* scdi                                   = _readNC->scdi;
  
     ErrorCode rval;
     std::string tag_name;
  
     // <__NUM_DIMS>
     Tag numDimsTag = 0;
     tag_name       = "__NUM_DIMS";
     int numDims    = dimNames.size();
     rval = mbImpl->tag_get_handle( tag_name.c_str(), 1, MB_TYPE_INTEGER, numDimsTag, MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     rval = mbImpl->tag_set_data( numDimsTag, &_fileSet, 1, &numDims );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // <__NUM_VARS>
     Tag numVarsTag = 0;
     tag_name       = "__NUM_VARS";
     int numVars    = varInfo.size();
     rval = mbImpl->tag_get_handle( tag_name.c_str(), 1, MB_TYPE_INTEGER, numVarsTag, MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     rval = mbImpl->tag_set_data( numVarsTag, &_fileSet, 1, &numVars );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // <__DIM_NAMES>
     Tag dimNamesTag = 0;
     tag_name        = "__DIM_NAMES";
     std::string dimnames;
     unsigned int dimNamesSz = dimNames.size();
     for( unsigned int i = 0; i != dimNamesSz; i++ )
     {
         dimnames.append( dimNames[i] );
         dimnames.push_back( '\0' );
     }
     int dimnamesSz = dimnames.size();
     rval           = mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, dimNamesTag,
                                              MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     const void* ptr = dimnames.c_str();
     rval            = mbImpl->tag_set_by_ptr( dimNamesTag, &_fileSet, 1, &ptr, &dimnamesSz );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // <__DIM_LENS>
     Tag dimLensTag = 0;
     tag_name       = "__DIM_LENS";
     int dimLensSz  = dimLens.size();
     rval           = mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_INTEGER, dimLensTag,
                                              MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     ptr  = &( dimLens[0] );
     rval = mbImpl->tag_set_by_ptr( dimLensTag, &_fileSet, 1, &ptr, &dimLensSz );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // <__VAR_NAMES>
     Tag varNamesTag = 0;
     tag_name        = "__VAR_NAMES";
     std::string varnames;
     std::map< std::string, ReadNC::VarData >::iterator mapIter;
     for( mapIter = varInfo.begin(); mapIter != varInfo.end(); ++mapIter )
     {
         varnames.append( mapIter->first );
         varnames.push_back( '\0' );
     }
     int varnamesSz = varnames.size();
     rval           = mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, varNamesTag,
                                              MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     ptr  = varnames.c_str();
     rval = mbImpl->tag_set_by_ptr( varNamesTag, &_fileSet, 1, &ptr, &varnamesSz );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // __<dim_name>_LOC_MINMAX (for time)
     for( unsigned int i = 0; i != dimNamesSz; i++ )
     {
         if( dimNames[i] == "time" || dimNames[i] == "Time" || dimNames[i] == "t" )
         {
             // some files might have Time dimension as 0, it will not appear in any
             // variables, so skip it
             if( nTimeSteps == 0 ) continue;
             std::stringstream ss_tag_name;
             ss_tag_name << "__" << dimNames[i] << "_LOC_MINMAX";
             tag_name = ss_tag_name.str();
             Tag tagh = 0;
             std::vector< int > val( 2, 0 );
             val[0] = 0;
             val[1] = nTimeSteps - 1;
             rval   = mbImpl->tag_get_handle( tag_name.c_str(), 2, MB_TYPE_INTEGER, tagh, MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
             rval = mbImpl->tag_set_data( tagh, &_fileSet, 1, &val[0] );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
             dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
         }
     }
  
     // __<dim_name>_LOC_VALS (for time)
     for( unsigned int i = 0; i != dimNamesSz; i++ )
     {
         if( dimNames[i] == "time" || dimNames[i] == "Time" || dimNames[i] == "t" )
         {
             std::vector< int > val;
             if( !tstep_nums.empty() )
                 val = tstep_nums;
             else
             {
                 // some files might have Time dimension as 0, it will not appear in any
                 // variables, so skip it
                 if( tVals.empty() ) continue;
                 val.resize( tVals.size() );
                 for( unsigned int j = 0; j != tVals.size(); j++ )
                     val[j] = j;
             }
             Tag tagh = 0;
             std::stringstream ss_tag_name;
             ss_tag_name << "__" << dimNames[i] << "_LOC_VALS";
             tag_name = ss_tag_name.str();
             rval     = mbImpl->tag_get_handle( tag_name.c_str(), val.size(), MB_TYPE_INTEGER, tagh,
                                                MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
             rval = mbImpl->tag_set_data( tagh, &_fileSet, 1, &val[0] );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
             dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
         }
     }
  
     // __<var_name>_DIMS
     for( mapIter = varInfo.begin(); mapIter != varInfo.end(); ++mapIter )
     {
         Tag varNamesDimsTag = 0;
         std::stringstream ss_tag_name;
         ss_tag_name << "__" << mapIter->first << "_DIMS";
         tag_name              = ss_tag_name.str();
         unsigned int varDimSz = varInfo[mapIter->first].varDims.size();
         if( varDimSz == 0 ) continue;
         std::vector< Tag > varDimTags( varDimSz );
         for( unsigned int i = 0; i != varDimSz; i++ )
         {
             Tag tmptag             = 0;
             std::string tmptagname = dimNames[varInfo[mapIter->first].varDims[i]];
             rval = mbImpl->tag_get_handle( tmptagname.c_str(), 0, MB_TYPE_OPAQUE, tmptag, MB_TAG_ANY );MB_CHK_SET_ERR( rval, "Trouble getting tag " << tmptagname );
             varDimTags[i] = tmptag;
         }
         // rval = mbImpl->tag_get_handle(tag_name.c_str(), varDimSz, MB_TYPE_HANDLE,
         // varNamesDimsTag, MB_TAG_SPARSE | MB_TAG_CREAT); We should not use MB_TYPE_HANDLE for Tag
         // here. Tag is a pointer, which is 4 bytes on 32 bit machines and 8 bytes on 64 bit
         // machines. Normally, entity handle is 8 bytes on 64 bit machines, but it can also be
         // configured to 4 bytes.
         rval = mbImpl->tag_get_handle( tag_name.c_str(), varDimSz * sizeof( Tag ), MB_TYPE_OPAQUE, varNamesDimsTag,
                                        MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
         rval = mbImpl->tag_set_data( varNamesDimsTag, &_fileSet, 1, &( varDimTags[0] ) );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
         dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
     }
  
     // <PARTITION_METHOD>
     Tag part_tag = scdi->part_method_tag();
     if( !part_tag ) MB_SET_ERR( MB_FAILURE, "Trouble getting PARTITION_METHOD tag" );
     rval = mbImpl->tag_set_data( part_tag, &_fileSet, 1, &partMethod );MB_CHK_SET_ERR( rval, "Trouble setting data to PARTITION_METHOD tag" );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // <__GLOBAL_ATTRIBS>
     tag_name         = "__GLOBAL_ATTRIBS";
     Tag globalAttTag = 0;
     rval             = mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, globalAttTag,
                                                MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     std::string gattVal;
     std::vector< int > gattLen;
     rval = create_attrib_string( globalAtts, gattVal, gattLen );MB_CHK_SET_ERR( rval, "Trouble creating global attribute string" );
     const void* gattptr = gattVal.c_str();
     int globalAttSz     = gattVal.size();
     rval                = mbImpl->tag_set_by_ptr( globalAttTag, &_fileSet, 1, &gattptr, &globalAttSz );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // <__GLOBAL_ATTRIBS_LEN>
     tag_name            = "__GLOBAL_ATTRIBS_LEN";
     Tag globalAttLenTag = 0;
     if( gattLen.size() == 0 ) gattLen.push_back( 0 );
     rval = mbImpl->tag_get_handle( tag_name.c_str(), gattLen.size(), MB_TYPE_INTEGER, globalAttLenTag,
                                    MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     rval = mbImpl->tag_set_data( globalAttLenTag, &_fileSet, 1, &gattLen[0] );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // __<var_name>_ATTRIBS and __<var_name>_ATTRIBS_LEN
     for( mapIter = varInfo.begin(); mapIter != varInfo.end(); ++mapIter )
     {
         std::stringstream ssTagName;
         ssTagName << "__" << mapIter->first << "_ATTRIBS";
         tag_name      = ssTagName.str();
         Tag varAttTag = 0;
         rval          = mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, varAttTag,
                                                 MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
  
         std::string varAttVal;
         std::vector< int > varAttLen;
         if( mapIter->second.numAtts < 1 )
         {
             if( dummyVarNames.find( mapIter->first ) != dummyVarNames.end() )
             {
                 // This variable is a dummy coordinate variable
                 varAttVal = "DUMMY_VAR";
             }
             else
             {
                 // This variable has no attributes
                 varAttVal = "NO_ATTRIBS";
             }
         }
         else
         {
             rval = create_attrib_string( mapIter->second.varAtts, varAttVal, varAttLen );MB_CHK_SET_ERR( rval, "Trouble creating attribute string for variable " << mapIter->first );
         }
         const void* varAttPtr = varAttVal.c_str();
         int varAttSz          = varAttVal.size();
         if( 0 == varAttSz ) varAttSz = 1;
         rval = mbImpl->tag_set_by_ptr( varAttTag, &_fileSet, 1, &varAttPtr, &varAttSz );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
         dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
         ssTagName << "_LEN";
         tag_name         = ssTagName.str();
         Tag varAttLenTag = 0;
         if( 0 == varAttLen.size() ) varAttLen.push_back( 0 );
         rval = mbImpl->tag_get_handle( tag_name.c_str(), varAttLen.size(), MB_TYPE_INTEGER, varAttLenTag,
                                        MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
         rval = mbImpl->tag_set_data( varAttLenTag, &_fileSet, 1, &varAttLen[0] );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
         dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
     }
  
     // <__VAR_NAMES_LOCATIONS>
     tag_name            = "__VAR_NAMES_LOCATIONS";
     Tag varNamesLocsTag = 0;
     std::vector< int > varNamesLocs( varInfo.size() );
     rval = mbImpl->tag_get_handle( tag_name.c_str(), varNamesLocs.size(), MB_TYPE_INTEGER, varNamesLocsTag,
                                    MB_TAG_CREAT | MB_TAG_SPARSE );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     for( mapIter = varInfo.begin(); mapIter != varInfo.end(); ++mapIter )
     {
         varNamesLocs[std::distance( varInfo.begin(), mapIter )] = mapIter->second.entLoc;
     }
     rval = mbImpl->tag_set_data( varNamesLocsTag, &_fileSet, 1, &varNamesLocs[0] );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     // <__MESH_TYPE>
     Tag meshTypeTag          = 0;
     tag_name                 = "__MESH_TYPE";
     std::string meshTypeName = get_mesh_type_name();
  
     rval = mbImpl->tag_get_handle( tag_name.c_str(), 0, MB_TYPE_OPAQUE, meshTypeTag,
                                    MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating conventional tag " << tag_name );
     ptr      = meshTypeName.c_str();
     int leng = meshTypeName.size();
     rval     = mbImpl->tag_set_by_ptr( meshTypeTag, &_fileSet, 1, &ptr, &leng );MB_CHK_SET_ERR( rval, "Trouble setting data to conventional tag " << tag_name );
     dbgOut.tprintf( 2, "Conventional tag %s created\n", tag_name.c_str() );
  
     return MB_SUCCESS;
 }

References _fileSet, _readNC, create_attrib_string(), moab::ReadNC::dbgOut, moab::ReadNC::dimLens, moab::ReadNC::dimNames, dummyVarNames, ErrorCode, get_mesh_type_name(), moab::ReadNC::globalAtts, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_ANY, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TAG_VARLEN, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, moab::ReadNC::mbImpl, nTimeSteps, moab::ScdInterface::part_method_tag(), moab::ReadNC::partMethod, moab::ReadNC::scdi, moab::Interface::tag_get_handle(), moab::Interface::tag_set_by_ptr(), moab::Interface::tag_set_data(), moab::DebugOutput::tprintf(), tVals, and moab::ReadNC::varInfo.

Referenced by moab::ReadNC::load_file().

◆ create_dummy_variables()

ErrorCode moab::NCHelper::create_dummy_variables ( )

protected

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.

Definition at line 819 of file NCHelper.cpp.

 {
     Interface*& mbImpl                                = _readNC->mbImpl;
     std::vector< std::string >& dimNames              = _readNC->dimNames;
     std::vector< int >& dimLens                       = _readNC->dimLens;
     std::map< std::string, ReadNC::VarData >& varInfo = _readNC->varInfo;
     DebugOutput& dbgOut                               = _readNC->dbgOut;
  
     // Hack: look at all dimensions, and see if we have one that does not appear in the list of
     // varInfo names Right now, candidates are from unstructured meshes, such as ncol (HOMME) and
     // nCells (MPAS) For each of them, create a dummy coordinate variable with a sparse tag to store
     // the dimension length
     for( unsigned int i = 0; i < dimNames.size(); i++ )
     {
         // If there is a variable with this dimension name, skip
         if( varInfo.find( dimNames[i] ) != varInfo.end() ) continue;
  
         // Create a dummy coordinate variable
         int sizeTotalVar = varInfo.size();
         std::string var_name( dimNames[i] );
         ReadNC::VarData& data = varInfo[var_name];
         data.varName          = var_name;
         data.varId            = sizeTotalVar;
         data.varTags.resize( 1, 0 );
         data.varDataType = NC_INT;
         data.varDims.resize( 1 );
         data.varDims[0] = (int)i;
         data.numAtts    = 0;
         data.entLoc     = ReadNC::ENTLOCSET;
         dummyVarNames.insert( var_name );
         dbgOut.tprintf( 2, "Dummy coordinate variable created for dimension %s\n", var_name.c_str() );
  
         // Create a corresponding sparse tag
         Tag tagh;
         ErrorCode rval = mbImpl->tag_get_handle( var_name.c_str(), 0, MB_TYPE_INTEGER, tagh,
                                                  MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating tag for dummy coordinate variable " << var_name );
  
         // Tag value is the dimension length
         const void* ptr = &dimLens[i];
         // Tag size is 1
         int size = 1;
         rval     = mbImpl->tag_set_by_ptr( tagh, &_fileSet, 1, &ptr, &size );MB_CHK_SET_ERR( rval, "Trouble setting tag data for dummy coordinate variable " << var_name );
  
         dbgOut.tprintf( 2, "Sparse tag created for dimension %s\n", var_name.c_str() );
     }
  
     return MB_SUCCESS;
 }

References _fileSet, _readNC, moab::ReadNC::dbgOut, moab::ReadNC::dimLens, moab::ReadNC::dimNames, dummyVarNames, moab::ReadNC::VarData::entLoc, moab::ReadNC::ENTLOCSET, ErrorCode, MB_CHK_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TAG_VARLEN, MB_TYPE_INTEGER, moab::ReadNC::mbImpl, moab::ReadNC::VarData::numAtts, size, moab::Interface::tag_get_handle(), moab::Interface::tag_set_by_ptr(), moab::DebugOutput::tprintf(), moab::ReadNC::VarData::varDataType, moab::ReadNC::VarData::varDims, moab::ReadNC::VarData::varId, moab::ReadNC::varInfo, moab::ReadNC::VarData::varName, and moab::ReadNC::VarData::varTags.

Referenced by moab::NCHelperESMF::init_mesh_vals(), moab::NCHelperEuler::init_mesh_vals(), moab::NCHelperFV::init_mesh_vals(), moab::NCHelperGCRM::init_mesh_vals(), moab::NCHelperHOMME::init_mesh_vals(), and moab::NCHelperMPAS::init_mesh_vals().

◆ create_mesh()

virtual ErrorCode moab::NCHelper::create_mesh ( Range & faces )

pure virtual

Implemented in moab::NCHelperScrip, moab::NCHelperMPAS, moab::NCHelperHOMME, moab::NCHelperGCRM, moab::NCHelperESMF, moab::NCHelperDomain, and moab::ScdNCHelper.

Referenced by moab::ReadNC::load_file().

◆ get_default_ncformat_options()

std::string moab::NCHelper::get_default_ncformat_options ( ReadNC::NCFormatType format )

static

Get appropriate format to read the file.

Get appropriate file read options depending on the format of the NC file.

Definition at line 66 of file NCHelper.cpp.

 {
     switch( format )
     {
         case moab::ReadNC::NC_FORMAT_GCRM:  // GCRM format reader
         case moab::ReadNC::NC_FORMAT_MPAS:  // MPAS format reader
             return "PARALLEL=READ_PART;PARTITION_METHOD=RCBZOLTAN;"
                    "PARALLEL_RESOLVE_SHARED_ENTS;NO_EDGES;NO_MIXED_ELEMENTS;VARIABLE=;";
         case moab::ReadNC::NC_FORMAT_SCRIP:  // SCRIP format reader
             return "PARALLEL=READ_PART;PARTITION_METHOD=RCBZOLTAN;";
         case moab::ReadNC::NC_FORMAT_ESMF:  // ESMF unstructured format reader
             return "PARALLEL=READ_PART;PARTITION_METHOD=RCBZOLTAN;PARALLEL_RESOLVE_SHARED_ENTS;VARIABLE=;";
         case moab::ReadNC::NC_FORMAT_DOMAIN:  // Climate Domain reader
             return "PARALLEL=READ_PART;PARTITION_METHOD=SQIJ;VARIABLE=;";
         case moab::ReadNC::NC_FORMAT_HOMME:  // HOMME format reader
             return "PARALLEL=READ_PART;PARTITION_METHOD=TRIVIAL;PARALLEL_RESOLVE_SHARED_ENTS;";
         case moab::ReadNC::NC_FORMAT_EULER:  // Euler format reader
         case moab::ReadNC::NC_FORMAT_FV:     // FV climate format reader
             return "PARALLEL=READ_PART;PARTITION;PARALLEL_RESOLVE_SHARED_ENTS;"
                    "PARTITION_METHOD=SQIJ;VARIABLE=;";
         default:
             return "PARALLEL=READ_PART;PARTITION_METHOD=RCBZOLTAN;PARALLEL_RESOLVE_SHARED_ENTS;";
     }
 }

References moab::ReadNC::NC_FORMAT_DOMAIN, moab::ReadNC::NC_FORMAT_ESMF, moab::ReadNC::NC_FORMAT_EULER, moab::ReadNC::NC_FORMAT_FV, moab::ReadNC::NC_FORMAT_GCRM, moab::ReadNC::NC_FORMAT_HOMME, moab::ReadNC::NC_FORMAT_MPAS, and moab::ReadNC::NC_FORMAT_SCRIP.

◆ get_mesh_type_name()

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

pure virtual

Implemented in moab::NCHelperScrip, moab::NCHelperMPAS, moab::NCHelperHOMME, moab::NCHelperGCRM, moab::NCHelperFV, moab::NCHelperEuler, moab::NCHelperESMF, and moab::NCHelperDomain.

Referenced by create_conventional_tags().

◆ get_nc_format()

ReadNC::NCFormatType moab::NCHelper::get_nc_format	(	ReadNC *	readNC,
		int	fileId
	)

static

Get appropriate format to read the file.

Definition at line 24 of file NCHelper.cpp.

 {
     // Check if CF convention is being followed
     bool is_CF = false;
  
     std::map< std::string, ReadNC::AttData >& globalAtts     = readNC->globalAtts;
     std::map< std::string, ReadNC::AttData >::iterator attIt = globalAtts.find( "conventions" );
     if( attIt == globalAtts.end() ) attIt = globalAtts.find( "Conventions" );
  
     if( attIt != globalAtts.end() )
     {
         unsigned int sz = attIt->second.attLen;
         std::string att_data;
         att_data.resize( sz + 1 );
         att_data[sz] = '\000';
         int success =
             NCFUNC( get_att_text )( fileId, attIt->second.attVarId, attIt->second.attName.c_str(), &att_data[0] );
         if( 0 == success && att_data.find( "CF" ) != std::string::npos ) is_CF = true;
     }
  
     // Depending on the format, update FileOptions as well
     if( NCHelperMPAS::can_read_file( readNC ) )
         return ReadNC::NC_FORMAT_MPAS;
     else if( NCHelperScrip::can_read_file( readNC, fileId ) )
         return ReadNC::NC_FORMAT_SCRIP;
     else if( NCHelperESMF::can_read_file( readNC ) )
         return ReadNC::NC_FORMAT_ESMF;
     else if( NCHelperDomain::can_read_file( readNC, fileId ) ) // && is_CF )
         return ReadNC::NC_FORMAT_DOMAIN;
     else if( NCHelperHOMME::can_read_file( readNC, fileId ) )
         return ReadNC::NC_FORMAT_HOMME;
     else if( NCHelperEuler::can_read_file( readNC, fileId ) && is_CF )
         return ReadNC::NC_FORMAT_EULER;
     else if( NCHelperGCRM::can_read_file( readNC ) )
         return ReadNC::NC_FORMAT_GCRM;
     else if( NCHelperFV::can_read_file( readNC, fileId ) && is_CF )
         return ReadNC::NC_FORMAT_FV;
     else  // Unknown NetCDF grid (will fill this in later for POP, CICE and CLM)
         return ReadNC::NC_FORMAT_UNKNOWN_TYPE;
 }

Referenced by get_nc_helper().

◆ get_nc_helper()

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

static

Get appropriate helper instance for ReadNC class.

Definition at line 91 of file NCHelper.cpp.

 {
     ReadNC::NCFormatType nctype = NCHelper::get_nc_format( readNC, fileId );
  
     switch( nctype )
     {
         case ReadNC::NC_FORMAT_MPAS:  // MPAS format reader
             return new( std::nothrow ) NCHelperMPAS( readNC, fileId, opts, fileSet );
         case ReadNC::NC_FORMAT_SCRIP:  // SCRIP format reader
             // SCRIP can be CF or non CF, if it comes from MPAS :)
             return new( std::nothrow ) NCHelperScrip( readNC, fileId, opts, fileSet );
         case ReadNC::NC_FORMAT_ESMF:  // ESMF unstructured format reader
             return new( std::nothrow ) NCHelperESMF( readNC, fileId, opts, fileSet );
         case ReadNC::NC_FORMAT_DOMAIN:  // Climate Domain reader
             return new( std::nothrow ) NCHelperDomain( readNC, fileId, opts, fileSet );
         case ReadNC::NC_FORMAT_HOMME:  // HOMME format reader
             // For a HOMME connectivity file, there might be no CF convention
             return new( std::nothrow ) NCHelperHOMME( readNC, fileId, opts, fileSet );
         case ReadNC::NC_FORMAT_GCRM:  // GCRM format reader
             return new( std::nothrow ) NCHelperGCRM( readNC, fileId, opts, fileSet );
         case ReadNC::NC_FORMAT_EULER:  // Euler format reader
             return new( std::nothrow ) NCHelperEuler( readNC, fileId, opts, fileSet );
         case ReadNC::NC_FORMAT_FV:  // FV climate format reader
             return new( std::nothrow ) NCHelperFV( readNC, fileId, opts, fileSet );
         default:  // Unknown NetCDF grid (will fill this in later for POP, CICE and CLM)
             return nullptr;
     }
 }

References get_nc_format(), moab::ReadNC::NC_FORMAT_DOMAIN, moab::ReadNC::NC_FORMAT_ESMF, moab::ReadNC::NC_FORMAT_EULER, moab::ReadNC::NC_FORMAT_FV, moab::ReadNC::NC_FORMAT_GCRM, moab::ReadNC::NC_FORMAT_HOMME, moab::ReadNC::NC_FORMAT_MPAS, and moab::ReadNC::NC_FORMAT_SCRIP.

Referenced by moab::ReadNC::load_file().

◆ get_tag_to_nonset()

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

protected

Definition at line 694 of file NCHelper.cpp.

 {
     Interface*& mbImpl  = _readNC->mbImpl;
     DebugOutput& dbgOut = _readNC->dbgOut;
     int& tStepBase      = _readNC->tStepBase;
  
     if( tStepBase > 0 ) tstep_num += tStepBase;
  
     std::ostringstream tag_name;
     tag_name << var_data.varName << tstep_num;
  
     ErrorCode rval = MB_SUCCESS;
     tagh           = 0;
     switch( var_data.varDataType )
     {
         case NC_BYTE:
         case NC_CHAR:
             rval = mbImpl->tag_get_handle( tag_name.str().c_str(), num_lev, MB_TYPE_OPAQUE, tagh,
                                            MB_TAG_DENSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating tag " << tag_name.str() );
             break;
         case NC_SHORT:
         case NC_INT:
         case NC_INT64:
             rval = mbImpl->tag_get_handle( tag_name.str().c_str(), num_lev, MB_TYPE_INTEGER, tagh,
                                            MB_TAG_DENSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating tag " << tag_name.str() );
             break;
         case NC_FLOAT:
         case NC_DOUBLE:
             rval = mbImpl->tag_get_handle( tag_name.str().c_str(), num_lev, MB_TYPE_DOUBLE, tagh,
                                            MB_TAG_DENSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Trouble creating tag " << tag_name.str() );
             break;
         default:
             MB_SET_ERR( MB_FAILURE, "Unexpected data type for variable " << var_data.varName );
     }
  
     dbgOut.tprintf( 2, "Tag %s created\n", tag_name.str().c_str() );
  
     return rval;
 }

References _readNC, moab::ReadNC::dbgOut, ErrorCode, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, moab::ReadNC::mbImpl, moab::Interface::tag_get_handle(), moab::DebugOutput::tprintf(), moab::ReadNC::tStepBase, moab::ReadNC::VarData::varDataType, and moab::ReadNC::VarData::varName.

Referenced by moab::ScdNCHelper::read_scd_variables_to_nonset_allocate(), moab::NCHelperGCRM::read_ucd_variables_to_nonset_allocate(), moab::NCHelperHOMME::read_ucd_variables_to_nonset_allocate(), and moab::NCHelperMPAS::read_ucd_variables_to_nonset_allocate().

◆ get_tag_to_set()

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

protected

Definition at line 651 of file NCHelper.cpp.

 {
     Interface*& mbImpl  = _readNC->mbImpl;
     DebugOutput& dbgOut = _readNC->dbgOut;
     int& tStepBase      = _readNC->tStepBase;
  
     if( tStepBase > 0 ) tstep_num += tStepBase;
  
     std::ostringstream tag_name;
     if( var_data.has_tsteps )
         tag_name << var_data.varName << tstep_num;
     else
         tag_name << var_data.varName;
  
     ErrorCode rval = MB_SUCCESS;
     tagh           = 0;
     switch( var_data.varDataType )
     {
         case NC_BYTE:
         case NC_CHAR:
             rval = mbImpl->tag_get_handle( tag_name.str().c_str(), 0, MB_TYPE_OPAQUE, tagh,
                                            MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating tag " << tag_name.str() );
             break;
         case NC_SHORT:
         case NC_INT:
         case NC_INT64:  //  this is a big stretch; we should introduce LONG tag
             rval = mbImpl->tag_get_handle( tag_name.str().c_str(), 0, MB_TYPE_INTEGER, tagh,
                                            MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating tag " << tag_name.str() );
             break;
         case NC_FLOAT:
         case NC_DOUBLE:
             rval = mbImpl->tag_get_handle( tag_name.str().c_str(), 0, MB_TYPE_DOUBLE, tagh,
                                            MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble creating tag " << tag_name.str() );
             break;
         default:
             MB_SET_ERR( MB_FAILURE, "Unexpected data type for variable " << var_data.varName );
     }
  
     dbgOut.tprintf( 2, "Tag %s created\n", tag_name.str().c_str() );
  
     return rval;
 }

References _readNC, moab::ReadNC::dbgOut, ErrorCode, moab::ReadNC::VarData::has_tsteps, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TAG_VARLEN, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, moab::ReadNC::mbImpl, moab::Interface::tag_get_handle(), moab::DebugOutput::tprintf(), moab::ReadNC::tStepBase, moab::ReadNC::VarData::varDataType, and moab::ReadNC::VarData::varName.

Referenced by read_variables_to_set_allocate().

◆ init_mesh_vals()

virtual ErrorCode moab::NCHelper::init_mesh_vals ( )

pure virtual

Interfaces to be implemented in child classes.

Implemented in moab::NCHelperScrip, moab::NCHelperMPAS, moab::NCHelperHOMME, moab::NCHelperGCRM, moab::NCHelperFV, moab::NCHelperEuler, moab::NCHelperESMF, and moab::NCHelperDomain.

Referenced by moab::ReadNC::load_file().

◆ read_coordinate()

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

protected

Definition at line 619 of file NCHelper.cpp.

 {
     std::map< std::string, ReadNC::VarData >& varInfo       = _readNC->varInfo;
     std::map< std::string, ReadNC::VarData >::iterator vmit = varInfo.find( var_name );
     if( varInfo.end() == vmit ) MB_SET_ERR( MB_FAILURE, "Couldn't find variable " << var_name );
  
     assert( lmin >= 0 && lmax >= lmin );
     NCDF_SIZE tstart     = lmin;
     NCDF_SIZE tcount     = lmax - lmin + 1;
     NCDF_DIFF dum_stride = 1;
     int success;
  
     // Check size
     if( (std::size_t)tcount != cvals.size() ) cvals.resize( tcount );
  
     // Check to make sure it's a float or double
     switch( ( *vmit ).second.varDataType )
     {
         case NC_FLOAT:
         case NC_DOUBLE:
             // Read float as double
             success =
                 NCFUNCAG( _vars_double )( _fileId, ( *vmit ).second.varId, &tstart, &tcount, &dum_stride, &cvals[0] );
             if( success ) MB_SET_ERR( MB_FAILURE, "Failed to read float/double data for variable " << var_name );
             break;
         default:
             MB_SET_ERR( MB_FAILURE, "Unexpected data type for variable " << var_name );
     }
  
     return MB_SUCCESS;
 }

References _fileId, _readNC, MB_SET_ERR, MB_SUCCESS, NCDF_DIFF, NCDF_SIZE, NCFUNCAG, and moab::ReadNC::varInfo.

Referenced by moab::NCHelperGCRM::create_local_vertices(), moab::NCHelperEuler::init_mesh_vals(), moab::NCHelperFV::init_mesh_vals(), moab::NCHelperGCRM::init_mesh_vals(), moab::NCHelperHOMME::init_mesh_vals(), and moab::NCHelperMPAS::init_mesh_vals().

◆ read_variables()

virtual ErrorCode moab::NCHelper::read_variables	(	std::vector< std::string > &	var_names,
		std::vector< int > &	tstep_nums
	)

pure virtual

Implemented in moab::UcdNCHelper, and moab::ScdNCHelper.

Referenced by moab::ReadNC::load_file().

◆ read_variables_setup()

ErrorCode moab::NCHelper::read_variables_setup	(	std::vector< std::string > &	var_names,
		std::vector< int > &	tstep_nums,
		std::vector< ReadNC::VarData > &	vdatas,
		std::vector< ReadNC::VarData > &	vsetdatas
	)

protected

Separate set and non-set variables (common to scd mesh and ucd mesh)

Definition at line 421 of file NCHelper.cpp.

 {
     std::map< std::string, ReadNC::VarData >& varInfo = _readNC->varInfo;
     std::vector< std::string >& dimNames              = _readNC->dimNames;
  
     std::map< std::string, ReadNC::VarData >::iterator mit;
  
     // If empty read them all (except ignored variables)
     if( var_names.empty() )
     {
         for( mit = varInfo.begin(); mit != varInfo.end(); ++mit )
         {
             ReadNC::VarData vd = ( *mit ).second;
  
             // If read all variables at once, skip ignored ones
             if( ignoredVarNames.find( vd.varName ) != ignoredVarNames.end() ) continue;
  
             // Coordinate variables (include dummy ones) were read to the file set by default
             if( std::find( dimNames.begin(), dimNames.end(), vd.varName ) != dimNames.end() ) continue;
  
             if( vd.entLoc == ReadNC::ENTLOCSET )
                 vsetdatas.push_back( vd );
             else
                 vdatas.push_back( vd );
         }
     }
     else
     {
         // Read specified variables (might include ignored ones)
         for( unsigned int i = 0; i < var_names.size(); i++ )
         {
             mit = varInfo.find( var_names[i] );
             if( mit != varInfo.end() )
             {
                 ReadNC::VarData vd = ( *mit ).second;
  
                 // Upon creation of dummy coordinate variables, tag values have already been set
                 if( dummyVarNames.find( vd.varName ) != dummyVarNames.end() ) continue;
  
                 if( vd.entLoc == ReadNC::ENTLOCSET )
                     vsetdatas.push_back( vd );
                 else
                     vdatas.push_back( vd );
             }
             else
             {
                 MB_SET_ERR( MB_FAILURE, "Couldn't find specified variable " << var_names[i] );
             }
         }
     }
  
     if( tstep_nums.empty() && nTimeSteps > 0 )
     {
         // No timesteps input, get them all
         for( int i = 0; i < nTimeSteps; i++ )
             tstep_nums.push_back( i );
     }
  
     if( !tstep_nums.empty() )
     {
         for( unsigned int i = 0; i < vdatas.size(); i++ )
         {
             vdatas[i].varTags.resize( tstep_nums.size(), 0 );
             vdatas[i].varDatas.resize( tstep_nums.size() );
             // NC reader assumes that non-set variables always have timesteps
             assert( std::find( vdatas[i].varDims.begin(), vdatas[i].varDims.end(), tDim ) != vdatas[i].varDims.end() );
             vdatas[i].has_tsteps = true;
         }
  
         for( unsigned int i = 0; i < vsetdatas.size(); i++ )
         {
             if( ( std::find( vsetdatas[i].varDims.begin(), vsetdatas[i].varDims.end(), tDim ) !=
                   vsetdatas[i].varDims.end() ) &&
                 ( vsetdatas[i].varName != dimNames[tDim] ) )
             {
                 // Set variables with timesteps: e.g. xtime(Time) or xtime(Time, StrLen)
                 vsetdatas[i].varTags.resize( tstep_nums.size(), 0 );
                 vsetdatas[i].varDatas.resize( tstep_nums.size() );
                 vsetdatas[i].has_tsteps = true;
             }
             else
             {
                 // Set variables without timesteps: no time dimension, or time itself
                 vsetdatas[i].varTags.resize( 1, 0 );
                 vsetdatas[i].varDatas.resize( 1 );
                 vsetdatas[i].has_tsteps = false;
             }
         }
     }
  
     return MB_SUCCESS;
 }

References _readNC, moab::ReadNC::dimNames, dummyVarNames, moab::ReadNC::VarData::entLoc, moab::ReadNC::ENTLOCSET, ignoredVarNames, MB_SET_ERR, MB_SUCCESS, nTimeSteps, tDim, moab::ReadNC::varInfo, and moab::ReadNC::VarData::varName.

Referenced by moab::ScdNCHelper::read_variables(), and moab::UcdNCHelper::read_variables().

◆ read_variables_to_set()

ErrorCode moab::NCHelper::read_variables_to_set	(	std::vector< ReadNC::VarData > &	vdatas,
		std::vector< int > &	tstep_nums
	)

protected

Read set variables (common to scd mesh and ucd mesh)

Definition at line 517 of file NCHelper.cpp.

 {
     Interface*& mbImpl  = _readNC->mbImpl;
     DebugOutput& dbgOut = _readNC->dbgOut;
  
     ErrorCode rval = read_variables_to_set_allocate( vdatas, tstep_nums );MB_CHK_SET_ERR( rval, "Trouble allocating space to read set variables" );
  
     // Finally, read into that space
     int success;
     for( unsigned int i = 0; i < vdatas.size(); i++ )
     {
         // Note, for set variables without timesteps, loop one time and then break
         for( unsigned int t = 0; t < tstep_nums.size(); t++ )
         {
             void* data = vdatas[i].varDatas[t];
  
             // Set variables with timesteps, e.g. xtime(Time) or xtime(Time, StrLen)
             if( vdatas[i].has_tsteps )
             {
                 // Set readStart for each timestep along time dimension
                 vdatas[i].readStarts[0] = tstep_nums[t];
             }
  
             switch( vdatas[i].varDataType )
             {
                 case NC_BYTE:
                 case NC_CHAR:
                     success = NCFUNCAG( _vara_text )( _fileId, vdatas[i].varId, &vdatas[i].readStarts[0],
                                                       &vdatas[i].readCounts[0], (char*)data );
                     if( success )
                         MB_SET_ERR( MB_FAILURE, "Failed to read byte/char data for variable " << vdatas[i].varName );
                     break;
                 case NC_SHORT:
                 case NC_INT:
                     success = NCFUNCAG( _vara_int )( _fileId, vdatas[i].varId, &vdatas[i].readStarts[0],
                                                      &vdatas[i].readCounts[0], (int*)data );
                     if( success )
                         MB_SET_ERR( MB_FAILURE, "Failed to read short/int data for variable " << vdatas[i].varName );
                     break;
                 case NC_INT64:
                     success = NCFUNCAG( _vara_long )( _fileId, vdatas[i].varId, &vdatas[i].readStarts[0],
                                                       &vdatas[i].readCounts[0], (long*)data );
                     if( success )
                         MB_SET_ERR( MB_FAILURE, "Failed to read long data for variable " << vdatas[i].varName );
                     break;
                 case NC_FLOAT:
                 case NC_DOUBLE:
                     success = NCFUNCAG( _vara_double )( _fileId, vdatas[i].varId, &vdatas[i].readStarts[0],
                                                         &vdatas[i].readCounts[0], (double*)data );
                     if( success )
                         MB_SET_ERR( MB_FAILURE, "Failed to read float/double data for variable " << vdatas[i].varName );
                     break;
                 default:
                     MB_SET_ERR( MB_FAILURE, "Unexpected data type for variable " << vdatas[i].varName );
             }
  
             dbgOut.tprintf( 2, "Setting data for variable %s, time step %d\n", vdatas[i].varName.c_str(),
                             tstep_nums[t] );
             rval = mbImpl->tag_set_by_ptr( vdatas[i].varTags[t], &_fileSet, 1, &data, &vdatas[i].sz );MB_CHK_SET_ERR( rval, "Trouble setting tag data for variable " << vdatas[i].varName );
  
             // Memory pointed by pointer data can be deleted, as tag_set_by_ptr() has already copied
             // the tag values
             switch( vdatas[i].varDataType )
             {
                 case NC_BYTE:
                 case NC_CHAR:
                     delete[](char*)data;
                     break;
                 case NC_SHORT:
                 case NC_INT:
                     delete[](int*)data;
                     break;
                 case NC_INT64:
                     delete[](long*)data;
                     break;
                 case NC_FLOAT:
                 case NC_DOUBLE:
                     delete[](double*)data;
                     break;
                 default:
                     break;
             }
             vdatas[i].varDatas[t] = NULL;
  
             // Loop continues only for set variables with timesteps, e.g. xtime(Time) or xtime(Time,
             // StrLen)
             if( !vdatas[i].has_tsteps ) break;
         }
     }
  
     // Debug output, if requested
     if( 1 == dbgOut.get_verbosity() )
     {
         dbgOut.printf( 1, "Read variables: %s", vdatas.begin()->varName.c_str() );
         for( unsigned int i = 1; i < vdatas.size(); i++ )
             dbgOut.printf( 1, ", %s ", vdatas[i].varName.c_str() );
         dbgOut.tprintf( 1, "\n" );
     }
  
     return rval;
 }

References _fileId, _fileSet, _readNC, moab::ReadNC::dbgOut, ErrorCode, moab::DebugOutput::get_verbosity(), MB_CHK_SET_ERR, MB_SET_ERR, moab::ReadNC::mbImpl, NCFUNCAG, moab::DebugOutput::printf(), read_variables_to_set_allocate(), moab::Interface::tag_set_by_ptr(), and moab::DebugOutput::tprintf().

Referenced by moab::ScdNCHelper::read_variables(), and moab::UcdNCHelper::read_variables().

◆ read_variables_to_set_allocate()

ErrorCode moab::NCHelper::read_variables_to_set_allocate	(	std::vector< ReadNC::VarData > &	vdatas,
		std::vector< int > &	tstep_nums
	)

private

Used by read_variables_to_set()

Definition at line 868 of file NCHelper.cpp.

 {
     std::vector< int >& dimLens = _readNC->dimLens;
     DebugOutput& dbgOut         = _readNC->dbgOut;
  
     ErrorCode rval = MB_SUCCESS;
  
     for( unsigned int i = 0; i < vdatas.size(); i++ )
     {
         // Set up readStarts and readCounts
         if( vdatas[i].has_tsteps )
         {
             // First: time
             vdatas[i].readStarts.push_back( 0 );  // This value is timestep dependent, will be set later
             vdatas[i].readCounts.push_back( 1 );
  
             // Next: other dimensions
             for( unsigned int idx = 1; idx != vdatas[i].varDims.size(); idx++ )
             {
                 vdatas[i].readStarts.push_back( 0 );
                 vdatas[i].readCounts.push_back( dimLens[vdatas[i].varDims[idx]] );
             }
         }
         else
         {
             if( vdatas[i].varDims.empty() )
             {
                 // Scalar variable
                 vdatas[i].readStarts.push_back( 0 );
                 vdatas[i].readCounts.push_back( 1 );
             }
             else
             {
                 for( unsigned int idx = 0; idx != vdatas[i].varDims.size(); idx++ )
                 {
                     vdatas[i].readStarts.push_back( 0 );
                     vdatas[i].readCounts.push_back( dimLens[vdatas[i].varDims[idx]] );
                 }
             }
         }
  
         // Get variable size
         vdatas[i].sz = 1;
         for( std::size_t idx = 0; idx != vdatas[i].readCounts.size(); idx++ )
             vdatas[i].sz *= vdatas[i].readCounts[idx];
  
         // Note, for set variables without timesteps, loop one time and then break
         for( unsigned int t = 0; t < tstep_nums.size(); t++ )
         {
             dbgOut.tprintf( 2, "Reading variable %s, time step %d\n", vdatas[i].varName.c_str(), tstep_nums[t] );
  
             if( tstep_nums[t] >= dimLens[tDim] )
             {
                 MB_SET_ERR( MB_INDEX_OUT_OF_RANGE, "Wrong value for timestep number " << tstep_nums[t] );
             }
  
             // Get the tag to read into
             if( !vdatas[i].varTags[t] )
             {
                 rval = get_tag_to_set( vdatas[i], tstep_nums[t], vdatas[i].varTags[t] );MB_CHK_SET_ERR( rval, "Trouble getting tag to set variable " << vdatas[i].varName );
             }
  
             switch( vdatas[i].varDataType )
             {
                 case NC_BYTE:
                 case NC_CHAR:
                     vdatas[i].varDatas[t] = new char[vdatas[i].sz];
                     break;
                 case NC_SHORT:
                 case NC_INT:
                     vdatas[i].varDatas[t] = new int[vdatas[i].sz];
                     break;
                 case NC_INT64:
                     vdatas[i].varDatas[t] = new long[vdatas[i].sz];
                     break;
                 case NC_FLOAT:
                 case NC_DOUBLE:
                     vdatas[i].varDatas[t] = new double[vdatas[i].sz];
                     break;
                 default:
                     MB_SET_ERR( MB_FAILURE, "Unexpected data type for variable " << vdatas[i].varName );
             }
  
             // Loop continues only for set variables with timesteps, e.g. xtime(Time) or xtime(Time,
             // StrLen)
             if( !vdatas[i].has_tsteps ) break;
         }
     }
  
     return rval;
 }

References _readNC, moab::ReadNC::dbgOut, moab::ReadNC::dimLens, ErrorCode, get_tag_to_set(), MB_CHK_SET_ERR, MB_INDEX_OUT_OF_RANGE, MB_SET_ERR, MB_SUCCESS, tDim, and moab::DebugOutput::tprintf().

Referenced by read_variables_to_set().

◆ update_time_tag_vals()

ErrorCode moab::NCHelper::update_time_tag_vals ( )

Update time tag values if timesteps spread across files.

Definition at line 372 of file NCHelper.cpp.

 {
     Interface*& mbImpl                   = _readNC->mbImpl;
     std::vector< std::string >& dimNames = _readNC->dimNames;
  
     ErrorCode rval;
  
     // The time tag might be a dummy one (e.g. 'Time' for MPAS)
     std::string time_tag_name = dimNames[tDim];
     if( dummyVarNames.find( time_tag_name ) != dummyVarNames.end() ) return MB_SUCCESS;
  
     Tag time_tag      = 0;
     const void* data  = NULL;
     int time_tag_size = 0;
     rval              = mbImpl->tag_get_handle( time_tag_name.c_str(), 0, MB_TYPE_DOUBLE, time_tag, MB_TAG_VARLEN );MB_CHK_SET_ERR( rval, "Trouble getting tag " << time_tag_name );
     rval = mbImpl->tag_get_by_ptr( time_tag, &_fileSet, 1, &data, &time_tag_size );MB_CHK_SET_ERR( rval, "Trouble getting data of tag " << time_tag_name );
     const double* time_tag_vals = static_cast< const double* >( data );
  
     // Merge tVals (read from current file) to existing time tag
     // Assume that time_tag_vals and tVals are both sorted
     std::vector< double > merged_time_vals;
     merged_time_vals.reserve( time_tag_size + nTimeSteps );
     int i = 0;
     int j = 0;
  
     // Merge time values from time_tag_vals and tVals
     while( i < time_tag_size && j < nTimeSteps )
     {
         if( time_tag_vals[i] < tVals[j] )
             merged_time_vals.push_back( time_tag_vals[i++] );
         else
             merged_time_vals.push_back( tVals[j++] );
     }
  
     // Append remaining time values of time_tag_vals (if any)
     while( i < time_tag_size )
         merged_time_vals.push_back( time_tag_vals[i++] );
  
     // Append remaining time values of tVals (if any)
     while( j < nTimeSteps )
         merged_time_vals.push_back( tVals[j++] );
  
     data          = &merged_time_vals[0];
     time_tag_size = merged_time_vals.size();
     rval          = mbImpl->tag_set_by_ptr( time_tag, &_fileSet, 1, &data, &time_tag_size );MB_CHK_SET_ERR( rval, "Trouble setting data to tag " << time_tag_name );
  
     return MB_SUCCESS;
 }

References _fileSet, _readNC, moab::ReadNC::dimNames, dummyVarNames, ErrorCode, MB_CHK_SET_ERR, MB_SUCCESS, MB_TAG_VARLEN, MB_TYPE_DOUBLE, moab::ReadNC::mbImpl, nTimeSteps, moab::Interface::tag_get_by_ptr(), moab::Interface::tag_get_handle(), moab::Interface::tag_set_by_ptr(), tDim, and tVals.

Referenced by moab::ReadNC::load_file().

Member Data Documentation

◆ _fileId

int moab::NCHelper::_fileId

protected

Cache some information from ReadNC.

Definition at line 109 of file NCHelper.hpp.

Referenced by create_attrib_string(), moab::NCHelperMPAS::create_gather_set_cells(), moab::NCHelperGCRM::create_gather_set_edges(), moab::NCHelperMPAS::create_gather_set_edges(), moab::NCHelperGCRM::create_gather_set_vertices(), moab::NCHelperMPAS::create_gather_set_vertices(), moab::NCHelperGCRM::create_local_edges(), moab::NCHelperMPAS::create_local_edges(), moab::NCHelperESMF::create_local_vertices(), moab::NCHelperGCRM::create_local_vertices(), moab::NCHelperMPAS::create_local_vertices(), moab::NCHelperDomain::create_mesh(), moab::NCHelperESMF::create_mesh(), moab::NCHelperGCRM::create_mesh(), moab::NCHelperMPAS::create_mesh(), moab::NCHelperScrip::create_mesh(), moab::NCHelperGCRM::create_padded_gather_set_cells(), moab::NCHelperMPAS::create_padded_gather_set_cells(), moab::NCHelperESMF::init_mesh_vals(), moab::NCHelperHOMME::init_mesh_vals(), moab::NCHelperScrip::init_mesh_vals(), read_coordinate(), moab::ScdNCHelper::read_scd_variables_to_nonset(), moab::NCHelperGCRM::read_ucd_variables_to_nonset(), moab::NCHelperHOMME::read_ucd_variables_to_nonset(), moab::NCHelperMPAS::read_ucd_variables_to_nonset(), and read_variables_to_set().

◆ _fileSet

EntityHandle moab::NCHelper::_fileSet

protected

Definition at line 111 of file NCHelper.hpp.

Referenced by moab::ScdNCHelper::check_existing_mesh(), moab::NCHelperGCRM::check_existing_mesh(), moab::NCHelperHOMME::check_existing_mesh(), moab::NCHelperMPAS::check_existing_mesh(), create_conventional_tags(), create_dummy_variables(), moab::NCHelperESMF::create_local_cells(), moab::NCHelperMPAS::create_local_cells(), moab::NCHelperGCRM::create_local_edges(), moab::NCHelperMPAS::create_local_edges(), moab::NCHelperESMF::create_local_vertices(), moab::NCHelperGCRM::create_local_vertices(), moab::NCHelperMPAS::create_local_vertices(), moab::ScdNCHelper::create_mesh(), moab::NCHelperDomain::create_mesh(), moab::NCHelperHOMME::create_mesh(), moab::NCHelperMPAS::create_mesh(), moab::NCHelperScrip::create_mesh(), moab::NCHelperESMF::create_padded_local_cells(), moab::NCHelperGCRM::create_padded_local_cells(), moab::NCHelperMPAS::create_padded_local_cells(), moab::ScdNCHelper::create_quad_coordinate_tag(), moab::NCHelperDomain::init_mesh_vals(), moab::NCHelperEuler::init_mesh_vals(), moab::NCHelperFV::init_mesh_vals(), moab::NCHelperScrip::init_mesh_vals(), moab::ScdNCHelper::read_scd_variables_to_nonset_allocate(), moab::NCHelperGCRM::read_ucd_variables_to_nonset_allocate(), moab::NCHelperHOMME::read_ucd_variables_to_nonset_allocate(), moab::NCHelperMPAS::read_ucd_variables_to_nonset_allocate(), read_variables_to_set(), and update_time_tag_vals().

◆ _opts

const FileOptions& moab::NCHelper::_opts

protected

Definition at line 110 of file NCHelper.hpp.

Referenced by moab::NCHelperHOMME::create_mesh(), moab::NCHelperEuler::init_mesh_vals(), and moab::NCHelperFV::init_mesh_vals().

◆ _readNC

ReadNC* moab::NCHelper::_readNC

protected

Allow NCHelper to directly access members of ReadNC.

Definition at line 106 of file NCHelper.hpp.

◆ dummyVarNames

std::set< std::string > moab::NCHelper::dummyVarNames

protected

Dummy variables.

Definition at line 126 of file NCHelper.hpp.

Referenced by create_conventional_tags(), create_dummy_variables(), read_variables_setup(), and update_time_tag_vals().

◆ ignoredVarNames

std::set< std::string > moab::NCHelper::ignoredVarNames

protected

Ignored variables.

Definition at line 123 of file NCHelper.hpp.

Referenced by moab::NCHelperMPAS::init_mesh_vals(), moab::NCHelperGCRM::NCHelperGCRM(), moab::NCHelperMPAS::NCHelperMPAS(), and read_variables_setup().

◆ levDim

int moab::NCHelper::levDim

protected

Definition at line 120 of file NCHelper.hpp.

Referenced by moab::NCHelperDomain::init_mesh_vals(), moab::NCHelperEuler::init_mesh_vals(), moab::NCHelperFV::init_mesh_vals(), moab::NCHelperGCRM::init_mesh_vals(), moab::NCHelperHOMME::init_mesh_vals(), and moab::NCHelperMPAS::init_mesh_vals().

◆ levVals

std::vector< double > moab::NCHelper::levVals

protected

Definition at line 117 of file NCHelper.hpp.

Referenced by moab::NCHelperGCRM::create_gather_set_vertices(), moab::NCHelperGCRM::create_local_vertices(), moab::ScdNCHelper::create_mesh(), moab::NCHelperHOMME::create_mesh(), and moab::NCHelperHOMME::init_mesh_vals().

◆ nLevels

int moab::NCHelper::nLevels

protected

Definition at line 114 of file NCHelper.hpp.

Referenced by moab::NCHelperGCRM::create_local_vertices(), moab::NCHelperDomain::init_mesh_vals(), moab::NCHelperEuler::init_mesh_vals(), moab::NCHelperFV::init_mesh_vals(), moab::NCHelperGCRM::init_mesh_vals(), moab::NCHelperHOMME::init_mesh_vals(), and moab::NCHelperMPAS::init_mesh_vals().

◆ nTimeSteps

int moab::NCHelper::nTimeSteps

protected

Dimensions of time and level.

Definition at line 114 of file NCHelper.hpp.

Referenced by create_conventional_tags(), moab::NCHelperDomain::init_mesh_vals(), moab::NCHelperEuler::init_mesh_vals(), moab::NCHelperFV::init_mesh_vals(), moab::NCHelperGCRM::init_mesh_vals(), moab::NCHelperHOMME::init_mesh_vals(), moab::NCHelperMPAS::init_mesh_vals(), read_variables_setup(), and update_time_tag_vals().

◆ tDim

int moab::NCHelper::tDim

protected

Dimension numbers for time and level.

Definition at line 120 of file NCHelper.hpp.

Referenced by moab::NCHelperDomain::init_mesh_vals(), moab::NCHelperEuler::init_mesh_vals(), moab::NCHelperFV::init_mesh_vals(), moab::NCHelperGCRM::init_mesh_vals(), moab::NCHelperHOMME::init_mesh_vals(), moab::NCHelperMPAS::init_mesh_vals(), moab::ScdNCHelper::read_scd_variables_to_nonset_allocate(), moab::NCHelperGCRM::read_ucd_variables_to_nonset_allocate(), moab::NCHelperHOMME::read_ucd_variables_to_nonset_allocate(), moab::NCHelperMPAS::read_ucd_variables_to_nonset_allocate(), read_variables_setup(), read_variables_to_set_allocate(), and update_time_tag_vals().

◆ tVals

std::vector< double > moab::NCHelper::tVals

protected

Values for time and level.

Definition at line 117 of file NCHelper.hpp.

Referenced by create_conventional_tags(), moab::NCHelperDomain::init_mesh_vals(), moab::NCHelperEuler::init_mesh_vals(), moab::NCHelperFV::init_mesh_vals(), moab::NCHelperGCRM::init_mesh_vals(), moab::NCHelperHOMME::init_mesh_vals(), moab::NCHelperMPAS::init_mesh_vals(), and update_time_tag_vals().

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

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ NCHelper()

◆ ~NCHelper()

Member Function Documentation

◆ check_existing_mesh()

◆ create_attrib_string()

◆ create_conventional_tags()

◆ create_dummy_variables()

◆ create_mesh()

◆ get_default_ncformat_options()

◆ get_mesh_type_name()

◆ get_nc_format()

◆ get_nc_helper()

◆ get_tag_to_nonset()

◆ get_tag_to_set()

◆ init_mesh_vals()

◆ read_coordinate()

◆ read_variables()

◆ read_variables_setup()

◆ read_variables_to_set()

◆ read_variables_to_set_allocate()

◆ update_time_tag_vals()

Member Data Documentation

◆ _fileId

◆ _fileSet

◆ _opts

◆ _readNC

◆ dummyVarNames

◆ ignoredVarNames

◆ levDim

◆ levVals

◆ nLevels

◆ nTimeSteps

◆ tDim

◆ tVals